diff --git a/packages/typescript/enums/objectFlags.d.ts b/packages/typescript/enums/objectFlags.d.ts index fd17f37c6fc0b..1b0a911b1a531 100644 --- a/packages/typescript/enums/objectFlags.d.ts +++ b/packages/typescript/enums/objectFlags.d.ts @@ -34,7 +34,6 @@ 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, diff --git a/packages/typescript/enums/objectFlags.js b/packages/typescript/enums/objectFlags.js index 013bee411f001..d59fc5f642370 100644 --- a/packages/typescript/enums/objectFlags.js +++ b/packages/typescript/enums/objectFlags.js @@ -34,7 +34,6 @@ 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"; diff --git a/tsc/internal/api/enum_values_generated.go b/tsc/internal/api/enum_values_generated.go index 1697a479539a5..b223dab0403fb 100644 --- a/tsc/internal/api/enum_values_generated.go +++ b/tsc/internal/api/enum_values_generated.go @@ -242,7 +242,6 @@ 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), 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 bdedc411bdb9c..fa5edad258a7e 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" @@ -65,12 +66,39 @@ const ( TypeSystemPropertyNameWriteType TypeSystemPropertyNameInitializerIsUndefined TypeSystemPropertyNameAliasTarget + TypeSystemPropertyNameComputedPropertyName + TypeSystemPropertyNameContextChecked + TypeSystemPropertyNameVariances + TypeSystemPropertyNameStructuredMembers + TypeSystemPropertyNameCurrentNode + TypeSystemPropertyNameSimplifiedForReading + TypeSystemPropertyNameSimplifiedForWriting + TypeSystemPropertyNameDefaultType + TypeSystemPropertyNameAwaitedType + TypeSystemPropertyNameExplicitType + TypeSystemPropertyNameBindingElementParent + TypeSystemPropertyNameCallResolution + TypeSystemPropertyNameAssertionOperand + TypeSystemPropertyNamePatternInitializer + TypeSystemPropertyNameContextualBindingPattern ) 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 propertyName TypeSystemPropertyName result bool + // restartHidden records that a cycle entered below this resolution of a + // module table passes through it; see resolveModuleTableMembers. + restartHidden bool + // participant records that the resolution is in cycleParticipants. + participant 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 @@ -242,14 +270,6 @@ type PropertiesTypesKey struct { includeOrigin bool } -// NonExistentPropertyKey - -type NonExistentPropertyKey struct { - propNode *ast.Node - containingType *Type - isUncheckedJS bool -} - // FlowLoopKey type FlowLoopKey struct { @@ -257,9 +277,14 @@ type FlowLoopKey struct { refKey CacheHashKey } +type flowLoopCacheEntry struct { + t *Type +} + type FlowLoopInfo struct { key FlowLoopKey types []*Type + id uint64 } // InferenceFlags @@ -550,6 +575,15 @@ type WideningContext struct { type VarianceStackEntry struct { symbol *ast.Symbol typeParameters []*Type + resolution int // Index in Checker.resolutions of the resolution of the measurement + prevStackIndex int32 // varianceStackIndex of symbol before 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 } type ResolvingObjectType struct { @@ -592,248 +626,100 @@ 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 - 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 - signatureArena core.Arena[Signature] - signatureExtraArena core.Arena[signatureExtra] - indexInfoArena core.Arena[IndexInfo] - literalTypeArena core.Arena[LiteralType] - objectTypeArena core.Arena[ObjectType] - typeReferenceArena core.Arena[TypeReference] - interfaceTypeArena core.Arena[InterfaceType] - mappedTypeArena core.Arena[MappedType] - unionTypeArena core.Arena[UnionType] - intersectionTypeArena core.Arena[IntersectionType] - typeParameterArena core.Arena[TypeParameter] - indexedAccessTypeArena core.Arena[IndexedAccessType] - conditionalTypeArena core.Arena[ConditionalType] - typeListArena core.Arena[*Type] - outerTypeParameterListArena core.Arena[[]*Type] - valueSymbolExtraArena core.Arena[valueSymbolExtra] - structuredTypeExtraArena core.Arena[structuredTypeExtra] - lazyStateArena core.Arena[LazyState] - memberLayoutArena core.Arena[MemberLayout] - layoutMembers ast.SymbolTable - 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 + *memoStore + compareSymbols func(*ast.Symbol, *ast.Symbol) int + compareSymbolChains func([]*ast.Symbol, []*ast.Symbol) int + globalIDs map[globalKey]globalID + awaitedTypeErrors uint32 // Errors computing awaited types have reported or would report; see getAwaitedTypeNoAliasEx + resolutionSerials uint32 + resolutions []resolution + instantiationStack []*Type + conditionalConstraintDepth depthLimit + 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 + inQuery bool + 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 + isInferencePartiallyBlocked bool + wasCanceled bool + buildingExternalModuleContainers bool + evaluate evaluator.Evaluator + 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 + symbolArena core.Arena[ast.Symbol] + symbolWithDataArena core.Arena[ast.SymbolWithData] + symbolExtraArena ast.SymbolExtraArena + signatureArena core.Arena[Signature] + signatureExtraArena core.Arena[signatureExtra] + indexInfoArena core.Arena[IndexInfo] + literalTypeArena core.Arena[LiteralType] + objectTypeArena core.Arena[ObjectType] + typeReferenceArena core.Arena[TypeReference] + interfaceTypeArena core.Arena[InterfaceType] + mappedTypeArena core.Arena[MappedType] + unionTypeArena core.Arena[UnionType] + intersectionTypeArena core.Arena[IntersectionType] + typeParameterArena core.Arena[TypeParameter] + indexedAccessTypeArena core.Arena[IndexedAccessType] + conditionalTypeArena core.Arena[ConditionalType] + typeListArena core.Arena[*Type] + outerTypeParameterListArena core.Arena[[]*Type] + valueSymbolExtraArena core.Arena[valueSymbolExtra] + structuredTypeExtraArena core.Arena[structuredTypeExtra] + lazyStateArena core.Arena[LazyState] + memberLayoutArena core.Arena[MemberLayout] + layoutMembers ast.SymbolTable + layoutBaseIndices []int32 + freeTypeSets *temporaryTypeSet + freePropertyCounts *temporaryPropertyCounts + factory ast.NodeFactory + regExpScanner *scanner.Scanner + uniqueLiteralMapper *TypeMapper + reliabilityFlags RelationComparisonResult + reportUnreliableMapper *TypeMapper + reportUnmeasurableMapper *TypeMapper + restrictiveMapper *TypeMapper + permissiveMapper *TypeMapper + 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 + // Like typeResolutionTop, but skipping the type resolutions of current + // nodes, which are many and which nothing searches for. + searchableTop int + 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 + discardLogTrims int // Number of times trimDiscardLog cleared discardLog + 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 []TypeResolution // 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 + varianceStackIndex map[*ast.Symbol]int32 // 1 + the index in varianceStack of the measurement of a symbol in progress, if any + varianceCycleRoot int // 1 + index in varianceStack of the outermost measurement re-entered in progress, or 0; see getRecursiveVariances + incompleteVariances int // 1 + resolution index of the outermost measurement whose incomplete variances were observed, or 0; see getRecursiveVariances + measuringVariances bool // The comparison about to start measures variances; see isMarkerTypeAssignableTo + flushBuf []*memoState + resumeBuf []int + deferredAttach []*memoState // See attachState + flushStates *[]*memoState // Collects memo states given effects to replay, if non-nil; see withoutChecking apparentArgumentCount *int lastGetCombinedNodeFlagsNode *ast.Node lastGetCombinedNodeFlagsResult ast.NodeFlags @@ -841,32 +727,24 @@ type Checker struct { lastGetCombinedModifierFlagsResult ast.ModifierFlags freeinferenceState *InferenceState freeFlowState *FlowState - flowLoopCache map[FlowLoopKey]*Type flowLoopStack []FlowLoopInfo + signaturesResolving []signatureResolving // Calls whose resolution is in progress sharedFlows []SharedFlow + flowLoopFrameCount uint64 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 @@ -927,38 +805,274 @@ 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 + 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 + 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 + 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() @@ -976,49 +1090,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") @@ -1060,11 +1139,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) @@ -1072,7 +1146,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) @@ -1080,33 +1153,50 @@ 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) + } + 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*/) @@ -1160,8 +1250,25 @@ 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, which every checker sharing the + // store assigns alike. + 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), "checkers sharing a store assigned different global IDs") +} + +// 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 { @@ -1196,39 +1303,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, in the same order, so every +// checker sharing a store assigns the same IDs. +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.get(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.get(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 { @@ -1238,7 +1408,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) @@ -1252,6 +1422,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 } @@ -1391,10 +1567,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*/) @@ -1577,6 +1753,10 @@ func (c *Checker) createNameResolverForSuggestion() *binder.NameResolver { } func (c *Checker) symbolReferenced(symbol *ast.Symbol, meaning ast.SymbolFlags) { + if !c.checking { + c.recordEffect(func(c *Checker) { c.symbolReferenced(symbol, meaning) }) + return + } c.symbolReferenceLinks.Get(symbol).referenceKinds |= meaning } @@ -1642,6 +1822,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) { @@ -2235,14 +2426,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.get(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.get(c) } func (c *Checker) addTypeOnlyDeclarationRelatedInfo(diagnostic *ast.Diagnostic, typeOnlyDeclaration *ast.Node, name string) *ast.Diagnostic { @@ -2255,7 +2448,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 @@ -2274,6 +2481,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 { @@ -2292,8 +2503,8 @@ func (c *Checker) checkSourceFile(ctx context.Context, sourceFile *ast.SourceFil if !sourceFile.IsDeclarationFile && !c.isCanceled() { c.checkUnusedRenamedBindingElements() } + c.checkExternalHelperRequests(sourceFile) c.produceDeferredDiagnostics() - c.reportedUnreachableNodes.Clear() links.typeChecked = true } if checkUnused && !links.unusedChecked { @@ -2320,12 +2531,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 @@ -2470,64 +2685,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.get(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 { @@ -2562,6 +2777,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.checking { + c.recordEffect(func(c *Checker) { c.checkNodeDeferred(node) }) + return + } enclosingFile := ast.GetSourceFileOfNode(node) links := c.sourceFileLinks.Get(enclosingFile) if !links.typeChecked { @@ -2584,8 +2803,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: @@ -2615,7 +2836,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) { @@ -3042,17 +3265,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) } } } @@ -3215,12 +3437,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*/) @@ -3360,7 +3582,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) { @@ -3382,9 +3604,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} }) { @@ -3394,7 +3614,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) } @@ -3445,7 +3665,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) { @@ -3457,7 +3677,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) @@ -3526,10 +3746,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) { @@ -3853,13 +4070,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) } @@ -4502,9 +4713,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 @@ -4517,7 +4726,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 { @@ -4603,8 +4812,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: @@ -5014,10 +5223,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) { @@ -5121,8 +5329,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) @@ -5133,7 +5340,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) { @@ -5208,8 +5416,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) @@ -5239,7 +5446,7 @@ func (c *Checker) checkEnumDeclaration(node *ast.Node) { } } } - } + }) } func (c *Checker) checkEnumMember(node *ast.Node) { @@ -5249,8 +5456,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) + } } } @@ -5369,9 +5579,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.get(c, symbol); ok { return t } + c.moduleImportAttributesTypes.begin(c, symbol) var result *Type moduleDecl := core.Find(symbol.Declarations(), ast.IsModuleWithStringLiteralName) if moduleDecl == nil { @@ -5379,7 +5590,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 } @@ -5612,19 +5824,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.get(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.get(c) } func (c *Checker) getImportAttributesTypeForModuleSpecifier(moduleSpecifier *ast.Node) *Type { @@ -5891,8 +6103,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. @@ -5930,8 +6141,7 @@ func (c *Checker) checkExternalModuleExports(node *ast.Node) { } } } - links.exportsChecked = true - } + }) } func (c *Checker) hasExportedMembersOfKind(moduleSymbol *ast.Symbol, kind ast.SymbolFlags) bool { @@ -6019,6 +6229,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 + if !c.checking { + c.recordEffect(func(c *Checker) { c.renamedBindingElementsInTypes = append(c.renamedBindingElementsInTypes, node) }) + return + } c.renamedBindingElementsInTypes = append(c.renamedBindingElementsInTypes, node) // 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 @@ -6284,11 +6498,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 || decoratorSignature.resolvedReturnType.get(c) == nil { return } var headMessage *diagnostics.Message - expectedReturnType := decoratorSignature.resolvedReturnType + expectedReturnType := decoratorSignature.resolvedReturnType.get(c) switch node.Parent.Kind { case ast.KindClassDeclaration, ast.KindClassExpression: headMessage = diagnostics.Decorator_function_return_type_0_is_not_assignable_to_type_1 @@ -6483,31 +6697,38 @@ func (c *Checker) getIterationTypesOfIterable(t *Type, use IterationUse, errorNo if IsTypeAny(t) { return IterationTypes{c.anyType, c.anyType, c.anyType} } + 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) + } 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 c.memoActive() { + c.iterationTypesCache.begin(c, key) + result := c.getIterationTypesOfIterableCached(t, use, key) + c.endMemo() + return result } - result := c.getIterationTypesOfIterableWorker(t, use, errorNode, noCache) - if !noCache { - c.iterationTypesCache[key] = result + return c.getIterationTypesOfIterableCached(t, use, key) +} + +func (c *Checker) getIterationTypesOfIterableCached(t *Type, use IterationUse, key IterationTypesKey) IterationTypes { + if cached, ok := c.iterationTypesCache.get(c, key); ok { + return cached } + result := c.getIterationTypesOfIterableWorker(t, use, nil /*errorNode*/) + c.iterationTypesCache.set(c, key, result) return result } -func (c *Checker) getIterationTypesOfIterableWorker(t *Type, use IterationUse, errorNode *ast.Node, noCache bool) IterationTypes { +func (c *Checker) getIterationTypesOfIterableWorker(t *Type, use IterationUse, errorNode *ast.Node) IterationTypes { if t.flags&TypeFlagsUnion != 0 { allIterationTypes := make([]IterationTypes, 0, len(t.Types())) for _, constituent := range t.Types() { - iterationTypes := c.getIterationTypesOfIterableWorker(constituent, use, nil, noCache) + 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) }) } @@ -6560,7 +6781,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) @@ -7137,9 +7358,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 @@ -7255,6 +7480,10 @@ func (c *Checker) checkTypeParametersNotReferenced(root *ast.Node, typeParameter } func (c *Checker) registerForUnusedIdentifiersCheck(node *ast.Node) { + if !c.checking { + c.recordEffect(func(c *Checker) { c.registerForUnusedIdentifiersCheck(node) }) + return + } sourceFile := ast.GetSourceFileOfNode(node) links := c.sourceFileLinks.Get(sourceFile) links.identifierCheckNodes = append(links.identifierCheckNodes, node) @@ -7557,18 +7786,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.get(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 } @@ -7736,7 +7991,24 @@ 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.get(c); t != nil { + return t + } + if c.memoActive() { + links.resolvedType.begin(c) + result := c.checkExpressionCachedExUncached(node, checkMode) + c.endMemo() + return result + } + return c.checkExpressionCachedExUncached(node, checkMode) +} + +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.get(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. @@ -7744,11 +8016,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.get(c) } // Returns the type of an expression. Unlike checkExpression, this function is simply concerned @@ -7757,12 +8029,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.get(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 } @@ -7775,15 +8049,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 } @@ -8062,10 +8340,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.get(c) == nil { + links.resolvedSymbol.set(c, c.lookupSymbolForPrivateIdentifierDeclaration(node.Text(), node)) } - return links.resolvedSymbol + return links.resolvedSymbol.get(c) } func (c *Checker) checkSuperExpression(node *ast.Node) *Type { @@ -8227,11 +8505,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 } @@ -8244,7 +8520,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 { @@ -8322,12 +8598,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.get(c, key); ok { return cached } literalType := c.cloneTypeReference(t) literalType.objectFlags |= ObjectFlagsArrayLiteral | ObjectFlagsContainsObjectOrArrayLiteral - c.cachedTypes[key] = literalType + c.cachedTypes.intern(key, literalType) return literalType } @@ -8620,6 +8896,50 @@ 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.KindParenthesizedExpression, ast.KindSpreadElement, ast.KindArrayLiteralExpression, + ast.KindObjectLiteralExpression, ast.KindPropertyAssignment, ast.KindAwaitExpression: + node = parent + continue + 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: + 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 @@ -8628,15 +8948,57 @@ 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) + } + var result *Signature + if c.memoActive() { + c.signatureLinks.Get(node).resolvedSignature.begin(c) + result = c.getResolvedSignatureUncached(node, candidatesOutArray, checkMode) + c.endMemo() + } else { + result = c.getResolvedSignatureUncached(node, candidatesOutArray, checkMode) + } + 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.get(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)) && isContextuallyTypedByEnclosingCall(node) { + c.getContextualType(node, ContextFlagsNone) + } + cached = links.resolvedSignature.get(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 @@ -8645,10 +9007,12 @@ 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, signatureResolving{links, len(c.resolutions)}) 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. @@ -8658,21 +9022,51 @@ func (c *Checker) getResolvedSignature(node *ast.Node, candidatesOutArray *[]*Si // 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.get(c) != c.resolvingSignature { + result = links.resolvedSignature.get(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.ContainsFunc(c.signaturesResolving, func(r signatureResolving) bool { return r.links == links }) +} + +type signatureResolving struct { + links *SignatureLinks + start int // Index in resolutions on entry +} + +// 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 { + if c.visibleStart == 0 { + return false + } + for _, r := range slices.Backward(c.signaturesResolving) { + if r.links == links { + return r.start < c.visibleStart + } + } + return false +} + func (c *Checker) resolveSignature(node *ast.Node, candidatesOutArray *[]*Signature, checkMode CheckMode) *Signature { switch node.Kind { case ast.KindCallExpression: @@ -9154,15 +9548,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) 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 } @@ -9174,7 +9571,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.signatureLinks.Get(node).resolvedSignature.set(c, 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, @@ -9250,12 +9647,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.get(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 } @@ -10368,14 +10767,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.get(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 } } @@ -10396,19 +10797,73 @@ func (c *Checker) checkFunctionExpressionOrObjectLiteralMethod(node *ast.Node, c } func (c *Checker) contextuallyCheckFunctionExpressionOrObjectLiteralMethod(node *ast.Node, checkMode CheckMode) { + c.assignContextualParameterTypesOfFunction(node, checkMode) + c.beginMemo(memoKeyOf(node, memoContextChecked)) + c.contextuallyCheckFunctionExpressionOrObjectLiteralMethodUncached(node, checkMode) + c.endMemo() +} + +func (c *Checker) contextuallyCheckFunctionExpressionOrObjectLiteralMethodUncached(node *ast.Node, checkMode CheckMode) { + links := c.nodeLinks.Get(node) + if links.flags&NodeCheckFlagsContextChecked == 0 || links.flags&NodeCheckFlagsSignatureContextChecked != 0 { + 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.get(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.get(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)) + 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.pushTypeResolution(node, TypeSystemPropertyNameContextChecked) if c.isContextSensitive(node) { if contextualSignature != nil { inferenceContext := c.getInferenceContext(node) @@ -10438,20 +10893,17 @@ 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.checkSignatureDeclaration(node) + c.popTypeResolution() + 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) @@ -10600,6 +11052,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.logFlagMemoDiscard(func() { sig.setTypeParameters(c, nil) }) + } sig.setTypeParameters(c, context.TypeParameters()) } if context.ThisParameter() != nil { @@ -10651,7 +11106,7 @@ func (c *Checker) assignNonContextualParameterTypes(signature *Signature) { func (c *Checker) assignParameterType(parameter *ast.Symbol, contextualType *Type) { links := c.valueSymbolLinks.Get(parameter) - if links.resolvedType != nil { + if links.resolvedType.get(c) != nil { return } declaration := parameter.ValueDeclaration() @@ -10663,13 +11118,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.get(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.get(c)) } } @@ -10681,7 +11136,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) } @@ -10787,7 +11242,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) }) } @@ -10821,7 +11276,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) }) } @@ -10911,8 +11366,24 @@ 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) + } + c.beginMemo(memoKeyOf(entry, memoInstantiationExpressionType)) + result := c.getInstantiationExpressionTypeCached(exprType, node, typeArguments, entry) + c.endMemo() + return result +} + +type instantiationExpressionEntry struct { + t *Type +} + +func (c *Checker) getInstantiationExpressionTypeCached(exprType *Type, node *ast.Node, typeArguments *ast.NodeList, entry *instantiationExpressionEntry) *Type { + if entry.t != nil { + return entry.t } hasSomeApplicableSignature := false var nonApplicableType *Type @@ -10945,7 +11416,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 } @@ -10974,7 +11445,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 @@ -11320,8 +11791,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) @@ -11470,6 +11942,13 @@ 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) { @@ -11482,7 +11961,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 @@ -11597,7 +12076,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) }) @@ -11624,7 +12103,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()) @@ -11782,16 +12261,16 @@ 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 } - 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 } @@ -12551,26 +13030,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) + 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) @@ -13019,7 +13518,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.symbolNodeLinks.Get(left).resolvedSymbol.get(c); symbol != nil && len(symbol.Declarations()) > 1 && rightType.flags&TypeFlagsUndefined != 0 { return } } @@ -13347,7 +13846,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.symbolNodeLinks.Get(left).resolvedSymbol.get(c) == nil && ast.GetContainingClass(left) != nil { isUncheckedJS := c.isUncheckedJSSuggestion(left, rightType.symbol, true /*excludeClasses*/) c.reportNonexistentProperty(left, rightType, isUncheckedJS) } @@ -13428,7 +13927,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 } } @@ -13463,17 +13962,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() { @@ -13524,7 +14031,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 { @@ -13707,6 +14214,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.get(c, key); existing != nil { + return existing + } members := ast.NewSymbolTable() var skippedPrivateMembers collections.Set[string] var indexInfos []*IndexInfo @@ -13731,6 +14257,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.get(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()) @@ -13743,14 +14274,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 { @@ -13760,8 +14292,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 } @@ -13832,9 +14374,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()) @@ -13858,20 +14400,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.get(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 } @@ -14047,16 +14643,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) 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)) @@ -14177,23 +14772,37 @@ 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.get(c); symbol != nil { + return symbol + } + if c.memoActive() { + links.resolvedSymbol.begin(c) + result := c.getResolvedSymbolUncached(node) + c.endMemo() + return result + } + return c.getResolvedSymbolUncached(node) +} + +func (c *Checker) getResolvedSymbolUncached(node *ast.Node) *ast.Symbol { + links := c.symbolNodeLinks.Get(node) + if links.resolvedSymbol.get(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 + return links.resolvedSymbol.get(c) } func (c *Checker) getResolvedSymbolOrNil(node *ast.Node) *ast.Symbol { - return c.symbolNodeLinks.Get(node).resolvedSymbol + return c.symbolNodeLinks.Get(node).resolvedSymbol.get(c) } func (c *Checker) getReferencedValueOrAliasSymbol(reference *ast.Node) *ast.Symbol { - resolvedSymbol := c.symbolNodeLinks.Get(reference).resolvedSymbol + resolvedSymbol := c.symbolNodeLinks.Get(reference).resolvedSymbol.get(c) if resolvedSymbol != nil && resolvedSymbol != c.unknownSymbol { return resolvedSymbol } @@ -14256,24 +14865,34 @@ 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 + } c.deferredDiagnosticCallbacks = append(c.deferredDiagnosticCallbacks, callback) } func (c *Checker) produceDeferredDiagnostics() { for _, cb := range c.deferredDiagnosticCallbacks { - cb() + 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 + } return c.diagnostics.Add(diagnostic) } return diagnostic @@ -14281,7 +14900,11 @@ 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 + } return c.suggestionDiagnostics.Add(diagnostic) } return diagnostic @@ -14291,6 +14914,47 @@ 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 + } + 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() @@ -14379,13 +15043,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 } @@ -14396,8 +15060,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.get(c, symbol); merged != nil { + symbol = merged + } + combined.Set(id, symbol) + } c.mergeSymbolTable(combined, second, false, nil) return combined } @@ -14643,14 +15317,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) + 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.resolving.get(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 field := f.key.field(); f.key != 0 && (field == memoSymbolMembers || field == memoSymbolExports) { + if c.compareSymbols(f.key.symbol(), 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) + 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.discardLog = append(c.discardLog, discardEntry{nil, func() { links[resolutionKind] = nil }, false}) + } + } + 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] } @@ -16441,10 +17290,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.get(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 @@ -16495,10 +17344,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.get(c) } func (c *Checker) lateBindIndexSignature(parent *ast.Symbol, earlySymbols ast.SymbolTable, lateSymbols ast.SymbolTable, decl *ast.Node) { @@ -16566,10 +17415,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 } @@ -16701,11 +17562,25 @@ 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.get(c); target != nil { + return target + } + if c.memoActive() { + links.aliasTarget.begin(c) + result := c.resolveAliasUncached(symbol) + c.endMemo() + return result + } + return c.resolveAliasUncached(symbol) +} + +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 links.aliasTarget.get(c) == nil { if !c.pushTypeResolution(symbol, TypeSystemPropertyNameAliasTarget) { return c.unknownSymbol } @@ -16718,13 +17593,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.get(c) } func (c *Checker) resolveIndirectionAlias(source *ast.Symbol, target *ast.Symbol) *ast.Symbol { @@ -16739,7 +17614,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 links.aliasTarget.get(c) != nil || c.findResolutionCycleStartIndex(symbol, TypeSystemPropertyNameAliasTarget) < 0 { return c.resolveAlias(symbol) } return nil @@ -16837,20 +17712,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.get(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.get(c) } func (c *Checker) getWriteTypeOfSymbolWithDeferredType(symbol *ast.Symbol) *Type { links := c.valueSymbolLinks.Get(symbol) - if links.getWriteType() == nil { + if links.getWriteType(c) == nil { deferred := c.deferredSymbolLinks.Get(symbol) if len(deferred.writeConstituents) != 0 { if deferred.parent.flags&TypeFlagsUnion != 0 { @@ -16862,19 +17737,26 @@ func (c *Checker) getWriteTypeOfSymbolWithDeferredType(symbol *ast.Symbol) *Type links.setWriteType(c, c.getTypeOfSymbolWithDeferredType(symbol)) } } - return links.getWriteType() + return links.getWriteType(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.getWriteType(c), links.resolvedType.get(c)) } if symbol.Flags()&ast.SymbolFlagsProperty != 0 { return c.removeMissingType(c.getTypeOfSymbol(symbol), symbol.Flags()&ast.SymbolFlagsOptional != 0) @@ -16907,7 +17789,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) } } @@ -16927,7 +17809,33 @@ 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.symbolNodeLinks.Get(location).resolvedSymbol.get(c) + 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.get(c); t != nil { + return t + } + if c.memoActive() { + links.resolvedType.begin(c) + result := c.getTypeOfSymbolUncached(symbol) + c.endMemo() + return result + } + return c.getTypeOfSymbolUncached(symbol) +} + +func (c *Checker) getTypeOfSymbolUncached(symbol *ast.Symbol) *Type { if symbol.CheckFlags()&ast.CheckFlagsDeferredType != 0 { return c.getTypeOfSymbolWithDeferredType(symbol) } @@ -16964,23 +17872,23 @@ 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.get(c) == nil { + links.resolvedType.set(c, c.instantiateType(c.getTypeOfSymbol(links.target), links.mapper)) } - return links.resolvedType + return links.resolvedType.get(c) } func (c *Checker) getWriteTypeOfInstantiatedSymbol(symbol *ast.Symbol) *Type { links := c.valueSymbolLinks.Get(symbol) - if links.getWriteType() == nil { + if links.getWriteType(c) == nil { links.setWriteType(c, c.instantiateType(c.getWriteTypeOfSymbol(links.target), links.mapper)) } - return links.getWriteType() + return links.getWriteType(c) } func (c *Checker) getTypeOfVariableOrParameterOrProperty(symbol *ast.Symbol) *Type { links := c.valueSymbolLinks.Get(symbol) - if links.resolvedType == nil { + if links.resolvedType.get(c) == nil { t := c.getTypeOfVariableOrParameterOrPropertyWorker(symbol) if t == nil { panic("Unexpected nil type") @@ -16990,12 +17898,15 @@ 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.get(c); assigned != nil { + return assigned + } + if !c.isParameterOfContextSensitiveSignature(symbol) { + links.resolvedType.set(c, t) } return t } - return links.resolvedType + return links.resolvedType.get(c) } func (c *Checker) isParameterOfContextSensitiveSignature(symbol *ast.Symbol) bool { @@ -17030,17 +17941,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) + c.getTypeOfInitializer(initializer) + c.popTypeResolution() + } + } // Handle variable, parameter or property if !c.pushTypeResolution(symbol, TypeSystemPropertyNameType) { 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) + } + if !c.popTypeResolution() { + return c.reportCircularityError(symbol) } - return c.newAnonymousType(symbol, symbol.Members(), nil, nil, nil) + return result } - var result *Type switch declaration.Kind { case ast.KindParameter, ast.KindPropertyDeclaration, ast.KindPropertySignature, ast.KindVariableDeclaration, ast.KindBindingElement: @@ -17276,13 +18205,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 { @@ -17341,10 +18280,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.get(c) == nil { + links.resolvedType.set(c, c.getTypeOfFuncClassEnumModuleWorker(symbol)) } - return links.resolvedType + 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.get(c) } func (c *Checker) getTypeOfFuncClassEnumModuleWorker(symbol *ast.Symbol) *Type { @@ -17393,14 +18338,24 @@ func (c *Checker) getBaseTypeVariableOfClass(symbol *ast.Symbol) *Type { * * an object type with at least one construct signature. */ func (c *Checker) getBaseConstructorTypeOfClass(t *Type) *Type { + if c.memoActive() { + t.AsInterfaceType().resolvedBaseConstructorType.begin(c) + result := c.getBaseConstructorTypeOfClassUncached(t) + c.endMemo() + return result + } + return c.getBaseConstructorTypeOfClassUncached(t) +} + +func (c *Checker) getBaseConstructorTypeOfClassUncached(t *Type) *Type { data := t.AsInterfaceType() - if data.resolvedBaseConstructorType != nil { - return data.resolvedBaseConstructorType + if data.resolvedBaseConstructorType.get(c) != nil { + return data.resolvedBaseConstructorType.get(c) } baseTypeNode := getBaseTypeNodeOfClass(t) if baseTypeNode == nil { - data.resolvedBaseConstructorType = c.undefinedType - return data.resolvedBaseConstructorType + data.resolvedBaseConstructorType.set(c, c.undefinedType) + return data.resolvedBaseConstructorType.get(c) } if !c.pushTypeResolution(t, TypeSystemPropertyNameResolvedBaseConstructorType) { return c.errorType @@ -17413,10 +18368,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.get(c) == nil { + data.resolvedBaseConstructorType.set(c, c.errorType) } - return data.resolvedBaseConstructorType + return data.resolvedBaseConstructorType.get(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)) @@ -17433,15 +18388,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.get(c) == nil { + data.resolvedBaseConstructorType.set(c, c.errorType) } - return data.resolvedBaseConstructorType + return data.resolvedBaseConstructorType.get(c) } - if data.resolvedBaseConstructorType == nil { - data.resolvedBaseConstructorType = baseConstructorType + if data.resolvedBaseConstructorType.get(c) == nil { + data.resolvedBaseConstructorType.set(c, baseConstructorType) } - return data.resolvedBaseConstructorType + return data.resolvedBaseConstructorType.get(c) } func (c *Checker) isFunctionType(t *Type) bool { @@ -17495,6 +18450,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) } @@ -17512,7 +18478,7 @@ func (c *Checker) getConstraintFromTypeParameter(t *Type) *Type { } tp := t.AsTypeParameter() - if tp.constraint == nil { + if tp.constraint.get(c) == nil { var constraint *Type if tp.target != nil { constraint = c.instantiateType(c.getConstraintOfTypeParameter(tp.target), tp.mapper) @@ -17536,10 +18502,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.get(c) != c.noConstraintType { + return tp.constraint.get(c) } return nil } @@ -17636,7 +18602,7 @@ func (c *Checker) getTypeParametersForTypeReferenceOrImport(node *ast.Node) []*T 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 } } @@ -17700,7 +18666,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, @@ -17709,19 +18675,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 @@ -17733,7 +18698,7 @@ 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 && !c.isRestrictiveInstantiation(t) { constraint := c.getSimplifiedType(d.checkType, false /*writing*/) if constraint == d.checkType { constraint = c.getConstraintOfType(constraint) @@ -17741,25 +18706,24 @@ func (c *Checker) getConstraintOfDistributiveConditionalType(t *Type) *Type { 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.get(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 @@ -17772,16 +18736,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.get(c) } /** @@ -17909,15 +18872,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 ref.AsTypeReference().resolvedTypeArguments.peek() { 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) @@ -17928,7 +18891,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('>') @@ -17954,6 +18917,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.resolvedType.peek() != otherLinks.resolvedType.peek() { + return false + } + } + return true +} + func getTypeListKey(types []*Type) CacheHashKey { var b keyBuilder b.writeTypes(types) @@ -18071,15 +19079,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) @@ -18098,9 +19113,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) }) } @@ -18157,8 +19172,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) } } } @@ -18291,9 +19306,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 @@ -18364,7 +19382,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) } var result *Type if ast.IsObjectBindingPattern(pattern) { @@ -18373,7 +19394,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 } @@ -18398,19 +19419,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).resolvedType.peek()) + } + 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 } @@ -18454,9 +19497,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 } @@ -18649,16 +19700,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 @@ -18689,8 +19741,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 } @@ -18824,9 +19875,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.get(c, key); cached != nil { return cached } + c.cachedTypes.begin(c, key) + defer c.endMemo() } var result *Type switch { @@ -18855,7 +19909,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) } @@ -18879,11 +19933,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 { @@ -18909,7 +19968,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 { @@ -18956,26 +20015,35 @@ 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.get(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.get(c) == nil { + links.resolvedType.set(c, c.getDeclaredTypeOfEnumMember(symbol)) } - return links.resolvedType + return links.resolvedType.get(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 links.resolvedType.get(c) == nil { if !c.pushTypeResolution(symbol, TypeSystemPropertyNameType) { return c.errorType } @@ -19021,16 +20089,16 @@ func (c *Checker) getTypeOfAccessors(symbol *ast.Symbol) *Type { } t = c.anyType } - if links.resolvedType == nil { - links.resolvedType = t + if links.resolvedType.get(c) == nil { + links.resolvedType.set(c, t) } } - return links.resolvedType + return links.resolvedType.get(c) } func (c *Checker) getWriteTypeOfAccessors(symbol *ast.Symbol) *Type { links := c.valueSymbolLinks.Get(symbol) - if links.getWriteType() == nil { + if links.getWriteType(c) == nil { if !c.pushTypeResolution(symbol, TypeSystemPropertyNameWriteType) { return c.errorType } @@ -19049,7 +20117,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.getWriteType(c) == nil { if writeType != nil { links.setWriteType(c, writeType) } else { @@ -19057,12 +20125,12 @@ func (c *Checker) getWriteTypeOfAccessors(symbol *ast.Symbol) *Type { } } } - return links.getWriteType() + return links.getWriteType(c) } func (c *Checker) getTypeOfAlias(symbol *ast.Symbol) *Type { links := c.valueSymbolLinks.Get(symbol) - if links.resolvedType == nil { + if links.resolvedType.get(c) == nil { if !c.pushTypeResolution(symbol, TypeSystemPropertyNameType) { return c.errorType } @@ -19073,22 +20141,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.get(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.get(c) == nil { + links.resolvedType.set(c, c.errorType) } - return links.resolvedType + return links.resolvedType.get(c) } } - return links.resolvedType + return links.resolvedType.get(c) } func (c *Checker) addOptionality(t *Type) *Type { @@ -19173,12 +20241,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.get(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 @@ -19223,33 +20292,686 @@ func (c *Checker) getCombinedModifierFlagsCached(node *ast.Node) ast.ModifierFla func (c *Checker) pushTypeResolution(target TypeSystemEntity, propertyName TypeSystemPropertyName) 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) + 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].prevSearchable) - 1; i >= 0; i = int(c.resolutions[i].prevSearchable) - 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 + savedDepths [3]depthLimit + savedReverseMapped reverseMappedState + savedContextual []ContextualInfo + savedInference []InferenceContextInfo + floor int + 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 +// 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 + } + } + if first == nil || first == entered || c.isYieldingTo(first.target, first.propertyName) { + return nil + } + return first +} + +// 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 true + case TypeSystemPropertyNameResolvedReturnType: + sig := r.target.(*Signature) + return sig.target == nil && sig.getComposite() == nil && sig.declaration != nil + } + 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; t.propertyName == TypeSystemPropertyNameStructuredMembers && c.isModuleTableType(t.target.(*Type)) { + t.restartHidden = true + c.markResolutionCycle(m) + return false + } + c.beginCycleYield(r.target, r.propertyName, len(c.resolutions), m) + 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 field := f.key.field(); f.key != 0 && (field == memoSymbolMembers || field == memoSymbolExports) { + 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, + 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, + floor: floor, + }) + // 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.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.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.resolving.set(sh.key, sh.index) + } + 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) { + c.cycleParticipants = append(c.cycleParticipants, *r) + } + 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.searchableTop - 1; i >= c.visibleStart; i = int(c.resolutions[i].prevSearchable) - 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.participant = true + c.cycleParticipants = append(c.cycleParticipants, *r) + } + } +} + +// 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 during the cycle has +// been discarded and the caller must resolve the canonical member before +// resolving the head again. +func (c *Checker) popCircularHead() TypeSystemEntity { + r := c.topTypeResolution() + canonical := r.canonical + if canonical == r.target { + canonical = nil + } + 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 type 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 + } + // beginTypeResolution, without the call, for a resolution that is not + // searchable. + 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.typeResolution.target = node + f.typeResolution.propertyName = TypeSystemPropertyNameCurrentNode + f.typeResolution.result = true + c.typeResolutionTop = len(c.resolutions) + c.currentNodeResolution = c.typeResolutionTop + return save +} + +func (c *Checker) exitCurrentNode(save savedCurrentNode) { + if c.currentNodeResolution == save.resolution { + // The node had no resolution of its own; see enterCurrentNode. + if c.circularityStart >= save.resolution { + c.endCircularity() + } else if len(c.innerCycles) != 0 { + c.endInnerCycles(save.resolution - 1) + } + c.currentNode = save.node + return + } + // popTypeResolution, without the call. + n := len(c.resolutions) - 1 + debug.Assert(c.currentNodeResolution == n+1 && c.typeResolutionTop == n+1, "resolutions left on the stack") + f := &c.resolutions[n] + c.typeResolutionTop = int(f.prevTypeResolution) + *f = resolution{} + c.resolutions = c.resolutions[:n] + if c.circularityStart > n { + c.endCircularity() + } else if len(c.innerCycles) != 0 { + c.endInnerCycles(n) + } + if len(c.cycleYields) != 0 && c.cycleYields[len(c.cycleYields)-1].end == n { + c.endCycleYield() + } + 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) { + if c.checking && c.memoTop != 0 { + 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. +// - The resolution is inside the outermost measurement of variances, which +// hides what is below it and is measured from the canonical entry of its +// circularity, so what it computes is the same whatever led to it, and it +// only observed its incomplete variances. Computing it first from scratch +// reaches the measurement and computes it again inside, the same way. +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 { + y := &c.cycleYields[len(c.cycleYields)-1] + if n >= y.floor && int(f.prevTypeResolution) <= y.floor && (observed == 0 || int(observed) > y.floor) { + return true + } + } + return c.observedOnlyOutermostMeasurement(n) +} + +func minObservedHead(a int32, b int32) int32 { + if a == 0 || b != 0 && b < a { + return b + } + return a +} + +// observedOnlyOutermostMeasurement reports whether the cycle in progress is +// the one headed by the outermost measurement of variances, which the +// resolution at index n is inside, and no other. +func (c *Checker) observedOnlyOutermostMeasurement(n int) bool { + if len(c.varianceStack) == 0 || len(c.innerCycles) != 0 { + return false + } + head := c.varianceStack[0].resolution + return n > head && c.circularityStart == head+1 +} + +// 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) { + 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++ +} + +func (l *depthLimit) exit() { + l.depth-- +} + +/** + * 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 + c.observedHead = minObservedHead(f.prevObservedHead, observed) + if r := &f.typeResolution; result && !r.participant && c.circularityStart != 0 && c.keepsResultInCycle(n, f, observed) { + r.participant = true + c.cycleParticipants = append(c.cycleParticipants, *r) + } + c.typeResolutionTop = int(f.prevTypeResolution) + if f.typeResolution.propertyName != TypeSystemPropertyNameCurrentNode { + c.searchableTop = int(f.prevSearchable) + } + c.resolutions[n] = resolution{} + c.resolutions = c.resolutions[:n] + if c.circularityStart > n { + c.endCircularity() + } else if len(c.innerCycles) != 0 { + c.endInnerCycles(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. +func (c *Checker) beginTypeResolution(target TypeSystemEntity, propertyName TypeSystemPropertyName) { + 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.propertyName = propertyName + f.typeResolution.result = true + c.typeResolutionTop = len(c.resolutions) + if propertyName != TypeSystemPropertyNameCurrentNode { + f.prevSearchable = int32(c.searchableTop) + c.searchableTop = 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) findResolutionCycleStartIndex(target TypeSystemEntity, propertyName TypeSystemPropertyName) int { + for i := c.searchableTop - 1; i >= c.resolutionStart; i = int(c.resolutions[i].prevSearchable) - 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 p := c.typeResolutionMemo(resolution); p != nil { + c.observeCell(p) + } + } + return -1 } if resolution.target == target && resolution.propertyName == propertyName { return i @@ -19258,28 +20980,56 @@ func (c *Checker) findResolutionCycleStartIndex(target TypeSystemEntity, propert 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].prevSearchable) - 1; i >= c.resolutionStart; i = int(c.resolutions[i].prevSearchable) - 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 != nil + return c.valueSymbolLinks.Get(r.target.(*ast.Symbol)).resolvedType.peek() != nil case TypeSystemPropertyNameDeclaredType: - return c.typeAliasLinks.Get(r.target.(*ast.Symbol)).declaredType != nil + return c.typeAliasLinks.Get(r.target.(*ast.Symbol)).declaredType.peek() != nil case TypeSystemPropertyNameResolvedTypeArguments: - return r.target.(*Type).AsTypeReference().resolvedTypeArguments != nil + return r.target.(*Type).AsTypeReference().resolvedTypeArguments.peek() != nil case TypeSystemPropertyNameResolvedBaseTypes: return r.target.(*Type).AsInterfaceType().baseTypesResolved case TypeSystemPropertyNameResolvedBaseConstructorType: - return r.target.(*Type).AsInterfaceType().resolvedBaseConstructorType != nil + return r.target.(*Type).AsInterfaceType().resolvedBaseConstructorType.peek() != nil case TypeSystemPropertyNameResolvedReturnType: - return r.target.(*Signature).resolvedReturnType != nil + return r.target.(*Signature).resolvedReturnType.peek() != nil case TypeSystemPropertyNameResolvedBaseConstraint: - return r.target.(*Type).AsConstrainedType().resolvedBaseConstraint != nil + return r.target.(*Type).AsConstrainedType().resolvedBaseConstraint.peek() != 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 + 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 != nil + return c.aliasSymbolLinks.Get(r.target.(*ast.Symbol)).aliasTarget.peek() != nil + case TypeSystemPropertyNameContextChecked, TypeSystemPropertyNameStructuredMembers, TypeSystemPropertyNameCurrentNode, + TypeSystemPropertyNameSimplifiedForReading, TypeSystemPropertyNameSimplifiedForWriting, TypeSystemPropertyNameDefaultType, + TypeSystemPropertyNameAwaitedType, TypeSystemPropertyNameExplicitType, + TypeSystemPropertyNameBindingElementParent, TypeSystemPropertyNameCallResolution, + TypeSystemPropertyNameAssertionOperand, TypeSystemPropertyNamePatternInitializer, TypeSystemPropertyNameContextualBindingPattern: + // Marked as checked or resolved on entry, so it is only on the stack + // while in progress. + return false + 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 } panic("Unhandled case in typeResolutionHasProperty") } @@ -19318,7 +21068,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 } @@ -19349,28 +21099,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.get(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 { @@ -19395,7 +21148,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 @@ -19445,9 +21198,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) { @@ -19589,30 +21348,260 @@ func (c *Checker) isApplicableIndexType(source *Type, target *Type) bool { } 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") + 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) } - case t.flags&TypeFlagsUnion != 0: - c.resolveUnionTypeMembers(t) - case t.flags&TypeFlagsIntersection != 0: - c.resolveIntersectionTypeMembers(t) + } else { + c.isResolutionInProgress(t, TypeSystemPropertyNameStructuredMembers) + } + if j, ok := c.resolving.get(key); 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. + c.markResolutionCycle(c.visibleStart) + } + published = c.resolutions[enclosing].membersPublished + } + 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) + 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") } - return t.AsStructuredType() +} + +// 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) { + if c.checking { + // Results computed starting from another table are discarded along + // with their effects, so resolve while recording effects. + c.withoutChecking(func() { + c.resolveModuleTableMembers(t) + }) + return + } + mark := c.markDiscard() + hidden := false + for { + c.beginTypeResolution(t, TypeSystemPropertyNameStructuredMembers) + c.resolveAnonymousTypeMembers(t) + r := c.topTypeResolution() + restart := r.restartHidden && !hidden + canonical := r.canonical + if canonical == t { + canonical = nil + } + if canonical != nil || restart { + // Discard while the cycle is still in progress, so that the + // results of its participants are discarded too. + c.discardSince(mark) + } + c.popTypeResolution() + if canonical == nil && !restart { + break + } + c.clearStructuredMembers(t) + key := memoKeyOf(t, memoStructuredMembers) + i, _ := c.resolving.get(key) + c.resolutions[i].membersPublished = false + if canonical != nil { + c.resolveStructuredTypeMembers(canonical.(*Type)) + continue + } + // 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) 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 + } +} + +// 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.discardLog = append(c.discardLog, discardEntry{nil, func() { + if _, ok := c.resolvingAnyIndex(memoKeyOf(t, memoStructuredMembers)); ok { + // An enclosing resolution of the same members sets them again. + return + } + 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 + } + if t.objectFlags&(ObjectFlagsClassOrInterface|ObjectFlagsReference) != 0 { + t.AsTypeReference().lazy = nil + } + }, false}) +} + +// 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.discardLog = append(c.discardLog, discardEntry{nil, func() { + properties[index] = nil + lazy.propertiesResolved = false + if t.AsType().AsTypeReference().lazy == lazy { + t.members = nil + } + }, false}) } func (c *Checker) resolveObjectTypeMembers(t *Type) { @@ -19666,7 +21655,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 @@ -19697,15 +21686,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.get(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 { @@ -19784,17 +21770,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.get(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 + return data.resolvedBaseTypes.get(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) @@ -19818,8 +21823,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{&data.resolvedBaseTypes.memoHeader, func() { data.baseTypesResolved = false }, false}) + } } - return data.resolvedBaseTypes + return data.resolvedBaseTypes.get(c) } func (c *Checker) getTupleBaseType(t *Type) *Type { @@ -19880,7 +21888,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 { @@ -19919,7 +21927,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 } } @@ -19936,10 +21944,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.get(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 } @@ -20017,10 +22027,12 @@ func (c *Checker) getErasedSignature(signature *Signature) *Signature { return signature } key := CachedSignatureKey{sig: signature, key: SignatureKeyErased} - erased := c.cachedSignatures[key] + erased, _ := c.cachedSignatures.get(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 } @@ -20030,10 +22042,12 @@ func (c *Checker) getCanonicalSignature(signature *Signature) *Signature { return signature } key := CachedSignatureKey{sig: signature, key: SignatureKeyCanonical} - canonical := c.cachedSignatures[key] + canonical, _ := c.cachedSignatures.get(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 } @@ -20060,9 +22074,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.get(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) })) @@ -20077,7 +22092,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 } @@ -20123,7 +22139,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.get(c), baseType)) } else { c.reportCircularBaseType(declaration, t) } @@ -20237,16 +22253,32 @@ 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 + if c.logResults() { + c.logFlagMemoDiscard(func() { d.declaredMembersResolved = false }) + } + c.setFlagMemo(memoKeyOf(t, memoDeclaredMembers)) 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 { @@ -20461,9 +22493,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.get(c) != nil { + return links.resolvedSignature.get(c) } var parameters []*ast.Symbol var flags SignatureFlags @@ -20532,8 +22575,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.get(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.get(c) } func (c *Checker) getTypeParametersFromDeclaration(declaration *ast.Node) []*Type { @@ -20626,8 +22675,21 @@ func isLateBindableAST(node *ast.Node) bool { } func (c *Checker) getReturnTypeOfSignature(sig *Signature) *Type { - if sig.resolvedReturnType != nil { - return sig.resolvedReturnType + if t := sig.resolvedReturnType.get(c); t != nil { + return t + } + if c.memoActive() { + sig.resolvedReturnType.begin(c) + result := c.getReturnTypeOfSignatureUncached(sig) + c.endMemo() + return result + } + return c.getReturnTypeOfSignatureUncached(sig) +} + +func (c *Checker) getReturnTypeOfSignatureUncached(sig *Signature) *Type { + if sig.resolvedReturnType.get(c) != nil { + return sig.resolvedReturnType.get(c) } if !c.pushTypeResolution(sig, TypeSystemPropertyNameResolvedReturnType) { return c.errorType @@ -20654,25 +22716,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.get(c) == nil { + sig.resolvedReturnType.set(c, t) + } + return sig.resolvedReturnType.get(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 { @@ -21277,22 +23345,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 @@ -21317,7 +23385,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())) @@ -21325,7 +23393,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) @@ -21381,12 +23449,12 @@ func (c *Checker) instantiateSymbol(symbol *ast.Symbol, m *TypeMapper) *ast.Symb } // 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 links.resolvedType.get(c) != nil && !c.couldContainTypeVariables(links.resolvedType.get(c)) { if symbol.Flags()&ast.SymbolFlagsSetAccessor == 0 { return symbol } // If we're a setter, check writeType. - if links.getWriteType() != nil && !c.couldContainTypeVariables(links.getWriteType()) { + if links.getWriteType(c) != nil && !c.couldContainTypeVariables(links.getWriteType(c)) { return symbol } } @@ -21496,7 +23564,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 { @@ -21512,7 +23580,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) @@ -21595,15 +23663,15 @@ 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) } func (c *Checker) getTypeOfMappedSymbol(symbol *ast.Symbol) *Type { links := c.valueSymbolLinks.Get(symbol) - if links.resolvedType == nil { + if links.resolvedType.get(c) == nil { mappedType := links.getContainingType() if !c.pushTypeResolution(symbol, TypeSystemPropertyNameType) { - mappedType.AsMappedType().containsError = true + mappedType.AsMappedType().containsError.setIdentity(c, true) return c.errorType } templateType := c.getTemplateTypeFromMappedType(core.OrElse(mappedType.AsMappedType().target, mappedType)) @@ -21619,17 +23687,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.get(c) == nil { + links.resolvedType.set(c, propType) } } else { - if links.resolvedType == nil { - links.resolvedType = c.errorType + if links.resolvedType.get(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.get(c) } // Return the lower bound of the key type in a mapped type. Intuitively, the lower @@ -21682,7 +23750,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 { @@ -21884,18 +23952,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.get(c), mapper)) } params[longestCount] = restParamSymbol } @@ -21935,7 +24003,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 }) } @@ -21946,7 +24014,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 { @@ -22020,7 +24088,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 } @@ -22043,29 +24111,28 @@ 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 - } + cache = &d.propertyCacheWithoutFunctionPropertyAugment + } + if prop, _ := cache.get(c, name); prop != nil { + return prop + } + if !skipObjectFunctionPropertyAugment { // 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 { + if prop, _ := d.propertyCacheWithoutFunctionPropertyAugment.get(c, name); prop != nil && prop.CheckFlags()&ast.CheckFlagsPartial == 0 { 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 } @@ -22210,7 +24277,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.get(c) singlePropMapper = links.mapper } clone := c.createSymbolWithType(singleProp, singlePropType) @@ -22220,7 +24287,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 { @@ -22286,15 +24353,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 @@ -22341,13 +24408,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 @@ -22404,10 +24501,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 { @@ -22437,16 +24531,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.get(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 } @@ -22461,27 +24556,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 { @@ -22530,7 +24627,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 } @@ -22548,7 +24645,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)) @@ -22574,42 +24671,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.get(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) { + 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 { @@ -22676,6 +24787,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 } @@ -22688,39 +24810,78 @@ func (c *Checker) getDefaultFromTypeParameter(t *Type) *Type { func (c *Checker) getResolvedTypeParameterDefault(t *Type) *Type { d := t.AsTypeParameter() - if d.resolvedDefaultType == nil { + if d.resolvedDefaultType.get(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 - } - } 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) - } - } - if d.resolvedDefaultType == c.resolvingDefaultType { - // If we have not been called recursively, set the correct default type. - d.resolvedDefaultType = defaultType + d.resolvedDefaultType.set(c, c.noConstraintType) } + } else { + c.resolveTypeParameterDefault(t) } - } else if d.resolvedDefaultType == c.resolvingDefaultType { + } else if d.resolvedDefaultType.get(c) == c.resolvingDefaultType { // If we are called recursively for this type parameter, mark the default as circular. - d.resolvedDefaultType = c.circularConstraintType + c.observeCircularHead(t, TypeSystemPropertyNameDefaultType, c.compareTypeParameterDeclarations) + d.resolvedDefaultType.swap(c.circularConstraintType) + return c.circularConstraintType + } + return d.resolvedDefaultType.get(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() + if c.checking { + // Results computed starting from another default are discarded + // along with their effects, so resolve while recording effects. + c.withoutChecking(func() { + c.resolveTypeParameterDefault(t) + }) + return + } + 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.pushTypeResolution(t, TypeSystemPropertyNameDefaultType) + 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) + } + } + if d.resolvedDefaultType.swap(nil) != c.resolvingDefaultType { + // We were called recursively, so the default is circular. + defaultType = c.circularConstraintType + } + canonical := c.popCircularHead() + if canonical == nil { + d.resolvedDefaultType.set(c, defaultType) + break + } + c.discardSince(mark) + 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 { @@ -22766,21 +24927,33 @@ 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. + 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 } @@ -22791,8 +24964,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++ @@ -22802,13 +24978,18 @@ 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] 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 { @@ -22823,20 +25004,44 @@ 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". + stack := c.instantiationStack + total := len(stack) == instantiationTotalDepthLimit + if !total { + stack = stack[c.currentResolution().depthStart:] + } + for _, t := range stack { 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) + } + } + } + if total && len(circularSymbols) > 1 { + // The whole instantiation is named, and which of the types in the + // cycle it entered first depends on what was cached before, so the + // cycle is named starting from the type declared first. + first := 0 + for i, s := range circularSymbols { + if c.compareSymbols(s, circularSymbols[first]) < 0 { + first = i } } + circularSymbols = append(circularSymbols[first:], circularSymbols[:first]...) + } + var circularTypeNames []string + for _, s := range circularSymbols { + if name := c.SymbolToString(s); !slices.Contains(circularTypeNames, name) { + circularTypeNames = append(circularTypeNames, name) + } } return circularTypeNames } @@ -22849,7 +25054,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]{}) } } @@ -22880,16 +25085,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 || 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 } @@ -22921,7 +25131,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().resolvedTypeArguments.peek() newTypeArguments := c.instantiateTypes(resolvedTypeArguments, m) if core.Same(newTypeArguments, resolvedTypeArguments) { return t @@ -23011,14 +25221,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 = links.resolvedType.get(c) case t.objectFlags&ObjectFlagsInstantiated != 0: target = t.Target() default: target = t } - typeParameters = links.getOuterTypeParameters() + typeParameters = links.getOuterTypeParameters(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 @@ -23041,6 +25252,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 @@ -23056,38 +25268,47 @@ func (c *Checker) getObjectTypeInstantiation(t *Type, m *TypeMapper, alias *Type if newAlias == nil { newAlias = c.instantiateTypeAlias(t.alias, 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 - } - result := data.instantiations[key] - if result == nil { - newMapper := newTypeMapper(typeParameters, typeArguments) - if target.objectFlags&ObjectFlagsSingleSignatureType != 0 && m != nil { - newMapper = c.combineTypeMappers(newMapper, m) - } + instantiate := func(newMapper *TypeMapper) *Type { switch { case target.objectFlags&ObjectFlagsReference != 0: - result = c.createDeferredTypeReference(t.Target(), t.AsTypeReference().node, newMapper, newAlias) + return c.createDeferredTypeReference(t.Target(), t.AsTypeReference().node, newMapper, newAlias) case target.objectFlags&ObjectFlagsMapped != 0: - result = c.instantiateMappedType(target, newMapper, newAlias) + return c.instantiateMappedType(target, newMapper, newAlias) default: - result = c.instantiateAnonymousType(target, newMapper, newAlias) + return c.instantiateAnonymousType(target, newMapper, newAlias) } - data.instantiations[key] = result + } + 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.isEmpty() { + data.instantiations.intern(getTypeInstantiationKey(typeParameters, target.alias, false), target) + } + result, _ := data.instantiations.get(c, key) + if result == nil { + reports := c.startCurrentNodeErrors() + data.instantiations.begin(c, key) + result = instantiate(newTypeMapper(typeParameters, typeArguments)) + 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 { + key := memoKeyOf(result, memoCouldContainTypeVariables) + mask := ObjectFlagsCouldContainTypeVariablesComputed | ObjectFlagsCouldContainTypeVariables if result.objectFlags&(ObjectFlagsMapped|ObjectFlagsAnonymous|ObjectFlagsReference) != 0 { - result.objectFlags |= ObjectFlagsCouldContainTypeVariablesComputed | core.IfElse(resultCouldContainObjectFlags, ObjectFlagsCouldContainTypeVariables, 0) - } else { + setFlagMemoBits(c, key, &result.objectFlags, mask, ObjectFlagsCouldContainTypeVariablesComputed|core.IfElse(resultCouldContainObjectFlags, ObjectFlagsCouldContainTypeVariables, 0)) + } 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) + setFlagMemoBits(c, key, &result.objectFlags, mask, ObjectFlagsCouldContainTypeVariablesComputed) } } } @@ -23158,7 +25379,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: @@ -23185,8 +25406,10 @@ 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.get(c, key) if result == nil { + reports := c.startCurrentNodeErrors() + root.instantiations.begin(c, key) newMapper := newTypeMapper(root.outerTypeParameters, typeArguments) checkType := root.checkType var distributionType *Type @@ -23203,7 +25426,8 @@ func (c *Checker) getConditionalTypeInstantiation(t *Type, mapper *TypeMapper, f } else { result = c.getConditionalType(root, newMapper, forConstraint, alias) } - root.instantiations[key] = result + root.instantiations.setReported(c, key, result, c.endCurrentNodeErrors(reports)) + c.endMemo() } return result } @@ -23247,7 +25471,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.isResolutionInProgress(typeVariable, TypeSystemPropertyNameResolvedBaseConstraint) && c.hasArrayOrTypeTypeConstraint(typeVariable) { return c.instantiateMappedArrayType(s, t, prependTypeMapping(typeVariable, s, m)) } if isTupleType(s) { @@ -23364,18 +25588,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 { @@ -23383,22 +25605,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 { @@ -23500,26 +25719,70 @@ func (c *Checker) tryGetTypeFromTypeNode(node *ast.Node) *Type { } func (c *Checker) getTypeFromTypeNode(node *ast.Node) *Type { - return c.getConditionalFlowTypeOfType(c.getTypeFromTypeNodeWorker(node), node) + 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) + if t := c.peekTypeFromTypeNode(node); t != nil && c.readsWithoutMemo(key) { + return t + } + c.beginMemo(key) + result := c.getTypeFromTypeNodeUncached(node) + c.endMemo() + return result } -func (c *Checker) getTypeFromTypeNodeWorker(node *ast.Node) *Type { +// 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 { + if c.memoActive() { + c.typeNodeLinks.Get(node).resolvedType.begin(c) + result := worker(c, node) + c.endMemo() + return result + } + return worker(c, node) +} + +// peekTypeFromTypeNode returns the type of node if reading it only reads a +// cached result, or nil: for a kind whose type is cached in the node's links, +// at a location where getConditionalFlowTypeOfType leaves it unchanged. +func (c *Checker) peekTypeFromTypeNode(node *ast.Node) *Type { + 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: + links := c.typeNodeLinks.TryGet(node) + if links == nil || links.resolvedType.peek() == nil || isConditionalFlowTypeLocation(node) { + return nil + } + return links.resolvedType.peek() + } + return nil +} + +// 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: @@ -23544,6 +25807,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: @@ -23594,10 +25883,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.get(c) == nil { + links.resolvedType.set(c, c.getThisType(node)) } - return links.resolvedType + return links.resolvedType.get(c) } func (c *Checker) getThisType(node *ast.Node) *Type { @@ -23619,66 +25908,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.get(c) == nil { + links.resolvedType.set(c, c.getRegularTypeOfLiteralType(c.checkExpression(node.AsLiteralTypeNode().Literal))) } - return links.resolvedType + return links.resolvedType.get(c) } func (c *Checker) getTypeFromTypeLiteralOrFunctionOrConstructorTypeNode(node *ast.Node) *Type { links := c.typeNodeLinks.Get(node) - if links.resolvedType == nil { + if links.resolvedType.get(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.get(c) } func (c *Checker) getTypeFromIndexedAccessTypeNode(node *ast.Node) *Type { links := c.typeNodeLinks.Get(node) - if links.resolvedType == nil { + if links.resolvedType.get(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.get(c) } func (c *Checker) getTypeFromTypeOperatorNode(node *ast.Node) *Type { links := c.typeNodeLinks.Get(node) - if links.resolvedType == nil { + if links.resolvedType.get(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.get(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) @@ -23687,7 +25976,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 } @@ -23697,19 +25986,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.get(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.get(c) } func (c *Checker) getDistributedTypeParameter(node *ast.Node, t *Type) *Type { @@ -23731,15 +26026,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 } @@ -23806,13 +26103,23 @@ func (c *Checker) getIntendedTypeFromJSDocTypeReference(node *ast.Node) *Type { } func (c *Checker) getSymbolFromTypeReference(node *ast.Node) *ast.Symbol { + if c.memoActive() { + c.symbolNodeLinks.Get(node).resolvedSymbol.begin(c) + result := c.getSymbolFromTypeReferenceCached(node) + c.endMemo() + return result + } + return c.getSymbolFromTypeReferenceCached(node) +} + +func (c *Checker) getSymbolFromTypeReferenceCached(node *ast.Node) *ast.Symbol { links := c.symbolNodeLinks.Get(node) - if links.resolvedSymbol == nil { + if links.resolvedSymbol.get(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.get(c) } func (c *Checker) resolveTypeReferenceName(typeReference *ast.Node, meaning ast.SymbolFlags, ignoreErrors bool) *ast.Symbol { @@ -23855,12 +26162,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 } @@ -24108,10 +26415,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. @@ -24313,16 +26621,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) @@ -24384,13 +26692,13 @@ 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 { - mapper := newTypeMapper(typeParameters, c.fillMissingTypeArguments(typeArguments, typeParameters, c.getMinTypeArgumentCount(typeParameters), ast.IsInJSFile(symbol.ValueDeclaration()))) - instantiation = c.instantiateTypeWithAlias(t, mapper, alias) - links.instantiations[key] = instantiation + if instantiation, _ := links.instantiations.get(c, key); instantiation != nil { + return instantiation } - return instantiation + return links.instantiations.compute(c, key, func() *Type { + mapper := newTypeMapper(typeParameters, c.fillMissingTypeArguments(typeArguments, typeParameters, c.getMinTypeArgumentCount(typeParameters), ast.IsInJSFile(symbol.ValueDeclaration()))) + return c.instantiateTypeWithAlias(t, mapper, alias) + }) } func isLocalTypeAlias(symbol *ast.Symbol) bool { @@ -24399,6 +26707,17 @@ func isLocalTypeAlias(symbol *ast.Symbol) bool { } func (c *Checker) getDeclaredTypeOfSymbol(symbol *ast.Symbol) *Type { + key := memoKeyOf(symbol, memoDeclaredType) + if t := c.peekDeclaredTypeOfSymbol(symbol); 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 @@ -24406,6 +26725,22 @@ func (c *Checker) getDeclaredTypeOfSymbol(symbol *ast.Symbol) *Type { return result } +// peekDeclaredTypeOfSymbol returns the declared type of symbol if it is +// resolved, or nil. +func (c *Checker) peekDeclaredTypeOfSymbol(symbol *ast.Symbol) *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 { + return 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 { + return links.declaredType.peek() + } + } + return nil +} + func (c *Checker) tryGetDeclaredTypeOfSymbol(symbol *ast.Symbol) *Type { switch { case symbol.Flags()&(ast.SymbolFlagsClass|ast.SymbolFlagsInterface) != 0: @@ -24507,9 +26842,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 { @@ -24569,20 +26903,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.get(c) == nil { + links.declaredType.setIdentity(c, c.newTypeParameter(symbol)) } - return links.declaredType + return links.declaredType.get(c) } func (c *Checker) getDeclaredTypeOfTypeAlias(symbol *ast.Symbol) *Type { links := c.typeAliasLinks.Get(symbol) - if links.declaredType == nil { + if links.declaredType.get(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) { return c.errorType } + reports := c.startCurrentNodeErrors() declaration := core.Find(symbol.Declarations(), ast.IsTypeOrJSTypeAliasDeclaration) typeNode := declaration.Type() t := c.getTypeFromTypeNode(typeNode) @@ -24592,8 +26927,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() @@ -24606,16 +26940,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.get(c) } func (c *Checker) getDeclaredTypeOfEnum(symbol *ast.Symbol) *Type { links := c.declaredTypeLinks.Get(symbol) - if !(links.declaredType != nil) { + if !(links.declaredType.get(c) != nil) { var memberTypeList []*Type for _, declaration := range symbol.Declarations() { if declaration.Kind == ast.KindEnumDeclaration { @@ -24629,7 +26965,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) } } @@ -24645,9 +26981,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.get(c) } func (c *Checker) getEnumMemberValue(node *ast.Node) evaluator.Result { @@ -24667,19 +27003,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.get(c) != nil) { enumType := c.getDeclaredTypeOfEnum(c.getParentOfSymbol(symbol)) - if links.declaredType == nil { - links.declaredType = enumType + if links.declaredType.get(c) == nil { + links.declaredType.setIdentity(c, enumType) } } - return links.declaredType + return links.declaredType.get(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() { @@ -24756,8 +27098,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 } @@ -24834,36 +27174,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.get(c) == nil { + links.declaredType.set(c, c.getDeclaredTypeOfSymbol(c.resolveAlias(symbol))) } - return links.declaredType + return links.declaredType.get(c) } func (c *Checker) getTypeFromTypeQueryNode(node *ast.Node) *Type { links := c.typeNodeLinks.Get(node) - if links.resolvedType == nil { + if links.resolvedType.get(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.get(c) } func (c *Checker) getTypeFromArrayOrTupleTypeNode(node *ast.Node) *Type { links := c.typeNodeLinks.Get(node) - if links.resolvedType == nil { + if links.resolvedType.get(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 @@ -24873,13 +27214,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.createNormalizedTupleTypeEx(target, elementTypes, ObjectFlagsFromTypeNode)) } else { - links.resolvedType = c.createTypeReferenceEx(target, elementTypes, ObjectFlagsFromTypeNode) + links.resolvedType.set(c, c.createTypeReferenceEx(target, elementTypes, ObjectFlagsFromTypeNode)) } } } - return links.resolvedType + return links.resolvedType.get(c) } func (c *Checker) isVariadicTupleElement(node *ast.Node) bool { @@ -24904,14 +27245,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.get(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.get(c) } func (c *Checker) getTypeFromRestTypeNode(node *ast.Node) *Type { @@ -24949,16 +27290,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.get(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.get(c) } func (c *Checker) getTypeFromIntersectionTypeNode(node *ast.Node) *Type { links := c.typeNodeLinks.Get(node) - if links.resolvedType == nil { + if links.resolvedType.get(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, @@ -24972,14 +27313,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.get(c) } func (c *Checker) getTypeFromTemplateTypeNode(node *ast.Node) *Type { links := c.typeNodeLinks.Get(node) - if links.resolvedType == nil { + if links.resolvedType.get(c) == nil { spans := node.AsTemplateLiteralTypeNode().TemplateSpans texts := make([]string, len(spans.Nodes)+1) types := make([]*Type, len(spans.Nodes)) @@ -24988,28 +27329,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.get(c) } func (c *Checker) getTypeFromMappedTypeNode(node *ast.Node) *Type { links := c.typeNodeLinks.Get(node) - if links.resolvedType == nil { + if links.resolvedType.get(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.get(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.get(c) == nil { checkType := c.getTypeFromTypeNode(node.AsConditionalTypeNode().CheckType) alias := c.getAliasForTypeNode(node) allOuterTypeParameters := c.getOuterTypeParameters(node, true /*includeThisTypes*/) @@ -25026,16 +27370,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.get(c)) } } - return links.resolvedType + return links.resolvedType.get(c) } func (c *Checker) getConditionalType(root *ConditionalRoot, mapper *TypeMapper, forConstraint bool, alias *TypeAlias) *Type { @@ -25049,7 +27391,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) @@ -25222,11 +27564,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.get(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 } @@ -25235,31 +27579,41 @@ 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.get(c, key); cached != nil { return cached } + c.cachedTypes.begin(c, key) result := c.instantiateType(t, c.restrictiveMapper) - c.cachedTypes[key] = result + c.cachedTypes.set(c, key, result) + c.endMemo() // 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.intern(CachedTypeKey{kind: CachedTypeKindRestrictiveInstantiation, typeId: result.id}, result) return result } +// isRestrictiveInstantiation reports whether t is the result of a restrictive +// instantiation, which is recorded purely from its construction. +func (c *Checker) isRestrictiveInstantiation(t *Type) bool { + r, _ := c.cachedTypes.get(c, CachedTypeKey{kind: CachedTypeKindRestrictiveInstantiation, typeId: t.id}) + return r == t +} + func (c *Checker) getRestrictiveTypeParameter(t *Type) *Type { - if t.AsTypeParameter().constraint == nil && c.getConstraintDeclaration(t) == nil || t.AsTypeParameter().constraint == c.noConstraintType { + if t.AsTypeParameter().constraint.get(c) == nil && c.getConstraintDeclaration(t) == nil || t.AsTypeParameter().constraint.get(c) == c.noConstraintType { return t } key := CachedTypeKey{kind: CachedTypeKindRestrictiveTypeParameter, typeId: t.id} - if cached := c.cachedTypes[key]; cached != nil { + if cached, _ := c.cachedTypes.get(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 } @@ -25279,57 +27633,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.get(c) == nil { + links.resolvedType.set(c, c.getDeclaredTypeOfTypeParameter(c.getSymbolOfDeclaration(node.AsInferTypeNode().TypeParameter))) } - return links.resolvedType + return links.resolvedType.get(c) } func (c *Checker) getTypeFromImportTypeNode(node *ast.Node) *Type { links := c.typeNodeLinks.Get(node) - if links.resolvedType == nil { + if links.resolvedType.get(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.get(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.get(c) } moduleSymbol := c.resolveExternalModuleSymbol(innerModuleSymbol, false /*dontResolveAlias*/) if !ast.NodeIsMissing(n.Qualifier) { @@ -25364,28 +27714,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.get(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.get(c) } func (c *Checker) getIdentifierChain(node *ast.Node) []*ast.Node { @@ -25397,7 +27747,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) @@ -25421,18 +27771,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.get(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 { @@ -25498,10 +27852,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 } @@ -25530,7 +27884,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) } @@ -25539,25 +27893,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 @@ -25621,17 +27977,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 @@ -25677,10 +28036,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 { @@ -25747,7 +28104,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) } @@ -25856,14 +28213,14 @@ func (c *Checker) createTypeReference(target *Type, typeArguments []*Type) *Type 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.get(c, id); ok { return t } t := c.newObjectType(ObjectFlagsReference|objectFlags|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 } @@ -25887,12 +28244,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(source.AsTypeReference().resolvedTypeArguments.peek()) 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) @@ -26010,10 +28373,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 } @@ -26060,10 +28423,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 } @@ -26077,19 +28440,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 } @@ -26126,11 +28489,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 } @@ -26138,11 +28501,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 } @@ -26233,11 +28596,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.get(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 } @@ -26407,10 +28772,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.get(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 } @@ -26511,7 +28878,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 @@ -26519,13 +28886,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) { @@ -26706,9 +29073,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.get(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. @@ -26762,7 +29130,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 } } @@ -26787,7 +29156,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 } @@ -26934,8 +29304,9 @@ func (c *Checker) getIntersectionTypeEx(types []*Type, flags IntersectionFlags, } } key := getIntersectionKey(typeSet, flags, alias) - result := c.intersectionTypes[key] + result, _ := c.intersectionTypes.get(c, key) if result == nil { + c.intersectionTypes.begin(c, key) if includes&TypeFlagsUnion != 0 { var reduced bool typeSet, reduced = c.intersectUnionsOfPrimitiveTypes(typeSet) @@ -26971,6 +29342,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) @@ -26979,16 +29351,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 } @@ -27425,7 +29815,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 @@ -27490,9 +29880,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.get(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) @@ -27513,7 +29904,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 } @@ -27574,23 +29966,40 @@ func isInvalidComputedPropertyName(node *ast.Node) bool { } func (c *Checker) checkComputedPropertyName(node *ast.Node) *Type { + if c.memoActive() { + c.typeNodeLinks.Get(node).resolvedType.begin(c) + result := c.checkComputedPropertyNameUncached(node) + c.endMemo() + return result + } + return c.checkComputedPropertyNameUncached(node) +} + +func (c *Checker) checkComputedPropertyNameUncached(node *ast.Node) *Type { links := c.typeNodeLinks.Get(node) - if links.resolvedType == nil { - links.resolvedType = c.circularConstraintType + if links.resolvedType.get(c) == nil { if isInvalidComputedPropertyName(node) { - links.resolvedType = c.errorType - return links.resolvedType + links.resolvedType.set(c, c.errorType) + return links.resolvedType.get(c) + } + if !c.pushTypeResolution(node, TypeSystemPropertyNameComputedPropertyName) { + return c.errorType + } + t := c.checkExpression(node.Expression()) + c.popTypeResolution() + if links.resolvedType.get(c) != nil { + return links.resolvedType.get(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.get(c).flags&TypeFlagsNullable != 0 || + !c.isTypeAssignableToKind(links.resolvedType.get(c), TypeFlagsStringLike|TypeFlagsNumberLike|TypeFlagsESSymbolLike) && + !c.isTypeAssignableTo(links.resolvedType.get(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.get(c) } func (c *Checker) isNoInferType(t *Type) bool { @@ -27629,11 +30038,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.get(c, key); indexType != nil { return indexType } indexType := c.newIndexType(t, indexFlags&IndexFlagsStringsOnly) - c.cachedTypes[key] = indexType + c.cachedTypes.intern(key, indexType) return indexType } @@ -27733,12 +30142,12 @@ func (c *Checker) getIndexedAccessTypeOrUndefined(objectType *Type, indexType *T } // Defer the operation by creating an indexed access type. persistentAccessFlags := accessFlags & AccessFlagsPersistent - key := getIndexedAccessKey(objectType, indexType, accessFlags, alias) - t := c.indexedAccessTypes[key] + key := getIndexedAccessKey(objectType, indexType, persistentAccessFlags, alias) + 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 } @@ -27811,7 +30220,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 @@ -27910,7 +30319,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)) @@ -28191,11 +30600,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 } @@ -28219,12 +30628,23 @@ func (c *Checker) getBaseConstraintOfType(t *Type) *Type { } func (c *Checker) getResolvedBaseConstraint(t *Type, stack []RecursionId) *Type { + if constrained := t.AsConstrainedType(); constrained != nil && constrained.resolvedBaseConstraint.peek() != nil { + // A resolved base constraint is only read. + return constrained.resolvedBaseConstraint.get(c) + } + c.beginMemo(memoKeyOf(t, memoBaseConstraint)) + result := c.getResolvedBaseConstraintUncached(t, stack) + c.endMemo() + return result +} + +func (c *Checker) getResolvedBaseConstraintUncached(t *Type, stack []RecursionId) *Type { constrained := t.AsConstrainedType() if constrained == nil { return t } - if constrained.resolvedBaseConstraint != nil { - return constrained.resolvedBaseConstraint + if constrained.resolvedBaseConstraint.get(c) != nil { + return constrained.resolvedBaseConstraint.get(c) } if !c.pushTypeResolution(t, TypeSystemPropertyNameResolvedBaseConstraint) { return c.circularConstraintType @@ -28236,7 +30656,7 @@ 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) + identity := c.getRecursionIdentity(t) if len(stack) < 10 || len(stack) < 50 && !slices.Contains(stack, identity) { constraint = c.computeBaseConstraint(c.getSimplifiedType(t /*writing*/, false), append(stack, identity)) } @@ -28244,10 +30664,21 @@ func (c *Checker) getResolvedBaseConstraint(t *Type, stack []RecursionId) *Type 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 @@ -28255,8 +30686,8 @@ func (c *Checker) getResolvedBaseConstraint(t *Type, stack []RecursionId) *Type if constraint == nil { constraint = c.noConstraintType } - if constrained.resolvedBaseConstraint == nil { - constrained.resolvedBaseConstraint = constraint + if constrained.resolvedBaseConstraint.get(c) == nil { + constrained.resolvedBaseConstraint.set(c, constraint) } return constraint } @@ -28334,12 +30765,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.conditionalConstraintDepth.exit() return c.getNextBaseConstraint(constraint, stack) case t.flags&TypeFlagsSubstitution != 0: return c.getNextBaseConstraint(c.getSubstitutionIntersection(t), stack) @@ -28500,7 +30931,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 { @@ -28520,9 +30951,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) } @@ -28576,14 +31007,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 } @@ -28698,16 +31131,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.get(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) 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 } @@ -28789,11 +31230,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.get(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 } @@ -28883,10 +31326,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.get(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) @@ -28914,36 +31364,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 { @@ -28955,15 +31401,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.get(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 } @@ -28973,7 +31430,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) } @@ -29370,6 +31827,45 @@ 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 + } + links := c.sourceFileLinks.Get(sourceFile) + if links.typeChecked { + 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 @@ -29615,8 +32111,23 @@ func (c *Checker) markAliasReferenced(symbol *ast.Symbol, location *ast.Node) { // 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). func (c *Checker) markAliasSymbolAsReferenced(symbol *ast.Symbol) { + if !c.checking { + c.recordReferenceMark(symbol) + return + } + c.referenceAliasSymbol(symbol) +} + +func (c *Checker) referenceAliasSymbol(symbol *ast.Symbol) { links := c.aliasSymbolLinks.Get(symbol) - if !links.referenced { + // Emit marks references too (see withReferenceMarks), but reports + // nothing, so checking must still follow them once to report errors. + followed := links.referenced + if c.checking { + followed = links.referenceChecked + links.referenceChecked = true + } + if !followed { links.referenced = true node := c.getDeclarationOfAliasSymbol(symbol) if node == nil { @@ -29728,13 +32239,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.get(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) { @@ -29786,9 +32313,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 { @@ -29995,7 +32520,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 @@ -30014,10 +32539,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 } @@ -30087,10 +32612,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 } @@ -30280,8 +32805,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): @@ -30291,7 +32815,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) @@ -30596,7 +33120,7 @@ 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. var signature *Signature - if c.signatureLinks.Get(callTarget).resolvedSignature == c.resolvingSignature { + if links := c.signatureLinks.Get(callTarget); links.resolvedSignature.get(c) == c.resolvingSignature && !c.isSignatureResolutionHidden(links) { signature = c.resolvingSignature } else { signature = c.getResolvedSignature(callTarget, nil, CheckModeNormal) @@ -30641,7 +33165,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 @@ -30975,15 +33499,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.get(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 @@ -31008,7 +33533,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 @@ -31027,16 +33552,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.get(c) == c.anySignature { return nil } - return links.decoratorSignature + return links.decoratorSignature.get(c) } func (c *Checker) getESDecoratorCallSignature(decorator *ast.Node) *Signature { @@ -31122,15 +33648,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.get(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 @@ -31171,7 +33698,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 @@ -31208,13 +33735,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.get(c) == c.anySignature { return nil } - return links.decoratorSignature + return links.decoratorSignature.get(c) } func (c *Checker) newClassDecoratorContextType(classType *Type) *Type { @@ -31250,7 +33778,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.get(c, key); overrideType != nil { return overrideType } members := ast.NewSymbolTable() @@ -31258,7 +33786,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 } @@ -31424,7 +33952,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) @@ -31476,7 +34004,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 links.resolvedType.get(c) == nil && c.isResolutionInProgress(symbol, TypeSystemPropertyNameType) } return false } @@ -31567,9 +34095,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.get(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 { @@ -31591,7 +34120,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 } @@ -31957,7 +34487,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 { @@ -32090,32 +34620,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.get(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.get(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 @@ -32149,6 +34700,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) } @@ -32156,13 +34708,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. @@ -32181,6 +34729,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 { @@ -32190,10 +34739,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) +} + +// 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() @@ -32453,7 +35013,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 @@ -32487,7 +35047,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: @@ -32686,13 +35246,19 @@ func (c *Checker) getSymbolOfNameOrPropertyAccessExpression(name *ast.Node) *ast 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 links.resolvedSymbol.get(c) != nil { + return links.resolvedSymbol.get(c) } + // 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) if ast.IsPropertyAccessExpression(name) { c.checkPropertyAccessExpression(name, CheckModeNormal, false /*writeOnly*/) - if links.resolvedSymbol == nil && !ast.IsPrivateIdentifier(name.Name()) { - links.resolvedSymbol = c.getApplicableIndexSymbol( + if links.resolvedSymbol.get(c) == nil && !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()), ) @@ -32700,10 +35266,10 @@ func (c *Checker) getSymbolOfNameOrPropertyAccessExpression(name *ast.Node) *ast } else { c.checkQualifiedName(name, CheckModeNormal) } - if links.resolvedSymbol == nil && isJSDoc && ast.IsQualifiedName(name) { + if links.resolvedSymbol.get(c) == nil && isJSDoc && ast.IsQualifiedName(name) { return c.resolveJSDocMemberName(name) } - return links.resolvedSymbol + return links.resolvedSymbol.get(c) } } else if ast.IsEntityName(name) && isTypeReferenceIdentifier(name) { meaning := core.IfElse(name.Parent.Kind == ast.KindTypeReference, ast.SymbolFlagsType, ast.SymbolFlagsNamespace) @@ -32920,7 +35486,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 } } @@ -32941,9 +35507,10 @@ func (c *Checker) containsArgumentsReference(node *ast.Node) bool { return false } - if containsArguments, ok := c.cachedArgumentsReferenced[node]; ok { + if containsArguments, ok := c.cachedArgumentsReferenced.get(c, node); ok { return containsArguments } + c.cachedArgumentsReferenced.begin(c, node) var visit func(node *ast.Node) bool visit = func(node *ast.Node) bool { @@ -32969,7 +35536,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 42ae368d35924..53c48fc111d6a 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" @@ -177,6 +181,46 @@ 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 := compiler.NewProgram(compiler.ProgramOptions{Config: parsed, Host: host}) + 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 @@ -208,3 +252,467 @@ 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) + 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 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) + if !ok || slices.Contains(notCacheOwners, spec.Name.Name) || name != "types.go" && !strings.HasSuffix(spec.Name.Name, "Links") && spec.Name.Name != "memoStore" && !interned[spec.Name.Name] { + return true + } + for _, field := range st.Fields.List { + if isMemoType(field.Type) { + continue + } + for _, fieldName := range field.Names { + key := spec.Name.Name + "." + fieldName.Name + seen[key] = true + 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) + } + } +} + +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" + 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"} + +var unmemoizedCacheFields = map[string]string{ + "valueSymbolExtra.nameType": unmemoizedCreated, + "valueSymbolExtra.containingType": unmemoizedCreated, + "TypeAlias.symbol": unmemoizedCreated, + "TypeAlias.typeArguments": unmemoizedCreated, + "Type.flags": unmemoizedCreated, + "Type.objectFlags": unmemoizedEntityFlags, + "Type.id": unmemoizedCounter, + "Type.kind": unmemoizedCreated, + "Type.generation": unmemoizedDerived, + "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.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.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, + "AliasSymbolLinks.referenceChecked": unmemoizedChecking, + "SourceFileLinks.typeChecked": unmemoizedChecking, + "SourceFileLinks.unusedChecked": unmemoizedChecking, + "SourceFileLinks.deferredNodes": unmemoizedChecking, + "SourceFileLinks.identifierCheckNodes": unmemoizedChecking, + "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, + "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.isVisible": unmemoizedEmit, + "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/emitresolver.go b/tsc/internal/checker/emitresolver.go index e4fad5c3f5b1f..7223d5d4b9167 100644 --- a/tsc/internal/checker/emitresolver.go +++ b/tsc/internal/checker/emitresolver.go @@ -398,7 +398,7 @@ func (r *EmitResolver) IsReferencedAliasDeclaration(node *ast.Node) bool { if aliasLinks.referenced { return true } - target := aliasLinks.aliasTarget + target := aliasLinks.aliasTarget.get(c) if target != nil && node.ModifierFlags()&ast.ModifierFlagsExport != 0 && c.getSymbolFlags(target)&ast.SymbolFlagsValue != 0 && (c.compilerOptions.ShouldPreserveConstEnums() || !isConstEnumOrConstEnumOnlyModule(target)) { @@ -502,6 +502,12 @@ func (r *EmitResolver) MarkLinkedReferencesRecursively(file *ast.SourceFile) { defer r.checkerMu.Unlock() if file != nil { + r.checker.withReferenceMarks(func() { r.markLinkedReferencesRecursively(file) }) + } +} + +func (r *EmitResolver) markLinkedReferencesRecursively(file *ast.SourceFile) { + { var visit ast.Visitor visit = func(n *ast.Node) bool { if ast.IsImportEqualsDeclaration(n) && n.ModifierFlags()&ast.ModifierFlagsExport == 0 { diff --git a/tsc/internal/checker/flow.go b/tsc/internal/checker/flow.go index 05daef984819d..d8a0632d00dce 100644 --- a/tsc/internal/checker/flow.go +++ b/tsc/internal/checker/flow.go @@ -35,6 +35,9 @@ func (c *Checker) newFlowType(t *Type, incomplete bool) FlowType { type SharedFlow struct { flow *ast.FlowNode flowType FlowType + // loopFrame is the flow loop stack frame that was on top when flowType was + // computed, or zero when the stack was empty. + loopFrame uint64 } type FlowState struct { @@ -44,6 +47,7 @@ type FlowState struct { flowContainer *ast.Node refKey CacheHashKey depth int + limitHits int sharedFlowStart int reduceLabels []*ast.FlowReduceLabelData next *FlowState @@ -79,9 +83,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 +97,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 +120,64 @@ func (c *Checker) getFlowTypeOfReferenceEx(reference *ast.Node, declaredType *Ty return resultType } +const maxFlowDepth = 2000 + 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. + budget := maxFlowDepth - f.depth + remember := len(c.flowLoopStack) == 0 && len(f.reduceLabels) == 0 + if remember && len(c.flowDepthFailures) != 0 && c.hasFlowReferenceKey(f) { + if b, ok := c.flowDepthFailures[FlowLoopKey{flowNode: flow, refKey: f.refKey}]; ok && budget <= b { + f.limitHits++ + c.reportFlowControlError(f.reference) + return FlowType{t: c.errorType} + } + } + hits := f.limitHits + t := c.getTypeAtFlowNodeWorker(f, flow) + if f.limitHits != hits && remember && c.hasFlowReferenceKey(f) { + 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.discardLog = append(c.discardLog, discardEntry{nil, func() { + if ok { + c.flowDepthFailures[key] = b + } else { + delete(c.flowDepthFailures, key) + } + }, false}) + } + c.flowDepthFailures[key] = budget + } + } + return t +} + +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 { // 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 +190,13 @@ 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 { + // An incomplete type computed under a loop back edge that has since been + // exited reflects that loop's partial types, so it is no longer valid. + // Reusing it would make the result depend on which reference was + // analyzed first. + if s := &c.sharedFlows[i]; s.flow == flow && (!s.flowType.incomplete || c.isFlowLoopFrameActive(s.loopFrame)) { f.depth-- - return c.sharedFlows[i].flowType + return s.flowType } } sharedFlow = flow @@ -198,7 +258,7 @@ func (c *Checker) getTypeAtFlowNode(f *FlowState, flow *ast.FlowNode) FlowType { } if sharedFlow != nil { // Record visited node and the associated type in the cache. - c.sharedFlows = append(c.sharedFlows, SharedFlow{flow: sharedFlow, flowType: t}) + c.sharedFlows = append(c.sharedFlows, SharedFlow{flow: sharedFlow, flowType: t, loopFrame: c.currentFlowLoopFrame()}) } f.depth-- return t @@ -383,14 +443,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.inlineLevel.exit() return result } } @@ -848,11 +908,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.get(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 } @@ -1322,6 +1384,17 @@ func (c *Checker) getUnionOrEvolvingArrayType(f *FlowState, types []*Type, subty return result } +func (c *Checker) currentFlowLoopFrame() uint64 { + if len(c.flowLoopStack) == 0 { + return 0 + } + return c.flowLoopStack[len(c.flowLoopStack)-1].id +} + +func (c *Checker) isFlowLoopFrameActive(id uint64) bool { + return id == 0 || slices.ContainsFunc(c.flowLoopStack, func(info FlowLoopInfo) bool { return info.id == id }) +} + func (c *Checker) getTypeAtFlowLoopLabel(f *FlowState, flow *ast.FlowNode) FlowType { if f.refKey.IsZero() { f.refKey = c.getFlowReferenceKey(f) @@ -1331,10 +1404,22 @@ 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) + } + c.beginMemo(memoKeyOf(entry, memoFlowLoopType)) + result := c.getTypeAtFlowLoopLabelCached(f, flow, key, entry) + c.endMemo() + return result +} + +func (c *Checker) getTypeAtFlowLoopLabelCached(f *FlowState, flow *ast.FlowNode, key FlowLoopKey, entry *flowLoopCacheEntry) FlowType { // 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 { + return FlowType{t: entry.t} } // 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. @@ -1364,7 +1449,8 @@ 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. - c.flowLoopStack = append(c.flowLoopStack, FlowLoopInfo{key: key, types: antecedentTypes}) + c.flowLoopFrameCount++ + c.flowLoopStack = append(c.flowLoopStack, FlowLoopInfo{key: key, types: antecedentTypes, id: c.flowLoopFrameCount}) saveFlowTypeCache := c.flowTypeCache c.flowTypeCache = nil flowType = c.getTypeAtFlowNode(f, list.Flow) @@ -1373,8 +1459,8 @@ func (c *Checker) getTypeAtFlowLoopLabel(f *FlowState, flow *ast.FlowNode) FlowT // 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 +1483,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 +1597,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.get(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 +1660,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 { @@ -1944,18 +2030,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.get(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.get(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.get(c) == ExhaustiveStateTrue } func (c *Checker) computeExhaustiveSwitchStatement(node *ast.Node) bool { @@ -2037,16 +2126,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.get(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.get(c) } func (c *Checker) getTypeOfSwitchClause(clause *ast.Node) *Type { @@ -2058,8 +2148,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.get(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 +2182,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 +2258,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) + defer c.popTypeResolution() if symbol.Flags()&(ast.SymbolFlagsFunction|ast.SymbolFlagsMethod|ast.SymbolFlagsClass|ast.SymbolFlagsValueModule) != 0 { return c.getTypeOfSymbol(symbol) } @@ -2274,7 +2367,7 @@ func (c *Checker) getTypeOfInitializer(node *ast.Node) *Type { // 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 + t := c.typeNodeLinks.Get(node).resolvedType.get(c) if t != nil { return t } @@ -2416,10 +2509,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.get(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 +2621,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.get(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 +2726,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.get(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() } noCacheCheck = false } @@ -2688,18 +2791,16 @@ func (c *Checker) ensureAssignmentsMarked(symbol *ast.Symbol) { if parent == nil { return } - links := c.nodeLinks.Get(parent) - if links.flags&NodeCheckFlagsAssignmentsMarked == 0 { - links.flags |= NodeCheckFlagsAssignmentsMarked + c.assignmentsMarked.once(c, parent, func() { 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 + return ast.IsFunctionOrSourceFile(node) && c.assignmentsMarked.has(c, node) }) != nil } diff --git a/tsc/internal/checker/grammarchecks.go b/tsc/internal/checker/grammarchecks.go index 93bed4b355296..5465144583732 100644 --- a/tsc/internal/checker/grammarchecks.go +++ b/tsc/internal/checker/grammarchecks.go @@ -2026,13 +2026,20 @@ func (c *Checker) checkGrammarSourceFile(node *ast.SourceFile) bool { return node.Flags&ast.NodeFlagsAmbient != 0 && c.checkGrammarTopLevelElementsForRequiredDeclareModifier(node) } +func (c *Checker) reportStatementInAmbientContext(links *NodeLinks, node *ast.Node, message *diagnostics.Message) bool { + links.hasReportedStatementInAmbientContext.begin(c) + reported := c.grammarErrorOnFirstToken(node, message) + links.hasReportedStatementInAmbientContext.set(c, reported) + c.endMemo() + return reported +} + 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 !links.hasReportedStatementInAmbientContext.get(c) && (ast.IsFunctionLike(node.Parent) || ast.IsAccessor(node.Parent)) { + return c.reportStatementInAmbientContext(links, node, diagnostics.An_implementation_cannot_be_declared_in_ambient_contexts) } // We are either parented by another statement, or some sort of block. @@ -2043,9 +2050,8 @@ func (c *Checker) checkGrammarStatementInAmbientContext(node *ast.Node) bool { 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 + if !links.hasReportedStatementInAmbientContext.get(c) { + return c.reportStatementInAmbientContext(links, node, diagnostics.Statements_are_not_allowed_in_ambient_contexts) } } else { // We must be parented by a statement. If so, there's no need diff --git a/tsc/internal/checker/inference.go b/tsc/internal/checker/inference.go index 8b0cc87aedef4..27ddc6aed15e6 100644 --- a/tsc/internal/checker/inference.go +++ b/tsc/internal/checker/inference.go @@ -285,11 +285,11 @@ func (c *Checker) inferFromAliasTypeArguments(n *InferenceState, source *Type, t nodeIsInJsFile := ast.IsInJSFile(source.alias.symbol.ValueDeclaration()) sourceTypes := c.fillMissingTypeArguments(source.alias.typeArguments, params, minParams, nodeIsInJsFile) targetTypes := c.fillMissingTypeArguments(target.alias.typeArguments, params, minParams, nodeIsInJsFile) - c.inferFromTypeArguments(n, sourceTypes, targetTypes, c.getAliasVariances(source.alias.symbol)) + c.inferFromTypeArguments(n, sourceTypes, targetTypes, c.getVariancesForInference(func() []VarianceFlags { return c.getAliasVariances(source.alias.symbol) })) } func (c *Checker) inferFromReferenceTypeArguments(n *InferenceState, source *Type, target *Type) { - c.inferFromTypeArguments(n, c.getTypeArguments(source), c.getTypeArguments(target), c.getVariances(source.AsTypeReference().target)) + c.inferFromTypeArguments(n, c.getTypeArguments(source), c.getTypeArguments(target), c.getVariancesForInference(func() []VarianceFlags { return c.getVariances(source.AsTypeReference().target) })) } func (c *Checker) inferFromTypeArguments(n *InferenceState, sourceTypes []*Type, targetTypes []*Type, variances []VarianceFlags) { @@ -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.get(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.get(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,16 @@ 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] c.reverseExpandingFlags = saveExpandingFlags - c.reverseMappedCache[key] = t + c.reverseMappedCache.set(c, key, t) + c.endMemo() return t } @@ -1155,16 +1166,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.get(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.get(c) } // If the original mapped type had an intersection constraint we extract its components, @@ -1250,7 +1261,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()) diff --git a/tsc/internal/checker/jsx.go b/tsc/internal/checker/jsx.go index 1054f4d46f8c5..02c7ed54d54e1 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.get(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.get(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.set(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.set(c, childTypes[0]) case childrenContextualType != nil && someType(childrenContextualType, c.isTupleLikeType): - links.resolvedType = c.createTupleType(childTypes) + links.resolvedType.set(c, c.createTupleType(childTypes)) default: - links.resolvedType = c.createArrayType(c.getUnionType(childTypes)) + links.resolvedType.set(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.set(c, result) return c.newSignature(SignatureFlagsNone, nil, nil, nil, []*ast.Symbol{parameterSymbol}, elementType, nil, 1) } @@ -1188,23 +1193,34 @@ 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.get(c); t != nil { + return t } + if c.memoActive() { + links.resolvedJsxElementAttributesType.begin(c) + result := c.getIntrinsicAttributesTypeFromJsxOpeningLikeElementUncached(node, links) + c.endMemo() + return result + } + return c.getIntrinsicAttributesTypeFromJsxOpeningLikeElementUncached(node, links) +} + +func (c *Checker) getIntrinsicAttributesTypeFromJsxOpeningLikeElementUncached(node *ast.Node, links *JsxElementLinks) *Type { + if t := links.resolvedJsxElementAttributesType.get(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 +1228,25 @@ 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 { + if c.memoActive() { + c.symbolNodeLinks.Get(node).resolvedSymbol.begin(c) + result := c.getIntrinsicTagSymbolUncached(node) + c.endMemo() + return result + } + return c.getIntrinsicTagSymbolUncached(node) +} + +// 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.get(c) != nil { + return links.resolvedSymbol.get(c) } intrinsicElementsType := c.getJsxType(JsxNames.IntrinsicElements, node) if !c.isErrorType(intrinsicElementsType) { @@ -1226,32 +1258,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.get(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.get(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.get(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.get(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.get(c) } func (c *Checker) getJsxStatelessElementTypeAt(location *ast.Node) *Type { @@ -1302,14 +1334,31 @@ 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) + } + links := c.jsxElementLinks.Get(location) + if s := links.jsxNamespace.get(c); s != nil && s != c.unknownSymbol { + return s } - if links != nil && links.jsxNamespace != nil && links.jsxNamespace != c.unknownSymbol { - return links.jsxNamespace + if c.memoActive() { + links.jsxNamespace.begin(c) + result := c.getJsxNamespaceAtUncached(location, links) + c.endMemo() + return result + } + return c.getJsxNamespaceAtUncached(location, links) +} + +func (c *Checker) getJsxNamespaceAtUncached(location *ast.Node, links *JsxElementLinks) *ast.Symbol { + var cached *ast.Symbol + if links != nil { + cached = links.jsxNamespace.get(c) + if cached != nil && cached != c.unknownSymbol { + return cached + } } - if links == nil || links.jsxNamespace != c.unknownSymbol { + if cached != c.unknownSymbol { resolvedNamespace := c.getJsxNamespaceContainerForImplicitImport(location) if resolvedNamespace == nil || resolvedNamespace == c.unknownSymbol { namespaceName := c.getJsxNamespace(location) @@ -1319,13 +1368,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 @@ -1449,6 +1498,13 @@ func markAsSynthetic(node *ast.Node) bool { func (c *Checker) getJsxNamespaceContainerForImplicitImport(location *ast.Node) *ast.Symbol { file := ast.GetSourceFileOfNode(location) links := c.jsxElementLinks.Get(file.AsNode()) + c.beginMemo(memoKeyOf(links, memoJsxImplicitImportContainer)) + result := c.getJsxNamespaceContainerForImplicitImportCached(file, links) + c.endMemo() + return result +} + +func (c *Checker) getJsxNamespaceContainerForImplicitImportCached(file *ast.SourceFile, links *JsxElementLinks) *ast.Symbol { if links.jsxImplicitImportContainer != nil { return core.IfElse(links.jsxImplicitImportContainer == c.unknownSymbol, nil, links.jsxImplicitImportContainer) } @@ -1479,7 +1535,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/memo.go b/tsc/internal/checker/memo.go new file mode 100644 index 0000000000000..b29b356fd165d --- /dev/null +++ b/tsc/internal/checker/memo.go @@ -0,0 +1,2133 @@ +package checker + +import ( + "iter" + "maps" + "math/bits" + "slices" + "unsafe" + + "github.com/microsoft/TypeScript/tsc/internal/ast" + + "github.com/microsoft/TypeScript/tsc/internal/debug" +) + +// 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 + memoTypeAlias + memoEnumMemberValue + memoBaseConstraint + memoAccessorType + memoContextualParameters + memoContextChecked + memoInitializerIsUndefined + memoFlowExpressionType + memoFlowLoopType + memoJsxImplicitImportContainer + memoModuleExports + memoInstantiationExpressionType + memoTypePredicate + memoDeclaredMembers + memoCouldContainTypeVariables + memoGenericObjectFlags + memoUnknownLikeUnion + memoNeverIntersection + memoDiscriminant + 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 + // The computation publishes a partial result before it finishes, and + // re-entry observes that partial result. Results derived from it may + // differ depending on which computation starts first. + reentryPartial +) + +// memoReentry is the re-entry policy of 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 except by symbol, whose entity outlives the key. + return memoKey(uint64(uintptr(unsafe.Pointer(entity)))<<8 | uint64(field)) +} + +// symbol returns the symbol identified by a key of a symbol's memo field. +func (k memoKey) symbol() *ast.Symbol { + p := uintptr(k >> 8) + // SAFETY: k was made by memoKeyOf from a symbol that lives as long as the + // program or checker store, which outlives every key made from it, so the + // address still points to that symbol. + return *(**ast.Symbol)(unsafe.Pointer(&p)) +} + +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 + replayed 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 { + marks []*ast.Symbol // Aliases marked referenced, also among effects; see withReferenceMarks + cycles []memoCycleDep // The cycle heads memoCycle added to deps, from highest to lowest +} + +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) +} + +// get returns the cached result, accounting for the effects of computing it. +func (m *memo[T]) get(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]) get(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.discardLog = append(c.discardLog, discardEntry{&m.memoHeader, func() { + m.memoValue = old + }, false}) +} + +// 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 +} + +// exchange 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 +} + +// init 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 +} + +// enter 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.get(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 + resolvingKeys []K // Keys of computations in progress without a memo state yet + resolvingAt []int32 // Index in Checker.resolutions of each + // The occurrences of each key in resolvingKeys, kept while there are + // many, so that looking one up does not scan them all. + resolvingCount map[K]resolvingOccurrences + // 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 []uint64 + hasErrors bool // Whether an entry ever had reports; see setReported +} + +func (m *memoMap[K, V]) sideTable() *memoMapSide[K] { + if m.side == nil { + m.side = &memoMapSide[K]{} + } + return m.side +} + +// 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 +} + +// states returns the memo states of the entries, or nil. +func (m *memoMap[K, V]) states() map[K]*memoState { + if m.side == nil { + return nil + } + return m.side.memoStates +} + +const memoMapStateFilterBits = 20 + +// 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 { + if i := s.keyBits(k) >> (64 - memoMapStateFilterBits); s.stateKeys[i/64]&(1<<(i%64)) == 0 { + return nil + } + } + return s.memoStates[k] +} + +// get returns the cached result for k, accounting for the effects of +// computing it. +func (m *memoMap[K, V]) get(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 +} + +// peek returns the cached result for k without observing it, for results +// that are interned and never change. +func (m *memoMap[K, V]) peek(k K) (V, bool) { + 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)) + } +} + +// has reports whether a result is cached for k; see get. +func (m *memoMap[K, V]) has(c *Checker, k K) bool { + _, ok := m.get(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.discardLog = append(c.discardLog, discardEntry{nil, func() { + m.writes++ + if ok { + m.memoEntries[k] = old + } else { + delete(m.memoEntries, k) + } + }, false}) +} + +// 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 +} + +// enter starts the computation of the result for k; see beginMemo. +func (m *memoMap[K, V]) begin(c *Checker, k K) { + side := m.sideTable() + outer := 0 + if len(side.resolvingKeys) != 0 { + outer = m.resolvingIndex(c, k) + } + if outer != 0 { + // Re-entering an entry marks the cycle circular; see reentryCircular. + c.markCircular(outer - 1) + } + side.resolvingKeys = append(side.resolvingKeys, k) + side.resolvingAt = append(side.resolvingAt, int32(len(c.resolutions))) + if side.resolvingCount != nil { + side.countResolving(k, len(side.resolvingKeys)-1) + } else if len(side.resolvingKeys) > resolvingCountMin { + side.countAllResolving() + } + c.beginResolution(m, len(side.resolvingKeys)-1) + if c.checking && c.memoPendingCount == 0 && c.memoTop|c.currentNodeResolution != 0 && !c.logEffects() { + // 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) +} + +// 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 { + if m.side == nil { + return 0 + } + start := 0 + if m.side.resolvingCount != nil { + o, ok := m.side.resolvingCount[k] + if !ok { + return 0 + } + start = int(o.first) + if o.count == 1 { + if j := int(m.side.resolvingAt[start]); j >= c.visibleStart { + return j + 1 + } + return 0 + } + } + for i := start; i < len(m.side.resolvingKeys); i++ { + if m.side.resolvingKeys[i] != k { + continue + } + j := int(m.side.resolvingAt[i]) + debug.Assert(c.resolutions[j].source == memoStateSource(m) && int(c.resolutions[j].index) == i, "entry in progress without a resolution") + if j >= c.visibleStart { + return j + 1 + } + // Hidden; see yieldCycle. + } + 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) { + if counts := m.side.resolvingCount; counts != nil { + if i < resolvingCountMin/4 { + m.side.resolvingCount = nil + } else { + for _, k := range m.side.resolvingKeys[i:] { + // Keys are popped last in first out, so the first + // occurrence is popped last. + if o := counts[k]; o.count == 1 { + delete(counts, k) + } else { + o.count-- + counts[k] = o + } + } + } + } + clear(m.side.resolvingKeys[i:]) + m.side.resolvingKeys = m.side.resolvingKeys[:i] + m.side.resolvingAt = m.side.resolvingAt[:i] +} + +// Number of computations of a memo map in progress above which they are +// counted by key; see resolvingCount. +const resolvingCountMin = 64 + +type resolvingOccurrences struct { + first int32 // Index in resolvingKeys of the first + count int32 +} + +func (side *memoMapSide[K]) countAllResolving() { + side.resolvingCount = make(map[K]resolvingOccurrences, 2*len(side.resolvingKeys)) + for i, k := range side.resolvingKeys { + side.countResolving(k, i) + } +} + +func (side *memoMapSide[K]) countResolving(k K, i int) { + o, ok := side.resolvingCount[k] + if !ok { + o.first = int32(i) + } + o.count++ + side.resolvingCount[k] = o +} + +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) + if s.keyBits != nil { + s.stateKeys = make([]uint64, 1<> (64 - memoMapStateFilterBits) + s.stateKeys[i/64] |= 1 << (i % 64) + } + } + 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{}] +} + +// has reports whether k has run; see memoMap.get. +func (s *memoSet[K]) has(c *Checker, k K) bool { + return s.m.has(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.has(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.resolving.get(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.logEffects() { + // 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. + f.isQuery = true + debug.Assert(!c.inQuery, "nested query") + c.inQuery = true + 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.resolutions[n].isTypeResolution { + n-- + debug.Assert(c.resolutions[n].isQuery, "resolution left on the stack") + c.exitCurrentNode(c.querySave) + c.inQuery = false + } + 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(key, c.memoStates) + } + return state +} + +// stateKeyFilter is a filter of the keys of memoStates, 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 + +func (f *stateKeyFilter) index(key memoKey) uint64 { + return uint64(key) * 0x9E3779B97F4A7C15 >> f.shift +} + +func (f *stateKeyFilter) mayContain(key memoKey) bool { + if f.words == nil { + return false + } + i := f.index(key) + return f.words[i/64]&(1<<(i%64)) != 0 +} + +// add adds key, which states has just been given a state for. +func (f *stateKeyFilter) add(key memoKey, states map[memoKey]*memoState) { + 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(k) + } + return + } + f.set(key) +} + +func (f *stateKeyFilter) set(key memoKey) { + i := f.index(key) + f.words[i/64] |= 1 << (i % 64) +} + +const errorFilterBits = 12 + +type errorKeyFilter [1 << errorFilterBits / 64]uint64 + +func errorFilterIndex(key memoKey) uint64 { + return uint64(key) * 0x9E3779B97F4A7C15 >> (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(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 + } + c.attachState(c.memoState(key)) +} + +// 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, state) + return + } + c.linkState(state, c.memoEffectsAt(n)) +} + +// linkState makes the result in state depend on the effects f of the +// computation that cached it. +func (c *Checker) linkState(state *memoState, f *memoEffects) { + if c.logResults() { + 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.flushStates != nil { + *c.flushStates = append(*c.flushStates, 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 { + 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.delete(f.key) + } + 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)) + } + *f = resolution{} + c.resolutions = c.resolutions[:n] + if c.circularityStart > n { + c.endCircularity() + } else if len(c.innerCycles) != 0 { + c.endInnerCycles(n) + } + return + } + if f := c.stopEffects(); f != nil && f.effects != nil { + c.retainEffects(c.resolutionState(f), f.effects) + } + c.endResolution() +} + +// 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.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.flushStates != nil { + // withoutChecking replays effects through the results computed. + 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.flushStates != nil { + *c.flushStates = append(*c.flushStates, 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. +func (c *Checker) replayEffects(f *memoEffects, outerEntry *ast.Node, outerEntered bool) { + if f.replayed { + return + } + f.replayed = true + 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 + } + for _, e := range f.effects { + e(c) + } + for _, d := range f.deps { + c.replayEffects(d, outerEntry, outerEntered) + } + c.currentNode = saveCurrentNode + f.effects = nil + f.deps = nil + f.rare = nil +} + +// 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) + } +} + +// recordReferenceMark records marking an alias referenced, an effect that +// emit applies itself (see withReferenceMarks). +func (c *Checker) recordReferenceMark(symbol *ast.Symbol) { + if f := c.currentMemoEffects(); f != nil { + f.effects = append(f.effects, func(c *Checker) { c.markAliasSymbolAsReferenced(symbol) }) + rare := f.rareFields() + rare.marks = append(rare.marks, symbol) + } +} + +// withReferenceMarks runs fn as a query, then marks referenced the aliases +// that everything fn computed would mark, which emit relies on to elide +// imports. Unlike checking, it reports nothing, so diagnostics do not depend +// on whether a file was emitted before it was checked. Other effects stay +// pending for checking to replay. +func (c *Checker) withReferenceMarks(fn func()) { + debug.Assert(!c.checking && c.memoTop == 0, "withReferenceMarks inside a computation") + c.beginNodeResolution() + c.startEffects(&memoState{}) + fn() + f := c.stopEffects().effects + c.endResolution() + if f == nil { + return + } + var marks []*ast.Symbol + visited := make(map[*memoEffects]struct{}) + var collect func(f *memoEffects) + collect = func(f *memoEffects) { + if _, ok := visited[f]; ok { + return + } + visited[f] = struct{}{} + if f.rare != nil { + marks = append(marks, f.rare.marks...) + } + for _, d := range f.deps { + collect(d) + } + } + collect(f) + for _, symbol := range marks { + c.withReferenceMarks(func() { c.referenceAliasSymbol(symbol) }) + } +} + +// withoutChecking runs fn in a query from a check, then replays the effects +// of everything fn computed, as if fn had run in the check. Unlike effects +// applied directly, recorded effects can be discarded with the results they +// belong to. +func (c *Checker) withoutChecking(fn func()) { + debug.Assert(c.checking && c.flushStates == nil, "withoutChecking outside a check") + if c.memoTop != 0 { + // The effects of the computations in progress are recorded from + // here on, and with them those of everything fn computes. + c.recordFromCheck() + fn() + return + } + saveMemoTop := c.memoTop + var states []*memoState + c.checking = false + c.syncObserving() + c.memoTop = 0 + c.flushStates = &states + fn() + c.flushStates = nil + c.checking = true + c.syncObserving() + c.memoTop = saveMemoTop + // Replaying is in order of computation, so effects apply in the order + // they would have in the check. They also happened at the current node, + // so only the effects of computations started there are located at it. + for _, state := range states { + if state.pending != nil { + f := state.pending + state.pending = nil + c.memoPendingCount-- + c.syncObserving() + c.replayEffects(f, c.currentNode, true) + } + } +} + +// 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.logEffects() { + c.recordFromCheck() + } +} + +// recordFromCheck makes the outermost computation in progress in a check a +// query from here on, like withoutChecking, 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() { + debug.Assert(c.checking && c.memoTop != 0 && c.flushStates == nil, "recording from a check outside a computation") + 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.flushStates = &c.flushBuf +} + +// endQueryFromCheck ends the query begun by recordFromCheck, replaying +// the effects of everything it computed in the check. +func (c *Checker) endQueryFromCheck() { + if c.flushStates == nil { + // The query already ended; see resumeChecking. + return + } + states := *c.flushStates + c.flushStates = nil + 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 { + 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.flushStates != &c.flushBuf || c.logEffects() || len(c.innerCycles) != 0 || len(c.discardLog) != 0 { + 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.flushStates = nil + 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 + } + saveStart, saveVarianceRoot := c.circularityStart, c.varianceCycleRoot + c.circularityStart, c.varianceCycleRoot = 0, 0 + for k := start; k < end; k++ { + if state := c.deferredAttach[k]; state != nil { + c.deferredAttach[k] = nil + c.linkState(state, f) + } + } + c.circularityStart, c.varianceCycleRoot = saveStart, saveVarianceRoot +} + +// 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 + restore func() + effects bool // Restores the effects of a result rather than the result +} + +// 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 +} + +// 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 +} + +// 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 := len(c.discardLog) - 1; i >= start; i-- { + c.discardLog[i].restore() + } + clear(c.discardLog[start:]) + c.discardLog = c.discardLog[:start] +} + +// trimDiscardLog clears the discard log if nothing in progress can discard. +func (c *Checker) trimDiscardLog() { + if !c.logEffects() && len(c.discardLog) != 0 { + c.discardLogTrims++ + clear(c.discardLog) + c.discardLog = c.discardLog[:0] + } +} + +// 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 with setFlagMemo after logging how +// to discard it with logFlagMemoDiscard. + +// 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) + } +} + +// logFlagMemoDiscard logs how to discard the result of a flag memo in the +// discard log; the caller checks logResults so that the closure is only +// allocated when needed. +// +//go:noinline +func (c *Checker) logFlagMemoDiscard(restore func()) { + c.discardLog = append(c.discardLog, discardEntry{nil, restore, false}) +} + +// 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.logFlagMemoDiscard(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.logFlagMemoDiscard(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.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 i := range participants { + if p := c.typeResolutionMemo(&participants[i]); 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 + } + 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) { + c.observedHead = minObservedHead(c.observedHead, int32(head)) + if c.checking && c.memoTop != 0 { + 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}) +} + +// 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 { + discardLog int + participants int + circularityStart int + 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 { + if c.checking { + c.recordFromCheck() + } + n := c.memoTop - 1 + f := c.memoEffectsAt(n) + m := discardMark{ + discardLog: len(c.discardLog), + participants: len(c.cycleParticipants), + circularityStart: c.circularityStart, + 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.discardLogSince(m.discardLog) + c.cycleParticipants = c.cycleParticipants[:min(m.participants, len(c.cycleParticipants))] + c.circularityStart = m.circularityStart + debug.Assert(c.memoTop-1 == m.resolutionIndex && c.resolutions[m.resolutionIndex].effects == m.recording, "effects discarded outside their computation") + f := m.recording + clear(f.effects[m.effects:]) + f.effects = f.effects[:m.effects] + f.truncateDeps(m.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) + } + }}) +} + +// typeResolutionMemo returns the address of the memo caching the result of +// a type resolution, or nil if it is not cached in a memo. +func (c *Checker) typeResolutionMemo(r *TypeResolution) *memoHeader { + switch r.propertyName { + case TypeSystemPropertyNameType: + return &c.valueSymbolLinks.Get(r.target.(*ast.Symbol)).resolvedType.memoHeader + case TypeSystemPropertyNameDeclaredType: + return &c.typeAliasLinks.Get(r.target.(*ast.Symbol)).declaredType.memoHeader + case TypeSystemPropertyNameResolvedTypeArguments: + return &r.target.(*Type).AsTypeReference().resolvedTypeArguments.memoHeader + case TypeSystemPropertyNameResolvedBaseTypes: + return &r.target.(*Type).AsInterfaceType().resolvedBaseTypes.memoHeader + case TypeSystemPropertyNameResolvedBaseConstructorType: + return &r.target.(*Type).AsInterfaceType().resolvedBaseConstructorType.memoHeader + case TypeSystemPropertyNameResolvedReturnType: + return &r.target.(*Signature).resolvedReturnType.memoHeader + case TypeSystemPropertyNameResolvedBaseConstraint: + return &r.target.(*Type).AsConstrainedType().resolvedBaseConstraint.memoHeader + case TypeSystemPropertyNameWriteType: + if extra := c.valueSymbolLinks.Get(r.target.(*ast.Symbol)).extra; extra != nil { + return &extra.writeType.memoHeader + } + case TypeSystemPropertyNameAliasTarget: + return &c.aliasSymbolLinks.Get(r.target.(*ast.Symbol)).aliasTarget.memoHeader + case TypeSystemPropertyNameComputedPropertyName: + return &c.typeNodeLinks.Get(r.target.(*ast.Node)).resolvedType.memoHeader + case TypeSystemPropertyNameVariances: + return &c.varianceLinks.Get(r.target.(*ast.Symbol)).variances.memoHeader + } + return nil +} + +// 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 much larger limit on the whole +// outermost instantiation, which is only reached by runaway instantiations, +// and which does depend on what was cached before. +// +// The limit on the number of instantiations is likewise 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. + +const ( + instantiationDepthLimit = 100 + instantiationTotalDepthLimit = 200 + instantiationCountLimit = 5_000_000 +) + +func (c *Checker) instantiationDepthLimitReached() bool { + depth := len(c.instantiationStack) + return depth-int(c.currentResolution().depthStart) == instantiationDepthLimit || depth == instantiationTotalDepthLimit +} 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 7c90f3f320fbc..595d2aecbf887 100644 --- a/tsc/internal/checker/nodebuilderimpl.go +++ b/tsc/internal/checker/nodebuilderimpl.go @@ -519,7 +519,7 @@ func (b *NodeBuilderImpl) tryGetResolvedSymbolFromTypeNode(node *ast.Node) *ast. if links == nil { return nil } - return links.resolvedSymbol + return links.resolvedSymbol.get(b.ch) } func (b *NodeBuilderImpl) existingTypeNodeIsNotReferenceOrIsReferenceWithCompatibleTypeArgumentCount(existing *ast.TypeNode, t *Type) bool { @@ -576,7 +576,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 @@ -2063,9 +2063,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.set(c, c.createArrayType(t)) } else { - links.resolvedType = t + links.resolvedType.set(c, t) } return symbol }) @@ -2591,6 +2591,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 @@ -2627,7 +2637,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) @@ -2669,7 +2679,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, @@ -2758,7 +2768,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) } @@ -2800,14 +2810,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 && t.AsMappedType().containsError.get(b.ch)) { 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{})) @@ -2836,9 +2846,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..e3885a24be95d 100644 --- a/tsc/internal/checker/nodecopy.go +++ b/tsc/internal/checker/nodecopy.go @@ -354,8 +354,10 @@ func getExistingNodeTreeVisitor(b *NodeBuilderImpl, bound *recoveryBoundary) *as 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..7132ae615e70e 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.serializationLevel.exit() 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..45bfc16971541 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" @@ -96,23 +97,26 @@ func asRecursionId[T *ast.Node | *ast.Symbol | *Type](value T) RecursionId { return RecursionId{value: value} } -type Relation struct { - results map[CacheHashKey]RelationComparisonResult +// 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 + +// relationKeyBits returns well-mixed bits of a relation key, which is a hash. +func relationKeyBits(k CacheHashKey) uint64 { + return k.Lo } -func (r *Relation) get(key CacheHashKey) RelationComparisonResult { - return r.results[key] +type Relation struct { + results memoMap[CacheHashKey, RelationComparisonResult] } -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) get(c *Checker, key CacheHashKey) RelationComparisonResult { + result, _ := r.results.get(c, key) + return result } -func (r *Relation) size() int { - return len(r.results) +func (r *Relation) set(c *Checker, key CacheHashKey, result RelationComparisonResult) { + r.results.set(c, key, result) } func (c *Checker) isTypeIdenticalTo(source *Type, target *Type) bool { @@ -191,11 +195,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 { + 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 := relation.get(c, id) + if related != RelationComparisonResultNone && related&RelationComparisonResultOverflow == 0 { return related&RelationComparisonResultSucceeded != 0 } + 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 +296,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.get(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 +320,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 +330,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 +345,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 +379,76 @@ 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 { + measuring := c.measuringVariances + c.measuringVariances = false + if measuring { + e := c.varianceStack[len(c.varianceStack)-1] + r.measured, r.measuredResolution = c.varianceLinks.Get(e.symbol), e.resolution + } + saveIncomplete := c.incompleteVariances + c.incompleteVariances = 0 + result = r.isRelatedToEx(source, target, RecursionFlagsBoth, errorNode != nil /*reportErrors*/, headMessage, IntersectionStateNone) + incomplete := c.incompleteVariances + c.incompleteVariances = saveIncomplete + if incomplete != 0 && !measuring { + c.markIncompleteVariances(incomplete) + } + 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 +835,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) { @@ -776,18 +845,20 @@ func (c *Checker) isDeeplyNestedType(t *Type, stack []*Type, maxDepth int) bool } else { identity := 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,11 +866,109 @@ 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().resolvedTypeArguments.peek()) + } 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.valueSymbolLinks.Get(prop).resolvedType.get(c); 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 } } @@ -808,8 +977,8 @@ func hasMatchingRecursionIdentity(t *Type, identity RecursionId) bool { return getRecursionIdentityFromTarget(target) == identity } -func getRecursionIdentity(t *Type) RecursionId { - return getRecursionIdentityFromTarget(getRecursionIdentityTarget(t)) +func (c *Checker) getRecursionIdentity(t *Type) RecursionId { + return getRecursionIdentityFromTarget(c.getRecursionIdentityTarget(t)) } // Get the recursion identity target type from a type. Recursively (a) obtain the target object type of an @@ -818,15 +987,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 @@ -1084,18 +1253,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.logFlagMemoDiscard(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 +1299,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 +1514,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 +1524,266 @@ 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 - } - // 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{} + if variances := links.variances.get(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.get(c) + formatted := make([]string, len(variances)) + for i, v := range variances { + formatted[i] = v.String() + } + traceArgs["variances"] = formatted + popFn() + }() + } + links.variances.begin(c) + // The measurement may have to be discarded; see below. What it caches is + // logged from when it re-enters a measurement in progress, as what it + // caches before observes nothing in progress. + mark := c.markVarianceDiscard() + 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, typeParameters: typeParameters, resolution: len(c.resolutions), prevStackIndex: c.varianceStackIndex[symbol], low: index, min: symbol, minTypeParameters: typeParameters}) + if c.varianceStackIndex == nil { + c.varianceStackIndex = make(map[*ast.Symbol]int32) + } + c.varianceStackIndex[symbol] = int32(index + 1) + c.beginTypeResolution(symbol, TypeSystemPropertyNameVariances) + variances := c.measureVariances(symbol, typeParameters, links) + e := c.varianceStack[index] + 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(mark) + saveVarianceStack, saveCycleRoot := c.varianceStack, c.varianceCycleRoot + c.varianceStack, c.varianceCycleRoot = nil, 0 + c.beginCycleYield(e.min, TypeSystemPropertyNameVariances, -1, len(c.resolutions)) + c.getVariancesWorker(e.min, e.minTypeParameters) + c.endCycleYield() + c.varianceStack, c.varianceCycleRoot = saveVarianceStack, saveCycleRoot + variances = links.variances.get(c) + if len(variances) == 0 { + variances = c.measureVariances(symbol, typeParameters, links) + } + } else if restarted := links.variances.get(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 e.prevStackIndex != 0 { + c.varianceStackIndex[symbol] = e.prevStackIndex + } else { + delete(c.varianceStackIndex, symbol) + } + if index != 0 && e.low < index { + // This type is in a circularity with the measurement that reached it. + 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 + } + } + 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: a comparison observing them is not cached, and once the + // outermost one completes, what reads its result is discarded when the + // measurement re-entered finishes, unless it is one measuring variances, + // which are kept if measured from the canonical entry. What is cached + // from now on until the measurement re-entered finishes is logged, so + // that it can be discarded otherwise. + if c.varianceCycleRoot == 0 { + if c.checking && c.memoTop != 0 { + c.recordFromCheck() + } + c.varianceCycleRoot = stackIndex + 1 + } else { + c.varianceCycleRoot = min(c.varianceCycleRoot, stackIndex+1) + } + c.incompleteVariances = minIncompleteVariances(c.incompleteVariances, c.varianceStack[stackIndex].resolution+1) + return []VarianceFlags{} +} + +// A varianceDiscardMark is the state when a measurement of variances began, +// to which it is discarded if it entered a circularity at a type other than +// the canonical entry; see getVariancesWorker. +type varianceDiscardMark struct { + discardLog int + discardLogTrims int + participants int + circularityStart int + resolutionIndex int // Index in resolutions of the measurement's memo +} + +func (c *Checker) markVarianceDiscard() varianceDiscardMark { + return varianceDiscardMark{ + discardLog: len(c.discardLog), + discardLogTrims: c.discardLogTrims, + participants: len(c.cycleParticipants), + circularityStart: c.circularityStart, + resolutionIndex: c.memoTop - 1, + } +} + +// discardVariancesSince discards the results cached since m, like +// discardSince, and all the effects the measurement recorded. +func (c *Checker) discardVariancesSince(m varianceDiscardMark) { + start := m.discardLog + if c.discardLogTrims != m.discardLogTrims { + // Everything logged is from after the mark. + start = 0 + } + c.discardLogSince(start) + c.cycleParticipants = c.cycleParticipants[:min(m.participants, len(c.cycleParticipants))] + c.circularityStart = m.circularityStart + if f := c.resolutions[m.resolutionIndex].effects; f != nil { + clear(f.effects) + f.effects = f.effects[:0] + f.truncateDeps(0) + } +} + +func minIncompleteVariances(a int, b int) int { + if a == 0 || b != 0 && b < a { + return b + } + return a +} + +// markIncompleteVariances marks circular the measurement of variances in +// progress at index head-1 in resolutions, whose incomplete variances were +// observed, keeping the variances of it and those measured above it. +func (c *Checker) markIncompleteVariances(head int) { + for _, e := range c.varianceStack { + if e.resolution >= head-1 { + c.cycleParticipants = append(c.cycleParticipants, c.resolutions[e.resolution].typeResolution) + } + } + c.markTypeResolutionCircular(head - 1) +} + +// getVariancesForInference returns the variances get returns, for an +// inference, which is discarded if they are incomplete. +func (c *Checker) getVariancesForInference(get func() []VarianceFlags) []VarianceFlags { + saveIncomplete := c.incompleteVariances + c.incompleteVariances = 0 + variances := get() + if c.incompleteVariances != 0 { + c.markIncompleteVariances(c.incompleteVariances) + } + c.incompleteVariances = saveIncomplete + return variances +} + +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.isMarkerTypeAssignableTo(typeWithSub, typeWithSuper), VarianceFlagsCovariant, 0) | + core.IfElse(c.isMarkerTypeAssignableTo(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.isMarkerTypeAssignableTo(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.get(c)) != 0 { + break } + variances[i] = variance } - return links.variances + return variances } +// isMarkerTypeAssignableTo is isTypeAssignableTo for a comparison measuring +// variances. +func (c *Checker) isMarkerTypeAssignableTo(source *Type, target *Type) bool { + c.measuringVariances = true + result := c.isTypeAssignableTo(source, target) + c.measuringVariances = false + return result +} + +// getVarianceStackIndex returns the index in the variance stack of the +// measurement of the variances of symbol in progress, or -1. A measurement +// hidden with the rest of the stack 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 } - return -1 + i := int(c.varianceStackIndex[symbol]) - 1 + if i < 0 || i >= len(c.varianceStack) || c.varianceStack[i].symbol != symbol { + return -1 + } + return i } func (c *Checker) createMarkerType(symbol *ast.Symbol, source *Type, target *Type) *Type { @@ -1454,16 +1794,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().resolvedTypeArguments.peek()) + } + } + 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 +2133,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.get(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 +2182,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 +2455,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 +2488,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) && (sig.resolvedReturnType.get(c) == nil || sig.resolvedReturnType.get(c).flags&TypeFlagsBoolean != 0) && c.getParameterCount(sig) > 0: sig.setResolvedTypePredicate(c, c.noTypePredicate) // avoid infinite loop sig.setResolvedTypePredicate(c, c.getTypePredicateFromBody(sig.declaration)) } @@ -2077,11 +2498,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 +2566,18 @@ 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 + if signature.resolvedReturnType.get(c) != nil { + return false + } + 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.get(c) == nil } func (c *Checker) findMatchingSignatures(signatureLists [][]*Signature, signature *Signature, listIndex int) []*Signature { @@ -2582,22 +3009,94 @@ 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 + // measured is the variances of the type whose measurement the + // comparison is part of, if any, and measuredResolution the index in + // Checker.resolutions of that measurement. + measured *VarianceLinks + measuredResolution 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.get(c, r.topKey) + } + r.topEntryValid = true + if r.topEntry&RelationComparisonResultOverflow != 0 { + r.topBegun = false + r.overflow = true + return false + } + r.relation.results.begin(c, r.topKey) + return true } func (c *Checker) getRelater() *Relater { @@ -2610,15 +3109,26 @@ 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.measured, r.measuredResolution = nil, 0 + r.next = c.freeRelater c.freeRelater = r } @@ -3120,16 +3630,47 @@ 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.measured != nil && len(r.measured.variances.peek()) != 0 { + // A restart from a circularity measured the type from the canonical + // entry (see getRecursiveVariances), so the measurement in progress is + // superseded and its result unused. It stops here, as reading the + // incomplete variances of the measurement, so that what it compared + // is not cached. + r.c.incompleteVariances = minIncompleteVariances(r.c.incompleteVariances, r.measuredResolution+1) + 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.get(r.c, id) + } + } else { + id, constrained = r.c.getRelationKey(source, target, intersectionState, r.relation == r.c.identityRelation, false /*ignoreConstraints*/) + entry = r.relation.get(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 { 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 } @@ -3141,91 +3682,191 @@ 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.get(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 r.c.reliabilityFlags = 0 + saveIncomplete := r.c.incompleteVariances + r.c.incompleteVariances = 0 var result Ternary if r.expandingFlags == ExpandingFlagsBoth { 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 r.c.reliabilityFlags |= saveReliabilityFlags + incomplete := r.c.incompleteVariances + r.c.incompleteVariances = minIncompleteVariances(saveIncomplete, incomplete) 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 != 0 && 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 != 0: + // 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 +3959,23 @@ 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 (see getVariancesWorker). 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 +4109,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.getVarianceStackIndex(source.alias.symbol) >= 0, intersectionState) if ok { return varianceResult } @@ -3595,7 +4249,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 +4431,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 +4539,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.getVarianceStackIndex(source.Target().symbol) >= 0, intersectionState) if ok { return varianceResult } @@ -4795,7 +5448,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 +5476,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().constraint.get(r.c)): 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..f614e2a364639 --- /dev/null +++ b/tsc/internal/checker/resolutions.go @@ -0,0 +1,309 @@ +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 + + // A query records the effects of a memoized computation, for replay by + // reuse of its result; see memo.go. + memo bool + isQuery bool + resolving bool // The resolution is the one in Checker.resolving for key + fromCheck bool // The query began in a check; see recordFromCheck + // The structured members the outermost resolution of key computes are + // available before it completes; see resolveStructuredTypeMembersUncached. + membersPublished 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 + + // 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 + // Checker.searchableTop on entry, for a type resolution other than that + // of a current node. + prevSearchable int32 +} + +// 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] + } + return &c.resolutions[n] +} + +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))) +} + +// beginNodeResolution starts a resolution that is not a computation, which +// continues the depth limit of the enclosing resolution. +func (c *Checker) beginNodeResolution() { + c.appendResolution(0, nil, 0, c.currentResolution().depthStart) +} + +func (c *Checker) appendResolution(key memoKey, source memoStateSource, index int, depthBase int32) { + c.resolutionSerials++ + f := c.pushResolution() + f.key = key + 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.resolutions[n] = resolution{} + c.resolutions = c.resolutions[:n] + if c.circularityStart > n { + c.endCircularity() + } else if len(c.innerCycles) != 0 { + c.endInnerCycles(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) + f.key, f.source = 0, nil +} + +// 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.resolving.get(key); ok && int(i) >= c.visibleStart { + return int(i) + 1 + } + return 0 +} + +// resolvingTable maps the keys of computations in progress to the index in +// resolutions of the outermost one. It only holds keys on the resolution +// stack, so it stays small, and it is looked up far more often than it +// changes. It uses open addressing with linear probing, with zero marking an +// empty slot, as no memo key is zero. +type resolvingTable struct { + slots []resolvingSlot + count int +} + +type resolvingSlot struct { + key memoKey + index int32 +} + +func (t *resolvingTable) home(key memoKey) int { + return int(uint64(key) * 0x9E3779B97F4A7C15 >> 32 & uint64(len(t.slots)-1)) +} + +func (t *resolvingTable) get(key memoKey) (int32, bool) { + if t.count == 0 { + return 0, false + } + mask := len(t.slots) - 1 + for i := t.home(key); ; i = (i + 1) & mask { + switch t.slots[i].key { + case key: + return t.slots[i].index, true + case 0: + return 0, false + } + } +} + +// slot returns the slot holding key, or else the empty slot where it would +// be inserted, with room for the insertion. +func (t *resolvingTable) slot(key memoKey) *resolvingSlot { + if 2*(t.count+1) > len(t.slots) { + t.grow() + } + mask := len(t.slots) - 1 + for i := t.home(key); ; i = (i + 1) & mask { + if k := t.slots[i].key; k == key || k == 0 { + return &t.slots[i] + } + } +} + +func (t *resolvingTable) set(key memoKey, index int32) { + if 2*(t.count+1) > len(t.slots) { + t.grow() + } + mask := len(t.slots) - 1 + for i := t.home(key); ; i = (i + 1) & mask { + switch t.slots[i].key { + case key: + t.slots[i].index = index + return + case 0: + t.slots[i] = resolvingSlot{key, index} + t.count++ + return + } + } +} + +func (t *resolvingTable) delete(key memoKey) { + if t.count == 0 { + return + } + mask := len(t.slots) - 1 + i := t.home(key) + for t.slots[i].key != key { + if t.slots[i].key == 0 { + return + } + i = (i + 1) & mask + } + // Shift later entries of the probe sequence back into the hole, so that + // lookups need no tombstones. + for j := (i + 1) & mask; t.slots[j].key != 0; j = (j + 1) & mask { + if h := t.home(t.slots[j].key); (j-h)&mask >= (j-i)&mask { + t.slots[i] = t.slots[j] + i = j + } + } + t.slots[i] = resolvingSlot{} + t.count-- +} + +func (t *resolvingTable) grow() { + old := t.slots + t.slots = make([]resolvingSlot, max(2*len(old), 64)) + t.count = 0 + for _, slot := range old { + if slot.key != 0 { + t.set(slot.key, slot.index) + } + } +} + +// 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 the policy of its kind says; see memoReentry. It reports +// whether the resolution is recorded. +func (c *Checker) beginResolving(key memoKey) bool { + slot := c.resolving.slot(key) + if slot.key == 0 { + *slot = resolvingSlot{key, int32(len(c.resolutions))} + c.resolving.count++ + return true + } + i := slot.index + if int(i) >= c.visibleStart { + if memoReentry[key.field()] == reentryCircular { + c.markCircular(int(i)) + } + return false + } + y := &c.cycleYields[len(c.cycleYields)-1] + y.shadowed = append(y.shadowed, shadowedResolving{key, i}) + slot.index = int32(len(c.resolutions)) + 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.resolving.get(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.delete(f.key) + f.resolving = false + } +} diff --git a/tsc/internal/checker/services.go b/tsc/internal/checker/services.go index 24cd180cb3e84..85e7155c730cc 100644 --- a/tsc/internal/checker/services.go +++ b/tsc/internal/checker/services.go @@ -153,7 +153,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) } @@ -369,22 +369,19 @@ func (c *Checker) runWithoutResolvedSignatureCaching[T any](node *ast.Node, fn f 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() 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 } @@ -870,10 +867,10 @@ func (c *Checker) GetConstantValue(node *ast.Node) any { return c.getEnumMemberValue(node).Value } - if c.symbolNodeLinks.Get(node).resolvedSymbol == nil { + if c.symbolNodeLinks.Get(node).resolvedSymbol.get(c) == nil { c.checkExpressionCached(node) // ensure cached resolved symbol is set } - symbol := c.symbolNodeLinks.Get(node).resolvedSymbol + symbol := c.symbolNodeLinks.Get(node).resolvedSymbol.get(c) if symbol == nil && ast.IsEntityNameExpression(node) { symbol = c.resolveEntityName( node, diff --git a/tsc/internal/checker/symbolaccessibility.go b/tsc/internal/checker/symbolaccessibility.go index 204062db49de0..e05c9cdf1b8d1 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.get(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.get(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,14 @@ 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 c.buildingExternalModuleContainers { // Re-entered from an alias resolved while building the index; answer this query without it. return c.scanExternalModuleContainers(symbol) } + index := c.externalModuleContainers.get(c) + if index == nil { + index = c.buildExternalModuleContainerIndex() + } containers := index.containersByTarget[c.getResolvedTarget(symbol)] parent := c.getParentOfSymbol(symbol) parentOrder, parentIsModule := index.moduleOrder[parent] @@ -250,12 +257,13 @@ func (c *Checker) getExternalModuleContainers(symbol *ast.Symbol) []*ast.Symbol return containers } -func (c *Checker) buildExternalModuleContainerIndex() { +func (c *Checker) buildExternalModuleContainerIndex() *externalModuleContainerIndex { + c.externalModuleContainers.begin(c) + c.buildingExternalModuleContainers = true 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 +277,10 @@ func (c *Checker) buildExternalModuleContainerIndex() { index.add(c.getResolvedTarget(exportEquals), container) } } - index.complete = true + c.buildingExternalModuleContainers = false + c.externalModuleContainers.set(c, index) + c.endMemo() + return index } func (c *Checker) scanExternalModuleContainers(symbol *ast.Symbol) []*ast.Symbol { @@ -374,7 +385,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.symbolNodeLinks.Get(d.Parent.AsBinaryExpression().Left.Expression()).resolvedSymbol.get(c) if sym != nil && !slices.Contains(candidates, sym) { candidates = append(candidates, sym) } @@ -513,15 +524,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.get(c, key); ok { return existing } + c.accessibleChains.begin(c, key) var result []*ast.Symbol @@ -533,7 +540,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 +581,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 +592,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 +885,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 +894,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 e2110ef695959..1f10d278c194b 100644 --- a/tsc/internal/checker/types.go +++ b/tsc/internal/checker/types.go @@ -181,23 +181,23 @@ 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 + writeType memo[*Type] nameType *Type containingType *Type // Mapped type for mapped type property, containing union or intersection type for synthetic property } -func (links *ValueSymbolLinks) getWriteType() *Type { +func (links *ValueSymbolLinks) getWriteType(c *Checker) *Type { if links.extra == nil { return nil } - return links.extra.writeType + return links.extra.writeType.get(c) } func (links *ValueSymbolLinks) getNameType() *Type { @@ -221,7 +221,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) { @@ -262,10 +274,11 @@ 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 + referenceChecked bool // True if checking has followed the reference; see referenceAliasSymbol + typeOnlyDeclaration *ast.Node // First resolved alias declaration that makes the symbol only usable in type constructs } // Links for module symbols @@ -273,7 +286,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 { @@ -298,20 +310,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 @@ -326,11 +333,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 { @@ -360,7 +366,7 @@ type SpreadLinks struct { // Links for variances of type aliases and interface types type VarianceLinks struct { - variances []VarianceFlags + variances memo[[]VarianceFlags] } type VarianceFlags uint32 @@ -383,17 +389,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 ( @@ -414,13 +415,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 ) @@ -430,39 +429,42 @@ const ( 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 + hasReportedStatementInAmbientContext memo[bool] // Cache boolean if we report statements in ambient context } 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) getOuterTypeParameters(c *Checker) []*Type { + if p := links.outerTypeParameters.get(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 @@ -471,18 +473,13 @@ 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] identifierCheckNodes []*ast.Node @@ -490,15 +487,15 @@ type SourceFileLinks struct { 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 @@ -712,9 +709,8 @@ 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 + ObjectFlagsFromTypeNode = 1 << 29 // Originates in resolution of AST type node // 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 @@ -788,6 +784,7 @@ type Type struct { objectFlags ObjectFlags id TypeId kind typeKind `customlint:"protected"` + generation uint16 // see Checker.typeGeneration; zero until computed symbol *ast.Symbol alias *TypeAlias checker *Checker @@ -904,6 +901,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. @@ -1113,7 +1118,7 @@ type UniqueESSymbolType struct { type ConstrainedType struct { TypeBase - resolvedBaseConstraint *Type + resolvedBaseConstraint memo[*Type] } func (t *ConstrainedType) AsConstrainedType() *ConstrainedType { return t } @@ -1151,7 +1156,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) } @@ -1163,12 +1168,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) @@ -1178,7 +1183,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] @@ -1191,19 +1196,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 } @@ -1250,7 +1258,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. @@ -1288,9 +1296,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 } @@ -1300,7 +1308,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 } @@ -1329,8 +1337,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 @@ -1420,19 +1428,19 @@ 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 } + typeParameter memo[*Type] + constraintType memo[*Type] + nameType memo[*Type] + templateType memo[*Type] + modifiersType memo[*Type] + resolvedApparentType memo[*Type] + containsError memo[bool] +} + +func (t *MappedType) TypeParameter() *Type { return t.typeParameter.peek() } +func (t *MappedType) ConstraintType() *Type { return t.constraintType.peek() } +func (t *MappedType) NameType() *Type { return t.nameType.peek() } +func (t *MappedType) TemplateType() *Type { return t.templateType.peek() } func (t *MappedType) ResolveComponents(c *Checker, typ *Type) { c.getTypeParameterFromMappedType(typ) c.getConstraintTypeFromMappedType(typ) @@ -1454,7 +1462,7 @@ type ReverseMappedType struct { type EvolvingArrayType struct { ObjectType elementType *Type - finalArrayType *Type + finalArrayType memo[*Type] } // UnionOrIntersectionTypeData @@ -1462,9 +1470,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 } @@ -1477,10 +1485,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 } @@ -1488,21 +1496,22 @@ 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 } @@ -1572,7 +1581,7 @@ type ConditionalRoot struct { isDistributive bool inferTypeParameters []*Type outerTypeParameters []*Type - instantiations map[CacheHashKey]*Type + instantiations memoMap[CacheHashKey, *Type] alias *TypeAlias } @@ -1581,11 +1590,11 @@ 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 } @@ -1624,10 +1633,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 @@ -1670,7 +1679,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.logFlagMemoDiscard(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..63ec6affc72df 100644 --- a/tsc/internal/checker/types_test.go +++ b/tsc/internal/checker/types_test.go @@ -2,6 +2,7 @@ package checker import ( "encoding/binary" + "math/rand/v2" "runtime" "slices" "strconv" @@ -18,8 +19,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 +30,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.get(first).id, TypeId(i+1)) + assert.Equal(t, first.signatureLinks.Get(node).resolvedSignature.get(first).id, SignatureId(i+1)) + assert.Equal(t, second.typeNodeLinks.Get(node).resolvedType.get(second).id, TypeId(i+2)) + assert.Equal(t, second.signatureLinks.Get(node).resolvedSignature.get(second).id, SignatureId(i+2)) } clone := nodes[0].Clone(f) assert.Assert(t, !first.typeNodeLinks.Has(clone)) @@ -85,7 +86,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 +176,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 +310,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 +352,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 +370,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 { @@ -488,7 +492,7 @@ func TestCompactValueSymbolLinksLayout(t *testing.T) { assert.Equal(t, unsafe.Sizeof(valueSymbolExtra{}), 3*unsafe.Sizeof(uintptr(0))) c, types := newCompositeTestChecker() var links ValueSymbolLinks - assert.Assert(t, links.getWriteType() == nil) + assert.Assert(t, links.getWriteType(c) == nil) assert.Assert(t, links.getNameType() == nil) assert.Assert(t, links.getContainingType() == nil) links.setWriteType(c, nil) @@ -505,12 +509,12 @@ func TestCompactValueSymbolLinksLayout(t *testing.T) { other.setNameType(c, types[2]) } runtime.GC() - assert.Equal(t, links.getWriteType(), types[0]) + assert.Equal(t, links.getWriteType(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.getWriteType(c), types[0]) assert.Equal(t, links.getContainingType(), types[2]) } @@ -539,9 +543,9 @@ func TestUnionIntersectionPropertyCacheSharing(t *testing.T) { 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()) + assert.Equal(t, len(data.propertyCacheWithoutFunctionPropertyAugment.memoEntries), members.Len()) if !augmentedFirst { - assert.Assert(t, data.propertyCache == nil) + assert.Assert(t, data.propertyCache.isEmpty()) } runtime.GC() for name, symbol := range members.All() { @@ -569,25 +573,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 +651,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.getOuterTypeParameters(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.getOuterTypeParameters(c) != nil) + assert.Equal(t, len(links.getOuterTypeParameters(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.getOuterTypeParameters(c)[0], types[0]) list[0] = types[1] - assert.Equal(t, links.getOuterTypeParameters()[0], types[1]) + assert.Equal(t, links.getOuterTypeParameters(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.getOuterTypeParameters(c)[0], types[1]) + assert.Equal(t, links.resolvedType.get(c), types[0]) links.setOuterTypeParameters(c, nil) - assert.Assert(t, links.getOuterTypeParameters() == nil) - assert.Equal(t, links.resolvedType, types[0]) + assert.Assert(t, links.getOuterTypeParameters(c) == nil) + assert.Equal(t, links.resolvedType.get(c), types[0]) runtime.KeepAlive(c) } @@ -693,7 +693,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,8 +748,36 @@ 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.get(c), types[0]) assert.Equal(t, sig.minArgumentCount, int32(1)) assert.Equal(t, sig.getResolvedTypePredicate(c), predicate) runtime.KeepAlive(c) } + +func TestResolvingTable(t *testing.T) { + t.Parallel() + var table resolvingTable + want := map[memoKey]int32{} + rng := rand.New(rand.NewPCG(1, 2)) + for i := range 200000 { + key := memoKey(rng.IntN(300)+1) << 8 + switch rng.IntN(3) { + case 0: + table.set(key, int32(i)) + want[key] = int32(i) + case 1: + table.delete(key) + delete(want, key) + } + got, ok := table.get(key) + wantIndex, wantOk := want[key] + assert.Equal(t, ok, wantOk) + assert.Equal(t, got, wantIndex) + assert.Equal(t, table.count, len(want)) + } + for key, index := range want { + got, ok := table.get(key) + assert.Assert(t, ok) + assert.Equal(t, got, index) + } +} diff --git a/tsc/internal/checker/utilities.go b/tsc/internal/checker/utilities.go index c4cc97fa29a1b..cd9da35086fde 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(t1.AsTypeReference().resolvedTypeArguments.peek(), t2.AsTypeReference().resolvedTypeArguments.peek()); 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,22 @@ func CompareTypes(t1, t2 *Type) int { if c := compareTypeMappers(m1, m2); c != 0 { return c } + if hasObjectLiteralMembers(t1) && hasObjectLiteralMembers(t2) { + if c := compareObjectLiteralMembers(t1, t2); 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. + if c := compareObjectMemberDeclarations(t1, t2); c != 0 { + return c + } + } } case t1.flags&TypeFlagsUnion != 0: // Unions are ordered by origin and then constituent type lists. @@ -580,6 +618,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 +635,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 +664,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 +749,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 +774,173 @@ 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 +} + +// compareObjectMemberDeclarations orders resolved object types by what their +// members declare, without consulting member types, which may not be resolved. +// Properties are compared pairwise because getNamedMembers sorts them. +func compareObjectMemberDeclarations(t1, t2 *Type) 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 + } + } + return 0 +} + +// compareObjectLiteralMembers is like compareObjectMemberDeclarations, and +// likewise relies on getNamedMembers sorting the properties. +func compareObjectLiteralMembers(t1, t2 *Type) 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] + // Members are created per object literal type, so they are ordered by + // what they declare rather than by identity. + 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 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.resolvedType.peek() + } + 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.constraint.peek(), p2.constraint.peek()) + } + 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/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/testrunner/compiler_runner.go b/tsc/internal/testrunner/compiler_runner.go index 6f2712632b5b8..3efc2ec3e71ca 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/harnessutil/checkorderfuzz.go b/tsc/internal/testutil/harnessutil/checkorderfuzz.go new file mode 100644 index 0000000000000..77ca00a90a837 --- /dev/null +++ b/tsc/internal/testutil/harnessutil/checkorderfuzz.go @@ -0,0 +1,353 @@ +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 +) + +var fuzzQueryKindNames = [...]string{ + fuzzQueryType: "type", + fuzzQuerySymbol: "symbol", + fuzzQueryContextualType: "contextual type", + fuzzQuerySignature: "signature", +} + +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()) + } + 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(ctx, host, fuzzConfig, 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 { + queries := fuzzQueries(createProgram(host, fuzzConfig), rand.New(rand.NewPCG(seed, stream))) + diverges := func(queries []fuzzQuery) bool { + return fuzzDiff(expected, fuzzRun(ctx, host, fuzzConfig, queries)) != "" + } + if !diverges(queries) { + continue + } + queries = fuzzMinimize(queries, diverges) + var b strings.Builder + fmt.Fprintf(&b, "check order fuzzing with TS_CHECK_ORDER_FUZZ_SEED=%d changed results after querying:\n", seed) + 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(ctx, host, fuzzConfig, 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}) + 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 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 "" +} + +// fuzzRun answers queries, given in the files of the program that +// fuzzQueries was given, in a fresh program, then returns its results. +func fuzzRun(ctx context.Context, host compiler.CompilerHost, config *tsoptions.ParsedCommandLine, queries []fuzzQuery) fuzzResult { + program := createProgram(host, config) + 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) + } + for _, q := range queries { + 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 + } + node := nodesByFile[string(file.FileName())][q.index] + c, done := program.Program().GetTypeCheckerForFile(ctx, file) + fuzzQueryResult(c, node, q.kind) + done() + } + + 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 r := fuzzQueryResult(c, node, kind); r != "" { + result = append(result, fmt.Sprintf("%s: %s", fuzzQuery{file, node, i, kind}, r)) + } + } + } + done() + } + 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() +} diff --git a/tsc/internal/testutil/harnessutil/harnessutil.go b/tsc/internal/testutil/harnessutil/harnessutil.go index bca59282a69fa..a742efcc39069 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(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,28 @@ 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", } func getHarnessOption(name string) *tsoptions.CommandLineOption { @@ -407,6 +432,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) } @@ -644,8 +675,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(ctx, host, preConfig, preProgram, harnessOptions.CheckOrder)...) if harnessOptions.CaptureSuggestions { preErrors = append(preErrors, preProgram.GetSuggestionDiagnostics(ctx, nil)...) } @@ -655,13 +685,12 @@ func compileFilesWithHost( preErrors = compiler.SortAndDeduplicateDiagnostics(preErrors) postProgram := createProgram(host, config) - emitResult := postProgram.Emit(ctx, compiler.EmitOptions{}) + emitResult := emitInOrder(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(ctx, host, config, postProgram, harnessOptions.CheckOrder)...) if postProgram.Options().GetEmitDeclarations() { postErrors = append(postErrors, postProgram.GetDeclarationDiagnostics(ctx, nil)...) } @@ -701,6 +730,113 @@ func compileFilesWithHost( 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(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(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)...) + 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(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{}) + } + 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(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) + } + } + } +} + type CompilationResult struct { Diagnostics []*ast.Diagnostic Result *compiler.EmitResult @@ -1159,6 +1295,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/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/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/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..1d225438007a0 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/circularIndexedPropertyInstantiation.errors.txt @@ -0,0 +1,17 @@ +circularIndexedPropertyInstantiation.ts(4,5): error TS5114: Instantiations of type 'Foo' appear infinitely circular. +circularIndexedPropertyInstantiation.ts(4,9): error TS5114: Instantiations of type 'Foo' appear infinitely circular. +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 TS5114: Instantiations of type 'Foo' appear infinitely circular. + ~~~~~~~~~~~~~~~ +!!! error TS5114: Instantiations of type 'Foo' appear infinitely circular. + 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/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/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..f1af064690eee --- /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<{ a: Type; 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<{ a: Type; b: () => Type; }[k_1]> +>$ : Scope<{ a: Type; b: () => Type; }> +>type : (k: k_1) => Resolve<{ a: Type; 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<{ a: Type; 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<{ a: Type; b: () => Type; }[k_1]> +>$2 : Scope<{ a: Type; b: () => Type; }> +>type : (k: k_1) => Resolve<{ a: Type; 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..f1af064690eee --- /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<{ a: Type; 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<{ a: Type; b: () => Type; }[k_1]> +>$ : Scope<{ a: Type; b: () => Type; }> +>type : (k: k_1) => Resolve<{ a: Type; 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<{ a: Type; 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<{ a: Type; b: () => Type; }[k_1]> +>$2 : Scope<{ a: Type; b: () => Type; }> +>type : (k: k_1) => Resolve<{ a: Type; 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/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/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/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/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/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..512f22fa8a9b6 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,11 @@ -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 (2 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..07239f7d2748f 100644 --- a/tsc/testdata/baselines/reference/compiler/declarationEmitUnknownImport2(target=es2015).errors.txt +++ b/tsc/testdata/baselines/reference/compiler/declarationEmitUnknownImport2(target=es2015).errors.txt @@ -1,15 +1,11 @@ -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 (4 errors) ==== import Foo From './Foo'; // Syntax error - ~~~~~~~~~~~~~~~ -!!! error TS2303: Circular definition of import alias 'Foo'. ~~~~ !!! error TS1005: '=' expected. ~~~~ @@ -18,6 +14,4 @@ declarationEmitUnknownImport2.ts(2,1): error TS2303: Circular definition of impo !!! 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 | ((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: Types of property 'queries' are incompatible. +!!! 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: Types of property 'queries' are incompatible. +!!! 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/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/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/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/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.errors.txt b/tsc/testdata/baselines/reference/compiler/varianceDeclarationOrder.errors.txt new file mode 100644 index 0000000000000..76e1b58ab4906 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/varianceDeclarationOrder.errors.txt @@ -0,0 +1,31 @@ +refFirst.ts(10,14): error TS2322: Type 'DS<{ total: M; }, string>' is not assignable to type 'DS, string>'. + Property 'total' is missing in type 'Record' but required in type '{ total: M; }'. + + +==== refFirst.ts (1 errors) ==== + 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; + ~ +!!! error TS2322: Type 'DS<{ total: M; }, string>' is not assignable to type 'DS, string>'. +!!! error TS2322: Property 'total' is missing in type 'Record' but required in type '{ total: M; }'. + +==== dsFirst.ts (0 errors) ==== + 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; + \ No newline at end of file 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/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/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..9d4e77b1bfb1f 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,14): error TS5114: Instantiations of type 'Circular' appear infinitely circular. recursiveMappedTypes.ts(20,19): error TS5114: Instantiations of type 'Circular' appear infinitely circular. +recursiveMappedTypes.ts(21,10): error TS5114: Instantiations of type 'Circular' appear infinitely circular. 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 TS5114: Instantiations of type 'Circular' appear infinitely circular. ~~~~~~~~~~~~~ !!! error TS5114: Instantiations of type 'Circular' appear infinitely circular. return arg; + ~~~ +!!! error TS5114: Instantiations of type 'Circular' appear infinitely circular. } // 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/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-with-multiple-files-and-complex-types.js b/tsc/testdata/baselines/reference/tsc/generateTrace/generateTrace-with-multiple-files-and-complex-types.js index 21aa78f4efbca..1cdf348a9d041 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 @@ -212,12 +212,12 @@ declare const console: { log(msg: any): void; }; {"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":105,"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":106,"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":107,"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":108,"symbolName":"__object","recursionId":93,"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":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":110,"symbolName":"__function","recursionId":95,"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":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"}, @@ -228,7 +228,6 @@ declare const console: { log(msg: any): void; }; {"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":121,"recursionId":101,"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 3c629aeec7fcb..98bd4a0d2e0e1 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; } tsgo -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 tsgo -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 7e3f0da04d4e6..610f7fa7e72b5 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 @@ tsgo 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 tsgo 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 @@ tsgo 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 tsgo 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 009ea164deed4..211fd77b970ec 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 @@ tsgo 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 tsgo 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 @@ tsgo 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 tsgo 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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/jsExpandoIndexedAssignmentDiagnostic.errors.txt b/tsc/testdata/baselines/reference/compiler/jsExpandoIndexedAssignmentDiagnostic.errors.txt new file mode 100644 index 0000000000000..108d7440f9df4 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/jsExpandoIndexedAssignmentDiagnostic.errors.txt @@ -0,0 +1,25 @@ +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,11): error TS7022: 'otherPixel' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. +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(6,5): error TS7022: 'skip' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. + + +==== file.js (5 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 TS7022: 'otherPixel' 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; }'. + properties.skip = isNaN(pixel) || isNaN(otherPixel); + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS7022: 'skip' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. + } \ 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/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..8c8a4f0003e86 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 TS5115: Instantiations of the following types appear infinitely circular: 'Exclude', 'Model', 'ModelAttributes'. keyofGenericExtendingClassDoubleLayer.ts(10,12): error TS2564: Property 'age' has no initializer and is not definitely assigned in the constructor. +keyofGenericExtendingClassDoubleLayer.ts(13,13): error TS5115: Instantiations of the following types appear infinitely circular: 'Exclude', 'Model', 'ModelAttributes'. -==== 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 TS5115: Instantiations of the following types appear infinitely circular: 'Exclude', 'Model', 'ModelAttributes'. 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 TS5115: Instantiations of the following types appear infinitely circular: 'Exclude', 'Model', 'ModelAttributes'. } } \ No newline at end of file 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..fec9882355546 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/lateBoundMutualMemberTables.errors.txt @@ -0,0 +1,29 @@ +lateBoundMutualMemberTables.ts(6,8): error TS2339: Property 'by' does not exist on type 'B<"b">'. +lateBoundMutualMemberTables.ts(11,8): error TS2339: Property 'b' does not exist on type 'A<"a">'. +lateBoundMutualMemberTables.ts(15,21): error TS2339: Property 'fromA2' does not exist on type 'A<"a">'. + + +==== lateBoundMutualMemberTables.ts (3 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"; + ~ +!!! error TS2339: Property 'b' does not exist on type 'A<"a">'. + } + 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..b908bb32df049 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/limitDeepInstantiations(checkorder=default).errors.txt @@ -0,0 +1,18 @@ +limitDeepInstantiations.ts(4,5): error TS5114: Instantiations of type 'Foo' appear infinitely circular. +limitDeepInstantiations.ts(4,9): error TS5114: Instantiations of type 'Foo' appear infinitely circular. +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 TS5114: Instantiations of type 'Foo' appear infinitely circular. + ~~~~~~~~~~~~~~~ +!!! error TS5114: Instantiations of type 'Foo' appear infinitely circular. + 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..b908bb32df049 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/limitDeepInstantiations(checkorder=typesfirst).errors.txt @@ -0,0 +1,18 @@ +limitDeepInstantiations.ts(4,5): error TS5114: Instantiations of type 'Foo' appear infinitely circular. +limitDeepInstantiations.ts(4,9): error TS5114: Instantiations of type 'Foo' appear infinitely circular. +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 TS5114: Instantiations of type 'Foo' appear infinitely circular. + ~~~~~~~~~~~~~~~ +!!! error TS5114: Instantiations of type 'Foo' appear infinitely circular. + 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/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/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/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/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/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/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/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/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/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/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/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/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/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/varianceCircularConsistency.errors.txt b/tsc/testdata/baselines/reference/compiler/varianceCircularConsistency.errors.txt new file mode 100644 index 0000000000000..07e45f9bb2d02 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/varianceCircularConsistency.errors.txt @@ -0,0 +1,70 @@ +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, {}>'. + Types of property 'queries' are incompatible. + 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, {}>'. + Types of property 'queries' are incompatible. + 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