From 80d663f6de3411e1e1a0109431b9b60d038d073f Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Thu, 5 Nov 2026 10:38:38 -0800 Subject: [PATCH 01/60] Fail tests whose baseline should be deleted When a test stops producing a baseline that has a reference, the harness wrote the .delete marker but did not fail the test, so the change went unnoticed until someone ran baseline-accept and lost the reference without reviewing why. --- tsc/internal/testutil/baseline/baseline.go | 2 ++ 1 file changed, 2 insertions(+) diff --git a/tsc/internal/testutil/baseline/baseline.go b/tsc/internal/testutil/baseline/baseline.go index 539728ce16579..bdec15966b34a 100644 --- a/tsc/internal/testutil/baseline/baseline.go +++ b/tsc/internal/testutil/baseline/baseline.go @@ -65,7 +65,9 @@ func writeComparison(t *testing.T, actualContent string, local, reference string if actualContent == NoContent { if err := os.WriteFile(local+".delete", []byte{}, 0o644); err != nil { t.Error(fmt.Errorf("failed to write the local baseline file %s: %w", local+".delete", err)) + return } + t.Errorf("the baseline file %s should be deleted. (Run `hereby baseline-accept` if the deletion is correct.)", reference) return } if err := os.WriteFile(local, []byte(actualContent), 0o644); err != nil { From 2421fa61515fb8d245a2e4633702c7ebc2ed360b Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Wed, 21 Oct 2026 21:38:28 -0700 Subject: [PATCH 02/60] Add check order variants and a check order fuzzer to the test harness Checker results should not depend on which files were checked first, on which types an editor happened to ask for before diagnostics were requested, or on whether a file was emitted before it was checked. Tests had no way to show such dependence, so fixes for it could only be described, not demonstrated. The harness-only checkOrder option queries the checker in a different order: files in reverse, each file in its own program, or every expression's type, symbol, contextual type, resolved signature, and the types of names in type annotations before any diagnostics. The same orders apply to emit. Listing several orders produces a baseline for each, so order dependence shows up as differing baselines. Fixed orders over whole files miss results that depend on which single query a checker answers first. With TS_CHECK_ORDER_FUZZ=n, each test without a checkOrder option is checked again n times in fresh programs that first answer a seeded random selection of queries and single file emits. Any change in diagnostics, emitted output, or the type or symbol of a node fails the test with the seed and a minimized list of queries that reproduces it. Symbol IDs in printed names are ignored, as they follow creation order by design. The fuzzer is off by default, so it does not slow the normal suite. --- tsc/internal/testrunner/compiler_runner.go | 11 +- .../testutil/harnessutil/checkorderfuzz.go | 353 ++++++++++++++++++ .../testutil/harnessutil/harnessutil.go | 149 +++++++- 3 files changed, 507 insertions(+), 6 deletions(-) create mode 100644 tsc/internal/testutil/harnessutil/checkorderfuzz.go diff --git a/tsc/internal/testrunner/compiler_runner.go b/tsc/internal/testrunner/compiler_runner.go index 75c8329bafba8..c7081ce8b6b44 100644 --- a/tsc/internal/testrunner/compiler_runner.go +++ b/tsc/internal/testrunner/compiler_runner.go @@ -13,6 +13,7 @@ import ( "github.com/microsoft/TypeScript/tsc/internal/ast" "github.com/microsoft/TypeScript/tsc/internal/checker" + "github.com/microsoft/TypeScript/tsc/internal/collections" "github.com/microsoft/TypeScript/tsc/internal/core" "github.com/microsoft/TypeScript/tsc/internal/repo" "github.com/microsoft/TypeScript/tsc/internal/testutil" @@ -186,6 +187,14 @@ func (r *CompilerBaselineRunner) runSingleConfigTest(t *testing.T, testName stri compilerTest.verifyParentPointers(t) } +// compilerTestVaryBy adds harness options that may vary to the compiler options +// that may vary. +var compilerTestVaryBy = func() *collections.Set[string] { + s := compilerVaryBy.Clone() + s.Add("checkorder") + return s +}() + type compilerFileBasedTest struct { filename string content string @@ -198,7 +207,7 @@ func getCompilerFileBasedTest(t *testing.T, filename string) *compilerFileBasedT panic("Could not read test file: " + filename) } settings := extractCompilerSettings(content) - configurations := harnessutil.GetFileBasedTestConfigurations(t, settings, compilerVaryBy) + configurations := harnessutil.GetFileBasedTestConfigurations(t, settings, compilerTestVaryBy) return &compilerFileBasedTest{ filename: filename, content: content, diff --git a/tsc/internal/testutil/harnessutil/checkorderfuzz.go b/tsc/internal/testutil/harnessutil/checkorderfuzz.go new file mode 100644 index 0000000000000..3411de7c29fcd --- /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(t, 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(t, host, fuzzConfig), rand.New(rand.NewPCG(seed, stream))) + diverges := func(queries []fuzzQuery) bool { + return fuzzDiff(expected, fuzzRun(t, 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(t, 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(t *testing.T, ctx context.Context, host compiler.CompilerHost, config *tsoptions.ParsedCommandLine, queries []fuzzQuery) fuzzResult { + program := createProgram(t, 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 97055cb812622..ce171273c6d53 100644 --- a/tsc/internal/testutil/harnessutil/harnessutil.go +++ b/tsc/internal/testutil/harnessutil/harnessutil.go @@ -18,6 +18,7 @@ import ( "github.com/microsoft/TypeScript/tsc/internal/ast" "github.com/microsoft/TypeScript/tsc/internal/bundled" + "github.com/microsoft/TypeScript/tsc/internal/checker" "github.com/microsoft/TypeScript/tsc/internal/collections" "github.com/microsoft/TypeScript/tsc/internal/compiler" "github.com/microsoft/TypeScript/tsc/internal/contentmapper" @@ -76,6 +77,7 @@ type HarnessOptions struct { ReportDiagnostics bool CaptureSuggestions bool TypescriptVersion string + CheckOrder string } func CompileFiles( @@ -226,6 +228,7 @@ func CompileFilesEx( result := compileFilesWithHost(t, host, config, harnessOptions) result.Symlinks = symlinks result.Trace = host.tracer.String() + fuzzCheckOrder(t, host, config, harnessOptions) result.Repeat = func(testConfig TestConfiguration) *CompilationResult { newHarnessOptions := *harnessOptions newCompilerOptions := compilerOptions.Clone() @@ -362,6 +365,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) } @@ -645,8 +676,7 @@ func compileFilesWithHost( preErrors = append(preErrors, preProgram.GetConfigFileParsingDiagnostics()...) preErrors = append(preErrors, preProgram.GetProgramDiagnostics()...) preErrors = append(preErrors, preProgram.GetSyntacticDiagnostics(ctx, nil)...) - preErrors = append(preErrors, preProgram.GetSemanticDiagnostics(ctx, nil)...) - preErrors = append(preErrors, preProgram.GetGlobalDiagnostics(ctx)...) + preErrors = append(preErrors, getCheckerDiagnostics(t, ctx, host, preConfig, preProgram, harnessOptions.CheckOrder)...) if harnessOptions.CaptureSuggestions { preErrors = append(preErrors, preProgram.GetSuggestionDiagnostics(ctx, nil)...) } @@ -656,13 +686,12 @@ func compileFilesWithHost( preErrors = compiler.SortAndDeduplicateDiagnostics(preErrors) postProgram := createProgram(t, host, config) - emitResult := postProgram.Emit(ctx, compiler.EmitOptions{}) + emitResult := emitInOrder(t, ctx, host, config, postProgram, harnessOptions.CheckOrder) var postErrors []*ast.Diagnostic postErrors = append(postErrors, postProgram.GetConfigFileParsingDiagnostics()...) postErrors = append(postErrors, postProgram.GetProgramDiagnostics()...) postErrors = append(postErrors, postProgram.GetSyntacticDiagnostics(ctx, nil)...) - postErrors = append(postErrors, postProgram.GetSemanticDiagnostics(ctx, nil)...) - postErrors = append(postErrors, postProgram.GetGlobalDiagnostics(ctx)...) + postErrors = append(postErrors, getCheckerDiagnostics(t, ctx, host, config, postProgram, harnessOptions.CheckOrder)...) if postProgram.Options().GetEmitDeclarations() { postErrors = append(postErrors, postProgram.GetDeclarationDiagnostics(ctx, nil)...) } @@ -702,6 +731,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(t *testing.T, ctx context.Context, host compiler.CompilerHost, config *tsoptions.ParsedCommandLine, program compiler.ProgramLike, order string) []*ast.Diagnostic { + var files []*ast.SourceFile + for _, file := range program.GetSourceFiles() { + if !program.Program().SkipTypeChecking(file, false) { + files = append(files, file) + } + } + var result []*ast.Diagnostic + switch order { + case "", "default": + result = append(result, program.GetSemanticDiagnostics(ctx, nil)...) + result = append(result, program.GetGlobalDiagnostics(ctx)...) + case "reverse": + for _, file := range slices.Backward(files) { + result = append(result, program.GetSemanticDiagnostics(ctx, file)...) + } + result = append(result, program.GetGlobalDiagnostics(ctx)...) + case "isolated": + for _, file := range files { + isolated := createProgram(t, host, config) + isolatedFile := isolated.GetSourceFile(file.FileName()) + result = append(result, isolated.GetSemanticDiagnostics(ctx, isolatedFile)...) + result = append(result, isolated.GetGlobalDiagnostics(ctx)...) + } + case "typesfirst": + for _, file := range slices.Backward(files) { + c, done := program.Program().GetTypeCheckerForFile(ctx, file) + queryNodes(c, file) + done() + } + result = append(result, program.GetSemanticDiagnostics(ctx, nil)...) + result = append(result, program.GetGlobalDiagnostics(ctx)...) + default: + panic("unknown check order " + order) + } + return compiler.SortAndDeduplicateDiagnostics(result) +} + +// emitInOrder emits program, querying the checker in the given order: each +// file emitted separately, in reverse or in a program of its own, or after +// querying every node of every file in reverse. +func emitInOrder(t *testing.T, ctx context.Context, host compiler.CompilerHost, config *tsoptions.ParsedCommandLine, program compiler.ProgramLike, order string) *compiler.EmitResult { + options := program.Options() + if order == "" || order == "default" || options.OutFile != "" || options.NoEmitOnError.IsTrue() { + // Emitting files separately would change what a bundle or an emit + // blocked by errors contains. + return program.Emit(ctx, compiler.EmitOptions{}) + } + files := program.GetSourceFiles() + if order == "typesfirst" { + for _, file := range slices.Backward(files) { + if program.Program().SkipTypeChecking(file, false) { + continue + } + c, done := program.Program().GetTypeCheckerForFile(ctx, file) + queryNodes(c, file) + done() + } + return program.Emit(ctx, compiler.EmitOptions{}) + } + result := &compiler.EmitResult{} + emitFile := func(p compiler.ProgramLike, file *ast.SourceFile) { + r := p.Emit(ctx, compiler.EmitOptions{TargetSourceFiles: []*ast.SourceFile{file}}) + result.EmitSkipped = result.EmitSkipped || r.EmitSkipped + result.Diagnostics = append(result.Diagnostics, r.Diagnostics...) + result.EmittedFiles = append(result.EmittedFiles, r.EmittedFiles...) + result.SourceMaps = append(result.SourceMaps, r.SourceMaps...) + } + switch order { + case "reverse": + for _, file := range slices.Backward(files) { + emitFile(program, file) + } + case "isolated": + for _, file := range files { + isolated := createProgram(t, host, config) + emitFile(isolated, isolated.GetSourceFile(file.FileName())) + } + default: + panic("unknown check order " + order) + } + result.Diagnostics = compiler.SortAndDeduplicateDiagnostics(result.Diagnostics) + return result +} + +func queryNodes(c *checker.Checker, file *ast.SourceFile) { + var nodes []*ast.Node + var visit func(n *ast.Node) bool + visit = func(n *ast.Node) bool { + if n.Flags&ast.NodeFlagsReparsed == 0 { + nodes = append(nodes, n) + } + n.ForEachChild(visit) + return false + } + file.AsNode().ForEachChild(visit) + for _, n := range slices.Backward(nodes) { + if ast.IsExpressionNode(n) || n.Kind == ast.KindIdentifier || ast.IsDeclarationName(n) { + for _, kind := range fuzzNodeQueryKinds(n) { + fuzzQueryResult(c, n, kind) + } + } + } +} + type CompilationResult struct { Diagnostics []*ast.Diagnostic Result *compiler.EmitResult @@ -1165,6 +1301,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 } From a2d8a85d97260d5d7b9a0ef4970099ce9f65fb02 Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Tue, 3 Nov 2026 14:16:07 -0800 Subject: [PATCH 03/60] Fuzz which files share a checker Order independence should also mean that results do not depend on which files a checker has been given, since project and compiler checker pools assign files differently. Let tests pick the checker of every file, and have the check order fuzzer use a seeded random assignment over two to four checkers for half of its seeds. --- tsc/internal/compiler/checkerpool.go | 41 +++++++++---- tsc/internal/compiler/program.go | 11 ++-- .../testutil/harnessutil/checkorderfuzz.go | 58 +++++++++++++++---- .../testutil/harnessutil/harnessutil.go | 6 ++ 4 files changed, 91 insertions(+), 25 deletions(-) diff --git a/tsc/internal/compiler/checkerpool.go b/tsc/internal/compiler/checkerpool.go index 2ee68c75c6275..6f63f62cf535a 100644 --- a/tsc/internal/compiler/checkerpool.go +++ b/tsc/internal/compiler/checkerpool.go @@ -33,6 +33,7 @@ type checkerPool struct { checkers []*checker.Checker locks []*sync.Mutex fileAssociations map[*ast.SourceFile]*checker.Checker + associations []int // from ProgramFactories.AssignCheckers, if set } var _ CheckerPool = (*checkerPool)(nil) @@ -307,20 +308,35 @@ func newCheckerPool(program *Program) *checkerPool { } func newCheckerPoolWithTracing(program *Program, tr *tracing.Tracing) *checkerPool { + return newCheckerPoolWithAssignment(program, tr, nil) +} + +// newCheckerPoolWithAssignment is newCheckerPoolWithTracing with the checker +// of each file given by assign, if set; see ProgramFactories.AssignCheckers. +func newCheckerPoolWithAssignment(program *Program, tr *tracing.Tracing, assign func([]*ast.SourceFile) []int) *checkerPool { + var associations []int checkerCount := 4 - if program.SingleThreaded() { + if assign != nil { + associations = assign(program.files) checkerCount = 1 - } else if c := program.Options().Checkers; c != nil { - checkerCount = *c + if len(associations) > 0 { + checkerCount = slices.Max(associations) + 1 + } + } else { + if program.SingleThreaded() { + checkerCount = 1 + } else if c := program.Options().Checkers; c != nil { + checkerCount = *c + } + checkerCount = max(min(checkerCount, len(program.files), 256), 1) } - checkerCount = max(min(checkerCount, len(program.files), 256), 1) - pool := &checkerPool{ - program: program, - checkers: make([]*checker.Checker, checkerCount), - locks: make([]*sync.Mutex, checkerCount), - tracing: tr, + program: program, + checkers: make([]*checker.Checker, checkerCount), + locks: make([]*sync.Mutex, checkerCount), + tracing: tr, + associations: associations, } return pool @@ -380,8 +396,11 @@ func (p *checkerPool) createCheckers() { wg.RunAndWait() - associations := make([]int, len(p.program.files)) - if checkerCount > 1 { + associations := p.associations + if associations == nil { + associations = make([]int, len(p.program.files)) + } + if checkerCount > 1 && p.associations == nil { baseWeights := make([]int, len(p.program.files)) importCounts := make([]int, len(p.program.files)) isDeclarationFile := make([]bool, len(p.program.files)) diff --git a/tsc/internal/compiler/program.go b/tsc/internal/compiler/program.go index 06854eada0bb7..30dc482904816 100644 --- a/tsc/internal/compiler/program.go +++ b/tsc/internal/compiler/program.go @@ -60,6 +60,9 @@ type ProgramHosts struct { type ProgramFactories struct { CreateCheckerPool func(*Program) CheckerPool CreateModuleResolver func(module.ResolverOptions) module.Resolver + // AssignCheckers, for testing, returns the index of the checker for each + // file of the program, in place of the usual checker count and assignment. + AssignCheckers func(files []*ast.SourceFile) []int } func (p *ProgramConfig) canUseProjectReferenceSource() bool { @@ -332,7 +335,7 @@ func NewProgram(ctx context.Context, opts ProgramOptions) (*Program, error) { if err := ctx.Err(); err != nil { return nil, err } - p.initCheckerPool(opts.CreateCheckerPool) + p.initCheckerPool(opts.CreateCheckerPool, opts.AssignCheckers) p.verifyCompilerOptions() p.collectContentMapperOptionDiagnostics() if err := ctx.Err(); err != nil { @@ -462,11 +465,11 @@ func (p *Program) ReuseProgram( } } result.replaceSyntheticImports(newFile, newSupplementalFiles) - result.initCheckerPool(createCheckerPool) + result.initCheckerPool(createCheckerPool, nil) return result, newFile, true } -func (p *Program) initCheckerPool(create func(*Program) CheckerPool) { +func (p *Program) initCheckerPool(create func(*Program) CheckerPool, assign func([]*ast.SourceFile) []int) { if !p.finishedProcessing { panic("Program must finish processing files before initializing checker pool") } @@ -474,7 +477,7 @@ func (p *Program) initCheckerPool(create func(*Program) CheckerPool) { if create != nil { p.checkerPool = create(p) } else { - pool := newCheckerPoolWithTracing(p, p.hosts.Tracing) + pool := newCheckerPoolWithAssignment(p, p.hosts.Tracing, assign) p.checkerPool = pool p.compilerCheckerPool = pool } diff --git a/tsc/internal/testutil/harnessutil/checkorderfuzz.go b/tsc/internal/testutil/harnessutil/checkorderfuzz.go index 3411de7c29fcd..f22957b7710f2 100644 --- a/tsc/internal/testutil/harnessutil/checkorderfuzz.go +++ b/tsc/internal/testutil/harnessutil/checkorderfuzz.go @@ -86,7 +86,7 @@ func fuzzCheckOrder(t *testing.T, host compiler.CompilerHost, config *tsoptions. fuzzConfig.Errors = config.Errors ctx := context.Background() - expected := fuzzRun(t, ctx, host, fuzzConfig, nil) + expected := fuzzRun(t, ctx, host, fuzzConfig, nil, nil) seeds := make([]uint64, n) for i := range seeds { seeds[i] = uint64(i) @@ -102,21 +102,40 @@ func fuzzCheckOrder(t *testing.T, host compiler.CompilerHost, config *tsoptions. h.Write([]byte(t.Name())) stream := h.Sum64() for _, seed := range seeds { - queries := fuzzQueries(createProgram(t, host, fuzzConfig), rand.New(rand.NewPCG(seed, stream))) + rng := rand.New(rand.NewPCG(seed, stream)) + queries := fuzzQueries(createProgram(t, host, fuzzConfig), rng) + assign := fuzzAssignCheckers(rng) diverges := func(queries []fuzzQuery) bool { - return fuzzDiff(expected, fuzzRun(t, ctx, host, fuzzConfig, queries)) != "" + return fuzzDiff(expected, fuzzRun(t, ctx, host, fuzzConfig, assign, 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) + fmt.Fprintf(&b, "check order fuzzing with TS_CHECK_ORDER_FUZZ_SEED=%d changed results", seed) + if assign != nil { + b.WriteString(" with files checked by checkers:\n") + program := createProgram(t, host, fuzzConfig).Program() + files := program.GetSourceFiles() + for i, c := range assign(files) { + if !program.IsSourceFileDefaultLibrary(files[i].PathKey()) { + fmt.Fprintf(&b, " %s: %d\n", files[i].FileName(), c) + } + } + } else { + b.WriteString("\n") + } + if diverges(nil) { + queries = nil + } else { + queries = fuzzMinimize(queries, diverges) + b.WriteString("after querying:\n") + for _, q := range queries { + fmt.Fprintf(&b, " %s\n", q) + } } b.WriteString("results in program order (-) and after the queries (+):\n") - b.WriteString(fuzzDiff(expected, fuzzRun(t, ctx, host, fuzzConfig, queries))) + b.WriteString(fuzzDiff(expected, fuzzRun(t, ctx, host, fuzzConfig, assign, queries))) t.Error(b.String()) } } @@ -248,10 +267,29 @@ func fuzzQueryResultWithIDs(c *checker.Checker, node *ast.Node, kind fuzzQueryKi return "" } +// fuzzAssignCheckers returns, for half of the seeds, a random assignment of +// files to up to four checkers, so that results cannot depend on which +// files share a checker. +func fuzzAssignCheckers(rng *rand.Rand) func([]*ast.SourceFile) []int { + if rng.IntN(2) == 0 { + return nil + } + count := 2 + rng.IntN(3) + seed := rng.Uint64() + return func(files []*ast.SourceFile) []int { + r := rand.New(rand.NewPCG(seed, 0)) + associations := make([]int, len(files)) + for i := range associations { + associations[i] = r.IntN(count) + } + return associations + } +} + // fuzzRun answers queries, given in the files of the program that // fuzzQueries was given, in a fresh program, then returns its results. -func fuzzRun(t *testing.T, ctx context.Context, host compiler.CompilerHost, config *tsoptions.ParsedCommandLine, queries []fuzzQuery) fuzzResult { - program := createProgram(t, host, config) +func fuzzRun(t *testing.T, ctx context.Context, host compiler.CompilerHost, config *tsoptions.ParsedCommandLine, assign func([]*ast.SourceFile) []int, queries []fuzzQuery) fuzzResult { + program := createProgramWithCheckers(t, host, config, assign) files := fuzzCheckedFiles(program) // Queries name nodes of another program over the same files, so find // the same nodes here by their index. diff --git a/tsc/internal/testutil/harnessutil/harnessutil.go b/tsc/internal/testutil/harnessutil/harnessutil.go index ce171273c6d53..5df552f26e102 100644 --- a/tsc/internal/testutil/harnessutil/harnessutil.go +++ b/tsc/internal/testutil/harnessutil/harnessutil.go @@ -1109,6 +1109,11 @@ func getTestBuildInfoReader(host compiler.CompilerHost) *testBuildInfoReader { } func createProgram(t *testing.T, host compiler.CompilerHost, config *tsoptions.ParsedCommandLine) compiler.ProgramLike { + t.Helper() + return createProgramWithCheckers(t, host, config, nil) +} + +func createProgramWithCheckers(t *testing.T, host compiler.CompilerHost, config *tsoptions.ParsedCommandLine, assignCheckers func([]*ast.SourceFile) []int) compiler.ProgramLike { t.Helper() var singleThreaded core.Tristate if testutil.TestProgramIsSingleThreaded() { @@ -1119,6 +1124,7 @@ func createProgram(t *testing.T, host compiler.CompilerHost, config *tsoptions.P Config: config, Host: host, SingleThreaded: singleThreaded, + AssignCheckers: assignCheckers, } program, err := compiler.NewProgram(t.Context(), programOptions) if err != nil { From bdd2e1fd8ff7d6f8f97a6c4c5abf44bfd69f58e5 Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Fri, 6 Nov 2026 22:33:49 -0800 Subject: [PATCH 04/60] Fuzz language service requests Editors ask the checker for more than the types and symbols the fuzzer queries: hover, signature help, completions and inlay hints reach parts of the checker those queries do not, such as the node builder and call resolution for signature help. With TS_CHECK_ORDER_FUZZ_LS set, the fuzzer also makes these requests, and compares their results. --- .../testutil/harnessutil/checkorderfuzz.go | 48 +++- .../testutil/harnessutil/checkorderfuzz_ls.go | 208 ++++++++++++++++++ 2 files changed, 255 insertions(+), 1 deletion(-) create mode 100644 tsc/internal/testutil/harnessutil/checkorderfuzz_ls.go diff --git a/tsc/internal/testutil/harnessutil/checkorderfuzz.go b/tsc/internal/testutil/harnessutil/checkorderfuzz.go index f22957b7710f2..e33977195e1cd 100644 --- a/tsc/internal/testutil/harnessutil/checkorderfuzz.go +++ b/tsc/internal/testutil/harnessutil/checkorderfuzz.go @@ -44,6 +44,11 @@ const ( fuzzQuerySignature fuzzQueryDiagnostics fuzzQueryEmit + fuzzQueryHover + fuzzQueryDefinition + fuzzQuerySignatureHelp + fuzzQueryCompletion + fuzzQueryInlayHints ) var fuzzQueryKindNames = [...]string{ @@ -51,6 +56,10 @@ var fuzzQueryKindNames = [...]string{ fuzzQuerySymbol: "symbol", fuzzQueryContextualType: "contextual type", fuzzQuerySignature: "signature", + fuzzQueryHover: "hover", + fuzzQueryDefinition: "definition", + fuzzQuerySignatureHelp: "signature help", + fuzzQueryCompletion: "completions", } func (q fuzzQuery) String() string { @@ -59,6 +68,8 @@ func (q fuzzQuery) String() string { return fmt.Sprintf("diagnostics of %s", q.file.FileName()) case fuzzQueryEmit: return fmt.Sprintf("emit of %s", q.file.FileName()) + case fuzzQueryInlayHints: + return fmt.Sprintf("inlay hints of %s", q.file.FileName()) } kind := fuzzQueryKindNames[q.kind] if ast.PositionIsSynthesized(q.node.Pos()) { @@ -146,6 +157,9 @@ func fuzzQueries(program compiler.ProgramLike, rng *rand.Rand) []fuzzQuery { var queries []fuzzQuery for _, file := range fuzzCheckedFiles(program) { queries = append(queries, fuzzQuery{file: file, kind: fuzzQueryDiagnostics}, fuzzQuery{file: file, kind: fuzzQueryEmit}) + if fuzzLS { + queries = append(queries, fuzzQuery{file: file, kind: fuzzQueryInlayHints}) + } for i, node := range fuzzNodes(file) { for _, kind := range fuzzNodeQueryKinds(node) { queries = append(queries, fuzzQuery{file, node, i, kind}) @@ -234,7 +248,7 @@ func fuzzNodeQueryKinds(node *ast.Node) []fuzzQueryKind { if ast.IsCallLikeExpression(node) { kinds = append(kinds, fuzzQuerySignature) } - return kinds + return fuzzLSNodeQueryKinds(node, kinds) } // fuzzSymbolIDs matches the symbol IDs that the names of unique symbol @@ -297,6 +311,10 @@ func fuzzRun(t *testing.T, ctx context.Context, host compiler.CompilerHost, conf for _, file := range files { nodesByFile[string(file.FileName())] = fuzzNodes(file) } + var lang *fuzzLSService + if fuzzLS { + lang = fuzzLanguageService(program.Program()) + } for _, q := range queries { file := program.GetSourceFile(q.file.FileName()) switch q.kind { @@ -306,8 +324,15 @@ func fuzzRun(t *testing.T, ctx context.Context, host compiler.CompilerHost, conf case fuzzQueryEmit: program.Emit(ctx, compiler.EmitOptions{TargetSourceFiles: []*ast.SourceFile{file}, WriteFile: fuzzDiscardOutput}) continue + case fuzzQueryInlayHints: + fuzzLSResult(ctx, lang, file, nil, q.kind) + continue } node := nodesByFile[string(file.FileName())][q.index] + if fuzzIsLSQuery(q.kind) { + fuzzLSResult(ctx, lang, file, node, q.kind) + continue + } c, done := program.Program().GetTypeCheckerForFile(ctx, file) fuzzQueryResult(c, node, q.kind) done() @@ -334,6 +359,9 @@ func fuzzRun(t *testing.T, ctx context.Context, host compiler.CompilerHost, conf c, done := program.Program().GetTypeCheckerForFile(ctx, file) for i, node := range nodesByFile[string(file.FileName())] { for _, kind := range fuzzNodeQueryKinds(node) { + if fuzzIsLSQuery(kind) { + continue + } if r := fuzzQueryResult(c, node, kind); r != "" { result = append(result, fmt.Sprintf("%s: %s", fuzzQuery{file, node, i, kind}, r)) } @@ -341,6 +369,24 @@ func fuzzRun(t *testing.T, ctx context.Context, host compiler.CompilerHost, conf } done() } + if lang != nil { + // Language service requests take the checker themselves. + for _, file := range files { + if r := fuzzLSResult(ctx, lang, file, nil, fuzzQueryInlayHints); r != "" { + result = append(result, fmt.Sprintf("%s: %s", fuzzQuery{file: file, kind: fuzzQueryInlayHints}, r)) + } + for i, node := range nodesByFile[string(file.FileName())] { + for _, kind := range fuzzNodeQueryKinds(node) { + if !fuzzIsLSQuery(kind) { + continue + } + if r := fuzzLSResult(ctx, lang, file, node, kind); r != "" { + result = append(result, fmt.Sprintf("%s: %s", fuzzQuery{file, node, i, kind}, r)) + } + } + } + } + } return result } diff --git a/tsc/internal/testutil/harnessutil/checkorderfuzz_ls.go b/tsc/internal/testutil/harnessutil/checkorderfuzz_ls.go new file mode 100644 index 0000000000000..d949355a9d07b --- /dev/null +++ b/tsc/internal/testutil/harnessutil/checkorderfuzz_ls.go @@ -0,0 +1,208 @@ +package harnessutil + +import ( + "cmp" + "context" + "os" + "slices" + "sync" + + "github.com/microsoft/TypeScript/tsc/internal/ast" + "github.com/microsoft/TypeScript/tsc/internal/compiler" + "github.com/microsoft/TypeScript/tsc/internal/core" + "github.com/microsoft/TypeScript/tsc/internal/json" + "github.com/microsoft/TypeScript/tsc/internal/ls" + "github.com/microsoft/TypeScript/tsc/internal/ls/autoimport" + "github.com/microsoft/TypeScript/tsc/internal/ls/lsconv" + "github.com/microsoft/TypeScript/tsc/internal/ls/lsutil" + "github.com/microsoft/TypeScript/tsc/internal/lsp/lsproto" + "github.com/microsoft/TypeScript/tsc/internal/scanner" + "github.com/microsoft/TypeScript/tsc/internal/sourcemap" + "github.com/microsoft/TypeScript/tsc/internal/tspath" +) + +// Setting TS_CHECK_ORDER_FUZZ_LS=1 as well also makes language service +// requests queries: hover and definition at identifiers, signature help at +// arguments, member completions after property accesses, and the inlay hints +// of a file. Their results must not differ either. +var fuzzLS = os.Getenv("TS_CHECK_ORDER_FUZZ_LS") != "" + +// fuzzLSNodeQueryKinds returns the kinds of language service request that +// apply to node. +func fuzzLSNodeQueryKinds(node *ast.Node, kinds []fuzzQueryKind) []fuzzQueryKind { + if !fuzzLS || ast.PositionIsSynthesized(node.Pos()) { + return kinds + } + if ast.IsIdentifier(node) { + kinds = append(kinds, fuzzQueryHover, fuzzQueryDefinition) + if ast.IsPropertyAccessExpression(node.Parent) && node.Parent.Name() == node { + kinds = append(kinds, fuzzQueryCompletion) + } + } + if parent := node.Parent; parent != nil && ast.IsCallOrNewExpression(parent) && node != parent.Expression() { + kinds = append(kinds, fuzzQuerySignatureHelp) + } + return kinds +} + +func fuzzIsLSQuery(kind fuzzQueryKind) bool { + return kind >= fuzzQueryHover +} + +// fuzzLanguageService returns a language service for program. +func fuzzLanguageService(program *compiler.Program) *fuzzLSService { + host := &fuzzLSHost{program: program} + // Results in lib files are converted often, and computing their line + // maps each time makes requests quadratic in their size. + var mu sync.Mutex + lineMaps := make(map[tspath.RootedFilePath]*lsconv.LSPLineMap) + host.converters = lsconv.NewConverters(lsproto.PositionEncodingKindUTF16, func(fileName tspath.RootedFilePath) *lsconv.LSPLineMap { + mu.Lock() + defer mu.Unlock() + if lineMap, ok := lineMaps[fileName]; ok { + return lineMap + } + var lineMap *lsconv.LSPLineMap + if file := program.GetSourceFile(fileName); file != nil { + lineMap = lsconv.ComputeLSPLineStarts(file.Text()) + } + lineMaps[fileName] = lineMap + return lineMap + }) + return &fuzzLSService{ls.NewLanguageService(fuzzProjectID{}, program, host, ""), host.converters} +} + +type fuzzLSService struct { + *ls.LanguageService + converters *lsconv.Converters +} + +// fuzzLSResult makes the language service request of kind at node, or for +// the whole file if node is nil, returning its result as text. +func fuzzLSResult(ctx context.Context, lang *fuzzLSService, file *ast.SourceFile, node *ast.Node, kind fuzzQueryKind) string { + uri := lsconv.FileNameToDocumentURI(file.FileName()) + if uri.FileName() != file.FileName() { + // The language service cannot find a file whose name a URI does not + // preserve. + return "" + } + position := func(pos int) lsproto.Position { + p, _ := lang.converters.ToLSPPosition(file, core.TextPos(pos)) + return p + } + var result any + var err error + switch kind { + case fuzzQueryHover: + result, err = lang.ProvideHover(ctx, &lsproto.HoverParams{ + TextDocument: lsproto.TextDocumentIdentifier{Uri: uri}, + Position: position(scanner.GetTokenPosOfNode(node, file, false)), + }) + case fuzzQueryDefinition: + result, err = lang.ProvideDefinition(ctx, uri, position(scanner.GetTokenPosOfNode(node, file, false))) + case fuzzQuerySignatureHelp: + result, err = lang.ProvideSignatureHelp(ctx, uri, position(scanner.GetTokenPosOfNode(node, file, false)), nil) + case fuzzQueryCompletion: + var completions lsproto.CompletionResponse + completions, err = lang.ProvideCompletion(ctx, uri, position(node.End()), nil) + if completions.List != nil { + // Editors sort items by sort text and label, and the language + // service leaves those that tie in no particular order. + slices.SortStableFunc(completions.List.Items, func(a, b *lsproto.CompletionItem) int { + return cmp.Or(cmp.Compare(fuzzSortText(a), fuzzSortText(b)), cmp.Compare(a.Label, b.Label)) + }) + } + result = completions + case fuzzQueryInlayHints: + result, err = lang.ProvideInlayHint(ctx, &lsproto.InlayHintParams{ + TextDocument: lsproto.TextDocumentIdentifier{Uri: uri}, + Range: lsproto.Range{Start: position(0), End: position(len(file.Text()))}, + }) + } + if err != nil { + return "error: " + err.Error() + } + text, err := json.Marshal(result) + if err != nil { + return "error: " + err.Error() + } + if string(text) == "null" { + return "" + } + return string(text) +} + +func fuzzSortText(item *lsproto.CompletionItem) string { + if item.SortText == nil { + return "" + } + return *item.SortText +} + +type fuzzProjectID struct{} + +func (fuzzProjectID) String() string { return "fuzz" } + +// fuzzLSHost is the language service host of a program alone. +type fuzzLSHost struct { + program *compiler.Program + converters *lsconv.Converters +} + +func (h *fuzzLSHost) CaseSensitivity() tspath.CaseSensitivity { + return h.program.Host().FS().CaseSensitivity() +} + +func (h *fuzzLSHost) ReadFile(path tspath.RootedFilePath) (string, bool) { + return h.program.Host().FS().ReadFile(path) +} + +func (h *fuzzLSHost) Converters() *lsconv.Converters { + return h.converters +} + +func (h *fuzzLSHost) GetPreferences(activeFile string) lsutil.UserPreferences { + preferences := lsutil.NewDefaultUserPreferences() + preferences.IncludeCompletionsForModuleExports = core.TSFalse + preferences.IncludeCompletionsForImportStatements = core.TSFalse + preferences.InlayHintsPreferences = lsutil.InlayHintsPreferences{ + IncludeInlayEnumMemberValueHints: core.TSTrue, + IncludeInlayFunctionLikeReturnTypeHints: core.TSTrue, + IncludeInlayFunctionParameterTypeHints: core.TSTrue, + IncludeInlayParameterNameHints: lsutil.IncludeInlayParameterNameHintsAll, + IncludeInlayPropertyDeclarationTypeHints: core.TSTrue, + IncludeInlayVariableTypeHints: core.TSTrue, + } + return preferences +} + +func (h *fuzzLSHost) GetWorkspaceFolders() []ls.WorkspaceFolder { + return nil +} + +func (h *fuzzLSHost) GetECMALineInfo(fileName tspath.RootedFilePath) *sourcemap.ECMALineInfo { + if file := h.program.GetSourceFile(fileName); file != nil { + return sourcemap.CreateECMALineInfo(file.Text(), file.ECMALineMap()) + } + return nil +} + +func (h *fuzzLSHost) AutoImportRegistry() *autoimport.Registry { + return nil +} + +func (h *fuzzLSHost) ReadDirectory(path tspath.RootedDirectoryPath, extensions []string, excludes []string, includes []string, depth int) []tspath.RootedFilePath { + return nil +} + +func (h *fuzzLSHost) GetDirectories(path tspath.RootedDirectoryPath) []string { + return nil +} + +func (h *fuzzLSHost) DirectoryExists(path tspath.RootedDirectoryPath) bool { + return h.program.Host().FS().DirectoryExists(path) +} + +func (h *fuzzLSHost) FileExists(path tspath.RootedFilePath) bool { + return h.program.Host().FS().FileExists(path) +} From ff85fad88eb72bd54310c54ae920d855c20a9c2f Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Sat, 7 Nov 2026 08:59:18 -0800 Subject: [PATCH 05/60] Add a check order that makes editor requests first Editors show inlay hints, hover and signature help, each of which asks the checker for things checking alone does not, and none of which is supposed to change the diagnostics or output of checking and emit. A check order that makes those requests first lets tests show where they do. --- .../testutil/harnessutil/harnessutil.go | 37 +++++++++++++++++++ 1 file changed, 37 insertions(+) diff --git a/tsc/internal/testutil/harnessutil/harnessutil.go b/tsc/internal/testutil/harnessutil/harnessutil.go index 5df552f26e102..eaec6c7286621 100644 --- a/tsc/internal/testutil/harnessutil/harnessutil.go +++ b/tsc/internal/testutil/harnessutil/harnessutil.go @@ -387,6 +387,10 @@ var checkOrders = []string{ // type and resolved signature of every expression and name in each // file, innermost and last first, as an editor might. "typesfirst", + // Before checking or emitting, make the requests an editor makes of + // each file: signature help at every argument, its inlay hints, then + // hover over every name, innermost and last first. + "editorfirst", } func getHarnessOption(name string) *tsoptions.CommandLineOption { @@ -765,6 +769,10 @@ func getCheckerDiagnostics(t *testing.T, ctx context.Context, host compiler.Comp } result = append(result, program.GetSemanticDiagnostics(ctx, nil)...) result = append(result, program.GetGlobalDiagnostics(ctx)...) + case "editorfirst": + makeEditorRequests(ctx, program, files) + result = append(result, program.GetSemanticDiagnostics(ctx, nil)...) + result = append(result, program.GetGlobalDiagnostics(ctx)...) default: panic("unknown check order " + order) } @@ -793,6 +801,12 @@ func emitInOrder(t *testing.T, ctx context.Context, host compiler.CompilerHost, } return program.Emit(ctx, compiler.EmitOptions{}) } + if order == "editorfirst" { + makeEditorRequests(ctx, program, core.Filter(files, func(file *ast.SourceFile) bool { + return !program.Program().SkipTypeChecking(file, false) + })) + return program.Emit(ctx, compiler.EmitOptions{}) + } result := &compiler.EmitResult{} emitFile := func(p compiler.ProgramLike, file *ast.SourceFile) { r := p.Emit(ctx, compiler.EmitOptions{TargetSourceFiles: []*ast.SourceFile{file}}) @@ -838,6 +852,29 @@ func queryNodes(c *checker.Checker, file *ast.SourceFile) { } } +// makeEditorRequests asks for signature help at every argument of each of +// files, its inlay hints, then hover over every name, innermost and last +// first. +func makeEditorRequests(ctx context.Context, program compiler.ProgramLike, files []*ast.SourceFile) { + lang := fuzzLanguageService(program.Program()) + for _, file := range slices.Backward(files) { + nodes := core.Filter(fuzzNodes(file), func(n *ast.Node) bool { + return !ast.PositionIsSynthesized(n.Pos()) + }) + for _, n := range slices.Backward(nodes) { + if parent := n.Parent; parent != nil && ast.IsCallOrNewExpression(parent) && n != parent.Expression() { + fuzzLSResult(ctx, lang, file, n, fuzzQuerySignatureHelp) + } + } + fuzzLSResult(ctx, lang, file, nil, fuzzQueryInlayHints) + for _, n := range slices.Backward(nodes) { + if ast.IsIdentifier(n) { + fuzzLSResult(ctx, lang, file, n, fuzzQueryHover) + } + } + } +} + type CompilationResult struct { Diagnostics []*ast.Diagnostic Result *compiler.EmitResult From a5a2476665af25c3f180bc815e62494fe8799f1d Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Wed, 21 Oct 2026 23:07:33 -0700 Subject: [PATCH 06/60] Add tests for check order dependence These tests record checker results that depend on the order in which files, declarations, and queries are checked, so that each later fix shows up as a reviewable baseline change. Most list several checkOrder variants; where the variants disagree, that disagreement is the bug. Some existing tests also gain the typesfirst order, as asking for types and symbols first changes the results they report. The cases cover: - variance measured through cycles of recursive references, which depended on which type in the cycle was measured first (64891, and a reduction of the react-relay DefinitelyTyped tests); - circularities whose blamed location is whichever use resolved first: circular type parameter defaults and constraints, a cycle through namespace spreads, awaiting a promise that refers back to itself, and import elision computing types before checking; - instantiation limit and excessive depth errors, reported only in whichever file reached the limit first; - late-bound members, computed enum members, and aliased module.exports members, which differ when queried before checking; - relation results cached against truncated or in-progress comparisons, including cycles through checks that branch on whether a nested comparison fails; - the order of types in unions, which followed type ids, and so creation order, for object literals, rest types, indexed accesses, type parameters, and iterator method types; - return type cycles through callbacks and subtype reduction, JSDoc type tags on contextually typed functions, a scope whose thunks refer to the scope, a never narrowing after a loop, and a const assertion inferred before its binding pattern (seen in OmniRoute, effect, webpack, arktype, uglify-js, and check order fuzzing). The circularity tests from PR 64834 are copied unchanged, to compare against how that PR handles the same cases. --- tsc/internal/testrunner/compiler_runner.go | 13 + ...hCheckOrder(checkorder=default).errors.txt | 19 + ...epthCheckOrder(checkorder=default).symbols | 141 + ...tDepthCheckOrder(checkorder=default).types | 24 + ...hCheckOrder(checkorder=typesfirst).symbols | 145 + ...pthCheckOrder(checkorder=typesfirst).types | 24 + ...yIdentifier(checkorder=default).errors.txt | 69 + ...rbirtraryIdentifier(checkorder=default).js | 44 + ...raryIdentifier(checkorder=default).symbols | 34 + ...rtraryIdentifier(checkorder=default).types | 44 + ...entifier(checkorder=typesfirst).errors.txt | 72 + ...rtraryIdentifier(checkorder=typesfirst).js | 44 + ...yIdentifier(checkorder=typesfirst).symbols | 34 + ...aryIdentifier(checkorder=typesfirst).types | 44 + ...rsiveTypeInferredThroughClosure.errors.txt | 86 + ...ecursiveTypeInferredThroughClosure.symbols | 424 +++ ...dRecursiveTypeInferredThroughClosure.types | 186 + ...sExpression(checkorder=default).errors.txt | 27 + ...lassExpression(checkorder=default).symbols | 33 + ...tClassExpression(checkorder=default).types | 47 + ...pression(checkorder=typesfirst).errors.txt | 24 + ...sExpression(checkorder=typesfirst).symbols | 33 + ...assExpression(checkorder=typesfirst).types | 47 + ...waitedCycle(checkorder=default).errors.txt | 24 + ...erAwaitedCycle(checkorder=default).symbols | 34 + ...rderAwaitedCycle(checkorder=default).types | 31 + ...aitedCycle(checkorder=isolated).errors.txt | 27 + ...rAwaitedCycle(checkorder=isolated).symbols | 34 + ...derAwaitedCycle(checkorder=isolated).types | 31 + ...waitedCycle(checkorder=reverse).errors.txt | 24 + ...erAwaitedCycle(checkorder=reverse).symbols | 34 + ...rderAwaitedCycle(checkorder=reverse).types | 31 + ...tedCycle(checkorder=typesfirst).errors.txt | 24 + ...waitedCycle(checkorder=typesfirst).symbols | 34 + ...rAwaitedCycle(checkorder=typesfirst).types | 31 + ...rConstraint(checkorder=default).errors.txt | 38 + ...rCircularConstraint(checkorder=default).js | 30 + ...ularConstraint(checkorder=default).symbols | 36 + ...rcularConstraint(checkorder=default).types | 41 + ...Constraint(checkorder=isolated).errors.txt | 37 + ...CircularConstraint(checkorder=isolated).js | 30 + ...larConstraint(checkorder=isolated).symbols | 36 + ...cularConstraint(checkorder=isolated).types | 41 + ...rConstraint(checkorder=reverse).errors.txt | 38 + ...rCircularConstraint(checkorder=reverse).js | 30 + ...ularConstraint(checkorder=reverse).symbols | 36 + ...rcularConstraint(checkorder=reverse).types | 41 + ...nstraint(checkorder=typesfirst).errors.txt | 38 + ...rcularConstraint(checkorder=typesfirst).js | 30 + ...rConstraint(checkorder=typesfirst).symbols | 36 + ...larConstraint(checkorder=typesfirst).types | 41 + ...larDefaults(checkorder=default).errors.txt | 15 + ...derCircularDefaults(checkorder=default).js | 31 + ...rcularDefaults(checkorder=default).symbols | 32 + ...CircularDefaults(checkorder=default).types | 22 + ...erCircularDefaults(checkorder=isolated).js | 31 + ...cularDefaults(checkorder=isolated).symbols | 32 + ...ircularDefaults(checkorder=isolated).types | 22 + ...larDefaults(checkorder=reverse).errors.txt | 15 + ...derCircularDefaults(checkorder=reverse).js | 31 + ...rcularDefaults(checkorder=reverse).symbols | 32 + ...CircularDefaults(checkorder=reverse).types | 22 + ...Defaults(checkorder=typesfirst).errors.txt | 15 + ...CircularDefaults(checkorder=typesfirst).js | 31 + ...larDefaults(checkorder=typesfirst).symbols | 32 + ...cularDefaults(checkorder=typesfirst).types | 22 + ...BeforeCheck(checkorder=default).errors.txt | 25 + ...rderEmitBeforeCheck(checkorder=default).js | 37 + ...mitBeforeCheck(checkorder=default).symbols | 49 + ...rEmitBeforeCheck(checkorder=default).types | 31 + ...eforeCheck(checkorder=isolated).errors.txt | 25 + ...derEmitBeforeCheck(checkorder=isolated).js | 37 + ...itBeforeCheck(checkorder=isolated).symbols | 49 + ...EmitBeforeCheck(checkorder=isolated).types | 31 + ...rEnumComputedMember(checkorder=default).js | 30 + ...ComputedMember(checkorder=default).symbols | 29 + ...umComputedMember(checkorder=default).types | 30 + ...EnumComputedMember(checkorder=isolated).js | 30 + ...omputedMember(checkorder=isolated).symbols | 29 + ...mComputedMember(checkorder=isolated).types | 30 + ...rEnumComputedMember(checkorder=reverse).js | 30 + ...ComputedMember(checkorder=reverse).symbols | 29 + ...umComputedMember(checkorder=reverse).types | 30 + ...umComputedMember(checkorder=typesfirst).js | 30 + ...putedMember(checkorder=typesfirst).symbols | 29 + ...omputedMember(checkorder=typesfirst).types | 30 + ...oundMembers(checkorder=default).errors.txt | 22 + ...teBoundMembers(checkorder=default).symbols | 25 + ...LateBoundMembers(checkorder=default).types | 24 + ...undMembers(checkorder=isolated).errors.txt | 22 + ...eBoundMembers(checkorder=isolated).symbols | 25 + ...ateBoundMembers(checkorder=isolated).types | 24 + ...oundMembers(checkorder=reverse).errors.txt | 22 + ...teBoundMembers(checkorder=reverse).symbols | 25 + ...LateBoundMembers(checkorder=reverse).types | 24 + ...dMembers(checkorder=typesfirst).errors.txt | 22 + ...oundMembers(checkorder=typesfirst).symbols | 25 + ...eBoundMembers(checkorder=typesfirst).types | 24 + ...rModuleExportsAlias(checkorder=default).js | 16 + ...leExportsAlias(checkorder=default).symbols | 23 + ...duleExportsAlias(checkorder=default).types | 26 + ...ModuleExportsAlias(checkorder=isolated).js | 16 + ...eExportsAlias(checkorder=isolated).symbols | 23 + ...uleExportsAlias(checkorder=isolated).types | 26 + ...rModuleExportsAlias(checkorder=reverse).js | 16 + ...leExportsAlias(checkorder=reverse).symbols | 23 + ...duleExportsAlias(checkorder=reverse).types | 26 + ...duleExportsAlias(checkorder=typesfirst).js | 16 + ...xportsAlias(checkorder=typesfirst).symbols | 23 + ...eExportsAlias(checkorder=typesfirst).types | 26 + ...arameterInTypeQuery(checkorder=default).js | 35 + ...terInTypeQuery(checkorder=default).symbols | 37 + ...meterInTypeQuery(checkorder=default).types | 40 + ...rameterInTypeQuery(checkorder=isolated).js | 35 + ...erInTypeQuery(checkorder=isolated).symbols | 37 + ...eterInTypeQuery(checkorder=isolated).types | 40 + ...arameterInTypeQuery(checkorder=reverse).js | 35 + ...terInTypeQuery(checkorder=reverse).symbols | 37 + ...meterInTypeQuery(checkorder=reverse).types | 40 + ...meterInTypeQuery(checkorder=typesfirst).js | 35 + ...InTypeQuery(checkorder=typesfirst).symbols | 37 + ...erInTypeQuery(checkorder=typesfirst).types | 40 + ...dexedAccess(checkorder=default).errors.txt | 36 + ...eIndexedAccess(checkorder=default).symbols | 58 + ...iveIndexedAccess(checkorder=default).types | 42 + ...exedAccess(checkorder=isolated).errors.txt | 36 + ...IndexedAccess(checkorder=isolated).symbols | 58 + ...veIndexedAccess(checkorder=isolated).types | 42 + ...dexedAccess(checkorder=reverse).errors.txt | 36 + ...eIndexedAccess(checkorder=reverse).symbols | 58 + ...iveIndexedAccess(checkorder=reverse).types | 42 + ...edAccess(checkorder=typesfirst).errors.txt | 36 + ...dexedAccess(checkorder=typesfirst).symbols | 58 + ...IndexedAccess(checkorder=typesfirst).types | 42 + ...eckOrderSpreadCycle(checkorder=default).js | 87 + ...derSpreadCycle(checkorder=default).symbols | 54 + ...OrderSpreadCycle(checkorder=default).types | 68 + ...ckOrderSpreadCycle(checkorder=isolated).js | 80 + ...erSpreadCycle(checkorder=isolated).symbols | 54 + ...rderSpreadCycle(checkorder=isolated).types | 68 + ...eckOrderSpreadCycle(checkorder=reverse).js | 87 + ...derSpreadCycle(checkorder=reverse).symbols | 54 + ...OrderSpreadCycle(checkorder=reverse).types | 68 + ...OrderSpreadCycle(checkorder=typesfirst).js | 87 + ...SpreadCycle(checkorder=typesfirst).symbols | 54 + ...erSpreadCycle(checkorder=typesfirst).types | 68 + ...ationErrors(checkorder=default).errors.txt | 35 + ...InstantiationErrors(checkorder=default).js | 49 + ...ntiationErrors(checkorder=default).symbols | 90 + ...tantiationErrors(checkorder=default).types | 64 + ...ationErrors(checkorder=reverse).errors.txt | 35 + ...InstantiationErrors(checkorder=reverse).js | 49 + ...ntiationErrors(checkorder=reverse).symbols | 90 + ...tantiationErrors(checkorder=reverse).types | 64 + ...onErrors(checkorder=typesfirst).errors.txt | 34 + ...tantiationErrors(checkorder=typesfirst).js | 49 + ...ationErrors(checkorder=typesfirst).symbols | 90 + ...tiationErrors(checkorder=typesfirst).types | 64 + ...Annotations(checkorder=default).errors.txt | 41 + ...AccessorAnnotations(checkorder=default).js | 55 + ...sorAnnotations(checkorder=default).symbols | 67 + ...essorAnnotations(checkorder=default).types | 64 + ...otations(checkorder=typesfirst).errors.txt | 41 + ...essorAnnotations(checkorder=typesfirst).js | 55 + ...Annotations(checkorder=typesfirst).symbols | 67 + ...orAnnotations(checkorder=typesfirst).types | 64 + ...larIndexedPropertyInstantiation.errors.txt | 14 + .../circularIndexedPropertyInstantiation.js | 14 + ...rcularIndexedPropertyInstantiation.symbols | 25 + ...circularIndexedPropertyInstantiation.types | 15 + ...tializerInference(strict=false).errors.txt | 40 + ...cularInitializerInference(strict=false).js | 42 + ...InitializerInference(strict=false).symbols | 98 + ...arInitializerInference(strict=false).types | 106 + ...itializerInference(strict=true).errors.txt | 61 + ...rcularInitializerInference(strict=true).js | 42 + ...rInitializerInference(strict=true).symbols | 98 + ...larInitializerInference(strict=true).types | 106 + ...TypeNoCrash(checkorder=default).errors.txt | 20 + ...pleTypeNoCrash(checkorder=default).symbols | 47 + ...TupleTypeNoCrash(checkorder=default).types | 40 + ...eNoCrash(checkorder=typesfirst).errors.txt | 19 + ...TypeNoCrash(checkorder=typesfirst).symbols | 47 + ...leTypeNoCrash(checkorder=typesfirst).types | 40 + ...ReturnTypeSubtypeReductionOrder.errors.txt | 50 + ...larReturnTypeSubtypeReductionOrder.symbols | 90 + ...cularReturnTypeSubtypeReductionOrder.types | 88 + ...gumentRelation(checkorder=default).symbols | 106 + ...ArgumentRelation(checkorder=default).types | 102 + ...entRelation(checkorder=typesfirst).symbols | 106 + ...umentRelation(checkorder=typesfirst).types | 102 + ...oughCallbackArgument(strict=false).symbols | 77 + ...hroughCallbackArgument(strict=false).types | 86 + ...ghCallbackArgument(strict=true).errors.txt | 46 + ...roughCallbackArgument(strict=true).symbols | 77 + ...ThroughCallbackArgument(strict=true).types | 86 + ...llbackArgument(checkorder=default).symbols | 38 + ...CallbackArgument(checkorder=default).types | 44 + ...ackArgument(checkorder=typesfirst).symbols | 38 + ...lbackArgument(checkorder=typesfirst).types | 44 + ...kReverseMapped(checkorder=default).symbols | 121 + ...unkReverseMapped(checkorder=default).types | 107 + ...verseMapped(checkorder=typesfirst).symbols | 121 + ...ReverseMapped(checkorder=typesfirst).types | 107 + ...iagnostics(noimplicitany=false).errors.txt | 80 + ...ularityDiagnostics(noimplicitany=false).js | 91 + ...tyDiagnostics(noimplicitany=false).symbols | 134 + ...rityDiagnostics(noimplicitany=false).types | 156 + ...Diagnostics(noimplicitany=true).errors.txt | 80 + ...cularityDiagnostics(noimplicitany=true).js | 91 + ...ityDiagnostics(noimplicitany=true).symbols | 134 + ...arityDiagnostics(noimplicitany=true).types | 156 + ...eterUnionOrder(checkorder=default).symbols | 66 + ...ameterUnionOrder(checkorder=default).types | 50 + ...eterUnionOrder(checkorder=reverse).symbols | 66 + ...ameterUnionOrder(checkorder=reverse).types | 50 + ...rUnionOrder(checkorder=typesfirst).symbols | 66 + ...terUnionOrder(checkorder=typesfirst).types | 50 + ...ternQueryOrder(checkorder=default).symbols | 31 + ...atternQueryOrder(checkorder=default).types | 31 + ...nQueryOrder(checkorder=typesfirst).symbols | 31 + ...ernQueryOrder(checkorder=typesfirst).types | 31 + ...heckReentryFromOuterTypeParameters.symbols | 81 + ...lCheckReentryFromOuterTypeParameters.types | 58 + ...TypeParameters(checkorder=default).symbols | 106 + ...erTypeParameters(checkorder=default).types | 120 + ...eParameters(checkorder=typesfirst).symbols | 106 + ...ypeParameters(checkorder=typesfirst).types | 120 + ...ReferenceCheckOrder(checkorder=default).js | 16 + ...enceCheckOrder(checkorder=default).symbols | 15 + ...erenceCheckOrder(checkorder=default).types | 18 + ...erenceCheckOrder(checkorder=typesfirst).js | 16 + ...eCheckOrder(checkorder=typesfirst).symbols | 15 + ...nceCheckOrder(checkorder=typesfirst).types | 18 + ...bleInitializer(checkorder=default).symbols | 45 + ...iableInitializer(checkorder=default).types | 47 + ...Initializer(checkorder=typesfirst).symbols | 45 + ...leInitializer(checkorder=typesfirst).types | 47 + ...eOfGenericCall(checkorder=default).symbols | 45 + ...cleOfGenericCall(checkorder=default).types | 43 + ...GenericCall(checkorder=typesfirst).symbols | 45 + ...OfGenericCall(checkorder=typesfirst).types | 43 + ...rrayPatternCallback(checkorder=default).js | 32 + ...atternCallback(checkorder=default).symbols | 89 + ...yPatternCallback(checkorder=default).types | 60 + ...Callback(checkorder=typesfirst).errors.txt | 24 + ...yPatternCallback(checkorder=typesfirst).js | 32 + ...ernCallback(checkorder=typesfirst).symbols | 89 + ...tternCallback(checkorder=typesfirst).types | 60 + ...hVarianceCheckOrder(checkorder=default).js | 24 + ...anceCheckOrder(checkorder=default).symbols | 39 + ...rianceCheckOrder(checkorder=default).types | 34 + ...rianceCheckOrder(checkorder=typesfirst).js | 24 + ...eCheckOrder(checkorder=typesfirst).symbols | 39 + ...nceCheckOrder(checkorder=typesfirst).types | 34 + ...erredTypeReferenceCycleRollback.errors.txt | 24 + ...deferredTypeReferenceCycleRollback.symbols | 70 + .../deferredTypeReferenceCycleRollback.types | 34 + ...heckorder=default,strict=false).errors.txt | 47 + ...tional(checkorder=default,strict=false).js | 61 + ...l(checkorder=default,strict=false).symbols | 124 + ...nal(checkorder=default,strict=false).types | 136 + ...checkorder=default,strict=true).errors.txt | 53 + ...ptional(checkorder=default,strict=true).js | 61 + ...al(checkorder=default,strict=true).symbols | 124 + ...onal(checkorder=default,strict=true).types | 136 + ...korder=typesfirst,strict=false).errors.txt | 47 + ...nal(checkorder=typesfirst,strict=false).js | 61 + ...heckorder=typesfirst,strict=false).symbols | 124 + ...(checkorder=typesfirst,strict=false).types | 136 + ...ckorder=typesfirst,strict=true).errors.txt | 59 + ...onal(checkorder=typesfirst,strict=true).js | 61 + ...checkorder=typesfirst,strict=true).symbols | 124 + ...l(checkorder=typesfirst,strict=true).types | 136 + ...entInitializer(checkorder=default).symbols | 62 + ...ementInitializer(checkorder=default).types | 70 + ...Initializer(checkorder=typesfirst).symbols | 62 + ...ntInitializer(checkorder=typesfirst).types | 70 + ...utiveConstraintOfCircularCheckType.symbols | 45 + ...ibutiveConstraintOfCircularCheckType.types | 31 + .../enumMemberTypeCacheConsistency.js | 29 + .../enumMemberTypeCacheConsistency.symbols | 29 + .../enumMemberTypeCacheConsistency.types | 30 + ...volvingArrayReadInLoopCondition.errors.txt | 23 + .../evolvingArrayReadInLoopCondition.symbols | 36 + .../evolvingArrayReadInLoopCondition.types | 46 + ...Circularity(checkorder=default).errors.txt | 43 + ...tchCheckCircularity(checkorder=default).js | 71 + ...eckCircularity(checkorder=default).symbols | 68 + ...CheckCircularity(checkorder=default).types | 85 + ...cularity(checkorder=typesfirst).errors.txt | 43 + ...CheckCircularity(checkorder=typesfirst).js | 71 + ...Circularity(checkorder=typesfirst).symbols | 68 + ...ckCircularity(checkorder=typesfirst).types | 85 + ...isibilityQueryOrder(checkorder=default).js | 35 + ...lityQueryOrder(checkorder=default).symbols | 33 + ...bilityQueryOrder(checkorder=default).types | 24 + ...ilityQueryOrder(checkorder=editorfirst).js | 63 + ...QueryOrder(checkorder=editorfirst).symbols | 33 + ...tyQueryOrder(checkorder=editorfirst).types | 24 + ...peInference(checkorder=default).errors.txt | 45 + ...ernForTypeInference(checkorder=default).js | 18 + ...rTypeInference(checkorder=default).symbols | 36 + ...ForTypeInference(checkorder=default).types | 49 + ...nference(checkorder=typesfirst).errors.txt | 51 + ...ForTypeInference(checkorder=typesfirst).js | 18 + ...peInference(checkorder=typesfirst).symbols | 36 + ...TypeInference(checkorder=typesfirst).types | 49 + ...Repeatedly2(checkorder=default).errors.txt | 29 + ...rametersRepeatedly2(checkorder=default).js | 25 + ...ersRepeatedly2(checkorder=default).symbols | 75 + ...etersRepeatedly2(checkorder=default).types | 59 + ...eatedly2(checkorder=typesfirst).errors.txt | 32 + ...etersRepeatedly2(checkorder=typesfirst).js | 25 + ...Repeatedly2(checkorder=typesfirst).symbols | 75 + ...rsRepeatedly2(checkorder=typesfirst).types | 59 + ...epthCheckOrder(checkorder=default).symbols | 3060 +++++++++++++++ ...pDepthCheckOrder(checkorder=default).types | 3069 +++++++++++++++ ...eckOrder(checkorder=typesfirst).errors.txt | 1031 +++++ ...hCheckOrder(checkorder=typesfirst).symbols | 3060 +++++++++++++++ ...pthCheckOrder(checkorder=typesfirst).types | 3069 +++++++++++++++ ...pCheckOrder(checkorder=default).errors.txt | 1126 ++++++ ...DeepCheckOrder(checkorder=default).symbols | 3352 ++++++++++++++++ ...ooDeepCheckOrder(checkorder=default).types | 3361 +++++++++++++++++ ...eckOrder(checkorder=typesfirst).errors.txt | 1126 ++++++ ...pCheckOrder(checkorder=typesfirst).symbols | 3352 ++++++++++++++++ ...eepCheckOrder(checkorder=typesfirst).types | 3361 +++++++++++++++++ ...eterDefault(checkorder=default).errors.txt | 31 + ...rameterDefault(checkorder=default).symbols | 51 + ...ParameterDefault(checkorder=default).types | 67 + ...rDefault(checkorder=typesfirst).errors.txt | 31 + ...eterDefault(checkorder=typesfirst).symbols | 51 + ...ameterDefault(checkorder=typesfirst).types | 67 + .../getterCircularityDiagnostics.errors.txt | 17 + .../compiler/getterCircularityDiagnostics.js | 22 + .../getterCircularityDiagnostics.symbols | 28 + .../getterCircularityDiagnostics.types | 25 + ...eQueryOrder(checkorder=default).errors.txt | 18 + ...eturnTypeQueryOrder(checkorder=default).js | 23 + ...TypeQueryOrder(checkorder=default).symbols | 29 + ...rnTypeQueryOrder(checkorder=default).types | 26 + ...ryOrder(checkorder=editorfirst).errors.txt | 18 + ...nTypeQueryOrder(checkorder=editorfirst).js | 23 + ...QueryOrder(checkorder=editorfirst).symbols | 29 + ...peQueryOrder(checkorder=editorfirst).types | 26 + ...eCheckOrder(checkorder=default).errors.txt | 19 + ...buteValueCheckOrder(checkorder=default).js | 15 + ...alueCheckOrder(checkorder=default).symbols | 10 + ...eValueCheckOrder(checkorder=default).types | 11 + ...eckOrder(checkorder=typesfirst).errors.txt | 22 + ...eValueCheckOrder(checkorder=typesfirst).js | 15 + ...eCheckOrder(checkorder=typesfirst).symbols | 10 + ...lueCheckOrder(checkorder=typesfirst).types | 11 + ...IndexedAccessOfDerivedInterface.errors.txt | 28 + ...ithIndexedAccessOfDerivedInterface.symbols | 45 + ...eWithIndexedAccessOfDerivedInterface.types | 36 + ...sUnionOrder(checkorder=default).errors.txt | 22 + ...lagsUnionOrder(checkorder=default).symbols | 50 + ...sFlagsUnionOrder(checkorder=default).types | 41 + ...sUnionOrder(checkorder=typesfirst).symbols | 50 + ...agsUnionOrder(checkorder=typesfirst).types | 41 + ...nCheckOrder(checkorder=default).errors.txt | 16 + ...ersectionCheckOrder(checkorder=default).js | 19 + ...tionCheckOrder(checkorder=default).symbols | 29 + ...ectionCheckOrder(checkorder=default).types | 18 + ...ectionCheckOrder(checkorder=typesfirst).js | 19 + ...nCheckOrder(checkorder=typesfirst).symbols | 29 + ...ionCheckOrder(checkorder=typesfirst).types | 18 + ...inferenceDeeplyNestedCheckOrder.errors.txt | 24 + .../inferenceDeeplyNestedCheckOrder.symbols | 52 + .../inferenceDeeplyNestedCheckOrder.types | 44 + ...onOfTypeParameterAndPromiseLike.errors.txt | 17 + ...UnionOfTypeParameterAndPromiseLike.symbols | 35 + ...omUnionOfTypeParameterAndPromiseLike.types | 19 + ...eThroughSortOfFlattenedIterable.errors.txt | 26 + ...enceThroughSortOfFlattenedIterable.symbols | 65 + ...erenceThroughSortOfFlattenedIterable.types | 61 + ...blesAfterCycle(checkorder=default).symbols | 69 + ...iablesAfterCycle(checkorder=default).types | 44 + ...sAfterCycle(checkorder=typesfirst).symbols | 69 + ...lesAfterCycle(checkorder=typesfirst).types | 44 + ...aredCheckOrder(checkorder=default).symbols | 41 + ...SharedCheckOrder(checkorder=default).types | 23 + ...eckOrder(checkorder=typesfirst).errors.txt | 16 + ...dCheckOrder(checkorder=typesfirst).symbols | 41 + ...redCheckOrder(checkorder=typesfirst).types | 23 + ...aredCheckOrder(checkorder=default).symbols | 32 + ...SharedCheckOrder(checkorder=default).types | 23 + ...eckOrder(checkorder=typesfirst).errors.txt | 16 + ...dCheckOrder(checkorder=typesfirst).symbols | 32 + ...redCheckOrder(checkorder=typesfirst).types | 23 + ...eCheckOrder(checkorder=default).errors.txt | 32 + ...aintCycleCheckOrder(checkorder=default).js | 46 + ...ycleCheckOrder(checkorder=default).symbols | 68 + ...tCycleCheckOrder(checkorder=default).types | 51 + ...eckOrder(checkorder=typesfirst).errors.txt | 38 + ...tCycleCheckOrder(checkorder=typesfirst).js | 46 + ...eCheckOrder(checkorder=typesfirst).symbols | 68 + ...cleCheckOrder(checkorder=typesfirst).types | 51 + ...nConstraintInStaticClassExpression.symbols | 37 + ...ionConstraintInStaticClassExpression.types | 29 + .../instantiationLimitsCheckOrder.errors.txt | 24 + .../instantiationLimitsCheckOrder.symbols | 54 + .../instantiationLimitsCheckOrder.types | 32 + ...tCheckOrder(checkorder=default).errors.txt | 24 + ...imitCheckOrder(checkorder=default).symbols | 35 + ...kLimitCheckOrder(checkorder=default).types | 31 + ...eckOrder(checkorder=typesfirst).errors.txt | 23 + ...tCheckOrder(checkorder=typesfirst).symbols | 35 + ...mitCheckOrder(checkorder=typesfirst).types | 31 + ...eCheckOrder(checkorder=default).errors.txt | 19 + ...ctorCycleCheckOrder(checkorder=default).js | 16 + ...ycleCheckOrder(checkorder=default).symbols | 17 + ...rCycleCheckOrder(checkorder=default).types | 16 + ...eckOrder(checkorder=typesfirst).errors.txt | 19 + ...rCycleCheckOrder(checkorder=typesfirst).js | 16 + ...eCheckOrder(checkorder=typesfirst).symbols | 17 + ...cleCheckOrder(checkorder=typesfirst).types | 16 + ...rtElisionQueryOrder(checkorder=default).js | 25 + ...sionQueryOrder(checkorder=default).symbols | 16 + ...lisionQueryOrder(checkorder=default).types | 16 + ...isionQueryOrder(checkorder=editorfirst).js | 106 + ...QueryOrder(checkorder=editorfirst).symbols | 16 + ...onQueryOrder(checkorder=editorfirst).types | 16 + ...eTagOnContextuallyTypedFunction.errors.txt | 33 + ...TypeTagOnContextuallyTypedFunction.symbols | 36 + ...ocTypeTagOnContextuallyTypedFunction.types | 45 + ...agmaComment(checkorder=default).errors.txt | 33 + ...rceNonPragmaComment(checkorder=default).js | 29 + ...nPragmaComment(checkorder=default).symbols | 22 + ...NonPragmaComment(checkorder=default).types | 29 + ...aComment(checkorder=typesfirst).errors.txt | 37 + ...NonPragmaComment(checkorder=typesfirst).js | 29 + ...agmaComment(checkorder=typesfirst).symbols | 22 + ...PragmaComment(checkorder=typesfirst).types | 29 + ...ementsExtendsRecord(checkorder=default).js | 13 + ...sExtendsRecord(checkorder=default).symbols | 14 + ...ntsExtendsRecord(checkorder=default).types | 11 + ...dsRecord(checkorder=typesfirst).errors.txt | 12 + ...ntsExtendsRecord(checkorder=typesfirst).js | 13 + ...tendsRecord(checkorder=typesfirst).symbols | 14 + ...ExtendsRecord(checkorder=typesfirst).types | 11 + ...eCheckOrder(checkorder=default).errors.txt | 14 + ...ycleCheckOrder(checkorder=default).symbols | 20 + ...eCycleCheckOrder(checkorder=default).types | 17 + ...eckOrder(checkorder=typesfirst).errors.txt | 14 + ...eCheckOrder(checkorder=typesfirst).symbols | 20 + ...cleCheckOrder(checkorder=typesfirst).types | 17 + ...tantiations(checkorder=default).errors.txt | 15 + ...tDeepInstantiations(checkorder=default).js | 15 + ...Instantiations(checkorder=default).symbols | 25 + ...epInstantiations(checkorder=default).types | 15 + ...tiations(checkorder=typesfirst).errors.txt | 14 + ...epInstantiations(checkorder=typesfirst).js | 15 + ...tantiations(checkorder=typesfirst).symbols | 25 + ...nstantiations(checkorder=typesfirst).types | 15 + ...dNeverAfterLoopWithAndCondition.errors.txt | 29 + ...owedNeverAfterLoopWithAndCondition.symbols | 47 + ...rrowedNeverAfterLoopWithAndCondition.types | 56 + ...eCheckOrder(checkorder=default).errors.txt | 75 + ...TypeCheckOrder(checkorder=default).symbols | 103 + ...alTypeCheckOrder(checkorder=default).types | 134 + ...eckOrder(checkorder=typesfirst).errors.txt | 75 + ...eCheckOrder(checkorder=typesfirst).symbols | 103 + ...ypeCheckOrder(checkorder=typesfirst).types | 134 + ...eckOrderJsx(checkorder=default).errors.txt | 35 + ...eCheckOrderJsx(checkorder=default).symbols | 52 + ...ypeCheckOrderJsx(checkorder=default).types | 55 + ...OrderJsx(checkorder=typesfirst).errors.txt | 35 + ...eckOrderJsx(checkorder=typesfirst).symbols | 52 + ...CheckOrderJsx(checkorder=typesfirst).types | 55 + ...icArrayAssignabilityAfterErrors.errors.txt | 38 + ...nericArrayAssignabilityAfterErrors.symbols | 98 + ...GenericArrayAssignabilityAfterErrors.types | 97 + ...AndWidenedCopyOrder(checkorder=default).js | 20 + ...denedCopyOrder(checkorder=default).symbols | 34 + ...WidenedCopyOrder(checkorder=default).types | 46 + ...WidenedCopyOrder(checkorder=typesfirst).js | 20 + ...edCopyOrder(checkorder=typesfirst).symbols | 34 + ...enedCopyOrder(checkorder=typesfirst).types | 46 + ...antiationOrder(checkorder=default).symbols | 44 + ...stantiationOrder(checkorder=default).types | 50 + ...iationOrder(checkorder=typesfirst).symbols | 44 + ...ntiationOrder(checkorder=typesfirst).types | 50 + ...ingDeferred(checkorder=default).errors.txt | 80 + ...intCheckingDeferred(checkorder=default).js | 37 + ...eckingDeferred(checkorder=default).symbols | 80 + ...CheckingDeferred(checkorder=default).types | 78 + ...Deferred(checkorder=typesfirst).errors.txt | 76 + ...CheckingDeferred(checkorder=typesfirst).js | 37 + ...ingDeferred(checkorder=typesfirst).symbols | 80 + ...ckingDeferred(checkorder=typesfirst).types | 78 + ...ThroughCall(checkorder=default).errors.txt | 34 + ...ingThroughCall(checkorder=default).symbols | 53 + ...blingThroughCall(checkorder=default).types | 62 + ...oughCall(checkorder=typesfirst).errors.txt | 34 + ...ThroughCall(checkorder=typesfirst).symbols | 53 + ...ngThroughCall(checkorder=typesfirst).types | 62 + ...rCheckOrder(checkorder=default).errors.txt | 16 + ...ycleErrorCheckOrder(checkorder=default).js | 16 + ...rrorCheckOrder(checkorder=default).symbols | 15 + ...eErrorCheckOrder(checkorder=default).types | 13 + ...eckOrder(checkorder=typesfirst).errors.txt | 16 + ...eErrorCheckOrder(checkorder=typesfirst).js | 16 + ...rCheckOrder(checkorder=typesfirst).symbols | 15 + ...rorCheckOrder(checkorder=typesfirst).types | 13 + ...enericInterfaceDeclarationOrder.errors.txt | 22 + ...veGenericInterfaceDeclarationOrder.symbols | 67 + ...siveGenericInterfaceDeclarationOrder.types | 35 + .../recursiveVarianceFixedPoint.errors.txt | 227 ++ .../recursiveVarianceFixedPoint.symbols | 455 +++ .../recursiveVarianceFixedPoint.types | 344 ++ ...lexityError(checkorder=default).errors.txt | 50 + ...omplexityError(checkorder=default).symbols | 91 + ...nComplexityError(checkorder=default).types | 77 + ...ityError(checkorder=typesfirst).errors.txt | 50 + ...lexityError(checkorder=typesfirst).symbols | 91 + ...mplexityError(checkorder=typesfirst).types | 77 + ...dCheckOrder(checkorder=default).errors.txt | 32 + ...aredCheckOrder(checkorder=default).symbols | 101 + ...SharedCheckOrder(checkorder=default).types | 77 + ...eckOrder(checkorder=typesfirst).errors.txt | 35 + ...dCheckOrder(checkorder=typesfirst).symbols | 101 + ...redCheckOrder(checkorder=typesfirst).types | 77 + ...eCheckOrder(checkorder=default).errors.txt | 104 + ...toneCheckOrder(checkorder=default).symbols | 361 ++ ...notoneCheckOrder(checkorder=default).types | 292 ++ ...ckOrder(checkorder=editorfirst).errors.txt | 107 + ...CheckOrder(checkorder=editorfirst).symbols | 361 ++ ...neCheckOrder(checkorder=editorfirst).types | 292 ++ ...eckOrder(checkorder=typesfirst).errors.txt | 107 + ...eCheckOrder(checkorder=typesfirst).symbols | 361 ++ ...oneCheckOrder(checkorder=typesfirst).types | 292 ++ .../relationDeeplyNestedCheckOrder.symbols | 54 + .../relationDeeplyNestedCheckOrder.types | 41 + ...aredCheckOrder(checkorder=default).symbols | 1217 ++++++ ...SharedCheckOrder(checkorder=default).types | 739 ++++ ...dCheckOrder(checkorder=typesfirst).symbols | 1217 ++++++ ...redCheckOrder(checkorder=typesfirst).types | 739 ++++ .../relationMaybeCheckOrder.errors.txt | 31 + .../compiler/relationMaybeCheckOrder.symbols | 69 + .../compiler/relationMaybeCheckOrder.types | 60 + ...aredCheckOrder(checkorder=default).symbols | 38 + ...SharedCheckOrder(checkorder=default).types | 29 + ...dCheckOrder(checkorder=typesfirst).symbols | 38 + ...redCheckOrder(checkorder=typesfirst).types | 29 + ...acheCheckOrder(checkorder=default).symbols | 48 + ...dCacheCheckOrder(checkorder=default).types | 37 + ...eckOrder(checkorder=typesfirst).errors.txt | 32 + ...eCheckOrder(checkorder=typesfirst).symbols | 48 + ...cheCheckOrder(checkorder=typesfirst).types | 37 + ...tantiationOfRestrictiveConditional.symbols | 682 ++++ ...nstantiationOfRestrictiveConditional.types | 338 ++ ...nferenceNotTooBroad(checkorder=default).js | 24 + ...nceNotTooBroad(checkorder=default).symbols | 69 + ...renceNotTooBroad(checkorder=default).types | 67 + ...renceNotTooBroad(checkorder=typesfirst).js | 24 + ...NotTooBroad(checkorder=typesfirst).symbols | 69 + ...ceNotTooBroad(checkorder=typesfirst).types | 67 + ...sectionBase(checkorder=default).errors.txt | 24 + ...tersectionBase(checkorder=default).symbols | 51 + ...IntersectionBase(checkorder=default).types | 42 + ...tionBase(checkorder=typesfirst).errors.txt | 24 + ...sectionBase(checkorder=typesfirst).symbols | 51 + ...ersectionBase(checkorder=typesfirst).types | 42 + ...eQueryOrder(checkorder=default).errors.txt | 16 + ...InferenceQueryOrder(checkorder=default).js | 16 + ...enceQueryOrder(checkorder=default).symbols | 51 + ...erenceQueryOrder(checkorder=default).types | 40 + ...renceQueryOrder(checkorder=editorfirst).js | 16 + ...QueryOrder(checkorder=editorfirst).symbols | 51 + ...ceQueryOrder(checkorder=editorfirst).types | 40 + ...InDeferredConditionalOfConditional.symbols | 94 + ...onInDeferredConditionalOfConditional.types | 35 + ...ssiveLength(checkorder=default).errors.txt | 48 + ...TypeExcessiveLength(checkorder=default).js | 45 + ...xcessiveLength(checkorder=default).symbols | 109 + ...eExcessiveLength(checkorder=default).types | 58 + ...veLength(checkorder=typesfirst).errors.txt | 41 + ...eExcessiveLength(checkorder=typesfirst).js | 45 + ...ssiveLength(checkorder=typesfirst).symbols | 109 + ...cessiveLength(checkorder=typesfirst).types | 58 + ...aultInCallInsideGenericCallback.errors.txt | 28 + ...DefaultInCallInsideGenericCallback.symbols | 76 + ...erDefaultInCallInsideGenericCallback.types | 64 + ...sConstraint(checkorder=default).errors.txt | 15 + ...HasSelfAsConstraint(checkorder=default).js | 14 + ...lfAsConstraint(checkorder=default).symbols | 15 + ...SelfAsConstraint(checkorder=default).types | 12 + ...nstraint(checkorder=typesfirst).errors.txt | 16 + ...SelfAsConstraint(checkorder=typesfirst).js | 14 + ...sConstraint(checkorder=typesfirst).symbols | 15 + ...fAsConstraint(checkorder=typesfirst).types | 12 + ...yCheckOrder(checkorder=default).errors.txt | 35 + ...tityCheckOrder(checkorder=default).symbols | 54 + ...entityCheckOrder(checkorder=default).types | 30 + ...eckOrder(checkorder=typesfirst).errors.txt | 54 + ...yCheckOrder(checkorder=typesfirst).symbols | 54 + ...ityCheckOrder(checkorder=typesfirst).types | 30 + ...eclaration1(checkorder=default).errors.txt | 28 + ...unctionDeclaration1(checkorder=default).js | 20 + ...onDeclaration1(checkorder=default).symbols | 21 + ...tionDeclaration1(checkorder=default).types | 25 + ...aration1(checkorder=typesfirst).errors.txt | 25 + ...tionDeclaration1(checkorder=typesfirst).js | 20 + ...eclaration1(checkorder=typesfirst).symbols | 21 + ...nDeclaration1(checkorder=typesfirst).types | 25 + ...rQueryOrder(checkorder=default).errors.txt | 12 + ...ParameterQueryOrder(checkorder=default).js | 17 + ...eterQueryOrder(checkorder=default).symbols | 14 + ...ameterQueryOrder(checkorder=default).types | 14 + ...meterQueryOrder(checkorder=editorfirst).js | 17 + ...QueryOrder(checkorder=editorfirst).symbols | 14 + ...erQueryOrder(checkorder=editorfirst).types | 14 + .../varianceCircularConsistency.errors.txt | 48 + .../varianceCircularConsistency.symbols | 146 + .../varianceCircularConsistency.types | 66 + ...redByInference(checkorder=default).symbols | 129 + ...teredByInference(checkorder=default).types | 90 + ...nference(checkorder=typesfirst).errors.txt | 56 + ...ByInference(checkorder=typesfirst).symbols | 129 + ...edByInference(checkorder=typesfirst).types | 90 + ...idesInvariance(checkorder=default).symbols | 279 ++ ...yHidesInvariance(checkorder=default).types | 131 + ...sInvariance(checkorder=typesfirst).symbols | 279 ++ ...desInvariance(checkorder=typesfirst).types | 131 + .../varianceCycleCachedResults.errors.txt | 25 + .../compiler/varianceCycleCachedResults.js | 35 + .../varianceCycleCachedResults.symbols | 52 + .../compiler/varianceCycleCachedResults.types | 49 + .../varianceCycleCapnwebRpcStub.errors.txt | 165 + .../varianceCycleCapnwebRpcStub.symbols | 754 ++++ .../varianceCycleCapnwebRpcStub.types | 280 ++ ...rianceCycleDiscardedDiagnostics.errors.txt | 31 + .../varianceCycleDiscardedDiagnostics.symbols | 73 + .../varianceCycleDiscardedDiagnostics.types | 65 + ...CanonicalEntry(checkorder=default).symbols | 132 + ...erCanonicalEntry(checkorder=default).types | 77 + ...onicalEntry(checkorder=typesfirst).symbols | 132 + ...anonicalEntry(checkorder=typesfirst).types | 77 + .../varianceCycleEntryOrder.errors.txt | 78 + .../compiler/varianceCycleEntryOrder.symbols | 106 + .../compiler/varianceCycleEntryOrder.types | 82 + .../varianceCycleRedoKeepsDiscardLog.symbols | 999 +++++ .../varianceCycleRedoKeepsDiscardLog.types | 518 +++ ...varianceCycleStructuralFallback.errors.txt | 86 + .../varianceCycleStructuralFallback.symbols | 120 + .../varianceCycleStructuralFallback.types | 94 + .../varianceDeclarationOrder.errors.txt | 31 + .../compiler/varianceDeclarationOrder.symbols | 126 + .../compiler/varianceDeclarationOrder.types | 62 + ...rianceMeasuredWithinCircularity.errors.txt | 63 + .../varianceMeasuredWithinCircularity.symbols | 89 + .../varianceMeasuredWithinCircularity.types | 52 + ...herComparisons(checkorder=default).symbols | 51 + ...OtherComparisons(checkorder=default).types | 37 + ...Comparisons(checkorder=typesfirst).symbols | 51 + ...erComparisons(checkorder=typesfirst).types | 37 + ...eclaration1(checkorder=default).errors.txt | 149 + ...InDeclaration1(checkorder=default).symbols | 175 + ...ceInDeclaration1(checkorder=default).types | 205 + ...aration1(checkorder=typesfirst).errors.txt | 152 + ...eclaration1(checkorder=typesfirst).symbols | 175 + ...nDeclaration1(checkorder=typesfirst).types | 205 + ...LiteralInitializers(checkorder=default).js | 126 + ...alInitializers(checkorder=default).symbols | 196 + ...eralInitializers(checkorder=default).types | 312 ++ ...ializers(checkorder=typesfirst).errors.txt | 75 + ...eralInitializers(checkorder=typesfirst).js | 126 + ...nitializers(checkorder=typesfirst).symbols | 196 + ...lInitializers(checkorder=typesfirst).types | 312 ++ ...importTag13(checkorder=default).errors.txt | 16 + .../importTag13(checkorder=default).symbols | 6 + .../importTag13(checkorder=default).types | 6 + ...ortTag13(checkorder=typesfirst).errors.txt | 19 + ...importTag13(checkorder=typesfirst).symbols | 6 + .../importTag13(checkorder=typesfirst).types | 6 + ...ldShadowing(checkorder=default).errors.txt | 23 + ...ClassFieldShadowing(checkorder=default).js | 46 + ...FieldShadowing(checkorder=default).symbols | 43 + ...ssFieldShadowing(checkorder=default).types | 44 + ...hadowing(checkorder=typesfirst).errors.txt | 23 + ...ssFieldShadowing(checkorder=typesfirst).js | 46 + ...ldShadowing(checkorder=typesfirst).symbols | 43 + ...ieldShadowing(checkorder=typesfirst).types | 44 + .../compiler/baseConstraintDepthCheckOrder.ts | 13 + .../compiler/bigintArbirtraryIdentifier.ts | 1 + ...ndedRecursiveTypeInferredThroughClosure.ts | 83 + ...exConstraintOfJavascriptClassExpression.ts | 1 + .../cases/compiler/checkOrderAwaitedCycle.ts | 21 + .../compiler/checkOrderCircularConstraint.ts | 14 + .../compiler/checkOrderCircularDefaults.ts | 16 + .../compiler/checkOrderEmitBeforeCheck.ts | 19 + .../compiler/checkOrderEnumComputedMember.ts | 12 + .../compiler/checkOrderLateBoundMembers.ts | 13 + .../compiler/checkOrderModuleExportsAlias.ts | 8 + .../checkOrderParameterInTypeQuery.ts | 19 + .../checkOrderRecursiveIndexedAccess.ts | 21 + .../cases/compiler/checkOrderSpreadCycle.ts | 31 + .../checkOrderStableInstantiationErrors.ts | 30 + .../compiler/circularAccessorAnnotations.ts | 1 + .../circularIndexedPropertyInstantiation.ts | 6 + .../compiler/circularInitializerInference.ts | 31 + ...ularInlineMappedGenericTupleTypeNoCrash.ts | 1 + ...circularReturnTypeSubtypeReductionOrder.ts | 42 + ...arReturnTypeThroughCallArgumentRelation.ts | 44 + ...rcularReturnTypeThroughCallbackArgument.ts | 27 + ...TypeThroughUncontextualCallbackArgument.ts | 22 + .../circularScopeThunkReverseMapped.ts | 26 + .../compiler/classCircularityDiagnostics.ts | 48 + .../compiler/clonedTypeParameterUnionOrder.ts | 15 + .../constAssertionBindingPatternQueryOrder.ts | 11 + ...tualCheckReentryFromOuterTypeParameters.ts | 17 + .../compiler/contextualOuterTypeParameters.ts | 6 + ...tualParameterDefaultReferenceCheckOrder.ts | 7 + ...lParameterInCircularVariableInitializer.ts | 20 + ...ParameterInReturnTypeCycleOfGenericCall.ts | 17 + .../contextualReturnArrayPatternCallback.ts | 1 + .../cycleYieldThroughVarianceCheckOrder.ts | 16 + .../deferredTypeReferenceCycleRollback.ts | 20 + .../deleteExpressionMustBeOptional.ts | 1 + ...tDestructuringBindingElementInitializer.ts | 1 + ...stributiveConstraintOfCircularCheckType.ts | 17 + .../enumMemberTypeCacheConsistency.ts | 11 + .../evolvingArrayReadInLoopCondition.ts | 16 + .../exhaustiveSwitchCheckCircularity.ts | 1 + ...ortAssignmentNestedVisibilityQueryOrder.ts | 17 + ...allbackToBindingPatternForTypeInference.ts | 1 + .../fixingTypeParametersRepeatedly2.ts | 1 + .../cases/compiler/flowLoopDepthCheckOrder.ts | 1028 +++++ .../compiler/flowLoopTooDeepCheckOrder.ts | 1123 ++++++ ...ricCallReturnedFunctionParameterDefault.ts | 28 + .../compiler/getterCircularityDiagnostics.ts | 14 + .../compiler/getterReturnTypeQueryOrder.ts | 15 + .../importAttributeValueCheckOrder.ts | 8 + ...tureWithIndexedAccessOfDerivedInterface.ts | 23 + .../indexedAccessAccessFlagsUnionOrder.ts | 13 + ...straintFromMappedIntersectionCheckOrder.ts | 10 + .../inferenceDeeplyNestedCheckOrder.ts | 23 + ...eFromUnionOfTypeParameterAndPromiseLike.ts | 10 + ...inferenceThroughSortOfFlattenedIterable.ts | 21 + ...tionCouldContainTypeVariablesAfterCycle.ts | 22 + .../instantiationCountSharedCheckOrder.ts | 14 + .../instantiationDepthSharedCheckOrder.ts | 14 + ...tionExpressionConstraintCycleCheckOrder.ts | 24 + ...essionConstraintInStaticClassExpression.ts | 15 + .../compiler/instantiationLimitsCheckOrder.ts | 19 + .../instantiationStackLimitCheckOrder.ts | 18 + ...ersectionBaseConstructorCycleCheckOrder.ts | 8 + .../jsdocLinkImportElisionQueryOrder.ts | 13 + ...jsdocTypeTagOnContextuallyTypedFunction.ts | 17 + .../jsxImportSourceNonPragmaComment.tsx | 1 + .../jsxIntrinsicElementsExtendsRecord.tsx | 1 + .../keyofIndexSignatureCycleCheckOrder.ts | 10 + .../cases/compiler/limitDeepInstantiations.ts | 1 + .../narrowedNeverAfterLoopWithAndCondition.ts | 22 + .../nestedCallContextualTypeCheckOrder.ts | 21 + .../nestedCallContextualTypeCheckOrderJsx.tsx | 17 + ...tedGenericArrayAssignabilityAfterErrors.ts | 32 + ...objectLiteralRegularAndWidenedCopyOrder.ts | 10 + .../objectRestUnionInstantiationOrder.ts | 11 + ...esolutionWithConstraintCheckingDeferred.ts | 1 + ...dingDefaultReferencesSiblingThroughCall.ts | 25 + .../qualifiedNameCycleErrorCheckOrder.ts | 8 + ...cursiveGenericInterfaceDeclarationOrder.ts | 17 + .../compiler/recursiveVarianceFixedPoint.ts | 159 + .../cases/compiler/relationComplexityError.ts | 49 +- .../relationComplexitySharedCheckOrder.ts | 26 + .../relationCycleNonMonotoneCheckOrder.ts | 98 + .../relationDeeplyNestedCheckOrder.ts | 17 + .../compiler/relationDepthSharedCheckOrder.ts | 253 ++ .../cases/compiler/relationMaybeCheckOrder.ts | 24 + .../relationNestingSharedCheckOrder.ts | 15 + .../relationTruncatedCacheCheckOrder.ts | 18 + ...veInstantiationOfRestrictiveConditional.ts | 183 + .../returnTypeInferenceNotTooBroad.ts | 1 + .../sharedMemberLayoutThisIntersectionBase.ts | 1 + .../signatureHelpInferenceQueryOrder.ts | 11 + ...utionInDeferredConditionalOfConditional.ts | 24 + .../templateLiteralTypeExcessiveLength.ts | 1 + ...meterDefaultInCallInsideGenericCallback.ts | 25 + .../typeParameterHasSelfAsConstraint.ts | 1 + ...ypeReferenceRecursionIdentityCheckOrder.ts | 16 + ...onDeclarationWithinFunctionDeclaration1.ts | 1 + .../compiler/unusedTypeParameterQueryOrder.ts | 10 + .../compiler/varianceCircularConsistency.ts | 29 + .../varianceCircularityEnteredByInference.ts | 51 + .../varianceCircularityHidesInvariance.ts | 74 + .../compiler/varianceCycleCachedResults.ts | 25 + .../compiler/varianceCycleCapnwebRpcStub.ts | 170 + .../varianceCycleDiscardedDiagnostics.ts | 28 + ...varianceCycleEnteredAfterCanonicalEntry.ts | 32 + .../cases/compiler/varianceCycleEntryOrder.ts | 32 + .../varianceCycleRedoKeepsDiscardLog.ts | 312 ++ .../varianceCycleStructuralFallback.ts | 33 + .../compiler/varianceDeclarationOrder.ts | 30 + .../varianceMeasuredWithinCircularity.ts | 30 + ...ersededMeasurementKeepsOtherComparisons.ts | 21 + .../privateNameNestedClassFieldShadowing.ts | 1 + ...ucturedVariablesReferenceInDeclaration1.ts | 1 + .../destructuringWithLiteralInitializers.ts | 1 + .../cases/conformance/jsdoc/importTag13.ts | 1 + 802 files changed, 77838 insertions(+), 17 deletions(-) create mode 100644 tsc/testdata/baselines/reference/compiler/baseConstraintDepthCheckOrder(checkorder=default).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/baseConstraintDepthCheckOrder(checkorder=default).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/baseConstraintDepthCheckOrder(checkorder=default).types create mode 100644 tsc/testdata/baselines/reference/compiler/baseConstraintDepthCheckOrder(checkorder=typesfirst).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/baseConstraintDepthCheckOrder(checkorder=typesfirst).types create mode 100644 tsc/testdata/baselines/reference/compiler/bigintArbirtraryIdentifier(checkorder=default).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/bigintArbirtraryIdentifier(checkorder=default).js create mode 100644 tsc/testdata/baselines/reference/compiler/bigintArbirtraryIdentifier(checkorder=default).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/bigintArbirtraryIdentifier(checkorder=default).types create mode 100644 tsc/testdata/baselines/reference/compiler/bigintArbirtraryIdentifier(checkorder=typesfirst).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/bigintArbirtraryIdentifier(checkorder=typesfirst).js create mode 100644 tsc/testdata/baselines/reference/compiler/bigintArbirtraryIdentifier(checkorder=typesfirst).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/bigintArbirtraryIdentifier(checkorder=typesfirst).types create mode 100644 tsc/testdata/baselines/reference/compiler/boundedRecursiveTypeInferredThroughClosure.errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/boundedRecursiveTypeInferredThroughClosure.symbols create mode 100644 tsc/testdata/baselines/reference/compiler/boundedRecursiveTypeInferredThroughClosure.types create mode 100644 tsc/testdata/baselines/reference/compiler/checkIndexConstraintOfJavascriptClassExpression(checkorder=default).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/checkIndexConstraintOfJavascriptClassExpression(checkorder=default).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/checkIndexConstraintOfJavascriptClassExpression(checkorder=default).types create mode 100644 tsc/testdata/baselines/reference/compiler/checkIndexConstraintOfJavascriptClassExpression(checkorder=typesfirst).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/checkIndexConstraintOfJavascriptClassExpression(checkorder=typesfirst).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/checkIndexConstraintOfJavascriptClassExpression(checkorder=typesfirst).types create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderAwaitedCycle(checkorder=default).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderAwaitedCycle(checkorder=default).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderAwaitedCycle(checkorder=default).types create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderAwaitedCycle(checkorder=isolated).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderAwaitedCycle(checkorder=isolated).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderAwaitedCycle(checkorder=isolated).types create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderAwaitedCycle(checkorder=reverse).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderAwaitedCycle(checkorder=reverse).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderAwaitedCycle(checkorder=reverse).types create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderAwaitedCycle(checkorder=typesfirst).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderAwaitedCycle(checkorder=typesfirst).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderAwaitedCycle(checkorder=typesfirst).types create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderCircularConstraint(checkorder=default).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderCircularConstraint(checkorder=default).js create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderCircularConstraint(checkorder=default).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderCircularConstraint(checkorder=default).types create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderCircularConstraint(checkorder=isolated).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderCircularConstraint(checkorder=isolated).js create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderCircularConstraint(checkorder=isolated).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderCircularConstraint(checkorder=isolated).types create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderCircularConstraint(checkorder=reverse).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderCircularConstraint(checkorder=reverse).js create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderCircularConstraint(checkorder=reverse).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderCircularConstraint(checkorder=reverse).types create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderCircularConstraint(checkorder=typesfirst).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderCircularConstraint(checkorder=typesfirst).js create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderCircularConstraint(checkorder=typesfirst).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderCircularConstraint(checkorder=typesfirst).types create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderCircularDefaults(checkorder=default).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderCircularDefaults(checkorder=default).js create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderCircularDefaults(checkorder=default).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderCircularDefaults(checkorder=default).types create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderCircularDefaults(checkorder=isolated).js create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderCircularDefaults(checkorder=isolated).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderCircularDefaults(checkorder=isolated).types create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderCircularDefaults(checkorder=reverse).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderCircularDefaults(checkorder=reverse).js create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderCircularDefaults(checkorder=reverse).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderCircularDefaults(checkorder=reverse).types create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderCircularDefaults(checkorder=typesfirst).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderCircularDefaults(checkorder=typesfirst).js create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderCircularDefaults(checkorder=typesfirst).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderCircularDefaults(checkorder=typesfirst).types create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderEmitBeforeCheck(checkorder=default).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderEmitBeforeCheck(checkorder=default).js create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderEmitBeforeCheck(checkorder=default).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderEmitBeforeCheck(checkorder=default).types create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderEmitBeforeCheck(checkorder=isolated).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderEmitBeforeCheck(checkorder=isolated).js create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderEmitBeforeCheck(checkorder=isolated).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderEmitBeforeCheck(checkorder=isolated).types create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderEnumComputedMember(checkorder=default).js create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderEnumComputedMember(checkorder=default).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderEnumComputedMember(checkorder=default).types create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderEnumComputedMember(checkorder=isolated).js create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderEnumComputedMember(checkorder=isolated).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderEnumComputedMember(checkorder=isolated).types create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderEnumComputedMember(checkorder=reverse).js create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderEnumComputedMember(checkorder=reverse).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderEnumComputedMember(checkorder=reverse).types create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderEnumComputedMember(checkorder=typesfirst).js create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderEnumComputedMember(checkorder=typesfirst).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderEnumComputedMember(checkorder=typesfirst).types create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderLateBoundMembers(checkorder=default).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderLateBoundMembers(checkorder=default).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderLateBoundMembers(checkorder=default).types create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderLateBoundMembers(checkorder=isolated).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderLateBoundMembers(checkorder=isolated).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderLateBoundMembers(checkorder=isolated).types create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderLateBoundMembers(checkorder=reverse).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderLateBoundMembers(checkorder=reverse).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderLateBoundMembers(checkorder=reverse).types create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderLateBoundMembers(checkorder=typesfirst).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderLateBoundMembers(checkorder=typesfirst).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderLateBoundMembers(checkorder=typesfirst).types create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderModuleExportsAlias(checkorder=default).js create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderModuleExportsAlias(checkorder=default).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderModuleExportsAlias(checkorder=default).types create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderModuleExportsAlias(checkorder=isolated).js create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderModuleExportsAlias(checkorder=isolated).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderModuleExportsAlias(checkorder=isolated).types create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderModuleExportsAlias(checkorder=reverse).js create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderModuleExportsAlias(checkorder=reverse).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderModuleExportsAlias(checkorder=reverse).types create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderModuleExportsAlias(checkorder=typesfirst).js create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderModuleExportsAlias(checkorder=typesfirst).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderModuleExportsAlias(checkorder=typesfirst).types create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderParameterInTypeQuery(checkorder=default).js create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderParameterInTypeQuery(checkorder=default).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderParameterInTypeQuery(checkorder=default).types create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderParameterInTypeQuery(checkorder=isolated).js create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderParameterInTypeQuery(checkorder=isolated).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderParameterInTypeQuery(checkorder=isolated).types create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderParameterInTypeQuery(checkorder=reverse).js create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderParameterInTypeQuery(checkorder=reverse).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderParameterInTypeQuery(checkorder=reverse).types create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderParameterInTypeQuery(checkorder=typesfirst).js create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderParameterInTypeQuery(checkorder=typesfirst).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderParameterInTypeQuery(checkorder=typesfirst).types create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderRecursiveIndexedAccess(checkorder=default).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderRecursiveIndexedAccess(checkorder=default).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderRecursiveIndexedAccess(checkorder=default).types create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderRecursiveIndexedAccess(checkorder=isolated).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderRecursiveIndexedAccess(checkorder=isolated).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderRecursiveIndexedAccess(checkorder=isolated).types create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderRecursiveIndexedAccess(checkorder=reverse).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderRecursiveIndexedAccess(checkorder=reverse).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderRecursiveIndexedAccess(checkorder=reverse).types create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderRecursiveIndexedAccess(checkorder=typesfirst).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderRecursiveIndexedAccess(checkorder=typesfirst).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderRecursiveIndexedAccess(checkorder=typesfirst).types create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=default).js create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=default).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=default).types create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=isolated).js create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=isolated).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=isolated).types create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=reverse).js create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=reverse).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=reverse).types create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=typesfirst).js create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=typesfirst).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=typesfirst).types create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderStableInstantiationErrors(checkorder=default).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderStableInstantiationErrors(checkorder=default).js create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderStableInstantiationErrors(checkorder=default).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderStableInstantiationErrors(checkorder=default).types create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderStableInstantiationErrors(checkorder=reverse).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderStableInstantiationErrors(checkorder=reverse).js create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderStableInstantiationErrors(checkorder=reverse).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderStableInstantiationErrors(checkorder=reverse).types create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderStableInstantiationErrors(checkorder=typesfirst).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderStableInstantiationErrors(checkorder=typesfirst).js create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderStableInstantiationErrors(checkorder=typesfirst).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderStableInstantiationErrors(checkorder=typesfirst).types create mode 100644 tsc/testdata/baselines/reference/compiler/circularAccessorAnnotations(checkorder=default).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/circularAccessorAnnotations(checkorder=default).js create mode 100644 tsc/testdata/baselines/reference/compiler/circularAccessorAnnotations(checkorder=default).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/circularAccessorAnnotations(checkorder=default).types create mode 100644 tsc/testdata/baselines/reference/compiler/circularAccessorAnnotations(checkorder=typesfirst).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/circularAccessorAnnotations(checkorder=typesfirst).js create mode 100644 tsc/testdata/baselines/reference/compiler/circularAccessorAnnotations(checkorder=typesfirst).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/circularAccessorAnnotations(checkorder=typesfirst).types create mode 100644 tsc/testdata/baselines/reference/compiler/circularIndexedPropertyInstantiation.errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/circularIndexedPropertyInstantiation.js create mode 100644 tsc/testdata/baselines/reference/compiler/circularIndexedPropertyInstantiation.symbols create mode 100644 tsc/testdata/baselines/reference/compiler/circularIndexedPropertyInstantiation.types create mode 100644 tsc/testdata/baselines/reference/compiler/circularInitializerInference(strict=false).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/circularInitializerInference(strict=false).js create mode 100644 tsc/testdata/baselines/reference/compiler/circularInitializerInference(strict=false).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/circularInitializerInference(strict=false).types create mode 100644 tsc/testdata/baselines/reference/compiler/circularInitializerInference(strict=true).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/circularInitializerInference(strict=true).js create mode 100644 tsc/testdata/baselines/reference/compiler/circularInitializerInference(strict=true).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/circularInitializerInference(strict=true).types create mode 100644 tsc/testdata/baselines/reference/compiler/circularInlineMappedGenericTupleTypeNoCrash(checkorder=default).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/circularInlineMappedGenericTupleTypeNoCrash(checkorder=default).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/circularInlineMappedGenericTupleTypeNoCrash(checkorder=default).types create mode 100644 tsc/testdata/baselines/reference/compiler/circularInlineMappedGenericTupleTypeNoCrash(checkorder=typesfirst).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/circularInlineMappedGenericTupleTypeNoCrash(checkorder=typesfirst).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/circularInlineMappedGenericTupleTypeNoCrash(checkorder=typesfirst).types create mode 100644 tsc/testdata/baselines/reference/compiler/circularReturnTypeSubtypeReductionOrder.errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/circularReturnTypeSubtypeReductionOrder.symbols create mode 100644 tsc/testdata/baselines/reference/compiler/circularReturnTypeSubtypeReductionOrder.types create mode 100644 tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallArgumentRelation(checkorder=default).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallArgumentRelation(checkorder=default).types create mode 100644 tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallArgumentRelation(checkorder=typesfirst).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallArgumentRelation(checkorder=typesfirst).types create mode 100644 tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallbackArgument(strict=false).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallbackArgument(strict=false).types create mode 100644 tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallbackArgument(strict=true).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallbackArgument(strict=true).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallbackArgument(strict=true).types create mode 100644 tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughUncontextualCallbackArgument(checkorder=default).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughUncontextualCallbackArgument(checkorder=default).types create mode 100644 tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughUncontextualCallbackArgument(checkorder=typesfirst).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughUncontextualCallbackArgument(checkorder=typesfirst).types create mode 100644 tsc/testdata/baselines/reference/compiler/circularScopeThunkReverseMapped(checkorder=default).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/circularScopeThunkReverseMapped(checkorder=default).types create mode 100644 tsc/testdata/baselines/reference/compiler/circularScopeThunkReverseMapped(checkorder=typesfirst).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/circularScopeThunkReverseMapped(checkorder=typesfirst).types create mode 100644 tsc/testdata/baselines/reference/compiler/classCircularityDiagnostics(noimplicitany=false).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/classCircularityDiagnostics(noimplicitany=false).js create mode 100644 tsc/testdata/baselines/reference/compiler/classCircularityDiagnostics(noimplicitany=false).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/classCircularityDiagnostics(noimplicitany=false).types create mode 100644 tsc/testdata/baselines/reference/compiler/classCircularityDiagnostics(noimplicitany=true).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/classCircularityDiagnostics(noimplicitany=true).js create mode 100644 tsc/testdata/baselines/reference/compiler/classCircularityDiagnostics(noimplicitany=true).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/classCircularityDiagnostics(noimplicitany=true).types create mode 100644 tsc/testdata/baselines/reference/compiler/clonedTypeParameterUnionOrder(checkorder=default).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/clonedTypeParameterUnionOrder(checkorder=default).types create mode 100644 tsc/testdata/baselines/reference/compiler/clonedTypeParameterUnionOrder(checkorder=reverse).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/clonedTypeParameterUnionOrder(checkorder=reverse).types create mode 100644 tsc/testdata/baselines/reference/compiler/clonedTypeParameterUnionOrder(checkorder=typesfirst).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/clonedTypeParameterUnionOrder(checkorder=typesfirst).types create mode 100644 tsc/testdata/baselines/reference/compiler/constAssertionBindingPatternQueryOrder(checkorder=default).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/constAssertionBindingPatternQueryOrder(checkorder=default).types create mode 100644 tsc/testdata/baselines/reference/compiler/constAssertionBindingPatternQueryOrder(checkorder=typesfirst).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/constAssertionBindingPatternQueryOrder(checkorder=typesfirst).types create mode 100644 tsc/testdata/baselines/reference/compiler/contextualCheckReentryFromOuterTypeParameters.symbols create mode 100644 tsc/testdata/baselines/reference/compiler/contextualCheckReentryFromOuterTypeParameters.types create mode 100644 tsc/testdata/baselines/reference/compiler/contextualOuterTypeParameters(checkorder=default).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/contextualOuterTypeParameters(checkorder=default).types create mode 100644 tsc/testdata/baselines/reference/compiler/contextualOuterTypeParameters(checkorder=typesfirst).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/contextualOuterTypeParameters(checkorder=typesfirst).types create mode 100644 tsc/testdata/baselines/reference/compiler/contextualParameterDefaultReferenceCheckOrder(checkorder=default).js create mode 100644 tsc/testdata/baselines/reference/compiler/contextualParameterDefaultReferenceCheckOrder(checkorder=default).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/contextualParameterDefaultReferenceCheckOrder(checkorder=default).types create mode 100644 tsc/testdata/baselines/reference/compiler/contextualParameterDefaultReferenceCheckOrder(checkorder=typesfirst).js create mode 100644 tsc/testdata/baselines/reference/compiler/contextualParameterDefaultReferenceCheckOrder(checkorder=typesfirst).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/contextualParameterDefaultReferenceCheckOrder(checkorder=typesfirst).types create mode 100644 tsc/testdata/baselines/reference/compiler/contextualParameterInCircularVariableInitializer(checkorder=default).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/contextualParameterInCircularVariableInitializer(checkorder=default).types create mode 100644 tsc/testdata/baselines/reference/compiler/contextualParameterInCircularVariableInitializer(checkorder=typesfirst).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/contextualParameterInCircularVariableInitializer(checkorder=typesfirst).types create mode 100644 tsc/testdata/baselines/reference/compiler/contextualParameterInReturnTypeCycleOfGenericCall(checkorder=default).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/contextualParameterInReturnTypeCycleOfGenericCall(checkorder=default).types create mode 100644 tsc/testdata/baselines/reference/compiler/contextualParameterInReturnTypeCycleOfGenericCall(checkorder=typesfirst).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/contextualParameterInReturnTypeCycleOfGenericCall(checkorder=typesfirst).types create mode 100644 tsc/testdata/baselines/reference/compiler/contextualReturnArrayPatternCallback(checkorder=default).js create mode 100644 tsc/testdata/baselines/reference/compiler/contextualReturnArrayPatternCallback(checkorder=default).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/contextualReturnArrayPatternCallback(checkorder=default).types create mode 100644 tsc/testdata/baselines/reference/compiler/contextualReturnArrayPatternCallback(checkorder=typesfirst).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/contextualReturnArrayPatternCallback(checkorder=typesfirst).js create mode 100644 tsc/testdata/baselines/reference/compiler/contextualReturnArrayPatternCallback(checkorder=typesfirst).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/contextualReturnArrayPatternCallback(checkorder=typesfirst).types create mode 100644 tsc/testdata/baselines/reference/compiler/cycleYieldThroughVarianceCheckOrder(checkorder=default).js create mode 100644 tsc/testdata/baselines/reference/compiler/cycleYieldThroughVarianceCheckOrder(checkorder=default).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/cycleYieldThroughVarianceCheckOrder(checkorder=default).types create mode 100644 tsc/testdata/baselines/reference/compiler/cycleYieldThroughVarianceCheckOrder(checkorder=typesfirst).js create mode 100644 tsc/testdata/baselines/reference/compiler/cycleYieldThroughVarianceCheckOrder(checkorder=typesfirst).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/cycleYieldThroughVarianceCheckOrder(checkorder=typesfirst).types create mode 100644 tsc/testdata/baselines/reference/compiler/deferredTypeReferenceCycleRollback.errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/deferredTypeReferenceCycleRollback.symbols create mode 100644 tsc/testdata/baselines/reference/compiler/deferredTypeReferenceCycleRollback.types create mode 100644 tsc/testdata/baselines/reference/compiler/deleteExpressionMustBeOptional(checkorder=default,strict=false).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/deleteExpressionMustBeOptional(checkorder=default,strict=false).js create mode 100644 tsc/testdata/baselines/reference/compiler/deleteExpressionMustBeOptional(checkorder=default,strict=false).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/deleteExpressionMustBeOptional(checkorder=default,strict=false).types create mode 100644 tsc/testdata/baselines/reference/compiler/deleteExpressionMustBeOptional(checkorder=default,strict=true).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/deleteExpressionMustBeOptional(checkorder=default,strict=true).js create mode 100644 tsc/testdata/baselines/reference/compiler/deleteExpressionMustBeOptional(checkorder=default,strict=true).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/deleteExpressionMustBeOptional(checkorder=default,strict=true).types create mode 100644 tsc/testdata/baselines/reference/compiler/deleteExpressionMustBeOptional(checkorder=typesfirst,strict=false).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/deleteExpressionMustBeOptional(checkorder=typesfirst,strict=false).js create mode 100644 tsc/testdata/baselines/reference/compiler/deleteExpressionMustBeOptional(checkorder=typesfirst,strict=false).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/deleteExpressionMustBeOptional(checkorder=typesfirst,strict=false).types create mode 100644 tsc/testdata/baselines/reference/compiler/deleteExpressionMustBeOptional(checkorder=typesfirst,strict=true).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/deleteExpressionMustBeOptional(checkorder=typesfirst,strict=true).js create mode 100644 tsc/testdata/baselines/reference/compiler/deleteExpressionMustBeOptional(checkorder=typesfirst,strict=true).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/deleteExpressionMustBeOptional(checkorder=typesfirst,strict=true).types create mode 100644 tsc/testdata/baselines/reference/compiler/dependentDestructuringBindingElementInitializer(checkorder=default).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/dependentDestructuringBindingElementInitializer(checkorder=default).types create mode 100644 tsc/testdata/baselines/reference/compiler/dependentDestructuringBindingElementInitializer(checkorder=typesfirst).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/dependentDestructuringBindingElementInitializer(checkorder=typesfirst).types create mode 100644 tsc/testdata/baselines/reference/compiler/distributiveConstraintOfCircularCheckType.symbols create mode 100644 tsc/testdata/baselines/reference/compiler/distributiveConstraintOfCircularCheckType.types create mode 100644 tsc/testdata/baselines/reference/compiler/enumMemberTypeCacheConsistency.js create mode 100644 tsc/testdata/baselines/reference/compiler/enumMemberTypeCacheConsistency.symbols create mode 100644 tsc/testdata/baselines/reference/compiler/enumMemberTypeCacheConsistency.types create mode 100644 tsc/testdata/baselines/reference/compiler/evolvingArrayReadInLoopCondition.errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/evolvingArrayReadInLoopCondition.symbols create mode 100644 tsc/testdata/baselines/reference/compiler/evolvingArrayReadInLoopCondition.types create mode 100644 tsc/testdata/baselines/reference/compiler/exhaustiveSwitchCheckCircularity(checkorder=default).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/exhaustiveSwitchCheckCircularity(checkorder=default).js create mode 100644 tsc/testdata/baselines/reference/compiler/exhaustiveSwitchCheckCircularity(checkorder=default).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/exhaustiveSwitchCheckCircularity(checkorder=default).types create mode 100644 tsc/testdata/baselines/reference/compiler/exhaustiveSwitchCheckCircularity(checkorder=typesfirst).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/exhaustiveSwitchCheckCircularity(checkorder=typesfirst).js create mode 100644 tsc/testdata/baselines/reference/compiler/exhaustiveSwitchCheckCircularity(checkorder=typesfirst).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/exhaustiveSwitchCheckCircularity(checkorder=typesfirst).types create mode 100644 tsc/testdata/baselines/reference/compiler/exportAssignmentNestedVisibilityQueryOrder(checkorder=default).js create mode 100644 tsc/testdata/baselines/reference/compiler/exportAssignmentNestedVisibilityQueryOrder(checkorder=default).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/exportAssignmentNestedVisibilityQueryOrder(checkorder=default).types create mode 100644 tsc/testdata/baselines/reference/compiler/exportAssignmentNestedVisibilityQueryOrder(checkorder=editorfirst).js create mode 100644 tsc/testdata/baselines/reference/compiler/exportAssignmentNestedVisibilityQueryOrder(checkorder=editorfirst).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/exportAssignmentNestedVisibilityQueryOrder(checkorder=editorfirst).types create mode 100644 tsc/testdata/baselines/reference/compiler/fallbackToBindingPatternForTypeInference(checkorder=default).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/fallbackToBindingPatternForTypeInference(checkorder=default).js create mode 100644 tsc/testdata/baselines/reference/compiler/fallbackToBindingPatternForTypeInference(checkorder=default).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/fallbackToBindingPatternForTypeInference(checkorder=default).types create mode 100644 tsc/testdata/baselines/reference/compiler/fallbackToBindingPatternForTypeInference(checkorder=typesfirst).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/fallbackToBindingPatternForTypeInference(checkorder=typesfirst).js create mode 100644 tsc/testdata/baselines/reference/compiler/fallbackToBindingPatternForTypeInference(checkorder=typesfirst).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/fallbackToBindingPatternForTypeInference(checkorder=typesfirst).types create mode 100644 tsc/testdata/baselines/reference/compiler/fixingTypeParametersRepeatedly2(checkorder=default).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/fixingTypeParametersRepeatedly2(checkorder=default).js create mode 100644 tsc/testdata/baselines/reference/compiler/fixingTypeParametersRepeatedly2(checkorder=default).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/fixingTypeParametersRepeatedly2(checkorder=default).types create mode 100644 tsc/testdata/baselines/reference/compiler/fixingTypeParametersRepeatedly2(checkorder=typesfirst).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/fixingTypeParametersRepeatedly2(checkorder=typesfirst).js create mode 100644 tsc/testdata/baselines/reference/compiler/fixingTypeParametersRepeatedly2(checkorder=typesfirst).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/fixingTypeParametersRepeatedly2(checkorder=typesfirst).types create mode 100644 tsc/testdata/baselines/reference/compiler/flowLoopDepthCheckOrder(checkorder=default).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/flowLoopDepthCheckOrder(checkorder=default).types create mode 100644 tsc/testdata/baselines/reference/compiler/flowLoopDepthCheckOrder(checkorder=typesfirst).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/flowLoopDepthCheckOrder(checkorder=typesfirst).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/flowLoopDepthCheckOrder(checkorder=typesfirst).types create mode 100644 tsc/testdata/baselines/reference/compiler/flowLoopTooDeepCheckOrder(checkorder=default).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/flowLoopTooDeepCheckOrder(checkorder=default).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/flowLoopTooDeepCheckOrder(checkorder=default).types create mode 100644 tsc/testdata/baselines/reference/compiler/flowLoopTooDeepCheckOrder(checkorder=typesfirst).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/flowLoopTooDeepCheckOrder(checkorder=typesfirst).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/flowLoopTooDeepCheckOrder(checkorder=typesfirst).types create mode 100644 tsc/testdata/baselines/reference/compiler/genericCallReturnedFunctionParameterDefault(checkorder=default).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/genericCallReturnedFunctionParameterDefault(checkorder=default).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/genericCallReturnedFunctionParameterDefault(checkorder=default).types create mode 100644 tsc/testdata/baselines/reference/compiler/genericCallReturnedFunctionParameterDefault(checkorder=typesfirst).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/genericCallReturnedFunctionParameterDefault(checkorder=typesfirst).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/genericCallReturnedFunctionParameterDefault(checkorder=typesfirst).types create mode 100644 tsc/testdata/baselines/reference/compiler/getterCircularityDiagnostics.errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/getterCircularityDiagnostics.js create mode 100644 tsc/testdata/baselines/reference/compiler/getterCircularityDiagnostics.symbols create mode 100644 tsc/testdata/baselines/reference/compiler/getterCircularityDiagnostics.types create mode 100644 tsc/testdata/baselines/reference/compiler/getterReturnTypeQueryOrder(checkorder=default).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/getterReturnTypeQueryOrder(checkorder=default).js create mode 100644 tsc/testdata/baselines/reference/compiler/getterReturnTypeQueryOrder(checkorder=default).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/getterReturnTypeQueryOrder(checkorder=default).types create mode 100644 tsc/testdata/baselines/reference/compiler/getterReturnTypeQueryOrder(checkorder=editorfirst).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/getterReturnTypeQueryOrder(checkorder=editorfirst).js create mode 100644 tsc/testdata/baselines/reference/compiler/getterReturnTypeQueryOrder(checkorder=editorfirst).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/getterReturnTypeQueryOrder(checkorder=editorfirst).types create mode 100644 tsc/testdata/baselines/reference/compiler/importAttributeValueCheckOrder(checkorder=default).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/importAttributeValueCheckOrder(checkorder=default).js create mode 100644 tsc/testdata/baselines/reference/compiler/importAttributeValueCheckOrder(checkorder=default).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/importAttributeValueCheckOrder(checkorder=default).types create mode 100644 tsc/testdata/baselines/reference/compiler/importAttributeValueCheckOrder(checkorder=typesfirst).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/importAttributeValueCheckOrder(checkorder=typesfirst).js create mode 100644 tsc/testdata/baselines/reference/compiler/importAttributeValueCheckOrder(checkorder=typesfirst).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/importAttributeValueCheckOrder(checkorder=typesfirst).types create mode 100644 tsc/testdata/baselines/reference/compiler/indexSignatureWithIndexedAccessOfDerivedInterface.errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/indexSignatureWithIndexedAccessOfDerivedInterface.symbols create mode 100644 tsc/testdata/baselines/reference/compiler/indexSignatureWithIndexedAccessOfDerivedInterface.types create mode 100644 tsc/testdata/baselines/reference/compiler/indexedAccessAccessFlagsUnionOrder(checkorder=default).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/indexedAccessAccessFlagsUnionOrder(checkorder=default).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/indexedAccessAccessFlagsUnionOrder(checkorder=default).types create mode 100644 tsc/testdata/baselines/reference/compiler/indexedAccessAccessFlagsUnionOrder(checkorder=typesfirst).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/indexedAccessAccessFlagsUnionOrder(checkorder=typesfirst).types create mode 100644 tsc/testdata/baselines/reference/compiler/inferTypeParameterConstraintFromMappedIntersectionCheckOrder(checkorder=default).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/inferTypeParameterConstraintFromMappedIntersectionCheckOrder(checkorder=default).js create mode 100644 tsc/testdata/baselines/reference/compiler/inferTypeParameterConstraintFromMappedIntersectionCheckOrder(checkorder=default).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/inferTypeParameterConstraintFromMappedIntersectionCheckOrder(checkorder=default).types create mode 100644 tsc/testdata/baselines/reference/compiler/inferTypeParameterConstraintFromMappedIntersectionCheckOrder(checkorder=typesfirst).js create mode 100644 tsc/testdata/baselines/reference/compiler/inferTypeParameterConstraintFromMappedIntersectionCheckOrder(checkorder=typesfirst).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/inferTypeParameterConstraintFromMappedIntersectionCheckOrder(checkorder=typesfirst).types create mode 100644 tsc/testdata/baselines/reference/compiler/inferenceDeeplyNestedCheckOrder.errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/inferenceDeeplyNestedCheckOrder.symbols create mode 100644 tsc/testdata/baselines/reference/compiler/inferenceDeeplyNestedCheckOrder.types create mode 100644 tsc/testdata/baselines/reference/compiler/inferenceFromUnionOfTypeParameterAndPromiseLike.errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/inferenceFromUnionOfTypeParameterAndPromiseLike.symbols create mode 100644 tsc/testdata/baselines/reference/compiler/inferenceFromUnionOfTypeParameterAndPromiseLike.types create mode 100644 tsc/testdata/baselines/reference/compiler/inferenceThroughSortOfFlattenedIterable.errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/inferenceThroughSortOfFlattenedIterable.symbols create mode 100644 tsc/testdata/baselines/reference/compiler/inferenceThroughSortOfFlattenedIterable.types create mode 100644 tsc/testdata/baselines/reference/compiler/instantiationCouldContainTypeVariablesAfterCycle(checkorder=default).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/instantiationCouldContainTypeVariablesAfterCycle(checkorder=default).types create mode 100644 tsc/testdata/baselines/reference/compiler/instantiationCouldContainTypeVariablesAfterCycle(checkorder=typesfirst).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/instantiationCouldContainTypeVariablesAfterCycle(checkorder=typesfirst).types create mode 100644 tsc/testdata/baselines/reference/compiler/instantiationCountSharedCheckOrder(checkorder=default).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/instantiationCountSharedCheckOrder(checkorder=default).types create mode 100644 tsc/testdata/baselines/reference/compiler/instantiationCountSharedCheckOrder(checkorder=typesfirst).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/instantiationCountSharedCheckOrder(checkorder=typesfirst).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/instantiationCountSharedCheckOrder(checkorder=typesfirst).types create mode 100644 tsc/testdata/baselines/reference/compiler/instantiationDepthSharedCheckOrder(checkorder=default).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/instantiationDepthSharedCheckOrder(checkorder=default).types create mode 100644 tsc/testdata/baselines/reference/compiler/instantiationDepthSharedCheckOrder(checkorder=typesfirst).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/instantiationDepthSharedCheckOrder(checkorder=typesfirst).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/instantiationDepthSharedCheckOrder(checkorder=typesfirst).types create mode 100644 tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintCycleCheckOrder(checkorder=default).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintCycleCheckOrder(checkorder=default).js create mode 100644 tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintCycleCheckOrder(checkorder=default).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintCycleCheckOrder(checkorder=default).types create mode 100644 tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintCycleCheckOrder(checkorder=typesfirst).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintCycleCheckOrder(checkorder=typesfirst).js create mode 100644 tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintCycleCheckOrder(checkorder=typesfirst).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintCycleCheckOrder(checkorder=typesfirst).types create mode 100644 tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintInStaticClassExpression.symbols create mode 100644 tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintInStaticClassExpression.types create mode 100644 tsc/testdata/baselines/reference/compiler/instantiationLimitsCheckOrder.errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/instantiationLimitsCheckOrder.symbols create mode 100644 tsc/testdata/baselines/reference/compiler/instantiationLimitsCheckOrder.types create mode 100644 tsc/testdata/baselines/reference/compiler/instantiationStackLimitCheckOrder(checkorder=default).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/instantiationStackLimitCheckOrder(checkorder=default).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/instantiationStackLimitCheckOrder(checkorder=default).types create mode 100644 tsc/testdata/baselines/reference/compiler/instantiationStackLimitCheckOrder(checkorder=typesfirst).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/instantiationStackLimitCheckOrder(checkorder=typesfirst).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/instantiationStackLimitCheckOrder(checkorder=typesfirst).types create mode 100644 tsc/testdata/baselines/reference/compiler/intersectionBaseConstructorCycleCheckOrder(checkorder=default).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/intersectionBaseConstructorCycleCheckOrder(checkorder=default).js create mode 100644 tsc/testdata/baselines/reference/compiler/intersectionBaseConstructorCycleCheckOrder(checkorder=default).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/intersectionBaseConstructorCycleCheckOrder(checkorder=default).types create mode 100644 tsc/testdata/baselines/reference/compiler/intersectionBaseConstructorCycleCheckOrder(checkorder=typesfirst).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/intersectionBaseConstructorCycleCheckOrder(checkorder=typesfirst).js create mode 100644 tsc/testdata/baselines/reference/compiler/intersectionBaseConstructorCycleCheckOrder(checkorder=typesfirst).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/intersectionBaseConstructorCycleCheckOrder(checkorder=typesfirst).types create mode 100644 tsc/testdata/baselines/reference/compiler/jsdocLinkImportElisionQueryOrder(checkorder=default).js create mode 100644 tsc/testdata/baselines/reference/compiler/jsdocLinkImportElisionQueryOrder(checkorder=default).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/jsdocLinkImportElisionQueryOrder(checkorder=default).types create mode 100644 tsc/testdata/baselines/reference/compiler/jsdocLinkImportElisionQueryOrder(checkorder=editorfirst).js create mode 100644 tsc/testdata/baselines/reference/compiler/jsdocLinkImportElisionQueryOrder(checkorder=editorfirst).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/jsdocLinkImportElisionQueryOrder(checkorder=editorfirst).types create mode 100644 tsc/testdata/baselines/reference/compiler/jsdocTypeTagOnContextuallyTypedFunction.errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/jsdocTypeTagOnContextuallyTypedFunction.symbols create mode 100644 tsc/testdata/baselines/reference/compiler/jsdocTypeTagOnContextuallyTypedFunction.types create mode 100644 tsc/testdata/baselines/reference/compiler/jsxImportSourceNonPragmaComment(checkorder=default).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/jsxImportSourceNonPragmaComment(checkorder=default).js create mode 100644 tsc/testdata/baselines/reference/compiler/jsxImportSourceNonPragmaComment(checkorder=default).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/jsxImportSourceNonPragmaComment(checkorder=default).types create mode 100644 tsc/testdata/baselines/reference/compiler/jsxImportSourceNonPragmaComment(checkorder=typesfirst).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/jsxImportSourceNonPragmaComment(checkorder=typesfirst).js create mode 100644 tsc/testdata/baselines/reference/compiler/jsxImportSourceNonPragmaComment(checkorder=typesfirst).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/jsxImportSourceNonPragmaComment(checkorder=typesfirst).types create mode 100644 tsc/testdata/baselines/reference/compiler/jsxIntrinsicElementsExtendsRecord(checkorder=default).js create mode 100644 tsc/testdata/baselines/reference/compiler/jsxIntrinsicElementsExtendsRecord(checkorder=default).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/jsxIntrinsicElementsExtendsRecord(checkorder=default).types create mode 100644 tsc/testdata/baselines/reference/compiler/jsxIntrinsicElementsExtendsRecord(checkorder=typesfirst).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/jsxIntrinsicElementsExtendsRecord(checkorder=typesfirst).js create mode 100644 tsc/testdata/baselines/reference/compiler/jsxIntrinsicElementsExtendsRecord(checkorder=typesfirst).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/jsxIntrinsicElementsExtendsRecord(checkorder=typesfirst).types create mode 100644 tsc/testdata/baselines/reference/compiler/keyofIndexSignatureCycleCheckOrder(checkorder=default).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/keyofIndexSignatureCycleCheckOrder(checkorder=default).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/keyofIndexSignatureCycleCheckOrder(checkorder=default).types create mode 100644 tsc/testdata/baselines/reference/compiler/keyofIndexSignatureCycleCheckOrder(checkorder=typesfirst).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/keyofIndexSignatureCycleCheckOrder(checkorder=typesfirst).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/keyofIndexSignatureCycleCheckOrder(checkorder=typesfirst).types create mode 100644 tsc/testdata/baselines/reference/compiler/limitDeepInstantiations(checkorder=default).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/limitDeepInstantiations(checkorder=default).js create mode 100644 tsc/testdata/baselines/reference/compiler/limitDeepInstantiations(checkorder=default).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/limitDeepInstantiations(checkorder=default).types create mode 100644 tsc/testdata/baselines/reference/compiler/limitDeepInstantiations(checkorder=typesfirst).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/limitDeepInstantiations(checkorder=typesfirst).js create mode 100644 tsc/testdata/baselines/reference/compiler/limitDeepInstantiations(checkorder=typesfirst).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/limitDeepInstantiations(checkorder=typesfirst).types create mode 100644 tsc/testdata/baselines/reference/compiler/narrowedNeverAfterLoopWithAndCondition.errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/narrowedNeverAfterLoopWithAndCondition.symbols create mode 100644 tsc/testdata/baselines/reference/compiler/narrowedNeverAfterLoopWithAndCondition.types create mode 100644 tsc/testdata/baselines/reference/compiler/nestedCallContextualTypeCheckOrder(checkorder=default).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/nestedCallContextualTypeCheckOrder(checkorder=default).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/nestedCallContextualTypeCheckOrder(checkorder=default).types create mode 100644 tsc/testdata/baselines/reference/compiler/nestedCallContextualTypeCheckOrder(checkorder=typesfirst).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/nestedCallContextualTypeCheckOrder(checkorder=typesfirst).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/nestedCallContextualTypeCheckOrder(checkorder=typesfirst).types create mode 100644 tsc/testdata/baselines/reference/compiler/nestedCallContextualTypeCheckOrderJsx(checkorder=default).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/nestedCallContextualTypeCheckOrderJsx(checkorder=default).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/nestedCallContextualTypeCheckOrderJsx(checkorder=default).types create mode 100644 tsc/testdata/baselines/reference/compiler/nestedCallContextualTypeCheckOrderJsx(checkorder=typesfirst).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/nestedCallContextualTypeCheckOrderJsx(checkorder=typesfirst).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/nestedCallContextualTypeCheckOrderJsx(checkorder=typesfirst).types create mode 100644 tsc/testdata/baselines/reference/compiler/nestedGenericArrayAssignabilityAfterErrors.errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/nestedGenericArrayAssignabilityAfterErrors.symbols create mode 100644 tsc/testdata/baselines/reference/compiler/nestedGenericArrayAssignabilityAfterErrors.types create mode 100644 tsc/testdata/baselines/reference/compiler/objectLiteralRegularAndWidenedCopyOrder(checkorder=default).js create mode 100644 tsc/testdata/baselines/reference/compiler/objectLiteralRegularAndWidenedCopyOrder(checkorder=default).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/objectLiteralRegularAndWidenedCopyOrder(checkorder=default).types create mode 100644 tsc/testdata/baselines/reference/compiler/objectLiteralRegularAndWidenedCopyOrder(checkorder=typesfirst).js create mode 100644 tsc/testdata/baselines/reference/compiler/objectLiteralRegularAndWidenedCopyOrder(checkorder=typesfirst).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/objectLiteralRegularAndWidenedCopyOrder(checkorder=typesfirst).types create mode 100644 tsc/testdata/baselines/reference/compiler/objectRestUnionInstantiationOrder(checkorder=default).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/objectRestUnionInstantiationOrder(checkorder=default).types create mode 100644 tsc/testdata/baselines/reference/compiler/objectRestUnionInstantiationOrder(checkorder=typesfirst).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/objectRestUnionInstantiationOrder(checkorder=typesfirst).types create mode 100644 tsc/testdata/baselines/reference/compiler/overloadresolutionWithConstraintCheckingDeferred(checkorder=default).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/overloadresolutionWithConstraintCheckingDeferred(checkorder=default).js create mode 100644 tsc/testdata/baselines/reference/compiler/overloadresolutionWithConstraintCheckingDeferred(checkorder=default).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/overloadresolutionWithConstraintCheckingDeferred(checkorder=default).types create mode 100644 tsc/testdata/baselines/reference/compiler/overloadresolutionWithConstraintCheckingDeferred(checkorder=typesfirst).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/overloadresolutionWithConstraintCheckingDeferred(checkorder=typesfirst).js create mode 100644 tsc/testdata/baselines/reference/compiler/overloadresolutionWithConstraintCheckingDeferred(checkorder=typesfirst).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/overloadresolutionWithConstraintCheckingDeferred(checkorder=typesfirst).types create mode 100644 tsc/testdata/baselines/reference/compiler/parameterBindingDefaultReferencesSiblingThroughCall(checkorder=default).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/parameterBindingDefaultReferencesSiblingThroughCall(checkorder=default).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/parameterBindingDefaultReferencesSiblingThroughCall(checkorder=default).types create mode 100644 tsc/testdata/baselines/reference/compiler/parameterBindingDefaultReferencesSiblingThroughCall(checkorder=typesfirst).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/parameterBindingDefaultReferencesSiblingThroughCall(checkorder=typesfirst).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/parameterBindingDefaultReferencesSiblingThroughCall(checkorder=typesfirst).types create mode 100644 tsc/testdata/baselines/reference/compiler/qualifiedNameCycleErrorCheckOrder(checkorder=default).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/qualifiedNameCycleErrorCheckOrder(checkorder=default).js create mode 100644 tsc/testdata/baselines/reference/compiler/qualifiedNameCycleErrorCheckOrder(checkorder=default).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/qualifiedNameCycleErrorCheckOrder(checkorder=default).types create mode 100644 tsc/testdata/baselines/reference/compiler/qualifiedNameCycleErrorCheckOrder(checkorder=typesfirst).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/qualifiedNameCycleErrorCheckOrder(checkorder=typesfirst).js create mode 100644 tsc/testdata/baselines/reference/compiler/qualifiedNameCycleErrorCheckOrder(checkorder=typesfirst).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/qualifiedNameCycleErrorCheckOrder(checkorder=typesfirst).types create mode 100644 tsc/testdata/baselines/reference/compiler/recursiveGenericInterfaceDeclarationOrder.errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/recursiveGenericInterfaceDeclarationOrder.symbols create mode 100644 tsc/testdata/baselines/reference/compiler/recursiveGenericInterfaceDeclarationOrder.types create mode 100644 tsc/testdata/baselines/reference/compiler/recursiveVarianceFixedPoint.errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/recursiveVarianceFixedPoint.symbols create mode 100644 tsc/testdata/baselines/reference/compiler/recursiveVarianceFixedPoint.types create mode 100644 tsc/testdata/baselines/reference/compiler/relationComplexityError(checkorder=default).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/relationComplexityError(checkorder=default).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/relationComplexityError(checkorder=default).types create mode 100644 tsc/testdata/baselines/reference/compiler/relationComplexityError(checkorder=typesfirst).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/relationComplexityError(checkorder=typesfirst).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/relationComplexityError(checkorder=typesfirst).types create mode 100644 tsc/testdata/baselines/reference/compiler/relationComplexitySharedCheckOrder(checkorder=default).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/relationComplexitySharedCheckOrder(checkorder=default).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/relationComplexitySharedCheckOrder(checkorder=default).types create mode 100644 tsc/testdata/baselines/reference/compiler/relationComplexitySharedCheckOrder(checkorder=typesfirst).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/relationComplexitySharedCheckOrder(checkorder=typesfirst).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/relationComplexitySharedCheckOrder(checkorder=typesfirst).types create mode 100644 tsc/testdata/baselines/reference/compiler/relationCycleNonMonotoneCheckOrder(checkorder=default).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/relationCycleNonMonotoneCheckOrder(checkorder=default).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/relationCycleNonMonotoneCheckOrder(checkorder=default).types create mode 100644 tsc/testdata/baselines/reference/compiler/relationCycleNonMonotoneCheckOrder(checkorder=editorfirst).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/relationCycleNonMonotoneCheckOrder(checkorder=editorfirst).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/relationCycleNonMonotoneCheckOrder(checkorder=editorfirst).types create mode 100644 tsc/testdata/baselines/reference/compiler/relationCycleNonMonotoneCheckOrder(checkorder=typesfirst).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/relationCycleNonMonotoneCheckOrder(checkorder=typesfirst).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/relationCycleNonMonotoneCheckOrder(checkorder=typesfirst).types create mode 100644 tsc/testdata/baselines/reference/compiler/relationDeeplyNestedCheckOrder.symbols create mode 100644 tsc/testdata/baselines/reference/compiler/relationDeeplyNestedCheckOrder.types create mode 100644 tsc/testdata/baselines/reference/compiler/relationDepthSharedCheckOrder(checkorder=default).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/relationDepthSharedCheckOrder(checkorder=default).types create mode 100644 tsc/testdata/baselines/reference/compiler/relationDepthSharedCheckOrder(checkorder=typesfirst).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/relationDepthSharedCheckOrder(checkorder=typesfirst).types create mode 100644 tsc/testdata/baselines/reference/compiler/relationMaybeCheckOrder.errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/relationMaybeCheckOrder.symbols create mode 100644 tsc/testdata/baselines/reference/compiler/relationMaybeCheckOrder.types create mode 100644 tsc/testdata/baselines/reference/compiler/relationNestingSharedCheckOrder(checkorder=default).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/relationNestingSharedCheckOrder(checkorder=default).types create mode 100644 tsc/testdata/baselines/reference/compiler/relationNestingSharedCheckOrder(checkorder=typesfirst).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/relationNestingSharedCheckOrder(checkorder=typesfirst).types create mode 100644 tsc/testdata/baselines/reference/compiler/relationTruncatedCacheCheckOrder(checkorder=default).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/relationTruncatedCacheCheckOrder(checkorder=default).types create mode 100644 tsc/testdata/baselines/reference/compiler/relationTruncatedCacheCheckOrder(checkorder=typesfirst).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/relationTruncatedCacheCheckOrder(checkorder=typesfirst).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/relationTruncatedCacheCheckOrder(checkorder=typesfirst).types create mode 100644 tsc/testdata/baselines/reference/compiler/restrictiveInstantiationOfRestrictiveConditional.symbols create mode 100644 tsc/testdata/baselines/reference/compiler/restrictiveInstantiationOfRestrictiveConditional.types create mode 100644 tsc/testdata/baselines/reference/compiler/returnTypeInferenceNotTooBroad(checkorder=default).js create mode 100644 tsc/testdata/baselines/reference/compiler/returnTypeInferenceNotTooBroad(checkorder=default).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/returnTypeInferenceNotTooBroad(checkorder=default).types create mode 100644 tsc/testdata/baselines/reference/compiler/returnTypeInferenceNotTooBroad(checkorder=typesfirst).js create mode 100644 tsc/testdata/baselines/reference/compiler/returnTypeInferenceNotTooBroad(checkorder=typesfirst).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/returnTypeInferenceNotTooBroad(checkorder=typesfirst).types create mode 100644 tsc/testdata/baselines/reference/compiler/sharedMemberLayoutThisIntersectionBase(checkorder=default).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/sharedMemberLayoutThisIntersectionBase(checkorder=default).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/sharedMemberLayoutThisIntersectionBase(checkorder=default).types create mode 100644 tsc/testdata/baselines/reference/compiler/sharedMemberLayoutThisIntersectionBase(checkorder=typesfirst).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/sharedMemberLayoutThisIntersectionBase(checkorder=typesfirst).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/sharedMemberLayoutThisIntersectionBase(checkorder=typesfirst).types create mode 100644 tsc/testdata/baselines/reference/compiler/signatureHelpInferenceQueryOrder(checkorder=default).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/signatureHelpInferenceQueryOrder(checkorder=default).js create mode 100644 tsc/testdata/baselines/reference/compiler/signatureHelpInferenceQueryOrder(checkorder=default).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/signatureHelpInferenceQueryOrder(checkorder=default).types create mode 100644 tsc/testdata/baselines/reference/compiler/signatureHelpInferenceQueryOrder(checkorder=editorfirst).js create mode 100644 tsc/testdata/baselines/reference/compiler/signatureHelpInferenceQueryOrder(checkorder=editorfirst).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/signatureHelpInferenceQueryOrder(checkorder=editorfirst).types create mode 100644 tsc/testdata/baselines/reference/compiler/substitutionInDeferredConditionalOfConditional.symbols create mode 100644 tsc/testdata/baselines/reference/compiler/substitutionInDeferredConditionalOfConditional.types create mode 100644 tsc/testdata/baselines/reference/compiler/templateLiteralTypeExcessiveLength(checkorder=default).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/templateLiteralTypeExcessiveLength(checkorder=default).js create mode 100644 tsc/testdata/baselines/reference/compiler/templateLiteralTypeExcessiveLength(checkorder=default).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/templateLiteralTypeExcessiveLength(checkorder=default).types create mode 100644 tsc/testdata/baselines/reference/compiler/templateLiteralTypeExcessiveLength(checkorder=typesfirst).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/templateLiteralTypeExcessiveLength(checkorder=typesfirst).js create mode 100644 tsc/testdata/baselines/reference/compiler/templateLiteralTypeExcessiveLength(checkorder=typesfirst).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/templateLiteralTypeExcessiveLength(checkorder=typesfirst).types create mode 100644 tsc/testdata/baselines/reference/compiler/typeParameterDefaultInCallInsideGenericCallback.errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/typeParameterDefaultInCallInsideGenericCallback.symbols create mode 100644 tsc/testdata/baselines/reference/compiler/typeParameterDefaultInCallInsideGenericCallback.types create mode 100644 tsc/testdata/baselines/reference/compiler/typeParameterHasSelfAsConstraint(checkorder=default).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/typeParameterHasSelfAsConstraint(checkorder=default).js create mode 100644 tsc/testdata/baselines/reference/compiler/typeParameterHasSelfAsConstraint(checkorder=default).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/typeParameterHasSelfAsConstraint(checkorder=default).types create mode 100644 tsc/testdata/baselines/reference/compiler/typeParameterHasSelfAsConstraint(checkorder=typesfirst).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/typeParameterHasSelfAsConstraint(checkorder=typesfirst).js create mode 100644 tsc/testdata/baselines/reference/compiler/typeParameterHasSelfAsConstraint(checkorder=typesfirst).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/typeParameterHasSelfAsConstraint(checkorder=typesfirst).types create mode 100644 tsc/testdata/baselines/reference/compiler/typeReferenceRecursionIdentityCheckOrder(checkorder=default).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/typeReferenceRecursionIdentityCheckOrder(checkorder=default).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/typeReferenceRecursionIdentityCheckOrder(checkorder=default).types create mode 100644 tsc/testdata/baselines/reference/compiler/typeReferenceRecursionIdentityCheckOrder(checkorder=typesfirst).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/typeReferenceRecursionIdentityCheckOrder(checkorder=typesfirst).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/typeReferenceRecursionIdentityCheckOrder(checkorder=typesfirst).types create mode 100644 tsc/testdata/baselines/reference/compiler/unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1(checkorder=default).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1(checkorder=default).js create mode 100644 tsc/testdata/baselines/reference/compiler/unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1(checkorder=default).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1(checkorder=default).types create mode 100644 tsc/testdata/baselines/reference/compiler/unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1(checkorder=typesfirst).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1(checkorder=typesfirst).js create mode 100644 tsc/testdata/baselines/reference/compiler/unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1(checkorder=typesfirst).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1(checkorder=typesfirst).types create mode 100644 tsc/testdata/baselines/reference/compiler/unusedTypeParameterQueryOrder(checkorder=default).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/unusedTypeParameterQueryOrder(checkorder=default).js create mode 100644 tsc/testdata/baselines/reference/compiler/unusedTypeParameterQueryOrder(checkorder=default).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/unusedTypeParameterQueryOrder(checkorder=default).types create mode 100644 tsc/testdata/baselines/reference/compiler/unusedTypeParameterQueryOrder(checkorder=editorfirst).js create mode 100644 tsc/testdata/baselines/reference/compiler/unusedTypeParameterQueryOrder(checkorder=editorfirst).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/unusedTypeParameterQueryOrder(checkorder=editorfirst).types create mode 100644 tsc/testdata/baselines/reference/compiler/varianceCircularConsistency.errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/varianceCircularConsistency.symbols create mode 100644 tsc/testdata/baselines/reference/compiler/varianceCircularConsistency.types create mode 100644 tsc/testdata/baselines/reference/compiler/varianceCircularityEnteredByInference(checkorder=default).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/varianceCircularityEnteredByInference(checkorder=default).types create mode 100644 tsc/testdata/baselines/reference/compiler/varianceCircularityEnteredByInference(checkorder=typesfirst).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/varianceCircularityEnteredByInference(checkorder=typesfirst).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/varianceCircularityEnteredByInference(checkorder=typesfirst).types create mode 100644 tsc/testdata/baselines/reference/compiler/varianceCircularityHidesInvariance(checkorder=default).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/varianceCircularityHidesInvariance(checkorder=default).types create mode 100644 tsc/testdata/baselines/reference/compiler/varianceCircularityHidesInvariance(checkorder=typesfirst).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/varianceCircularityHidesInvariance(checkorder=typesfirst).types create mode 100644 tsc/testdata/baselines/reference/compiler/varianceCycleCachedResults.errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/varianceCycleCachedResults.js create mode 100644 tsc/testdata/baselines/reference/compiler/varianceCycleCachedResults.symbols create mode 100644 tsc/testdata/baselines/reference/compiler/varianceCycleCachedResults.types create mode 100644 tsc/testdata/baselines/reference/compiler/varianceCycleCapnwebRpcStub.errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/varianceCycleCapnwebRpcStub.symbols create mode 100644 tsc/testdata/baselines/reference/compiler/varianceCycleCapnwebRpcStub.types create mode 100644 tsc/testdata/baselines/reference/compiler/varianceCycleDiscardedDiagnostics.errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/varianceCycleDiscardedDiagnostics.symbols create mode 100644 tsc/testdata/baselines/reference/compiler/varianceCycleDiscardedDiagnostics.types create mode 100644 tsc/testdata/baselines/reference/compiler/varianceCycleEnteredAfterCanonicalEntry(checkorder=default).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/varianceCycleEnteredAfterCanonicalEntry(checkorder=default).types create mode 100644 tsc/testdata/baselines/reference/compiler/varianceCycleEnteredAfterCanonicalEntry(checkorder=typesfirst).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/varianceCycleEnteredAfterCanonicalEntry(checkorder=typesfirst).types create mode 100644 tsc/testdata/baselines/reference/compiler/varianceCycleEntryOrder.errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/varianceCycleEntryOrder.symbols create mode 100644 tsc/testdata/baselines/reference/compiler/varianceCycleEntryOrder.types create mode 100644 tsc/testdata/baselines/reference/compiler/varianceCycleRedoKeepsDiscardLog.symbols create mode 100644 tsc/testdata/baselines/reference/compiler/varianceCycleRedoKeepsDiscardLog.types create mode 100644 tsc/testdata/baselines/reference/compiler/varianceCycleStructuralFallback.errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/varianceCycleStructuralFallback.symbols create mode 100644 tsc/testdata/baselines/reference/compiler/varianceCycleStructuralFallback.types create mode 100644 tsc/testdata/baselines/reference/compiler/varianceDeclarationOrder.errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/varianceDeclarationOrder.symbols create mode 100644 tsc/testdata/baselines/reference/compiler/varianceDeclarationOrder.types create mode 100644 tsc/testdata/baselines/reference/compiler/varianceMeasuredWithinCircularity.errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/varianceMeasuredWithinCircularity.symbols create mode 100644 tsc/testdata/baselines/reference/compiler/varianceMeasuredWithinCircularity.types create mode 100644 tsc/testdata/baselines/reference/compiler/varianceSupersededMeasurementKeepsOtherComparisons(checkorder=default).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/varianceSupersededMeasurementKeepsOtherComparisons(checkorder=default).types create mode 100644 tsc/testdata/baselines/reference/compiler/varianceSupersededMeasurementKeepsOtherComparisons(checkorder=typesfirst).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/varianceSupersededMeasurementKeepsOtherComparisons(checkorder=typesfirst).types create mode 100644 tsc/testdata/baselines/reference/conformance/dependentDestructuredVariablesReferenceInDeclaration1(checkorder=default).errors.txt create mode 100644 tsc/testdata/baselines/reference/conformance/dependentDestructuredVariablesReferenceInDeclaration1(checkorder=default).symbols create mode 100644 tsc/testdata/baselines/reference/conformance/dependentDestructuredVariablesReferenceInDeclaration1(checkorder=default).types create mode 100644 tsc/testdata/baselines/reference/conformance/dependentDestructuredVariablesReferenceInDeclaration1(checkorder=typesfirst).errors.txt create mode 100644 tsc/testdata/baselines/reference/conformance/dependentDestructuredVariablesReferenceInDeclaration1(checkorder=typesfirst).symbols create mode 100644 tsc/testdata/baselines/reference/conformance/dependentDestructuredVariablesReferenceInDeclaration1(checkorder=typesfirst).types create mode 100644 tsc/testdata/baselines/reference/conformance/destructuringWithLiteralInitializers(checkorder=default).js create mode 100644 tsc/testdata/baselines/reference/conformance/destructuringWithLiteralInitializers(checkorder=default).symbols create mode 100644 tsc/testdata/baselines/reference/conformance/destructuringWithLiteralInitializers(checkorder=default).types create mode 100644 tsc/testdata/baselines/reference/conformance/destructuringWithLiteralInitializers(checkorder=typesfirst).errors.txt create mode 100644 tsc/testdata/baselines/reference/conformance/destructuringWithLiteralInitializers(checkorder=typesfirst).js create mode 100644 tsc/testdata/baselines/reference/conformance/destructuringWithLiteralInitializers(checkorder=typesfirst).symbols create mode 100644 tsc/testdata/baselines/reference/conformance/destructuringWithLiteralInitializers(checkorder=typesfirst).types create mode 100644 tsc/testdata/baselines/reference/conformance/importTag13(checkorder=default).errors.txt create mode 100644 tsc/testdata/baselines/reference/conformance/importTag13(checkorder=default).symbols create mode 100644 tsc/testdata/baselines/reference/conformance/importTag13(checkorder=default).types create mode 100644 tsc/testdata/baselines/reference/conformance/importTag13(checkorder=typesfirst).errors.txt create mode 100644 tsc/testdata/baselines/reference/conformance/importTag13(checkorder=typesfirst).symbols create mode 100644 tsc/testdata/baselines/reference/conformance/importTag13(checkorder=typesfirst).types create mode 100644 tsc/testdata/baselines/reference/conformance/privateNameNestedClassFieldShadowing(checkorder=default).errors.txt create mode 100644 tsc/testdata/baselines/reference/conformance/privateNameNestedClassFieldShadowing(checkorder=default).js create mode 100644 tsc/testdata/baselines/reference/conformance/privateNameNestedClassFieldShadowing(checkorder=default).symbols create mode 100644 tsc/testdata/baselines/reference/conformance/privateNameNestedClassFieldShadowing(checkorder=default).types create mode 100644 tsc/testdata/baselines/reference/conformance/privateNameNestedClassFieldShadowing(checkorder=typesfirst).errors.txt create mode 100644 tsc/testdata/baselines/reference/conformance/privateNameNestedClassFieldShadowing(checkorder=typesfirst).js create mode 100644 tsc/testdata/baselines/reference/conformance/privateNameNestedClassFieldShadowing(checkorder=typesfirst).symbols create mode 100644 tsc/testdata/baselines/reference/conformance/privateNameNestedClassFieldShadowing(checkorder=typesfirst).types create mode 100644 tsc/testdata/tests/cases/compiler/baseConstraintDepthCheckOrder.ts create mode 100644 tsc/testdata/tests/cases/compiler/boundedRecursiveTypeInferredThroughClosure.ts create mode 100644 tsc/testdata/tests/cases/compiler/checkOrderAwaitedCycle.ts create mode 100644 tsc/testdata/tests/cases/compiler/checkOrderCircularConstraint.ts create mode 100644 tsc/testdata/tests/cases/compiler/checkOrderCircularDefaults.ts create mode 100644 tsc/testdata/tests/cases/compiler/checkOrderEmitBeforeCheck.ts create mode 100644 tsc/testdata/tests/cases/compiler/checkOrderEnumComputedMember.ts create mode 100644 tsc/testdata/tests/cases/compiler/checkOrderLateBoundMembers.ts create mode 100644 tsc/testdata/tests/cases/compiler/checkOrderModuleExportsAlias.ts create mode 100644 tsc/testdata/tests/cases/compiler/checkOrderParameterInTypeQuery.ts create mode 100644 tsc/testdata/tests/cases/compiler/checkOrderRecursiveIndexedAccess.ts create mode 100644 tsc/testdata/tests/cases/compiler/checkOrderSpreadCycle.ts create mode 100644 tsc/testdata/tests/cases/compiler/checkOrderStableInstantiationErrors.ts create mode 100644 tsc/testdata/tests/cases/compiler/circularIndexedPropertyInstantiation.ts create mode 100644 tsc/testdata/tests/cases/compiler/circularInitializerInference.ts create mode 100644 tsc/testdata/tests/cases/compiler/circularReturnTypeSubtypeReductionOrder.ts create mode 100644 tsc/testdata/tests/cases/compiler/circularReturnTypeThroughCallArgumentRelation.ts create mode 100644 tsc/testdata/tests/cases/compiler/circularReturnTypeThroughCallbackArgument.ts create mode 100644 tsc/testdata/tests/cases/compiler/circularReturnTypeThroughUncontextualCallbackArgument.ts create mode 100644 tsc/testdata/tests/cases/compiler/circularScopeThunkReverseMapped.ts create mode 100644 tsc/testdata/tests/cases/compiler/classCircularityDiagnostics.ts create mode 100644 tsc/testdata/tests/cases/compiler/clonedTypeParameterUnionOrder.ts create mode 100644 tsc/testdata/tests/cases/compiler/constAssertionBindingPatternQueryOrder.ts create mode 100644 tsc/testdata/tests/cases/compiler/contextualCheckReentryFromOuterTypeParameters.ts create mode 100644 tsc/testdata/tests/cases/compiler/contextualParameterDefaultReferenceCheckOrder.ts create mode 100644 tsc/testdata/tests/cases/compiler/contextualParameterInCircularVariableInitializer.ts create mode 100644 tsc/testdata/tests/cases/compiler/contextualParameterInReturnTypeCycleOfGenericCall.ts create mode 100644 tsc/testdata/tests/cases/compiler/cycleYieldThroughVarianceCheckOrder.ts create mode 100644 tsc/testdata/tests/cases/compiler/deferredTypeReferenceCycleRollback.ts create mode 100644 tsc/testdata/tests/cases/compiler/distributiveConstraintOfCircularCheckType.ts create mode 100644 tsc/testdata/tests/cases/compiler/enumMemberTypeCacheConsistency.ts create mode 100644 tsc/testdata/tests/cases/compiler/evolvingArrayReadInLoopCondition.ts create mode 100644 tsc/testdata/tests/cases/compiler/exportAssignmentNestedVisibilityQueryOrder.ts create mode 100644 tsc/testdata/tests/cases/compiler/flowLoopDepthCheckOrder.ts create mode 100644 tsc/testdata/tests/cases/compiler/flowLoopTooDeepCheckOrder.ts create mode 100644 tsc/testdata/tests/cases/compiler/genericCallReturnedFunctionParameterDefault.ts create mode 100644 tsc/testdata/tests/cases/compiler/getterCircularityDiagnostics.ts create mode 100644 tsc/testdata/tests/cases/compiler/getterReturnTypeQueryOrder.ts create mode 100644 tsc/testdata/tests/cases/compiler/importAttributeValueCheckOrder.ts create mode 100644 tsc/testdata/tests/cases/compiler/indexSignatureWithIndexedAccessOfDerivedInterface.ts create mode 100644 tsc/testdata/tests/cases/compiler/indexedAccessAccessFlagsUnionOrder.ts create mode 100644 tsc/testdata/tests/cases/compiler/inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts create mode 100644 tsc/testdata/tests/cases/compiler/inferenceDeeplyNestedCheckOrder.ts create mode 100644 tsc/testdata/tests/cases/compiler/inferenceFromUnionOfTypeParameterAndPromiseLike.ts create mode 100644 tsc/testdata/tests/cases/compiler/inferenceThroughSortOfFlattenedIterable.ts create mode 100644 tsc/testdata/tests/cases/compiler/instantiationCouldContainTypeVariablesAfterCycle.ts create mode 100644 tsc/testdata/tests/cases/compiler/instantiationCountSharedCheckOrder.ts create mode 100644 tsc/testdata/tests/cases/compiler/instantiationDepthSharedCheckOrder.ts create mode 100644 tsc/testdata/tests/cases/compiler/instantiationExpressionConstraintCycleCheckOrder.ts create mode 100644 tsc/testdata/tests/cases/compiler/instantiationExpressionConstraintInStaticClassExpression.ts create mode 100644 tsc/testdata/tests/cases/compiler/instantiationLimitsCheckOrder.ts create mode 100644 tsc/testdata/tests/cases/compiler/instantiationStackLimitCheckOrder.ts create mode 100644 tsc/testdata/tests/cases/compiler/intersectionBaseConstructorCycleCheckOrder.ts create mode 100644 tsc/testdata/tests/cases/compiler/jsdocLinkImportElisionQueryOrder.ts create mode 100644 tsc/testdata/tests/cases/compiler/jsdocTypeTagOnContextuallyTypedFunction.ts create mode 100644 tsc/testdata/tests/cases/compiler/keyofIndexSignatureCycleCheckOrder.ts create mode 100644 tsc/testdata/tests/cases/compiler/narrowedNeverAfterLoopWithAndCondition.ts create mode 100644 tsc/testdata/tests/cases/compiler/nestedCallContextualTypeCheckOrder.ts create mode 100644 tsc/testdata/tests/cases/compiler/nestedCallContextualTypeCheckOrderJsx.tsx create mode 100644 tsc/testdata/tests/cases/compiler/nestedGenericArrayAssignabilityAfterErrors.ts create mode 100644 tsc/testdata/tests/cases/compiler/objectLiteralRegularAndWidenedCopyOrder.ts create mode 100644 tsc/testdata/tests/cases/compiler/objectRestUnionInstantiationOrder.ts create mode 100644 tsc/testdata/tests/cases/compiler/parameterBindingDefaultReferencesSiblingThroughCall.ts create mode 100644 tsc/testdata/tests/cases/compiler/qualifiedNameCycleErrorCheckOrder.ts create mode 100644 tsc/testdata/tests/cases/compiler/recursiveGenericInterfaceDeclarationOrder.ts create mode 100755 tsc/testdata/tests/cases/compiler/recursiveVarianceFixedPoint.ts create mode 100644 tsc/testdata/tests/cases/compiler/relationComplexitySharedCheckOrder.ts create mode 100644 tsc/testdata/tests/cases/compiler/relationCycleNonMonotoneCheckOrder.ts create mode 100644 tsc/testdata/tests/cases/compiler/relationDeeplyNestedCheckOrder.ts create mode 100644 tsc/testdata/tests/cases/compiler/relationDepthSharedCheckOrder.ts create mode 100644 tsc/testdata/tests/cases/compiler/relationMaybeCheckOrder.ts create mode 100644 tsc/testdata/tests/cases/compiler/relationNestingSharedCheckOrder.ts create mode 100644 tsc/testdata/tests/cases/compiler/relationTruncatedCacheCheckOrder.ts create mode 100644 tsc/testdata/tests/cases/compiler/restrictiveInstantiationOfRestrictiveConditional.ts create mode 100644 tsc/testdata/tests/cases/compiler/signatureHelpInferenceQueryOrder.ts create mode 100644 tsc/testdata/tests/cases/compiler/substitutionInDeferredConditionalOfConditional.ts create mode 100644 tsc/testdata/tests/cases/compiler/typeParameterDefaultInCallInsideGenericCallback.ts create mode 100644 tsc/testdata/tests/cases/compiler/typeReferenceRecursionIdentityCheckOrder.ts create mode 100644 tsc/testdata/tests/cases/compiler/unusedTypeParameterQueryOrder.ts create mode 100644 tsc/testdata/tests/cases/compiler/varianceCircularConsistency.ts create mode 100644 tsc/testdata/tests/cases/compiler/varianceCircularityEnteredByInference.ts create mode 100644 tsc/testdata/tests/cases/compiler/varianceCircularityHidesInvariance.ts create mode 100644 tsc/testdata/tests/cases/compiler/varianceCycleCachedResults.ts create mode 100644 tsc/testdata/tests/cases/compiler/varianceCycleCapnwebRpcStub.ts create mode 100644 tsc/testdata/tests/cases/compiler/varianceCycleDiscardedDiagnostics.ts create mode 100644 tsc/testdata/tests/cases/compiler/varianceCycleEnteredAfterCanonicalEntry.ts create mode 100644 tsc/testdata/tests/cases/compiler/varianceCycleEntryOrder.ts create mode 100644 tsc/testdata/tests/cases/compiler/varianceCycleRedoKeepsDiscardLog.ts create mode 100644 tsc/testdata/tests/cases/compiler/varianceCycleStructuralFallback.ts create mode 100644 tsc/testdata/tests/cases/compiler/varianceDeclarationOrder.ts create mode 100644 tsc/testdata/tests/cases/compiler/varianceMeasuredWithinCircularity.ts create mode 100644 tsc/testdata/tests/cases/compiler/varianceSupersededMeasurementKeepsOtherComparisons.ts diff --git a/tsc/internal/testrunner/compiler_runner.go b/tsc/internal/testrunner/compiler_runner.go index c7081ce8b6b44..8dbdc2623cc36 100644 --- a/tsc/internal/testrunner/compiler_runner.go +++ b/tsc/internal/testrunner/compiler_runner.go @@ -167,8 +167,21 @@ func (r *CompilerBaselineRunner) runTest(t *testing.T, filename string) { } } +// When a program checks its files on several checkers, these tests can see different results depending on which +// checker answers a query first. +var concurrentSkippedTests = map[string]string{ + "checkOrderCircularDefaults.ts": "Circular default results depend on which checker resolves the cycle first.", + "checkOrderSpreadCycle.ts": "Spread cycle results depend on which checker resolves the cycle first.", + "checkOrderStableInstantiationErrors.ts": "Instantiation limit errors depend on which checker instantiates first.", +} + func (r *CompilerBaselineRunner) runSingleConfigTest(t *testing.T, testName string, test *compilerFileBasedTest, config *harnessutil.NamedTestConfiguration) { t.Parallel() + if !testutil.TestProgramIsSingleThreaded() { + if msg, ok := concurrentSkippedTests[tspath.GetBaseFileName(test.filename)]; ok { + t.Skipf("Skipping in concurrent mode: %s", msg) + } + } defer testutil.RecoverAndFail(t, "Panic on compiler test "+test.filename) payload := makeUnitsFromTest(test.content, test.filename) diff --git a/tsc/testdata/baselines/reference/compiler/baseConstraintDepthCheckOrder(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/baseConstraintDepthCheckOrder(checkorder=default).errors.txt new file mode 100644 index 0000000000000..a247afb883ac5 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/baseConstraintDepthCheckOrder(checkorder=default).errors.txt @@ -0,0 +1,19 @@ +baseConstraintDepthCheckOrder.ts(7,7): error TS2339: Property 'length' does not exist on type 'T0'. +baseConstraintDepthCheckOrder.ts(8,7): error TS2339: Property 'length' does not exist on type 'T20'. + + +==== baseConstraintDepthCheckOrder.ts (2 errors) ==== + // The base constraint of 'T0' is 60 type parameters deep and gives up after + // 50, while that of 'T20' is found 40 deep. Neither may depend on which was + // computed first: computing 'T0' first must not leave 'T20' without its + // constraint, and computing 'T20' first must not let 'T0' reuse it. + + function f(x: T0, y: T20) { + x.length; + ~~~~~~ +!!! error TS2339: Property 'length' does not exist on type 'T0'. + y.length; + ~~~~~~ +!!! error TS2339: Property 'length' does not exist on type 'T20'. + } + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/baseConstraintDepthCheckOrder(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/baseConstraintDepthCheckOrder(checkorder=default).symbols new file mode 100644 index 0000000000000..5cbd14622b89f --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/baseConstraintDepthCheckOrder(checkorder=default).symbols @@ -0,0 +1,141 @@ +//// [tests/cases/compiler/baseConstraintDepthCheckOrder.ts] //// + +=== baseConstraintDepthCheckOrder.ts === +// The base constraint of 'T0' is 60 type parameters deep and gives up after +// 50, while that of 'T20' is found 40 deep. Neither may depend on which was +// computed first: computing 'T0' first must not leave 'T20' without its +// constraint, and computing 'T20' first must not let 'T0' reuse it. + +function f(x: T0, y: T20) { +>f : Symbol(f, Decl(baseConstraintDepthCheckOrder.ts, 0, 0)) +>T0 : Symbol(T0, Decl(baseConstraintDepthCheckOrder.ts, 5, 11)) +>T1 : Symbol(T1, Decl(baseConstraintDepthCheckOrder.ts, 5, 25)) +>T1 : Symbol(T1, Decl(baseConstraintDepthCheckOrder.ts, 5, 25)) +>T2 : Symbol(T2, Decl(baseConstraintDepthCheckOrder.ts, 5, 40)) +>T2 : Symbol(T2, Decl(baseConstraintDepthCheckOrder.ts, 5, 40)) +>T3 : Symbol(T3, Decl(baseConstraintDepthCheckOrder.ts, 5, 55)) +>T3 : Symbol(T3, Decl(baseConstraintDepthCheckOrder.ts, 5, 55)) +>T4 : Symbol(T4, Decl(baseConstraintDepthCheckOrder.ts, 5, 70)) +>T4 : Symbol(T4, Decl(baseConstraintDepthCheckOrder.ts, 5, 70)) +>T5 : Symbol(T5, Decl(baseConstraintDepthCheckOrder.ts, 5, 85)) +>T5 : Symbol(T5, Decl(baseConstraintDepthCheckOrder.ts, 5, 85)) +>T6 : Symbol(T6, Decl(baseConstraintDepthCheckOrder.ts, 5, 100)) +>T6 : Symbol(T6, Decl(baseConstraintDepthCheckOrder.ts, 5, 100)) +>T7 : Symbol(T7, Decl(baseConstraintDepthCheckOrder.ts, 5, 115)) +>T7 : Symbol(T7, Decl(baseConstraintDepthCheckOrder.ts, 5, 115)) +>T8 : Symbol(T8, Decl(baseConstraintDepthCheckOrder.ts, 5, 130)) +>T8 : Symbol(T8, Decl(baseConstraintDepthCheckOrder.ts, 5, 130)) +>T9 : Symbol(T9, Decl(baseConstraintDepthCheckOrder.ts, 5, 145)) +>T9 : Symbol(T9, Decl(baseConstraintDepthCheckOrder.ts, 5, 145)) +>T10 : Symbol(T10, Decl(baseConstraintDepthCheckOrder.ts, 5, 161)) +>T10 : Symbol(T10, Decl(baseConstraintDepthCheckOrder.ts, 5, 161)) +>T11 : Symbol(T11, Decl(baseConstraintDepthCheckOrder.ts, 5, 178)) +>T11 : Symbol(T11, Decl(baseConstraintDepthCheckOrder.ts, 5, 178)) +>T12 : Symbol(T12, Decl(baseConstraintDepthCheckOrder.ts, 5, 195)) +>T12 : Symbol(T12, Decl(baseConstraintDepthCheckOrder.ts, 5, 195)) +>T13 : Symbol(T13, Decl(baseConstraintDepthCheckOrder.ts, 5, 212)) +>T13 : Symbol(T13, Decl(baseConstraintDepthCheckOrder.ts, 5, 212)) +>T14 : Symbol(T14, Decl(baseConstraintDepthCheckOrder.ts, 5, 229)) +>T14 : Symbol(T14, Decl(baseConstraintDepthCheckOrder.ts, 5, 229)) +>T15 : Symbol(T15, Decl(baseConstraintDepthCheckOrder.ts, 5, 246)) +>T15 : Symbol(T15, Decl(baseConstraintDepthCheckOrder.ts, 5, 246)) +>T16 : Symbol(T16, Decl(baseConstraintDepthCheckOrder.ts, 5, 263)) +>T16 : Symbol(T16, Decl(baseConstraintDepthCheckOrder.ts, 5, 263)) +>T17 : Symbol(T17, Decl(baseConstraintDepthCheckOrder.ts, 5, 280)) +>T17 : Symbol(T17, Decl(baseConstraintDepthCheckOrder.ts, 5, 280)) +>T18 : Symbol(T18, Decl(baseConstraintDepthCheckOrder.ts, 5, 297)) +>T18 : Symbol(T18, Decl(baseConstraintDepthCheckOrder.ts, 5, 297)) +>T19 : Symbol(T19, Decl(baseConstraintDepthCheckOrder.ts, 5, 314)) +>T19 : Symbol(T19, Decl(baseConstraintDepthCheckOrder.ts, 5, 314)) +>T20 : Symbol(T20, Decl(baseConstraintDepthCheckOrder.ts, 5, 331)) +>T20 : Symbol(T20, Decl(baseConstraintDepthCheckOrder.ts, 5, 331)) +>T21 : Symbol(T21, Decl(baseConstraintDepthCheckOrder.ts, 5, 348)) +>T21 : Symbol(T21, Decl(baseConstraintDepthCheckOrder.ts, 5, 348)) +>T22 : Symbol(T22, Decl(baseConstraintDepthCheckOrder.ts, 5, 365)) +>T22 : Symbol(T22, Decl(baseConstraintDepthCheckOrder.ts, 5, 365)) +>T23 : Symbol(T23, Decl(baseConstraintDepthCheckOrder.ts, 5, 382)) +>T23 : Symbol(T23, Decl(baseConstraintDepthCheckOrder.ts, 5, 382)) +>T24 : Symbol(T24, Decl(baseConstraintDepthCheckOrder.ts, 5, 399)) +>T24 : Symbol(T24, Decl(baseConstraintDepthCheckOrder.ts, 5, 399)) +>T25 : Symbol(T25, Decl(baseConstraintDepthCheckOrder.ts, 5, 416)) +>T25 : Symbol(T25, Decl(baseConstraintDepthCheckOrder.ts, 5, 416)) +>T26 : Symbol(T26, Decl(baseConstraintDepthCheckOrder.ts, 5, 433)) +>T26 : Symbol(T26, Decl(baseConstraintDepthCheckOrder.ts, 5, 433)) +>T27 : Symbol(T27, Decl(baseConstraintDepthCheckOrder.ts, 5, 450)) +>T27 : Symbol(T27, Decl(baseConstraintDepthCheckOrder.ts, 5, 450)) +>T28 : Symbol(T28, Decl(baseConstraintDepthCheckOrder.ts, 5, 467)) +>T28 : Symbol(T28, Decl(baseConstraintDepthCheckOrder.ts, 5, 467)) +>T29 : Symbol(T29, Decl(baseConstraintDepthCheckOrder.ts, 5, 484)) +>T29 : Symbol(T29, Decl(baseConstraintDepthCheckOrder.ts, 5, 484)) +>T30 : Symbol(T30, Decl(baseConstraintDepthCheckOrder.ts, 5, 501)) +>T30 : Symbol(T30, Decl(baseConstraintDepthCheckOrder.ts, 5, 501)) +>T31 : Symbol(T31, Decl(baseConstraintDepthCheckOrder.ts, 5, 518)) +>T31 : Symbol(T31, Decl(baseConstraintDepthCheckOrder.ts, 5, 518)) +>T32 : Symbol(T32, Decl(baseConstraintDepthCheckOrder.ts, 5, 535)) +>T32 : Symbol(T32, Decl(baseConstraintDepthCheckOrder.ts, 5, 535)) +>T33 : Symbol(T33, Decl(baseConstraintDepthCheckOrder.ts, 5, 552)) +>T33 : Symbol(T33, Decl(baseConstraintDepthCheckOrder.ts, 5, 552)) +>T34 : Symbol(T34, Decl(baseConstraintDepthCheckOrder.ts, 5, 569)) +>T34 : Symbol(T34, Decl(baseConstraintDepthCheckOrder.ts, 5, 569)) +>T35 : Symbol(T35, Decl(baseConstraintDepthCheckOrder.ts, 5, 586)) +>T35 : Symbol(T35, Decl(baseConstraintDepthCheckOrder.ts, 5, 586)) +>T36 : Symbol(T36, Decl(baseConstraintDepthCheckOrder.ts, 5, 603)) +>T36 : Symbol(T36, Decl(baseConstraintDepthCheckOrder.ts, 5, 603)) +>T37 : Symbol(T37, Decl(baseConstraintDepthCheckOrder.ts, 5, 620)) +>T37 : Symbol(T37, Decl(baseConstraintDepthCheckOrder.ts, 5, 620)) +>T38 : Symbol(T38, Decl(baseConstraintDepthCheckOrder.ts, 5, 637)) +>T38 : Symbol(T38, Decl(baseConstraintDepthCheckOrder.ts, 5, 637)) +>T39 : Symbol(T39, Decl(baseConstraintDepthCheckOrder.ts, 5, 654)) +>T39 : Symbol(T39, Decl(baseConstraintDepthCheckOrder.ts, 5, 654)) +>T40 : Symbol(T40, Decl(baseConstraintDepthCheckOrder.ts, 5, 671)) +>T40 : Symbol(T40, Decl(baseConstraintDepthCheckOrder.ts, 5, 671)) +>T41 : Symbol(T41, Decl(baseConstraintDepthCheckOrder.ts, 5, 688)) +>T41 : Symbol(T41, Decl(baseConstraintDepthCheckOrder.ts, 5, 688)) +>T42 : Symbol(T42, Decl(baseConstraintDepthCheckOrder.ts, 5, 705)) +>T42 : Symbol(T42, Decl(baseConstraintDepthCheckOrder.ts, 5, 705)) +>T43 : Symbol(T43, Decl(baseConstraintDepthCheckOrder.ts, 5, 722)) +>T43 : Symbol(T43, Decl(baseConstraintDepthCheckOrder.ts, 5, 722)) +>T44 : Symbol(T44, Decl(baseConstraintDepthCheckOrder.ts, 5, 739)) +>T44 : Symbol(T44, Decl(baseConstraintDepthCheckOrder.ts, 5, 739)) +>T45 : Symbol(T45, Decl(baseConstraintDepthCheckOrder.ts, 5, 756)) +>T45 : Symbol(T45, Decl(baseConstraintDepthCheckOrder.ts, 5, 756)) +>T46 : Symbol(T46, Decl(baseConstraintDepthCheckOrder.ts, 5, 773)) +>T46 : Symbol(T46, Decl(baseConstraintDepthCheckOrder.ts, 5, 773)) +>T47 : Symbol(T47, Decl(baseConstraintDepthCheckOrder.ts, 5, 790)) +>T47 : Symbol(T47, Decl(baseConstraintDepthCheckOrder.ts, 5, 790)) +>T48 : Symbol(T48, Decl(baseConstraintDepthCheckOrder.ts, 5, 807)) +>T48 : Symbol(T48, Decl(baseConstraintDepthCheckOrder.ts, 5, 807)) +>T49 : Symbol(T49, Decl(baseConstraintDepthCheckOrder.ts, 5, 824)) +>T49 : Symbol(T49, Decl(baseConstraintDepthCheckOrder.ts, 5, 824)) +>T50 : Symbol(T50, Decl(baseConstraintDepthCheckOrder.ts, 5, 841)) +>T50 : Symbol(T50, Decl(baseConstraintDepthCheckOrder.ts, 5, 841)) +>T51 : Symbol(T51, Decl(baseConstraintDepthCheckOrder.ts, 5, 858)) +>T51 : Symbol(T51, Decl(baseConstraintDepthCheckOrder.ts, 5, 858)) +>T52 : Symbol(T52, Decl(baseConstraintDepthCheckOrder.ts, 5, 875)) +>T52 : Symbol(T52, Decl(baseConstraintDepthCheckOrder.ts, 5, 875)) +>T53 : Symbol(T53, Decl(baseConstraintDepthCheckOrder.ts, 5, 892)) +>T53 : Symbol(T53, Decl(baseConstraintDepthCheckOrder.ts, 5, 892)) +>T54 : Symbol(T54, Decl(baseConstraintDepthCheckOrder.ts, 5, 909)) +>T54 : Symbol(T54, Decl(baseConstraintDepthCheckOrder.ts, 5, 909)) +>T55 : Symbol(T55, Decl(baseConstraintDepthCheckOrder.ts, 5, 926)) +>T55 : Symbol(T55, Decl(baseConstraintDepthCheckOrder.ts, 5, 926)) +>T56 : Symbol(T56, Decl(baseConstraintDepthCheckOrder.ts, 5, 943)) +>T56 : Symbol(T56, Decl(baseConstraintDepthCheckOrder.ts, 5, 943)) +>T57 : Symbol(T57, Decl(baseConstraintDepthCheckOrder.ts, 5, 960)) +>T57 : Symbol(T57, Decl(baseConstraintDepthCheckOrder.ts, 5, 960)) +>T58 : Symbol(T58, Decl(baseConstraintDepthCheckOrder.ts, 5, 977)) +>T58 : Symbol(T58, Decl(baseConstraintDepthCheckOrder.ts, 5, 977)) +>T59 : Symbol(T59, Decl(baseConstraintDepthCheckOrder.ts, 5, 994)) +>T59 : Symbol(T59, Decl(baseConstraintDepthCheckOrder.ts, 5, 994)) +>x : Symbol(x, Decl(baseConstraintDepthCheckOrder.ts, 5, 1015)) +>T0 : Symbol(T0, Decl(baseConstraintDepthCheckOrder.ts, 5, 11)) +>y : Symbol(y, Decl(baseConstraintDepthCheckOrder.ts, 5, 1021)) +>T20 : Symbol(T20, Decl(baseConstraintDepthCheckOrder.ts, 5, 331)) + + x.length; +>x : Symbol(x, Decl(baseConstraintDepthCheckOrder.ts, 5, 1015)) + + y.length; +>y : Symbol(y, Decl(baseConstraintDepthCheckOrder.ts, 5, 1021)) +} + diff --git a/tsc/testdata/baselines/reference/compiler/baseConstraintDepthCheckOrder(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/baseConstraintDepthCheckOrder(checkorder=default).types new file mode 100644 index 0000000000000..fbc7735f18c4c --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/baseConstraintDepthCheckOrder(checkorder=default).types @@ -0,0 +1,24 @@ +//// [tests/cases/compiler/baseConstraintDepthCheckOrder.ts] //// + +=== baseConstraintDepthCheckOrder.ts === +// The base constraint of 'T0' is 60 type parameters deep and gives up after +// 50, while that of 'T20' is found 40 deep. Neither may depend on which was +// computed first: computing 'T0' first must not leave 'T20' without its +// constraint, and computing 'T20' first must not let 'T0' reuse it. + +function f(x: T0, y: T20) { +>f : (x: T0, y: T20) => void +>x : T0 +>y : T20 + + x.length; +>x.length : any +>x : T0 +>length : any + + y.length; +>y.length : any +>y : T20 +>length : any +} + diff --git a/tsc/testdata/baselines/reference/compiler/baseConstraintDepthCheckOrder(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/baseConstraintDepthCheckOrder(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..9b381179dc902 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/baseConstraintDepthCheckOrder(checkorder=typesfirst).symbols @@ -0,0 +1,145 @@ +//// [tests/cases/compiler/baseConstraintDepthCheckOrder.ts] //// + +=== baseConstraintDepthCheckOrder.ts === +// The base constraint of 'T0' is 60 type parameters deep and gives up after +// 50, while that of 'T20' is found 40 deep. Neither may depend on which was +// computed first: computing 'T0' first must not leave 'T20' without its +// constraint, and computing 'T20' first must not let 'T0' reuse it. + +function f(x: T0, y: T20) { +>f : Symbol(f, Decl(baseConstraintDepthCheckOrder.ts, 0, 0)) +>T0 : Symbol(T0, Decl(baseConstraintDepthCheckOrder.ts, 5, 11)) +>T1 : Symbol(T1, Decl(baseConstraintDepthCheckOrder.ts, 5, 25)) +>T1 : Symbol(T1, Decl(baseConstraintDepthCheckOrder.ts, 5, 25)) +>T2 : Symbol(T2, Decl(baseConstraintDepthCheckOrder.ts, 5, 40)) +>T2 : Symbol(T2, Decl(baseConstraintDepthCheckOrder.ts, 5, 40)) +>T3 : Symbol(T3, Decl(baseConstraintDepthCheckOrder.ts, 5, 55)) +>T3 : Symbol(T3, Decl(baseConstraintDepthCheckOrder.ts, 5, 55)) +>T4 : Symbol(T4, Decl(baseConstraintDepthCheckOrder.ts, 5, 70)) +>T4 : Symbol(T4, Decl(baseConstraintDepthCheckOrder.ts, 5, 70)) +>T5 : Symbol(T5, Decl(baseConstraintDepthCheckOrder.ts, 5, 85)) +>T5 : Symbol(T5, Decl(baseConstraintDepthCheckOrder.ts, 5, 85)) +>T6 : Symbol(T6, Decl(baseConstraintDepthCheckOrder.ts, 5, 100)) +>T6 : Symbol(T6, Decl(baseConstraintDepthCheckOrder.ts, 5, 100)) +>T7 : Symbol(T7, Decl(baseConstraintDepthCheckOrder.ts, 5, 115)) +>T7 : Symbol(T7, Decl(baseConstraintDepthCheckOrder.ts, 5, 115)) +>T8 : Symbol(T8, Decl(baseConstraintDepthCheckOrder.ts, 5, 130)) +>T8 : Symbol(T8, Decl(baseConstraintDepthCheckOrder.ts, 5, 130)) +>T9 : Symbol(T9, Decl(baseConstraintDepthCheckOrder.ts, 5, 145)) +>T9 : Symbol(T9, Decl(baseConstraintDepthCheckOrder.ts, 5, 145)) +>T10 : Symbol(T10, Decl(baseConstraintDepthCheckOrder.ts, 5, 161)) +>T10 : Symbol(T10, Decl(baseConstraintDepthCheckOrder.ts, 5, 161)) +>T11 : Symbol(T11, Decl(baseConstraintDepthCheckOrder.ts, 5, 178)) +>T11 : Symbol(T11, Decl(baseConstraintDepthCheckOrder.ts, 5, 178)) +>T12 : Symbol(T12, Decl(baseConstraintDepthCheckOrder.ts, 5, 195)) +>T12 : Symbol(T12, Decl(baseConstraintDepthCheckOrder.ts, 5, 195)) +>T13 : Symbol(T13, Decl(baseConstraintDepthCheckOrder.ts, 5, 212)) +>T13 : Symbol(T13, Decl(baseConstraintDepthCheckOrder.ts, 5, 212)) +>T14 : Symbol(T14, Decl(baseConstraintDepthCheckOrder.ts, 5, 229)) +>T14 : Symbol(T14, Decl(baseConstraintDepthCheckOrder.ts, 5, 229)) +>T15 : Symbol(T15, Decl(baseConstraintDepthCheckOrder.ts, 5, 246)) +>T15 : Symbol(T15, Decl(baseConstraintDepthCheckOrder.ts, 5, 246)) +>T16 : Symbol(T16, Decl(baseConstraintDepthCheckOrder.ts, 5, 263)) +>T16 : Symbol(T16, Decl(baseConstraintDepthCheckOrder.ts, 5, 263)) +>T17 : Symbol(T17, Decl(baseConstraintDepthCheckOrder.ts, 5, 280)) +>T17 : Symbol(T17, Decl(baseConstraintDepthCheckOrder.ts, 5, 280)) +>T18 : Symbol(T18, Decl(baseConstraintDepthCheckOrder.ts, 5, 297)) +>T18 : Symbol(T18, Decl(baseConstraintDepthCheckOrder.ts, 5, 297)) +>T19 : Symbol(T19, Decl(baseConstraintDepthCheckOrder.ts, 5, 314)) +>T19 : Symbol(T19, Decl(baseConstraintDepthCheckOrder.ts, 5, 314)) +>T20 : Symbol(T20, Decl(baseConstraintDepthCheckOrder.ts, 5, 331)) +>T20 : Symbol(T20, Decl(baseConstraintDepthCheckOrder.ts, 5, 331)) +>T21 : Symbol(T21, Decl(baseConstraintDepthCheckOrder.ts, 5, 348)) +>T21 : Symbol(T21, Decl(baseConstraintDepthCheckOrder.ts, 5, 348)) +>T22 : Symbol(T22, Decl(baseConstraintDepthCheckOrder.ts, 5, 365)) +>T22 : Symbol(T22, Decl(baseConstraintDepthCheckOrder.ts, 5, 365)) +>T23 : Symbol(T23, Decl(baseConstraintDepthCheckOrder.ts, 5, 382)) +>T23 : Symbol(T23, Decl(baseConstraintDepthCheckOrder.ts, 5, 382)) +>T24 : Symbol(T24, Decl(baseConstraintDepthCheckOrder.ts, 5, 399)) +>T24 : Symbol(T24, Decl(baseConstraintDepthCheckOrder.ts, 5, 399)) +>T25 : Symbol(T25, Decl(baseConstraintDepthCheckOrder.ts, 5, 416)) +>T25 : Symbol(T25, Decl(baseConstraintDepthCheckOrder.ts, 5, 416)) +>T26 : Symbol(T26, Decl(baseConstraintDepthCheckOrder.ts, 5, 433)) +>T26 : Symbol(T26, Decl(baseConstraintDepthCheckOrder.ts, 5, 433)) +>T27 : Symbol(T27, Decl(baseConstraintDepthCheckOrder.ts, 5, 450)) +>T27 : Symbol(T27, Decl(baseConstraintDepthCheckOrder.ts, 5, 450)) +>T28 : Symbol(T28, Decl(baseConstraintDepthCheckOrder.ts, 5, 467)) +>T28 : Symbol(T28, Decl(baseConstraintDepthCheckOrder.ts, 5, 467)) +>T29 : Symbol(T29, Decl(baseConstraintDepthCheckOrder.ts, 5, 484)) +>T29 : Symbol(T29, Decl(baseConstraintDepthCheckOrder.ts, 5, 484)) +>T30 : Symbol(T30, Decl(baseConstraintDepthCheckOrder.ts, 5, 501)) +>T30 : Symbol(T30, Decl(baseConstraintDepthCheckOrder.ts, 5, 501)) +>T31 : Symbol(T31, Decl(baseConstraintDepthCheckOrder.ts, 5, 518)) +>T31 : Symbol(T31, Decl(baseConstraintDepthCheckOrder.ts, 5, 518)) +>T32 : Symbol(T32, Decl(baseConstraintDepthCheckOrder.ts, 5, 535)) +>T32 : Symbol(T32, Decl(baseConstraintDepthCheckOrder.ts, 5, 535)) +>T33 : Symbol(T33, Decl(baseConstraintDepthCheckOrder.ts, 5, 552)) +>T33 : Symbol(T33, Decl(baseConstraintDepthCheckOrder.ts, 5, 552)) +>T34 : Symbol(T34, Decl(baseConstraintDepthCheckOrder.ts, 5, 569)) +>T34 : Symbol(T34, Decl(baseConstraintDepthCheckOrder.ts, 5, 569)) +>T35 : Symbol(T35, Decl(baseConstraintDepthCheckOrder.ts, 5, 586)) +>T35 : Symbol(T35, Decl(baseConstraintDepthCheckOrder.ts, 5, 586)) +>T36 : Symbol(T36, Decl(baseConstraintDepthCheckOrder.ts, 5, 603)) +>T36 : Symbol(T36, Decl(baseConstraintDepthCheckOrder.ts, 5, 603)) +>T37 : Symbol(T37, Decl(baseConstraintDepthCheckOrder.ts, 5, 620)) +>T37 : Symbol(T37, Decl(baseConstraintDepthCheckOrder.ts, 5, 620)) +>T38 : Symbol(T38, Decl(baseConstraintDepthCheckOrder.ts, 5, 637)) +>T38 : Symbol(T38, Decl(baseConstraintDepthCheckOrder.ts, 5, 637)) +>T39 : Symbol(T39, Decl(baseConstraintDepthCheckOrder.ts, 5, 654)) +>T39 : Symbol(T39, Decl(baseConstraintDepthCheckOrder.ts, 5, 654)) +>T40 : Symbol(T40, Decl(baseConstraintDepthCheckOrder.ts, 5, 671)) +>T40 : Symbol(T40, Decl(baseConstraintDepthCheckOrder.ts, 5, 671)) +>T41 : Symbol(T41, Decl(baseConstraintDepthCheckOrder.ts, 5, 688)) +>T41 : Symbol(T41, Decl(baseConstraintDepthCheckOrder.ts, 5, 688)) +>T42 : Symbol(T42, Decl(baseConstraintDepthCheckOrder.ts, 5, 705)) +>T42 : Symbol(T42, Decl(baseConstraintDepthCheckOrder.ts, 5, 705)) +>T43 : Symbol(T43, Decl(baseConstraintDepthCheckOrder.ts, 5, 722)) +>T43 : Symbol(T43, Decl(baseConstraintDepthCheckOrder.ts, 5, 722)) +>T44 : Symbol(T44, Decl(baseConstraintDepthCheckOrder.ts, 5, 739)) +>T44 : Symbol(T44, Decl(baseConstraintDepthCheckOrder.ts, 5, 739)) +>T45 : Symbol(T45, Decl(baseConstraintDepthCheckOrder.ts, 5, 756)) +>T45 : Symbol(T45, Decl(baseConstraintDepthCheckOrder.ts, 5, 756)) +>T46 : Symbol(T46, Decl(baseConstraintDepthCheckOrder.ts, 5, 773)) +>T46 : Symbol(T46, Decl(baseConstraintDepthCheckOrder.ts, 5, 773)) +>T47 : Symbol(T47, Decl(baseConstraintDepthCheckOrder.ts, 5, 790)) +>T47 : Symbol(T47, Decl(baseConstraintDepthCheckOrder.ts, 5, 790)) +>T48 : Symbol(T48, Decl(baseConstraintDepthCheckOrder.ts, 5, 807)) +>T48 : Symbol(T48, Decl(baseConstraintDepthCheckOrder.ts, 5, 807)) +>T49 : Symbol(T49, Decl(baseConstraintDepthCheckOrder.ts, 5, 824)) +>T49 : Symbol(T49, Decl(baseConstraintDepthCheckOrder.ts, 5, 824)) +>T50 : Symbol(T50, Decl(baseConstraintDepthCheckOrder.ts, 5, 841)) +>T50 : Symbol(T50, Decl(baseConstraintDepthCheckOrder.ts, 5, 841)) +>T51 : Symbol(T51, Decl(baseConstraintDepthCheckOrder.ts, 5, 858)) +>T51 : Symbol(T51, Decl(baseConstraintDepthCheckOrder.ts, 5, 858)) +>T52 : Symbol(T52, Decl(baseConstraintDepthCheckOrder.ts, 5, 875)) +>T52 : Symbol(T52, Decl(baseConstraintDepthCheckOrder.ts, 5, 875)) +>T53 : Symbol(T53, Decl(baseConstraintDepthCheckOrder.ts, 5, 892)) +>T53 : Symbol(T53, Decl(baseConstraintDepthCheckOrder.ts, 5, 892)) +>T54 : Symbol(T54, Decl(baseConstraintDepthCheckOrder.ts, 5, 909)) +>T54 : Symbol(T54, Decl(baseConstraintDepthCheckOrder.ts, 5, 909)) +>T55 : Symbol(T55, Decl(baseConstraintDepthCheckOrder.ts, 5, 926)) +>T55 : Symbol(T55, Decl(baseConstraintDepthCheckOrder.ts, 5, 926)) +>T56 : Symbol(T56, Decl(baseConstraintDepthCheckOrder.ts, 5, 943)) +>T56 : Symbol(T56, Decl(baseConstraintDepthCheckOrder.ts, 5, 943)) +>T57 : Symbol(T57, Decl(baseConstraintDepthCheckOrder.ts, 5, 960)) +>T57 : Symbol(T57, Decl(baseConstraintDepthCheckOrder.ts, 5, 960)) +>T58 : Symbol(T58, Decl(baseConstraintDepthCheckOrder.ts, 5, 977)) +>T58 : Symbol(T58, Decl(baseConstraintDepthCheckOrder.ts, 5, 977)) +>T59 : Symbol(T59, Decl(baseConstraintDepthCheckOrder.ts, 5, 994)) +>T59 : Symbol(T59, Decl(baseConstraintDepthCheckOrder.ts, 5, 994)) +>x : Symbol(x, Decl(baseConstraintDepthCheckOrder.ts, 5, 1015)) +>T0 : Symbol(T0, Decl(baseConstraintDepthCheckOrder.ts, 5, 11)) +>y : Symbol(y, Decl(baseConstraintDepthCheckOrder.ts, 5, 1021)) +>T20 : Symbol(T20, Decl(baseConstraintDepthCheckOrder.ts, 5, 331)) + + x.length; +>x.length : Symbol(String.length, Decl(lib.es5.d.ts, --, --)) +>x : Symbol(x, Decl(baseConstraintDepthCheckOrder.ts, 5, 1015)) +>length : Symbol(String.length, Decl(lib.es5.d.ts, --, --)) + + y.length; +>y.length : Symbol(String.length, Decl(lib.es5.d.ts, --, --)) +>y : Symbol(y, Decl(baseConstraintDepthCheckOrder.ts, 5, 1021)) +>length : Symbol(String.length, Decl(lib.es5.d.ts, --, --)) +} + diff --git a/tsc/testdata/baselines/reference/compiler/baseConstraintDepthCheckOrder(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/baseConstraintDepthCheckOrder(checkorder=typesfirst).types new file mode 100644 index 0000000000000..0fb24141449cc --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/baseConstraintDepthCheckOrder(checkorder=typesfirst).types @@ -0,0 +1,24 @@ +//// [tests/cases/compiler/baseConstraintDepthCheckOrder.ts] //// + +=== baseConstraintDepthCheckOrder.ts === +// The base constraint of 'T0' is 60 type parameters deep and gives up after +// 50, while that of 'T20' is found 40 deep. Neither may depend on which was +// computed first: computing 'T0' first must not leave 'T20' without its +// constraint, and computing 'T20' first must not let 'T0' reuse it. + +function f(x: T0, y: T20) { +>f : (x: T0, y: T20) => void +>x : T0 +>y : T20 + + x.length; +>x.length : number +>x : T0 +>length : number + + y.length; +>y.length : number +>y : T20 +>length : number +} + diff --git a/tsc/testdata/baselines/reference/compiler/bigintArbirtraryIdentifier(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/bigintArbirtraryIdentifier(checkorder=default).errors.txt new file mode 100644 index 0000000000000..5a959d4e04b62 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/bigintArbirtraryIdentifier(checkorder=default).errors.txt @@ -0,0 +1,69 @@ +badExport.ts(1,10): error TS2304: Cannot find name 'foo'. +badExport.ts(1,17): error TS1003: Identifier expected. +badExport.ts(1,20): error TS1128: Declaration or statement expected. +badExport2.ts(1,10): error TS1003: Identifier expected. +badExport2.ts(1,16): error TS2304: Cannot find name 'foo'. +badExport2.ts(1,20): error TS1128: Declaration or statement expected. +badImport.ts(1,10): error TS1003: Identifier expected. +badImport.ts(1,10): error TS1141: String literal expected. +badImport.ts(1,20): error TS1128: Declaration or statement expected. +badImport.ts(1,22): error TS1434: Unexpected keyword or identifier. +badImport.ts(1,22): error TS2304: Cannot find name 'from'. +badImport2.ts(1,17): error TS1003: Identifier expected. +badImport2.ts(1,17): error TS1141: String literal expected. +badImport2.ts(1,20): error TS1128: Declaration or statement expected. +badImport2.ts(1,22): error TS1434: Unexpected keyword or identifier. +badImport2.ts(1,22): error TS2304: Cannot find name 'from'. + + +==== foo.ts (0 errors) ==== + const foo = 0n; + export { foo as "0n" }; + +==== correctUse.ts (0 errors) ==== + import { "0n" as foo } from "./foo"; + export { foo as "0n" }; + +==== badImport.ts (5 errors) ==== + import { 0n as foo } from "./foo"; + ~~ +!!! error TS1003: Identifier expected. + ~~~~~~~~~ +!!! error TS1141: String literal expected. + ~ +!!! error TS1128: Declaration or statement expected. + ~~~~ +!!! error TS1434: Unexpected keyword or identifier. + ~~~~ +!!! error TS2304: Cannot find name 'from'. + +==== badImport2.ts (5 errors) ==== + import { foo as 0n } from "./foo"; + ~~ +!!! error TS1003: Identifier expected. + ~~ +!!! error TS1141: String literal expected. + ~ +!!! error TS1128: Declaration or statement expected. + ~~~~ +!!! error TS1434: Unexpected keyword or identifier. + ~~~~ +!!! error TS2304: Cannot find name 'from'. + +==== badExport.ts (3 errors) ==== + export { foo as 0n }; + ~~~ +!!! error TS2304: Cannot find name 'foo'. + ~~ +!!! error TS1003: Identifier expected. + ~ +!!! error TS1128: Declaration or statement expected. + +==== badExport2.ts (3 errors) ==== + export { 0n as foo }; + ~~ +!!! error TS1003: Identifier expected. + ~~~ +!!! error TS2304: Cannot find name 'foo'. + ~ +!!! error TS1128: Declaration or statement expected. \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/bigintArbirtraryIdentifier(checkorder=default).js b/tsc/testdata/baselines/reference/compiler/bigintArbirtraryIdentifier(checkorder=default).js new file mode 100644 index 0000000000000..139c1991c8c3f --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/bigintArbirtraryIdentifier(checkorder=default).js @@ -0,0 +1,44 @@ +//// [tests/cases/compiler/bigintArbirtraryIdentifier.ts] //// + +//// [foo.ts] +const foo = 0n; +export { foo as "0n" }; + +//// [correctUse.ts] +import { "0n" as foo } from "./foo"; +export { foo as "0n" }; + +//// [badImport.ts] +import { 0n as foo } from "./foo"; + +//// [badImport2.ts] +import { foo as 0n } from "./foo"; + +//// [badExport.ts] +export { foo as 0n }; + +//// [badExport2.ts] +export { 0n as foo }; + +//// [foo.js] +const foo = 0n; +export { foo as "0n" }; +//// [correctUse.js] +import { "0n" as foo } from "./foo"; +export { foo as "0n" }; +//// [badImport.js] +from; +"./foo"; +export {}; +//// [badImport2.js] +from; +"./foo"; +export {}; +//// [badExport.js] +export { foo as }; +0n; +; +//// [badExport2.js] +0n; +; +export {}; diff --git a/tsc/testdata/baselines/reference/compiler/bigintArbirtraryIdentifier(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/bigintArbirtraryIdentifier(checkorder=default).symbols new file mode 100644 index 0000000000000..8ef83a9eaec97 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/bigintArbirtraryIdentifier(checkorder=default).symbols @@ -0,0 +1,34 @@ +//// [tests/cases/compiler/bigintArbirtraryIdentifier.ts] //// + +=== foo.ts === +const foo = 0n; +>foo : Symbol(foo, Decl(foo.ts, 0, 5)) + +export { foo as "0n" }; +>foo : Symbol(foo, Decl(foo.ts, 0, 5)) +>"0n" : Symbol("0n", Decl(foo.ts, 1, 8)) + +=== correctUse.ts === +import { "0n" as foo } from "./foo"; +>foo : Symbol(foo, Decl(correctUse.ts, 0, 8)) + +export { foo as "0n" }; +>foo : Symbol(foo, Decl(correctUse.ts, 0, 8)) +>"0n" : Symbol("0n", Decl(correctUse.ts, 1, 8)) + +=== badImport.ts === +import { 0n as foo } from "./foo"; +>foo : Symbol(foo) + +=== badImport2.ts === +import { foo as 0n } from "./foo"; +> : Symbol((Missing), Decl(badImport2.ts, 0, 8)) + +=== badExport.ts === +export { foo as 0n }; +> : Symbol((Missing), Decl(badExport.ts, 0, 8)) + +=== badExport2.ts === +export { 0n as foo }; +>foo : Symbol(foo) + diff --git a/tsc/testdata/baselines/reference/compiler/bigintArbirtraryIdentifier(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/bigintArbirtraryIdentifier(checkorder=default).types new file mode 100644 index 0000000000000..c3f2d2ceb5859 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/bigintArbirtraryIdentifier(checkorder=default).types @@ -0,0 +1,44 @@ +//// [tests/cases/compiler/bigintArbirtraryIdentifier.ts] //// + +=== foo.ts === +const foo = 0n; +>foo : 0n +>0n : 0n + +export { foo as "0n" }; +>foo : 0n +>"0n" : 0n + +=== correctUse.ts === +import { "0n" as foo } from "./foo"; +>foo : 0n + +export { foo as "0n" }; +>foo : 0n +>"0n" : 0n + +=== badImport.ts === +import { 0n as foo } from "./foo"; +>0n as foo : foo +>0n : 0n +>from : any +>"./foo" : "./foo" + +=== badImport2.ts === +import { foo as 0n } from "./foo"; +>foo : any +> : any +>from : any +>"./foo" : "./foo" + +=== badExport.ts === +export { foo as 0n }; +>foo : any +> : any +>0n : 0n + +=== badExport2.ts === +export { 0n as foo }; +>0n as foo : foo +>0n : 0n + diff --git a/tsc/testdata/baselines/reference/compiler/bigintArbirtraryIdentifier(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/bigintArbirtraryIdentifier(checkorder=typesfirst).errors.txt new file mode 100644 index 0000000000000..e70af53237c1f --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/bigintArbirtraryIdentifier(checkorder=typesfirst).errors.txt @@ -0,0 +1,72 @@ +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,16): error TS2304: Cannot find name 'foo'. +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 (6 errors) ==== + import { 0n as foo } from "./foo"; + ~~ +!!! error TS1003: Identifier expected. + ~~~~~~~~~ +!!! error TS1141: String literal expected. + ~~~ +!!! error TS2304: Cannot find name 'foo'. + ~ +!!! 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/boundedRecursiveTypeInferredThroughClosure.errors.txt b/tsc/testdata/baselines/reference/compiler/boundedRecursiveTypeInferredThroughClosure.errors.txt new file mode 100644 index 0000000000000..e537c857eb57a --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/boundedRecursiveTypeInferredThroughClosure.errors.txt @@ -0,0 +1,86 @@ +boundedRecursiveTypeInferredThroughClosure.ts(79,12): error TS5115: Instantiations of the following types appear infinitely circular: 'InferData', 'UnpackKeyValue'. + + +==== boundedRecursiveTypeInferredThroughClosure.ts (1 errors) ==== + // The recursion of InferData and UnpackKeyValue is bounded by Next, so + // inferring it through a closure must not report it as infinite. + + type Prettify = { [K in keyof T]: T[K] } & {}; + type ExtractUndefined = { [K in keyof T]: undefined extends T[K] ? K : never }[keyof T]; + type ExtractDefined = { [K in keyof T]: undefined extends T[K] ? never : K }[keyof T]; + type Next = [1, 2, 3, 4, 5, 6]; + type JSONPrimitives = string | number | bigint | boolean | null | undefined; + type JSONValues = JSONPrimitives | CanBeSerialized; + type CanBeSerialized = { + toJSON(): T; + }; + type JSONDataTypes = JSONValues | JSONDataTypes[] | { + [key: string]: JSONDataTypes; + }; + type SerializeJSONObject = { + [K in ExtractDefined]: SerializeJSONTypes; + } & { + [K in ExtractUndefined]?: SerializeJSONTypes; + }; + interface ExtendedJSONTypes { + } + type NonAllowedJSTypes = Map | Set; + type ForcefullyAllowedTypes = { + [K in keyof ExtendedJSONTypes]: ExtendedJSONTypes[K]; + }[keyof ExtendedJSONTypes]; + type SerializeJSONOwnTypes = T extends JSONPrimitives ? T : T extends ForcefullyAllowedTypes ? T : T extends NonAllowedJSTypes ? never : T extends Array ? Array> : T extends object ? Prettify> : never; + type SerializeJSONTypes = T extends ForcefullyAllowedTypes ? T : T extends CanBeSerialized ? SerializeJSONOwnTypes : SerializeJSONOwnTypes; + interface ItemContract, MaxDepth extends Next[number], Variant extends string> { + $type: 'item'; + transformer: { + new (...args: any[]): Transformer; + }; + maxDepth: MaxDepth; + variant: Variant; + } + type UnpackKeyValue = [Value[0]] extends [never] ? SerializeJSONTypes : Value[0] extends ItemContract ? InferData | SerializeJSONTypes : SerializeJSONTypes; + type LimitDepth = [ + Value + ] extends [never] ? Key : Value extends ItemContract ? MaxDepth extends Depth ? never : Key : Key; + type UnpackOptionalValues = { + [O in { + [K in keyof Data]: [undefined] extends [Data[K]] ? LimitDepth[0], MaxDepth, Depth> : never; + }[keyof Data]]?: UnpackKeyValue, MaxDepth, Depth>; + }; + type UnpackRequiredValues = { + [O in { + [K in keyof Data]: [undefined] extends [Data[K]] ? never : LimitDepth[0], MaxDepth, Depth>; + }[keyof Data]]: UnpackKeyValue, MaxDepth, Depth>; + }; + type SplitItm = [ + Extract>, + Exclude> + ]; + type UnpackAsTopLevelItem = T extends ItemContract ? InferData : never; + type UnpackValues = Prettify & UnpackOptionalValues>; + type InferData = Transformer extends { + [K in Variant]: (...args: any[]) => unknown; + } ? UnpackValues>, MaxDepth, Depth> : never; + declare class Item, MaxDepth extends Next[number], Variant extends string> { + transformer: { new (...args: any[]): Transformer }; + maxDepth: MaxDepth; + variant: Variant; + $type: 'item'; + resolve(): Promise>; + } + type Ctor = { new (resource: any, ...rest: any[]): any }; + declare abstract class BaseTransformer { + static transform(this: Self, data: ConstructorParameters[0]): Item, 1, 'toObject'>; + constructor(resource: T); + } + class Size { + } + class SizeTransformer extends BaseTransformer { + toObject() { + } + } + declare function once(value: T): T; + once(() => SizeTransformer.transform(new Size())); + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS5115: Instantiations of the following types appear infinitely circular: 'InferData', 'UnpackKeyValue'. + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/boundedRecursiveTypeInferredThroughClosure.symbols b/tsc/testdata/baselines/reference/compiler/boundedRecursiveTypeInferredThroughClosure.symbols new file mode 100644 index 0000000000000..12f0269e1ddb6 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/boundedRecursiveTypeInferredThroughClosure.symbols @@ -0,0 +1,424 @@ +//// [tests/cases/compiler/boundedRecursiveTypeInferredThroughClosure.ts] //// + +=== boundedRecursiveTypeInferredThroughClosure.ts === +// The recursion of InferData and UnpackKeyValue is bounded by Next, so +// inferring it through a closure must not report it as infinite. + +type Prettify = { [K in keyof T]: T[K] } & {}; +>Prettify : Symbol(Prettify, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 0, 0)) +>T : Symbol(T, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 3, 14)) +>K : Symbol(K, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 3, 22)) +>T : Symbol(T, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 3, 14)) +>T : Symbol(T, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 3, 14)) +>K : Symbol(K, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 3, 22)) + +type ExtractUndefined = { [K in keyof T]: undefined extends T[K] ? K : never }[keyof T]; +>ExtractUndefined : Symbol(ExtractUndefined, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 3, 49)) +>T : Symbol(T, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 4, 22)) +>K : Symbol(K, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 4, 30)) +>T : Symbol(T, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 4, 22)) +>T : Symbol(T, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 4, 22)) +>K : Symbol(K, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 4, 30)) +>K : Symbol(K, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 4, 30)) +>T : Symbol(T, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 4, 22)) + +type ExtractDefined = { [K in keyof T]: undefined extends T[K] ? never : K }[keyof T]; +>ExtractDefined : Symbol(ExtractDefined, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 4, 91)) +>T : Symbol(T, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 5, 20)) +>K : Symbol(K, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 5, 28)) +>T : Symbol(T, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 5, 20)) +>T : Symbol(T, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 5, 20)) +>K : Symbol(K, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 5, 28)) +>K : Symbol(K, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 5, 28)) +>T : Symbol(T, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 5, 20)) + +type Next = [1, 2, 3, 4, 5, 6]; +>Next : Symbol(Next, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 5, 89)) + +type JSONPrimitives = string | number | bigint | boolean | null | undefined; +>JSONPrimitives : Symbol(JSONPrimitives, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 6, 31)) + +type JSONValues = JSONPrimitives | CanBeSerialized; +>JSONValues : Symbol(JSONValues, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 7, 76)) +>JSONPrimitives : Symbol(JSONPrimitives, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 6, 31)) +>CanBeSerialized : Symbol(CanBeSerialized, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 8, 56)) + +type CanBeSerialized = { +>CanBeSerialized : Symbol(CanBeSerialized, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 8, 56)) +>T : Symbol(T, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 9, 21)) +>JSONDataTypes : Symbol(JSONDataTypes, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 11, 2)) + + toJSON(): T; +>toJSON : Symbol(toJSON, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 9, 49)) +>T : Symbol(T, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 9, 21)) + +}; +type JSONDataTypes = JSONValues | JSONDataTypes[] | { +>JSONDataTypes : Symbol(JSONDataTypes, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 11, 2)) +>JSONValues : Symbol(JSONValues, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 7, 76)) +>JSONDataTypes : Symbol(JSONDataTypes, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 11, 2)) + + [key: string]: JSONDataTypes; +>key : Symbol(key, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 13, 5)) +>JSONDataTypes : Symbol(JSONDataTypes, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 11, 2)) + +}; +type SerializeJSONObject = { +>SerializeJSONObject : Symbol(SerializeJSONObject, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 14, 2)) +>T : Symbol(T, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 15, 25)) + + [K in ExtractDefined]: SerializeJSONTypes; +>K : Symbol(K, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 16, 5)) +>ExtractDefined : Symbol(ExtractDefined, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 4, 91)) +>T : Symbol(T, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 15, 25)) +>SerializeJSONTypes : Symbol(SerializeJSONTypes, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 26, 264)) +>T : Symbol(T, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 15, 25)) +>K : Symbol(K, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 16, 5)) + +} & { + [K in ExtractUndefined]?: SerializeJSONTypes; +>K : Symbol(K, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 18, 5)) +>ExtractUndefined : Symbol(ExtractUndefined, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 3, 49)) +>T : Symbol(T, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 15, 25)) +>SerializeJSONTypes : Symbol(SerializeJSONTypes, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 26, 264)) +>T : Symbol(T, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 15, 25)) +>K : Symbol(K, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 18, 5)) + +}; +interface ExtendedJSONTypes { +>ExtendedJSONTypes : Symbol(ExtendedJSONTypes, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 19, 2)) +} +type NonAllowedJSTypes = Map | Set; +>NonAllowedJSTypes : Symbol(NonAllowedJSTypes, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 21, 1)) +>Map : Symbol(Map, Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2026.collection.d.ts, --, --)) +>Set : Symbol(Set, Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2025.collection.d.ts, --, --)) + +type ForcefullyAllowedTypes = { +>ForcefullyAllowedTypes : Symbol(ForcefullyAllowedTypes, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 22, 50)) + + [K in keyof ExtendedJSONTypes]: ExtendedJSONTypes[K]; +>K : Symbol(K, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 24, 5)) +>ExtendedJSONTypes : Symbol(ExtendedJSONTypes, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 19, 2)) +>ExtendedJSONTypes : Symbol(ExtendedJSONTypes, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 19, 2)) +>K : Symbol(K, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 24, 5)) + +}[keyof ExtendedJSONTypes]; +>ExtendedJSONTypes : Symbol(ExtendedJSONTypes, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 19, 2)) + +type SerializeJSONOwnTypes = T extends JSONPrimitives ? T : T extends ForcefullyAllowedTypes ? T : T extends NonAllowedJSTypes ? never : T extends Array ? Array> : T extends object ? Prettify> : never; +>SerializeJSONOwnTypes : Symbol(SerializeJSONOwnTypes, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 25, 27)) +>T : Symbol(T, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 26, 27)) +>T : Symbol(T, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 26, 27)) +>JSONPrimitives : Symbol(JSONPrimitives, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 6, 31)) +>T : Symbol(T, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 26, 27)) +>T : Symbol(T, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 26, 27)) +>ForcefullyAllowedTypes : Symbol(ForcefullyAllowedTypes, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 22, 50)) +>T : Symbol(T, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 26, 27)) +>T : Symbol(T, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 26, 27)) +>NonAllowedJSTypes : Symbol(NonAllowedJSTypes, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 21, 1)) +>T : Symbol(T, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 26, 27)) +>Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --) ... and 4 more) +>item : Symbol(item, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 26, 161)) +>Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --) ... and 4 more) +>SerializeJSONTypes : Symbol(SerializeJSONTypes, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 26, 264)) +>item : Symbol(item, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 26, 161)) +>T : Symbol(T, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 26, 27)) +>Prettify : Symbol(Prettify, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 0, 0)) +>SerializeJSONObject : Symbol(SerializeJSONObject, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 14, 2)) +>T : Symbol(T, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 26, 27)) + +type SerializeJSONTypes = T extends ForcefullyAllowedTypes ? T : T extends CanBeSerialized ? SerializeJSONOwnTypes : SerializeJSONOwnTypes; +>SerializeJSONTypes : Symbol(SerializeJSONTypes, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 26, 264)) +>T : Symbol(T, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 27, 24)) +>T : Symbol(T, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 27, 24)) +>ForcefullyAllowedTypes : Symbol(ForcefullyAllowedTypes, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 22, 50)) +>T : Symbol(T, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 27, 24)) +>T : Symbol(T, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 27, 24)) +>CanBeSerialized : Symbol(CanBeSerialized, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 8, 56)) +>A : Symbol(A, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 27, 99)) +>SerializeJSONOwnTypes : Symbol(SerializeJSONOwnTypes, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 25, 27)) +>A : Symbol(A, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 27, 99)) +>SerializeJSONOwnTypes : Symbol(SerializeJSONOwnTypes, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 25, 27)) +>T : Symbol(T, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 27, 24)) + +interface ItemContract, MaxDepth extends Next[number], Variant extends string> { +>ItemContract : Symbol(ItemContract, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 27, 157)) +>Transformer : Symbol(Transformer, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 28, 23)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) +>MaxDepth : Symbol(MaxDepth, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 28, 63)) +>Next : Symbol(Next, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 5, 89)) +>Variant : Symbol(Variant, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 28, 94)) + + $type: 'item'; +>$type : Symbol(ItemContract.$type, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 28, 120)) + + transformer: { +>transformer : Symbol(ItemContract.transformer, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 29, 18)) + + new (...args: any[]): Transformer; +>args : Symbol(args, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 31, 13)) +>Transformer : Symbol(Transformer, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 28, 23)) + + }; + maxDepth: MaxDepth; +>maxDepth : Symbol(ItemContract.maxDepth, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 32, 6)) +>MaxDepth : Symbol(MaxDepth, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 28, 63)) + + variant: Variant; +>variant : Symbol(ItemContract.variant, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 33, 23)) +>Variant : Symbol(Variant, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 28, 94)) +} +type UnpackKeyValue = [Value[0]] extends [never] ? SerializeJSONTypes : Value[0] extends ItemContract ? InferData | SerializeJSONTypes : SerializeJSONTypes; +>UnpackKeyValue : Symbol(UnpackKeyValue, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 35, 1)) +>Value : Symbol(Value, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 36, 20)) +>MaxDepth : Symbol(MaxDepth, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 36, 45)) +>Depth : Symbol(Depth, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 36, 70)) +>Value : Symbol(Value, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 36, 20)) +>SerializeJSONTypes : Symbol(SerializeJSONTypes, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 26, 264)) +>Value : Symbol(Value, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 36, 20)) +>Value : Symbol(Value, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 36, 20)) +>ItemContract : Symbol(ItemContract, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 27, 157)) +>Transformer : Symbol(Transformer, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 36, 190)) +>LocalMaxDepth : Symbol(LocalMaxDepth, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 36, 209)) +>Variant : Symbol(Variant, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 36, 230)) +>InferData : Symbol(InferData, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 55, 173)) +>Transformer : Symbol(Transformer, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 36, 190)) +>Variant : Symbol(Variant, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 36, 230)) +>MaxDepth : Symbol(MaxDepth, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 36, 45)) +>LocalMaxDepth : Symbol(LocalMaxDepth, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 36, 209)) +>MaxDepth : Symbol(MaxDepth, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 36, 45)) +>Next : Symbol(Next, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 5, 89)) +>Depth : Symbol(Depth, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 36, 70)) +>SerializeJSONTypes : Symbol(SerializeJSONTypes, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 26, 264)) +>Value : Symbol(Value, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 36, 20)) +>SerializeJSONTypes : Symbol(SerializeJSONTypes, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 26, 264)) +>Value : Symbol(Value, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 36, 20)) + +type LimitDepth = [ +>LimitDepth : Symbol(LimitDepth, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 36, 397)) +>Key : Symbol(Key, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 37, 16)) +>Value : Symbol(Value, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 37, 20)) +>MaxDepth : Symbol(MaxDepth, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 37, 27)) +>Depth : Symbol(Depth, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 37, 52)) + + Value +>Value : Symbol(Value, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 37, 20)) + +] extends [never] ? Key : Value extends ItemContract ? MaxDepth extends Depth ? never : Key : Key; +>Key : Symbol(Key, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 37, 16)) +>Value : Symbol(Value, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 37, 20)) +>ItemContract : Symbol(ItemContract, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 27, 157)) +>MaxDepth : Symbol(MaxDepth, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 37, 27)) +>Depth : Symbol(Depth, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 37, 52)) +>Key : Symbol(Key, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 37, 16)) +>Key : Symbol(Key, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 37, 16)) + +type UnpackOptionalValues = { +>UnpackOptionalValues : Symbol(UnpackOptionalValues, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 39, 113)) +>Data : Symbol(Data, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 40, 26)) +>MaxDepth : Symbol(MaxDepth, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 40, 31)) +>Depth : Symbol(Depth, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 40, 56)) + + [O in { +>O : Symbol(O, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 41, 5)) + + [K in keyof Data]: [undefined] extends [Data[K]] ? LimitDepth[0], MaxDepth, Depth> : never; +>K : Symbol(K, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 42, 9)) +>Data : Symbol(Data, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 40, 26)) +>Data : Symbol(Data, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 40, 26)) +>K : Symbol(K, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 42, 9)) +>LimitDepth : Symbol(LimitDepth, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 36, 397)) +>K : Symbol(K, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 42, 9)) +>SplitItm : Symbol(SplitItm, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 49, 2)) +>Data : Symbol(Data, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 40, 26)) +>K : Symbol(K, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 42, 9)) +>MaxDepth : Symbol(MaxDepth, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 40, 31)) +>Depth : Symbol(Depth, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 40, 56)) + + }[keyof Data]]?: UnpackKeyValue, MaxDepth, Depth>; +>Data : Symbol(Data, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 40, 26)) +>UnpackKeyValue : Symbol(UnpackKeyValue, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 35, 1)) +>SplitItm : Symbol(SplitItm, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 49, 2)) +>Data : Symbol(Data, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 40, 26)) +>O : Symbol(O, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 41, 5)) +>MaxDepth : Symbol(MaxDepth, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 40, 31)) +>Depth : Symbol(Depth, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 40, 56)) + +}; +type UnpackRequiredValues = { +>UnpackRequiredValues : Symbol(UnpackRequiredValues, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 44, 2)) +>Data : Symbol(Data, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 45, 26)) +>MaxDepth : Symbol(MaxDepth, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 45, 31)) +>Depth : Symbol(Depth, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 45, 56)) + + [O in { +>O : Symbol(O, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 46, 5)) + + [K in keyof Data]: [undefined] extends [Data[K]] ? never : LimitDepth[0], MaxDepth, Depth>; +>K : Symbol(K, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 47, 9)) +>Data : Symbol(Data, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 45, 26)) +>Data : Symbol(Data, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 45, 26)) +>K : Symbol(K, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 47, 9)) +>LimitDepth : Symbol(LimitDepth, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 36, 397)) +>K : Symbol(K, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 47, 9)) +>SplitItm : Symbol(SplitItm, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 49, 2)) +>Data : Symbol(Data, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 45, 26)) +>K : Symbol(K, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 47, 9)) +>MaxDepth : Symbol(MaxDepth, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 45, 31)) +>Depth : Symbol(Depth, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 45, 56)) + + }[keyof Data]]: UnpackKeyValue, MaxDepth, Depth>; +>Data : Symbol(Data, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 45, 26)) +>UnpackKeyValue : Symbol(UnpackKeyValue, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 35, 1)) +>SplitItm : Symbol(SplitItm, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 49, 2)) +>Data : Symbol(Data, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 45, 26)) +>O : Symbol(O, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 46, 5)) +>MaxDepth : Symbol(MaxDepth, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 45, 31)) +>Depth : Symbol(Depth, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 45, 56)) + +}; +type SplitItm = [ +>SplitItm : Symbol(SplitItm, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 49, 2)) +>T : Symbol(T, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 50, 14)) + + Extract>, +>Extract : Symbol(Extract, Decl(lib.es5.d.ts, --, --)) +>T : Symbol(T, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 50, 14)) +>ItemContract : Symbol(ItemContract, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 27, 157)) + + Exclude> +>Exclude : Symbol(Exclude, Decl(lib.es5.d.ts, --, --)) +>T : Symbol(T, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 50, 14)) +>ItemContract : Symbol(ItemContract, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 27, 157)) + +]; +type UnpackAsTopLevelItem = T extends ItemContract ? InferData : never; +>UnpackAsTopLevelItem : Symbol(UnpackAsTopLevelItem, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 53, 2)) +>T : Symbol(T, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 54, 26)) +>Wrapper : Symbol(Wrapper, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 54, 28)) +>T : Symbol(T, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 54, 26)) +>ItemContract : Symbol(ItemContract, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 27, 157)) +>Transformer : Symbol(Transformer, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 54, 95)) +>Variant : Symbol(Variant, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 54, 119)) +>InferData : Symbol(InferData, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 55, 173)) +>Transformer : Symbol(Transformer, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 54, 95)) +>Variant : Symbol(Variant, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 54, 119)) + +type UnpackValues = Prettify & UnpackOptionalValues>; +>UnpackValues : Symbol(UnpackValues, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 54, 178)) +>Data : Symbol(Data, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 55, 18)) +>MaxDepth : Symbol(MaxDepth, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 55, 23)) +>Depth : Symbol(Depth, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 55, 48)) +>Prettify : Symbol(Prettify, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 0, 0)) +>UnpackRequiredValues : Symbol(UnpackRequiredValues, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 44, 2)) +>Data : Symbol(Data, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 55, 18)) +>MaxDepth : Symbol(MaxDepth, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 55, 23)) +>Depth : Symbol(Depth, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 55, 48)) +>UnpackOptionalValues : Symbol(UnpackOptionalValues, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 39, 113)) +>Data : Symbol(Data, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 55, 18)) +>MaxDepth : Symbol(MaxDepth, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 55, 23)) +>Depth : Symbol(Depth, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 55, 48)) + +type InferData = Transformer extends { +>InferData : Symbol(InferData, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 55, 173)) +>Transformer : Symbol(Transformer, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 56, 15)) +>Variant : Symbol(Variant, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 56, 27)) +>MaxDepth : Symbol(MaxDepth, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 56, 64)) +>Depth : Symbol(Depth, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 56, 94)) +>Transformer : Symbol(Transformer, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 56, 15)) + + [K in Variant]: (...args: any[]) => unknown; +>K : Symbol(K, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 57, 5)) +>Variant : Symbol(Variant, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 56, 27)) +>args : Symbol(args, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 57, 21)) + +} ? UnpackValues>, MaxDepth, Depth> : never; +>UnpackValues : Symbol(UnpackValues, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 54, 178)) +>Awaited : Symbol(Awaited, Decl(lib.es5.d.ts, --, --)) +>ReturnType : Symbol(ReturnType, Decl(lib.es5.d.ts, --, --)) +>Transformer : Symbol(Transformer, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 56, 15)) +>Variant : Symbol(Variant, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 56, 27)) +>MaxDepth : Symbol(MaxDepth, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 56, 64)) +>Depth : Symbol(Depth, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 56, 94)) + +declare class Item, MaxDepth extends Next[number], Variant extends string> { +>Item : Symbol(Item, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 58, 85)) +>Transformer : Symbol(Transformer, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 59, 19)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) +>MaxDepth : Symbol(MaxDepth, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 59, 59)) +>Next : Symbol(Next, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 5, 89)) +>Variant : Symbol(Variant, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 59, 90)) + + transformer: { new (...args: any[]): Transformer }; +>transformer : Symbol(Item.transformer, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 59, 116)) +>args : Symbol(args, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 60, 21)) +>Transformer : Symbol(Transformer, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 59, 19)) + + maxDepth: MaxDepth; +>maxDepth : Symbol(Item.maxDepth, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 60, 52)) +>MaxDepth : Symbol(MaxDepth, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 59, 59)) + + variant: Variant; +>variant : Symbol(Item.variant, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 61, 20)) +>Variant : Symbol(Variant, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 59, 90)) + + $type: 'item'; +>$type : Symbol(Item.$type, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 62, 18)) + + resolve(): Promise>; +>resolve : Symbol(Item.resolve, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 63, 15)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2018.promise.d.ts, --, --)) +>UnpackAsTopLevelItem : Symbol(UnpackAsTopLevelItem, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 53, 2)) +} +type Ctor = { new (resource: any, ...rest: any[]): any }; +>Ctor : Symbol(Ctor, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 65, 1)) +>resource : Symbol(resource, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 66, 19)) +>rest : Symbol(rest, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 66, 33)) + +declare abstract class BaseTransformer { +>BaseTransformer : Symbol(BaseTransformer, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 66, 57)) +>T : Symbol(T, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 67, 39)) + + static transform(this: Self, data: ConstructorParameters[0]): Item, 1, 'toObject'>; +>transform : Symbol(BaseTransformer.transform, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 67, 43)) +>Self : Symbol(Self, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 68, 18)) +>Ctor : Symbol(Ctor, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 65, 1)) +>this : Symbol(this, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 68, 37)) +>Self : Symbol(Self, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 68, 18)) +>data : Symbol(data, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 68, 48)) +>ConstructorParameters : Symbol(ConstructorParameters, Decl(lib.es5.d.ts, --, --)) +>Self : Symbol(Self, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 68, 18)) +>Item : Symbol(Item, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 58, 85)) +>InstanceType : Symbol(InstanceType, Decl(lib.es5.d.ts, --, --)) +>Self : Symbol(Self, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 68, 18)) + + constructor(resource: T); +>resource : Symbol(resource, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 69, 13)) +>T : Symbol(T, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 67, 39)) +} +class Size { +>Size : Symbol(Size, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 70, 1)) +} +class SizeTransformer extends BaseTransformer { +>SizeTransformer : Symbol(SizeTransformer, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 72, 1)) +>BaseTransformer : Symbol(BaseTransformer, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 66, 57)) +>Size : Symbol(Size, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 70, 1)) + + toObject() { +>toObject : Symbol(SizeTransformer.toObject, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 73, 53)) + } +} +declare function once(value: T): T; +>once : Symbol(once, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 76, 1)) +>T : Symbol(T, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 77, 22)) +>value : Symbol(value, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 77, 25)) +>T : Symbol(T, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 77, 22)) +>T : Symbol(T, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 77, 22)) + +once(() => SizeTransformer.transform(new Size())); +>once : Symbol(once, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 76, 1)) +>SizeTransformer.transform : Symbol(BaseTransformer.transform, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 67, 43)) +>SizeTransformer : Symbol(SizeTransformer, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 72, 1)) +>transform : Symbol(BaseTransformer.transform, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 67, 43)) +>Size : Symbol(Size, Decl(boundedRecursiveTypeInferredThroughClosure.ts, 70, 1)) + diff --git a/tsc/testdata/baselines/reference/compiler/boundedRecursiveTypeInferredThroughClosure.types b/tsc/testdata/baselines/reference/compiler/boundedRecursiveTypeInferredThroughClosure.types new file mode 100644 index 0000000000000..1f285bcdb698b --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/boundedRecursiveTypeInferredThroughClosure.types @@ -0,0 +1,186 @@ +//// [tests/cases/compiler/boundedRecursiveTypeInferredThroughClosure.ts] //// + +=== boundedRecursiveTypeInferredThroughClosure.ts === +// The recursion of InferData and UnpackKeyValue is bounded by Next, so +// inferring it through a closure must not report it as infinite. + +type Prettify = { [K in keyof T]: T[K] } & {}; +>Prettify : { [K in keyof T]: T[K]; } + +type ExtractUndefined = { [K in keyof T]: undefined extends T[K] ? K : never }[keyof T]; +>ExtractUndefined : ExtractUndefined + +type ExtractDefined = { [K in keyof T]: undefined extends T[K] ? never : K }[keyof T]; +>ExtractDefined : ExtractDefined + +type Next = [1, 2, 3, 4, 5, 6]; +>Next : Next + +type JSONPrimitives = string | number | bigint | boolean | null | undefined; +>JSONPrimitives : JSONPrimitives + +type JSONValues = JSONPrimitives | CanBeSerialized; +>JSONValues : JSONValues + +type CanBeSerialized = { +>CanBeSerialized : CanBeSerialized + + toJSON(): T; +>toJSON : () => T + +}; +type JSONDataTypes = JSONValues | JSONDataTypes[] | { +>JSONDataTypes : JSONDataTypes + + [key: string]: JSONDataTypes; +>key : string + +}; +type SerializeJSONObject = { +>SerializeJSONObject : SerializeJSONObject + + [K in ExtractDefined]: SerializeJSONTypes; +} & { + [K in ExtractUndefined]?: SerializeJSONTypes; +}; +interface ExtendedJSONTypes { +} +type NonAllowedJSTypes = Map | Set; +>NonAllowedJSTypes : NonAllowedJSTypes + +type ForcefullyAllowedTypes = { +>ForcefullyAllowedTypes : never + + [K in keyof ExtendedJSONTypes]: ExtendedJSONTypes[K]; +}[keyof ExtendedJSONTypes]; +type SerializeJSONOwnTypes = T extends JSONPrimitives ? T : T extends ForcefullyAllowedTypes ? T : T extends NonAllowedJSTypes ? never : T extends Array ? Array> : T extends object ? Prettify> : never; +>SerializeJSONOwnTypes : SerializeJSONOwnTypes + +type SerializeJSONTypes = T extends ForcefullyAllowedTypes ? T : T extends CanBeSerialized ? SerializeJSONOwnTypes : SerializeJSONOwnTypes; +>SerializeJSONTypes : SerializeJSONTypes + +interface ItemContract, MaxDepth extends Next[number], Variant extends string> { + $type: 'item'; +>$type : "item" + + transformer: { +>transformer : new (...args: any[]) => Transformer + + new (...args: any[]): Transformer; +>args : any[] + + }; + maxDepth: MaxDepth; +>maxDepth : MaxDepth + + variant: Variant; +>variant : Variant +} +type UnpackKeyValue = [Value[0]] extends [never] ? SerializeJSONTypes : Value[0] extends ItemContract ? InferData | SerializeJSONTypes : SerializeJSONTypes; +>UnpackKeyValue : UnpackKeyValue +>-1 : -1 +>1 : 1 + +type LimitDepth = [ +>LimitDepth : LimitDepth + + Value +] extends [never] ? Key : Value extends ItemContract ? MaxDepth extends Depth ? never : Key : Key; +type UnpackOptionalValues = { +>UnpackOptionalValues : UnpackOptionalValues + + [O in { + [K in keyof Data]: [undefined] extends [Data[K]] ? LimitDepth[0], MaxDepth, Depth> : never; + }[keyof Data]]?: UnpackKeyValue, MaxDepth, Depth>; +}; +type UnpackRequiredValues = { +>UnpackRequiredValues : UnpackRequiredValues + + [O in { + [K in keyof Data]: [undefined] extends [Data[K]] ? never : LimitDepth[0], MaxDepth, Depth>; + }[keyof Data]]: UnpackKeyValue, MaxDepth, Depth>; +}; +type SplitItm = [ +>SplitItm : SplitItm + + Extract>, + Exclude> +]; +type UnpackAsTopLevelItem = T extends ItemContract ? InferData : never; +>UnpackAsTopLevelItem : UnpackAsTopLevelItem +>-1 : -1 +>1 : 1 + +type UnpackValues = Prettify & UnpackOptionalValues>; +>UnpackValues : UnpackRequiredValues & UnpackOptionalValues extends infer T ? { [K in keyof T]: T[K]; } : never + +type InferData = Transformer extends { +>InferData : InferData +>-1 : -1 +>1 : 1 + + [K in Variant]: (...args: any[]) => unknown; +>args : any[] + +} ? UnpackValues>, MaxDepth, Depth> : never; +declare class Item, MaxDepth extends Next[number], Variant extends string> { +>Item : Item + + transformer: { new (...args: any[]): Transformer }; +>transformer : new (...args: any[]) => Transformer +>args : any[] + + maxDepth: MaxDepth; +>maxDepth : MaxDepth + + variant: Variant; +>variant : Variant + + $type: 'item'; +>$type : "item" + + resolve(): Promise>; +>resolve : () => Promise> +} +type Ctor = { new (resource: any, ...rest: any[]): any }; +>Ctor : Ctor +>resource : any +>rest : any[] + +declare abstract class BaseTransformer { +>BaseTransformer : BaseTransformer + + static transform(this: Self, data: ConstructorParameters[0]): Item, 1, 'toObject'>; +>transform : (this: Self, data: ConstructorParameters[0]) => Item, 1, 'toObject'> +>this : Self +>data : ConstructorParameters[0] + + constructor(resource: T); +>resource : T +} +class Size { +>Size : Size +} +class SizeTransformer extends BaseTransformer { +>SizeTransformer : SizeTransformer +>BaseTransformer : BaseTransformer + + toObject() { +>toObject : () => void + } +} +declare function once(value: T): T; +>once : (value: T) => T +>value : T + +once(() => SizeTransformer.transform(new Size())); +>once(() => SizeTransformer.transform(new Size())) : () => Item +>once : (value: T) => T +>() => SizeTransformer.transform(new Size()) : () => Item +>SizeTransformer.transform(new Size()) : Item +>SizeTransformer.transform : (this: Self, data: ConstructorParameters[0]) => Item, 1, 'toObject'> +>SizeTransformer : typeof SizeTransformer +>transform : (this: Self, data: ConstructorParameters[0]) => Item, 1, 'toObject'> +>new Size() : Size +>Size : typeof Size + diff --git a/tsc/testdata/baselines/reference/compiler/checkIndexConstraintOfJavascriptClassExpression(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/checkIndexConstraintOfJavascriptClassExpression(checkorder=default).errors.txt new file mode 100644 index 0000000000000..fa22beceb33e2 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkIndexConstraintOfJavascriptClassExpression(checkorder=default).errors.txt @@ -0,0 +1,27 @@ +weird.js(1,1): error TS2552: Cannot find name 'someFunction'. Did you mean 'Function'? +weird.js(1,23): error TS7006: Parameter 'BaseClass' implicitly has an 'any' type. +weird.js(9,17): error TS7006: Parameter 'error' implicitly has an 'any' type. + + +==== weird.js (3 errors) ==== + someFunction(function(BaseClass) { + ~~~~~~~~~~~~ +!!! error TS2552: Cannot find name 'someFunction'. Did you mean 'Function'? +!!! related TS2728 lib.es5.d.ts:--:--: 'Function' is declared here. + ~~~~~~~~~ +!!! error TS7006: Parameter 'BaseClass' implicitly has an 'any' type. + 'use strict'; + const DEFAULT_MESSAGE = "nop!"; + class Hello extends BaseClass { + constructor() { + super(); + this.foo = "bar"; + } + _render(error) { + ~~~~~ +!!! error TS7006: Parameter 'error' implicitly has an 'any' type. + const message = error.message || DEFAULT_MESSAGE; + } + } + }); + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/checkIndexConstraintOfJavascriptClassExpression(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/checkIndexConstraintOfJavascriptClassExpression(checkorder=default).symbols new file mode 100644 index 0000000000000..99ddd57e9d8cd --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkIndexConstraintOfJavascriptClassExpression(checkorder=default).symbols @@ -0,0 +1,33 @@ +//// [tests/cases/compiler/checkIndexConstraintOfJavascriptClassExpression.ts] //// + +=== weird.js === +someFunction(function(BaseClass) { +>BaseClass : Symbol(BaseClass, Decl(weird.js, 0, 22)) + + 'use strict'; + const DEFAULT_MESSAGE = "nop!"; +>DEFAULT_MESSAGE : Symbol(DEFAULT_MESSAGE, Decl(weird.js, 2, 9)) + + class Hello extends BaseClass { +>Hello : Symbol(Hello, Decl(weird.js, 2, 35)) +>BaseClass : Symbol(BaseClass, Decl(weird.js, 0, 22)) + + constructor() { + super(); + this.foo = "bar"; +>this.foo : Symbol(Hello.foo, Decl(weird.js, 5, 20)) +>this : Symbol(Hello, Decl(weird.js, 2, 35)) +>foo : Symbol(Hello.foo, Decl(weird.js, 5, 20)) + } + _render(error) { +>_render : Symbol(Hello._render, Decl(weird.js, 7, 9)) +>error : Symbol(error, Decl(weird.js, 8, 16)) + + const message = error.message || DEFAULT_MESSAGE; +>message : Symbol(message, Decl(weird.js, 9, 17)) +>error : Symbol(error, Decl(weird.js, 8, 16)) +>DEFAULT_MESSAGE : Symbol(DEFAULT_MESSAGE, Decl(weird.js, 2, 9)) + } + } +}); + diff --git a/tsc/testdata/baselines/reference/compiler/checkIndexConstraintOfJavascriptClassExpression(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/checkIndexConstraintOfJavascriptClassExpression(checkorder=default).types new file mode 100644 index 0000000000000..7f98768cc3b3e --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkIndexConstraintOfJavascriptClassExpression(checkorder=default).types @@ -0,0 +1,47 @@ +//// [tests/cases/compiler/checkIndexConstraintOfJavascriptClassExpression.ts] //// + +=== weird.js === +someFunction(function(BaseClass) { +>someFunction(function(BaseClass) { 'use strict'; const DEFAULT_MESSAGE = "nop!"; class Hello extends BaseClass { constructor() { super(); this.foo = "bar"; } _render(error) { const message = error.message || DEFAULT_MESSAGE; } }}) : any +>someFunction : any +>function(BaseClass) { 'use strict'; const DEFAULT_MESSAGE = "nop!"; class Hello extends BaseClass { constructor() { super(); this.foo = "bar"; } _render(error) { const message = error.message || DEFAULT_MESSAGE; } }} : (BaseClass: any) => void +>BaseClass : any + + 'use strict'; +>'use strict' : "use strict" + + const DEFAULT_MESSAGE = "nop!"; +>DEFAULT_MESSAGE : "nop!" +>"nop!" : "nop!" + + class Hello extends BaseClass { +>Hello : Hello +>BaseClass : any + + constructor() { + super(); +>super() : void +>super : any + + this.foo = "bar"; +>this.foo = "bar" : "bar" +>this.foo : any +>this : this +>foo : any +>"bar" : "bar" + } + _render(error) { +>_render : (error: any) => void +>error : any + + const message = error.message || DEFAULT_MESSAGE; +>message : any +>error.message || DEFAULT_MESSAGE : any +>error.message : any +>error : any +>message : any +>DEFAULT_MESSAGE : "nop!" + } + } +}); + diff --git a/tsc/testdata/baselines/reference/compiler/checkIndexConstraintOfJavascriptClassExpression(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/checkIndexConstraintOfJavascriptClassExpression(checkorder=typesfirst).errors.txt new file mode 100644 index 0000000000000..a15bd4d38db0d --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkIndexConstraintOfJavascriptClassExpression(checkorder=typesfirst).errors.txt @@ -0,0 +1,24 @@ +weird.js(1,1): error TS2552: Cannot find name 'someFunction'. Did you mean 'Function'? +weird.js(9,17): error TS7006: Parameter 'error' implicitly has an 'any' type. + + +==== weird.js (2 errors) ==== + someFunction(function(BaseClass) { + ~~~~~~~~~~~~ +!!! error TS2552: Cannot find name 'someFunction'. Did you mean 'Function'? +!!! related TS2728 lib.es5.d.ts:--:--: 'Function' is declared here. + '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..fbdc7623ca157 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderAwaitedCycle(checkorder=default).errors.txt @@ -0,0 +1,24 @@ +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'. + + +==== 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 (1 errors) ==== + async function f2() { + const b: number = await s; + ~ +!!! error TS2322: Type 'string' is not assignable to type 'number'. + } + \ 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..55a3e6d752ab1 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderAwaitedCycle(checkorder=reverse).errors.txt @@ -0,0 +1,24 @@ +a.ts(5,11): error TS2322: Type 'string' is not assignable to type 'number'. +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 (1 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'. + } + +==== 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..55a3e6d752ab1 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderAwaitedCycle(checkorder=typesfirst).errors.txt @@ -0,0 +1,24 @@ +a.ts(5,11): error TS2322: Type 'string' is not assignable to type 'number'. +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 (1 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'. + } + +==== 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..938f4b7bb63d2 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderCircularConstraint(checkorder=default).errors.txt @@ -0,0 +1,38 @@ +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. +!!! related TS2751 checkOrderCircularConstraint.ts:7:17: Circularity originates in type at this location. + 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..938f4b7bb63d2 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderCircularConstraint(checkorder=reverse).errors.txt @@ -0,0 +1,38 @@ +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. +!!! related TS2751 checkOrderCircularConstraint.ts:7:17: Circularity originates in type at this location. + 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..ef7991cfbe407 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderCircularConstraint(checkorder=typesfirst).errors.txt @@ -0,0 +1,38 @@ +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. +!!! related TS2751 checkOrderCircularConstraint.ts:10:17: Circularity originates in type at this location. + 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..5c28d3ee0a214 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderCircularDefaults(checkorder=default).errors.txt @@ -0,0 +1,15 @@ +a.ts(2,24): error TS2716: Type parameter 'T' has a circular default. + + +==== a.ts (1 errors) ==== + import type { B } from "./b"; + export interface A { a: T } + ~ +!!! error TS2716: Type parameter 'T' has a circular default. + export declare const a: A; + +==== b.ts (0 errors) ==== + import type { A } from "./a"; + export interface B { b: U } + 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..145f91d78caf3 --- /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).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..145f91d78caf3 --- /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..5c28d3ee0a214 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderCircularDefaults(checkorder=typesfirst).errors.txt @@ -0,0 +1,15 @@ +a.ts(2,24): error TS2716: Type parameter 'T' has a circular default. + + +==== a.ts (1 errors) ==== + import type { B } from "./b"; + export interface A { a: T } + ~ +!!! error TS2716: Type parameter 'T' has a circular default. + export declare const a: A; + +==== b.ts (0 errors) ==== + import type { A } from "./a"; + export interface B { b: U } + 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..145f91d78caf3 --- /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..0570bff3e21f0 --- /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(15,1): error TS2615: Type of property '"each"' circularly references itself in mapped type '{ [P in keyof ListWidget]: undefined extends ListWidget[P] ? never : P; }'. + + +==== 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. + } + + 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; }'. + \ 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..c220c7e1092af --- /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 '{ [P in keyof ListWidget]: undefined extends ListWidget[P] ? never : P; }'. + + +==== 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 '{ [P in keyof ListWidget]: undefined extends ListWidget[P] ? never : P; }'. + } + + 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..7ec12ac791f04 --- /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 : never +>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..0c9c1f6dcfb8d --- /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) => number +>new C() : C +>C : typeof C +>test1 : (a: C2) => number +>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..0c9c1f6dcfb8d --- /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) => number +>new C() : C +>C : typeof C +>test1 : (a: C2) => number +>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..433d0bfbb69b5 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=default).js @@ -0,0 +1,87 @@ +//// [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: {}; +}; +export = _exports; +//// [mb.d.ts] +export { v as pb } from "./xb"; +export declare const mb = 1; +//// [xa.d.ts] +declare const _exports: { + v: { + pb: {}; + mb: 1; + }; +}; +export = _exports; +//// [ma.d.ts] +export { v as pa } from "./xa"; +export declare const ma = 1; +//// [ia.d.ts] +declare const _exports: { + v: { + pa: { + pb: {}; + mb: 1; + }; + 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..901461cf3d36b --- /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: { 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; }; } +>{ 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") + +=== /ma.js === +export { v as pa } from "./xa"; +>v : { pb: {}; mb: 1; } +>pa : { pb: {}; mb: 1; } + +export const ma = 1; +>ma : 1 +>1 : 1 + +=== /mb.js === +export { v as pb } from "./xb"; +>v : {} +>pb : {} + +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: {}; mb: 1; }; } +>module.exports : { v: { pb: {}; mb: 1; }; } +>module : { exports: { v: { pb: {}; mb: 1; }; }; } +>exports : { v: { pb: {}; mb: 1; }; } +>{ v: { ...M } } : { v: { pb: {}; mb: 1; }; } +>v : { pb: {}; mb: 1; } +>{ ...M } : { pb: {}; 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: { pb: {}; mb: 1; }; ma: 1; }; } +>module.exports : { v: {}; } +>module : { exports: { v: {}; }; } +>exports : { 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") + 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..8621be455c50d --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=isolated).js @@ -0,0 +1,80 @@ +//// [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: any; +export = _exports; +//// [mb.d.ts] +export { v as pb } from "./xb"; +export declare const mb = 1; +//// [xa.d.ts] +declare const _exports: any; +export = _exports; +//// [ma.d.ts] +export { v as pa } from "./xa"; +export declare const ma = 1; +//// [ia.d.ts] +declare const _exports: { + v: { + pa: { + pb: {}; + mb: 1; + }; + 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..901461cf3d36b --- /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: { 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; }; } +>{ 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") + +=== /ma.js === +export { v as pa } from "./xa"; +>v : { pb: {}; mb: 1; } +>pa : { pb: {}; mb: 1; } + +export const ma = 1; +>ma : 1 +>1 : 1 + +=== /mb.js === +export { v as pb } from "./xb"; +>v : {} +>pb : {} + +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: {}; mb: 1; }; } +>module.exports : { v: { pb: {}; mb: 1; }; } +>module : { exports: { v: { pb: {}; mb: 1; }; }; } +>exports : { v: { pb: {}; mb: 1; }; } +>{ v: { ...M } } : { v: { pb: {}; mb: 1; }; } +>v : { pb: {}; mb: 1; } +>{ ...M } : { pb: {}; 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: { pb: {}; mb: 1; }; ma: 1; }; } +>module.exports : { v: {}; } +>module : { exports: { v: {}; }; } +>exports : { 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") + 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..433d0bfbb69b5 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=reverse).js @@ -0,0 +1,87 @@ +//// [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: {}; +}; +export = _exports; +//// [mb.d.ts] +export { v as pb } from "./xb"; +export declare const mb = 1; +//// [xa.d.ts] +declare const _exports: { + v: { + pb: {}; + mb: 1; + }; +}; +export = _exports; +//// [ma.d.ts] +export { v as pa } from "./xa"; +export declare const ma = 1; +//// [ia.d.ts] +declare const _exports: { + v: { + pa: { + pb: {}; + mb: 1; + }; + 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..901461cf3d36b --- /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: { 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; }; } +>{ 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") + +=== /ma.js === +export { v as pa } from "./xa"; +>v : { pb: {}; mb: 1; } +>pa : { pb: {}; mb: 1; } + +export const ma = 1; +>ma : 1 +>1 : 1 + +=== /mb.js === +export { v as pb } from "./xb"; +>v : {} +>pb : {} + +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: {}; mb: 1; }; } +>module.exports : { v: { pb: {}; mb: 1; }; } +>module : { exports: { v: { pb: {}; mb: 1; }; }; } +>exports : { v: { pb: {}; mb: 1; }; } +>{ v: { ...M } } : { v: { pb: {}; mb: 1; }; } +>v : { pb: {}; mb: 1; } +>{ ...M } : { pb: {}; 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: { pb: {}; mb: 1; }; ma: 1; }; } +>module.exports : { v: {}; } +>module : { exports: { v: {}; }; } +>exports : { 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") + 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..433d0bfbb69b5 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=typesfirst).js @@ -0,0 +1,87 @@ +//// [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: {}; +}; +export = _exports; +//// [mb.d.ts] +export { v as pb } from "./xb"; +export declare const mb = 1; +//// [xa.d.ts] +declare const _exports: { + v: { + pb: {}; + mb: 1; + }; +}; +export = _exports; +//// [ma.d.ts] +export { v as pa } from "./xa"; +export declare const ma = 1; +//// [ia.d.ts] +declare const _exports: { + v: { + pa: { + pb: {}; + mb: 1; + }; + 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..901461cf3d36b --- /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: { 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; }; } +>{ 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") + +=== /ma.js === +export { v as pa } from "./xa"; +>v : { pb: {}; mb: 1; } +>pa : { pb: {}; mb: 1; } + +export const ma = 1; +>ma : 1 +>1 : 1 + +=== /mb.js === +export { v as pb } from "./xb"; +>v : {} +>pb : {} + +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: {}; mb: 1; }; } +>module.exports : { v: { pb: {}; mb: 1; }; } +>module : { exports: { v: { pb: {}; mb: 1; }; }; } +>exports : { v: { pb: {}; mb: 1; }; } +>{ v: { ...M } } : { v: { pb: {}; mb: 1; }; } +>v : { pb: {}; mb: 1; } +>{ ...M } : { pb: {}; 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: { pb: {}; mb: 1; }; ma: 1; }; } +>module.exports : { v: {}; } +>module : { exports: { v: {}; }; } +>exports : { 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") + 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..735d4e676a17d --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderStableInstantiationErrors(checkorder=default).errors.txt @@ -0,0 +1,35 @@ +a.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 (1 errors) ==== + import { Recur } from "./lib"; + export let a: Recur<5, "a">; + ~~~~~~~~~~~~~ +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. + +==== b.ts (0 errors) ==== + import { Recur } from "./lib"; + export let b: Recur<5, "a">; + +==== 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..6e370b78d30f9 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderStableInstantiationErrors(checkorder=reverse).errors.txt @@ -0,0 +1,35 @@ +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 (0 errors) ==== + import { Recur } from "./lib"; + export let a: Recur<5, "a">; + +==== b.ts (1 errors) ==== + import { Recur } from "./lib"; + export let b: Recur<5, "a">; + ~~~~~~~~~~~~~ +!!! 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..9b99a0b62969b --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/checkOrderStableInstantiationErrors(checkorder=typesfirst).errors.txt @@ -0,0 +1,34 @@ +error TS2589: Type instantiation is excessively deep and possibly infinite. + + +!!! 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 (0 errors) ==== + import { Recur } from "./lib"; + export let a: Recur<5, "a">; + +==== b.ts (0 errors) ==== + import { Recur } from "./lib"; + export let b: Recur<5, "a">; + +==== 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..e6b4d1fca90ca --- /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: any; } + + get foo(): typeof c1.foo; +>foo : any +>c1.foo : any +>c1 : { readonly foo: any; } +>foo : any +} + +declare const c2: { +>c2 : { foo: any; } + + set foo(value: typeof c2.foo); +>foo : any +>value : any +>c2.foo : any +>c2 : { foo: any; } +>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..3322a7ea25b66 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/circularIndexedPropertyInstantiation.errors.txt @@ -0,0 +1,14 @@ +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 (2 errors) ==== + // Repro from #14837 + + type Foo = { "true": Foo> }[T]; + let f1: Foo<"true", {}>; + ~~~~~~~~~~~~~~~ +!!! 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..8d568d19a5373 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/circularInlineMappedGenericTupleTypeNoCrash(checkorder=default).errors.txt @@ -0,0 +1,20 @@ +circularInlineMappedGenericTupleTypeNoCrash.ts(11,12): error TS2589: Type instantiation is excessively deep and possibly infinite. + + +==== circularInlineMappedGenericTupleTypeNoCrash.ts (1 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. + } + } + \ 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..e78f397fc931f --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/circularInlineMappedGenericTupleTypeNoCrash(checkorder=typesfirst).errors.txt @@ -0,0 +1,19 @@ +error TS2589: Type instantiation is excessively deep and possibly infinite. + + +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. +==== circularInlineMappedGenericTupleTypeNoCrash.ts (0 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" }); + } + } + \ 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..f0b2f978c0228 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/circularReturnTypeSubtypeReductionOrder.errors.txt @@ -0,0 +1,50 @@ +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 '() => () => A | A' is not assignable to type 'A'. + + +==== expression.ts (1 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 '() => () => A | A' is not assignable to type 'A'. + rebuild() { + return flag ? this : new A(); + } + b() { + return this.rebuild(); + } + c() { + return this.rebuild; + } + }; + export {}; + +==== declaration.ts (0 errors) ==== + 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 {}; + \ 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..9088517456379 --- /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 : () => this | A + + return flag ? this : new A(); +>flag ? this : new A() : this | A +>flag : boolean +>this : this +>new A() : A +>A : new () => A + } + b() { +>b : () => this | A + + return this.rebuild(); +>this.rebuild() : this | A +>this.rebuild : () => this | A +>this : this +>rebuild : () => this | A + } + c() { +>c : () => () => this | A + + return this.rebuild; +>this.rebuild : () => this | A +>this : this +>rebuild : () => this | A + } +}; +export {}; + +=== declaration.ts === +interface B { + b(): B; +>b : () => B +} +declare const flag: boolean; +>flag : boolean + +class K { +>K : K + + rebuild() { +>rebuild : () => this | B + + return flag ? this : new B(); +>flag ? this : new B() : this | B +>flag : boolean +>this : this +>new B() : B +>B : new () => B + } + b() { +>b : () => this | B + + return this.rebuild(); +>this.rebuild() : this | B +>this.rebuild : () => this | B +>this : this +>rebuild : () => this | B + } +} +const B: new () => B = K; +>B : new () => B +>K : typeof K + +export {}; + diff --git a/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallArgumentRelation(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallArgumentRelation(checkorder=default).symbols new file mode 100644 index 0000000000000..c320ee58e23b7 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallArgumentRelation(checkorder=default).symbols @@ -0,0 +1,106 @@ +//// [tests/cases/compiler/circularReturnTypeThroughCallArgumentRelation.ts] //// + +=== circularReturnTypeThroughCallArgumentRelation.ts === +// Inferring a method's return type resolves a call whose argument check +// relates the method's own class to an interface containing that method, so +// the relation compares the method while its return type is in progress. +// TypeScript reads the in-progress return type as `any` there without failing +// it, and call resolution hides the resolutions below it, so no TS7023 is +// reported in any check order and the method gets the call's return type. +// (Reduced from meta/lexical HeadingNode.$config and effect SchemaAST getParser.) + +// Through a callback returning an instance (lexical). +interface Base { m(): unknown } +>Base : Symbol(Base, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 0, 0)) +>m : Symbol(Base.m, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 9, 16)) + +declare function config(config: { f?: () => Base }): void; +>config : Symbol(config, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 9, 31)) +>config : Symbol(config, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 10, 24)) +>f : Symbol(f, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 10, 33)) +>Base : Symbol(Base, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 0, 0)) + +declare const h: Heading; +>h : Symbol(h, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 12, 13)) +>Heading : Symbol(Heading, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 13, 18)) + +const b: Base = h; +>b : Symbol(b, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 13, 5)) +>Base : Symbol(Base, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 0, 0)) +>h : Symbol(h, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 12, 13)) + +class Heading { +>Heading : Symbol(Heading, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 13, 18)) + + m() { +>m : Symbol(Heading.m, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 15, 15)) + + return config({ f: () => create() }); +>config : Symbol(config, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 9, 31)) +>f : Symbol(f, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 17, 23)) +>create : Symbol(create, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 19, 1)) + } +} + +declare function create(): Heading; +>create : Symbol(create, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 19, 1)) +>Heading : Symbol(Heading, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 13, 18)) + +const r: void = new Heading().m(); +>r : Symbol(r, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 23, 5)) +>new Heading().m : Symbol(Heading.m, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 15, 15)) +>Heading : Symbol(Heading, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 13, 18)) +>m : Symbol(Heading.m, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 15, 15)) + +// Passing `this` directly (effect). +type Parser = (input: unknown) => unknown; +>Parser : Symbol(Parser, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 23, 34)) +>input : Symbol(input, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 26, 15)) + +interface NullNode { readonly _tag: "Null"; getParser(): Parser } +>NullNode : Symbol(NullNode, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 26, 42), Decl(circularReturnTypeThroughCallArgumentRelation.ts, 32, 5)) +>_tag : Symbol(NullNode._tag, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 27, 20)) +>getParser : Symbol(NullNode.getParser, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 27, 43)) +>Parser : Symbol(Parser, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 23, 34)) + +interface UndefinedNode { readonly _tag: "Undefined"; getParser(): Parser } +>UndefinedNode : Symbol(UndefinedNode, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 27, 65)) +>_tag : Symbol(UndefinedNode._tag, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 28, 25)) +>getParser : Symbol(UndefinedNode.getParser, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 28, 53)) +>Parser : Symbol(Parser, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 23, 34)) + +type AST = NullNode | UndefinedNode; +>AST : Symbol(AST, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 28, 75)) +>NullNode : Symbol(NullNode, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 26, 42), Decl(circularReturnTypeThroughCallArgumentRelation.ts, 32, 5)) +>UndefinedNode : Symbol(UndefinedNode, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 27, 65)) + +declare function fromConst(ast: AST, value: unknown): Parser; +>fromConst : Symbol(fromConst, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 29, 36)) +>ast : Symbol(ast, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 30, 27)) +>AST : Symbol(AST, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 28, 75)) +>value : Symbol(value, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 30, 36)) +>Parser : Symbol(Parser, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 23, 34)) + +const NullNode: new () => NullNode = class { +>NullNode : Symbol(NullNode, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 26, 42), Decl(circularReturnTypeThroughCallArgumentRelation.ts, 32, 5)) +>NullNode : Symbol(NullNode, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 26, 42), Decl(circularReturnTypeThroughCallArgumentRelation.ts, 32, 5)) + + readonly _tag = "Null"; +>_tag : Symbol(NullNode._tag, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 32, 44)) + + getParser() { +>getParser : Symbol(NullNode.getParser, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 33, 27)) + + return fromConst(this, null); +>fromConst : Symbol(fromConst, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 29, 36)) +>this : Symbol(NullNode, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 32, 36)) + } +}; + +const p: Parser = new NullNode().getParser(); +>p : Symbol(p, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 39, 5)) +>Parser : Symbol(Parser, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 23, 34)) +>new NullNode().getParser : Symbol(NullNode.getParser, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 27, 43)) +>NullNode : Symbol(NullNode, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 26, 42), Decl(circularReturnTypeThroughCallArgumentRelation.ts, 32, 5)) +>getParser : Symbol(NullNode.getParser, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 27, 43)) + diff --git a/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallArgumentRelation(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallArgumentRelation(checkorder=default).types new file mode 100644 index 0000000000000..21a3ba0434560 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallArgumentRelation(checkorder=default).types @@ -0,0 +1,102 @@ +//// [tests/cases/compiler/circularReturnTypeThroughCallArgumentRelation.ts] //// + +=== circularReturnTypeThroughCallArgumentRelation.ts === +// Inferring a method's return type resolves a call whose argument check +// relates the method's own class to an interface containing that method, so +// the relation compares the method while its return type is in progress. +// TypeScript reads the in-progress return type as `any` there without failing +// it, and call resolution hides the resolutions below it, so no TS7023 is +// reported in any check order and the method gets the call's return type. +// (Reduced from meta/lexical HeadingNode.$config and effect SchemaAST getParser.) + +// Through a callback returning an instance (lexical). +interface Base { m(): unknown } +>m : () => unknown + +declare function config(config: { f?: () => Base }): void; +>config : (config: { f?: () => Base; }) => void +>config : { f?: () => Base; } +>f : (() => Base) | undefined + +declare const h: Heading; +>h : Heading + +const b: Base = h; +>b : Base +>h : Heading + +class Heading { +>Heading : Heading + + m() { +>m : () => void + + return config({ f: () => create() }); +>config({ f: () => create() }) : void +>config : (config: { f?: () => Base; }) => void +>{ f: () => create() } : { f: () => Heading; } +>f : () => Heading +>() => create() : () => Heading +>create() : Heading +>create : () => Heading + } +} + +declare function create(): Heading; +>create : () => Heading + +const r: void = new Heading().m(); +>r : void +>new Heading().m() : void +>new Heading().m : () => void +>new Heading() : Heading +>Heading : typeof Heading +>m : () => void + +// Passing `this` directly (effect). +type Parser = (input: unknown) => unknown; +>Parser : Parser +>input : unknown + +interface NullNode { readonly _tag: "Null"; getParser(): Parser } +>_tag : "Null" +>getParser : () => Parser + +interface UndefinedNode { readonly _tag: "Undefined"; getParser(): Parser } +>_tag : "Undefined" +>getParser : () => Parser + +type AST = NullNode | UndefinedNode; +>AST : AST + +declare function fromConst(ast: AST, value: unknown): Parser; +>fromConst : (ast: AST, value: unknown) => Parser +>ast : AST +>value : unknown + +const NullNode: new () => NullNode = class { +>NullNode : new () => NullNode +>class { readonly _tag = "Null"; getParser() { return fromConst(this, null); }} : typeof NullNode + + readonly _tag = "Null"; +>_tag : "Null" +>"Null" : "Null" + + getParser() { +>getParser : () => Parser + + return fromConst(this, null); +>fromConst(this, null) : Parser +>fromConst : (ast: AST, value: unknown) => Parser +>this : this + } +}; + +const p: Parser = new NullNode().getParser(); +>p : Parser +>new NullNode().getParser() : Parser +>new NullNode().getParser : () => Parser +>new NullNode() : NullNode +>NullNode : new () => NullNode +>getParser : () => Parser + diff --git a/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallArgumentRelation(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallArgumentRelation(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..c320ee58e23b7 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallArgumentRelation(checkorder=typesfirst).symbols @@ -0,0 +1,106 @@ +//// [tests/cases/compiler/circularReturnTypeThroughCallArgumentRelation.ts] //// + +=== circularReturnTypeThroughCallArgumentRelation.ts === +// Inferring a method's return type resolves a call whose argument check +// relates the method's own class to an interface containing that method, so +// the relation compares the method while its return type is in progress. +// TypeScript reads the in-progress return type as `any` there without failing +// it, and call resolution hides the resolutions below it, so no TS7023 is +// reported in any check order and the method gets the call's return type. +// (Reduced from meta/lexical HeadingNode.$config and effect SchemaAST getParser.) + +// Through a callback returning an instance (lexical). +interface Base { m(): unknown } +>Base : Symbol(Base, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 0, 0)) +>m : Symbol(Base.m, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 9, 16)) + +declare function config(config: { f?: () => Base }): void; +>config : Symbol(config, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 9, 31)) +>config : Symbol(config, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 10, 24)) +>f : Symbol(f, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 10, 33)) +>Base : Symbol(Base, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 0, 0)) + +declare const h: Heading; +>h : Symbol(h, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 12, 13)) +>Heading : Symbol(Heading, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 13, 18)) + +const b: Base = h; +>b : Symbol(b, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 13, 5)) +>Base : Symbol(Base, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 0, 0)) +>h : Symbol(h, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 12, 13)) + +class Heading { +>Heading : Symbol(Heading, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 13, 18)) + + m() { +>m : Symbol(Heading.m, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 15, 15)) + + return config({ f: () => create() }); +>config : Symbol(config, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 9, 31)) +>f : Symbol(f, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 17, 23)) +>create : Symbol(create, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 19, 1)) + } +} + +declare function create(): Heading; +>create : Symbol(create, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 19, 1)) +>Heading : Symbol(Heading, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 13, 18)) + +const r: void = new Heading().m(); +>r : Symbol(r, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 23, 5)) +>new Heading().m : Symbol(Heading.m, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 15, 15)) +>Heading : Symbol(Heading, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 13, 18)) +>m : Symbol(Heading.m, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 15, 15)) + +// Passing `this` directly (effect). +type Parser = (input: unknown) => unknown; +>Parser : Symbol(Parser, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 23, 34)) +>input : Symbol(input, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 26, 15)) + +interface NullNode { readonly _tag: "Null"; getParser(): Parser } +>NullNode : Symbol(NullNode, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 26, 42), Decl(circularReturnTypeThroughCallArgumentRelation.ts, 32, 5)) +>_tag : Symbol(NullNode._tag, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 27, 20)) +>getParser : Symbol(NullNode.getParser, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 27, 43)) +>Parser : Symbol(Parser, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 23, 34)) + +interface UndefinedNode { readonly _tag: "Undefined"; getParser(): Parser } +>UndefinedNode : Symbol(UndefinedNode, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 27, 65)) +>_tag : Symbol(UndefinedNode._tag, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 28, 25)) +>getParser : Symbol(UndefinedNode.getParser, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 28, 53)) +>Parser : Symbol(Parser, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 23, 34)) + +type AST = NullNode | UndefinedNode; +>AST : Symbol(AST, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 28, 75)) +>NullNode : Symbol(NullNode, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 26, 42), Decl(circularReturnTypeThroughCallArgumentRelation.ts, 32, 5)) +>UndefinedNode : Symbol(UndefinedNode, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 27, 65)) + +declare function fromConst(ast: AST, value: unknown): Parser; +>fromConst : Symbol(fromConst, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 29, 36)) +>ast : Symbol(ast, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 30, 27)) +>AST : Symbol(AST, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 28, 75)) +>value : Symbol(value, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 30, 36)) +>Parser : Symbol(Parser, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 23, 34)) + +const NullNode: new () => NullNode = class { +>NullNode : Symbol(NullNode, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 26, 42), Decl(circularReturnTypeThroughCallArgumentRelation.ts, 32, 5)) +>NullNode : Symbol(NullNode, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 26, 42), Decl(circularReturnTypeThroughCallArgumentRelation.ts, 32, 5)) + + readonly _tag = "Null"; +>_tag : Symbol(NullNode._tag, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 32, 44)) + + getParser() { +>getParser : Symbol(NullNode.getParser, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 33, 27)) + + return fromConst(this, null); +>fromConst : Symbol(fromConst, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 29, 36)) +>this : Symbol(NullNode, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 32, 36)) + } +}; + +const p: Parser = new NullNode().getParser(); +>p : Symbol(p, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 39, 5)) +>Parser : Symbol(Parser, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 23, 34)) +>new NullNode().getParser : Symbol(NullNode.getParser, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 27, 43)) +>NullNode : Symbol(NullNode, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 26, 42), Decl(circularReturnTypeThroughCallArgumentRelation.ts, 32, 5)) +>getParser : Symbol(NullNode.getParser, Decl(circularReturnTypeThroughCallArgumentRelation.ts, 27, 43)) + diff --git a/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallArgumentRelation(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallArgumentRelation(checkorder=typesfirst).types new file mode 100644 index 0000000000000..21a3ba0434560 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallArgumentRelation(checkorder=typesfirst).types @@ -0,0 +1,102 @@ +//// [tests/cases/compiler/circularReturnTypeThroughCallArgumentRelation.ts] //// + +=== circularReturnTypeThroughCallArgumentRelation.ts === +// Inferring a method's return type resolves a call whose argument check +// relates the method's own class to an interface containing that method, so +// the relation compares the method while its return type is in progress. +// TypeScript reads the in-progress return type as `any` there without failing +// it, and call resolution hides the resolutions below it, so no TS7023 is +// reported in any check order and the method gets the call's return type. +// (Reduced from meta/lexical HeadingNode.$config and effect SchemaAST getParser.) + +// Through a callback returning an instance (lexical). +interface Base { m(): unknown } +>m : () => unknown + +declare function config(config: { f?: () => Base }): void; +>config : (config: { f?: () => Base; }) => void +>config : { f?: () => Base; } +>f : (() => Base) | undefined + +declare const h: Heading; +>h : Heading + +const b: Base = h; +>b : Base +>h : Heading + +class Heading { +>Heading : Heading + + m() { +>m : () => void + + return config({ f: () => create() }); +>config({ f: () => create() }) : void +>config : (config: { f?: () => Base; }) => void +>{ f: () => create() } : { f: () => Heading; } +>f : () => Heading +>() => create() : () => Heading +>create() : Heading +>create : () => Heading + } +} + +declare function create(): Heading; +>create : () => Heading + +const r: void = new Heading().m(); +>r : void +>new Heading().m() : void +>new Heading().m : () => void +>new Heading() : Heading +>Heading : typeof Heading +>m : () => void + +// Passing `this` directly (effect). +type Parser = (input: unknown) => unknown; +>Parser : Parser +>input : unknown + +interface NullNode { readonly _tag: "Null"; getParser(): Parser } +>_tag : "Null" +>getParser : () => Parser + +interface UndefinedNode { readonly _tag: "Undefined"; getParser(): Parser } +>_tag : "Undefined" +>getParser : () => Parser + +type AST = NullNode | UndefinedNode; +>AST : AST + +declare function fromConst(ast: AST, value: unknown): Parser; +>fromConst : (ast: AST, value: unknown) => Parser +>ast : AST +>value : unknown + +const NullNode: new () => NullNode = class { +>NullNode : new () => NullNode +>class { readonly _tag = "Null"; getParser() { return fromConst(this, null); }} : typeof NullNode + + readonly _tag = "Null"; +>_tag : "Null" +>"Null" : "Null" + + getParser() { +>getParser : () => Parser + + return fromConst(this, null); +>fromConst(this, null) : Parser +>fromConst : (ast: AST, value: unknown) => Parser +>this : this + } +}; + +const p: Parser = new NullNode().getParser(); +>p : Parser +>new NullNode().getParser() : Parser +>new NullNode().getParser : () => Parser +>new NullNode() : NullNode +>NullNode : new () => NullNode +>getParser : () => Parser + diff --git a/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallbackArgument(strict=false).symbols b/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallbackArgument(strict=false).symbols new file mode 100644 index 0000000000000..6db3b443be191 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallbackArgument(strict=false).symbols @@ -0,0 +1,77 @@ +//// [tests/cases/compiler/circularReturnTypeThroughCallbackArgument.ts] //// + +=== circularReturnTypeThroughCallbackArgument.ts === +declare function fan(g: () => number): number; +>fan : Symbol(fan, Decl(circularReturnTypeThroughCallbackArgument.ts, 0, 0)) +>g : Symbol(g, Decl(circularReturnTypeThroughCallbackArgument.ts, 0, 21)) + +export function a(n: number) { +>a : Symbol(a, Decl(circularReturnTypeThroughCallbackArgument.ts, 0, 46)) +>n : Symbol(n, Decl(circularReturnTypeThroughCallbackArgument.ts, 2, 18)) + + return fan(() => a(n)); +>fan : Symbol(fan, Decl(circularReturnTypeThroughCallbackArgument.ts, 0, 0)) +>a : Symbol(a, Decl(circularReturnTypeThroughCallbackArgument.ts, 0, 46)) +>n : Symbol(n, Decl(circularReturnTypeThroughCallbackArgument.ts, 2, 18)) +} + +declare function fanAll(g: () => Promise<{ ok: boolean }>): Promise<{ ok: boolean }>; +>fanAll : Symbol(fanAll, Decl(circularReturnTypeThroughCallbackArgument.ts, 4, 1)) +>g : Symbol(g, Decl(circularReturnTypeThroughCallbackArgument.ts, 6, 24)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2018.promise.d.ts, --, --)) +>ok : Symbol(ok, Decl(circularReturnTypeThroughCallbackArgument.ts, 6, 42)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2018.promise.d.ts, --, --)) +>ok : Symbol(ok, Decl(circularReturnTypeThroughCallbackArgument.ts, 6, 69)) + +export async function b(n: number) { +>b : Symbol(b, Decl(circularReturnTypeThroughCallbackArgument.ts, 6, 85)) +>n : Symbol(n, Decl(circularReturnTypeThroughCallbackArgument.ts, 8, 24)) + + if (n > 0) { +>n : Symbol(n, Decl(circularReturnTypeThroughCallbackArgument.ts, 8, 24)) + + return fanAll(() => b(n - 1)); +>fanAll : Symbol(fanAll, Decl(circularReturnTypeThroughCallbackArgument.ts, 4, 1)) +>b : Symbol(b, Decl(circularReturnTypeThroughCallbackArgument.ts, 6, 85)) +>n : Symbol(n, Decl(circularReturnTypeThroughCallbackArgument.ts, 8, 24)) + } + return { ok: true }; +>ok : Symbol(ok, Decl(circularReturnTypeThroughCallbackArgument.ts, 12, 12)) +} + +type Result = { success: boolean; [key: string]: unknown }; +>Result : Symbol(Result, Decl(circularReturnTypeThroughCallbackArgument.ts, 13, 1)) +>success : Symbol(success, Decl(circularReturnTypeThroughCallbackArgument.ts, 15, 15)) +>key : Symbol(key, Decl(circularReturnTypeThroughCallbackArgument.ts, 15, 35)) + +interface Other { success: boolean; url: string } +>Other : Symbol(Other, Decl(circularReturnTypeThroughCallbackArgument.ts, 15, 59)) +>success : Symbol(Other.success, Decl(circularReturnTypeThroughCallbackArgument.ts, 16, 17)) +>url : Symbol(Other.url, Decl(circularReturnTypeThroughCallbackArgument.ts, 16, 35)) + +declare function fanOut(generateOne: () => Promise): Promise; +>fanOut : Symbol(fanOut, Decl(circularReturnTypeThroughCallbackArgument.ts, 16, 49)) +>generateOne : Symbol(generateOne, Decl(circularReturnTypeThroughCallbackArgument.ts, 17, 24)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2018.promise.d.ts, --, --)) +>Result : Symbol(Result, Decl(circularReturnTypeThroughCallbackArgument.ts, 13, 1)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2018.promise.d.ts, --, --)) +>Result : Symbol(Result, Decl(circularReturnTypeThroughCallbackArgument.ts, 13, 1)) + +declare const other: Other; +>other : Symbol(other, Decl(circularReturnTypeThroughCallbackArgument.ts, 18, 13)) +>Other : Symbol(Other, Decl(circularReturnTypeThroughCallbackArgument.ts, 15, 59)) + +export async function c(n: number) { +>c : Symbol(c, Decl(circularReturnTypeThroughCallbackArgument.ts, 18, 27)) +>n : Symbol(n, Decl(circularReturnTypeThroughCallbackArgument.ts, 20, 24)) + + if (n) return other; +>n : Symbol(n, Decl(circularReturnTypeThroughCallbackArgument.ts, 20, 24)) +>other : Symbol(other, Decl(circularReturnTypeThroughCallbackArgument.ts, 18, 13)) + + return fanOut(() => c(n - 1)); +>fanOut : Symbol(fanOut, Decl(circularReturnTypeThroughCallbackArgument.ts, 16, 49)) +>c : Symbol(c, Decl(circularReturnTypeThroughCallbackArgument.ts, 18, 27)) +>n : Symbol(n, Decl(circularReturnTypeThroughCallbackArgument.ts, 20, 24)) +} + diff --git a/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallbackArgument(strict=false).types b/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallbackArgument(strict=false).types new file mode 100644 index 0000000000000..fb9e85bf2b1d7 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallbackArgument(strict=false).types @@ -0,0 +1,86 @@ +//// [tests/cases/compiler/circularReturnTypeThroughCallbackArgument.ts] //// + +=== circularReturnTypeThroughCallbackArgument.ts === +declare function fan(g: () => number): number; +>fan : (g: () => number) => number +>g : () => number + +export function a(n: number) { +>a : (n: number) => any +>n : number + + return fan(() => a(n)); +>fan(() => a(n)) : number +>fan : (g: () => number) => number +>() => a(n) : () => any +>a(n) : any +>a : (n: number) => any +>n : number +} + +declare function fanAll(g: () => Promise<{ ok: boolean }>): Promise<{ ok: boolean }>; +>fanAll : (g: () => Promise<{ ok: boolean; }>) => Promise<{ ok: boolean; }> +>g : () => Promise<{ ok: boolean; }> +>ok : boolean +>ok : boolean + +export async function b(n: number) { +>b : (n: number) => any +>n : number + + if (n > 0) { +>n > 0 : boolean +>n : number +>0 : 0 + + return fanAll(() => b(n - 1)); +>fanAll(() => b(n - 1)) : Promise<{ ok: boolean; }> +>fanAll : (g: () => Promise<{ ok: boolean; }>) => Promise<{ ok: boolean; }> +>() => b(n - 1) : () => any +>b(n - 1) : any +>b : (n: number) => any +>n - 1 : number +>n : number +>1 : 1 + } + return { ok: true }; +>{ ok: true } : { ok: boolean; } +>ok : boolean +>true : true +} + +type Result = { success: boolean; [key: string]: unknown }; +>Result : Result +>success : boolean +>key : string + +interface Other { success: boolean; url: string } +>success : boolean +>url : string + +declare function fanOut(generateOne: () => Promise): Promise; +>fanOut : (generateOne: () => Promise) => Promise +>generateOne : () => Promise + +declare const other: Other; +>other : Other + +export async function c(n: number) { +>c : (n: number) => any +>n : number + + if (n) return other; +>n : number +>other : Other + + return fanOut(() => c(n - 1)); +>fanOut(() => c(n - 1)) : Promise +>fanOut : (generateOne: () => Promise) => Promise +>() => c(n - 1) : () => any +>c(n - 1) : any +>c : (n: number) => any +>n - 1 : number +>n : number +>1 : 1 +} + diff --git a/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallbackArgument(strict=true).errors.txt b/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallbackArgument(strict=true).errors.txt new file mode 100644 index 0000000000000..a10fc6bcbe59c --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallbackArgument(strict=true).errors.txt @@ -0,0 +1,46 @@ +circularReturnTypeThroughCallbackArgument.ts(3,17): error TS7023: 'a' implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions. +circularReturnTypeThroughCallbackArgument.ts(4,16): error TS7024: Function implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions. +circularReturnTypeThroughCallbackArgument.ts(9,23): error TS7023: 'b' implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions. +circularReturnTypeThroughCallbackArgument.ts(11,23): error TS7024: Function implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions. +circularReturnTypeThroughCallbackArgument.ts(21,23): error TS7023: 'c' implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions. +circularReturnTypeThroughCallbackArgument.ts(23,19): error TS7024: Function implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions. + + +==== circularReturnTypeThroughCallbackArgument.ts (6 errors) ==== + declare function fan(g: () => number): number; + + export function a(n: number) { + ~ +!!! error TS7023: 'a' implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions. + return fan(() => a(n)); + ~~~~~~~~~~ +!!! error TS7024: Function implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions. + } + + declare function fanAll(g: () => Promise<{ ok: boolean }>): Promise<{ ok: boolean }>; + + export async function b(n: number) { + ~ +!!! error TS7023: 'b' implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions. + if (n > 0) { + return fanAll(() => b(n - 1)); + ~~~~~~~~~~~~~~ +!!! error TS7024: Function implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions. + } + return { ok: true }; + } + + type Result = { success: boolean; [key: string]: unknown }; + interface Other { success: boolean; url: string } + declare function fanOut(generateOne: () => Promise): Promise; + declare const other: Other; + + export async function c(n: number) { + ~ +!!! error TS7023: 'c' implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions. + if (n) return other; + return fanOut(() => c(n - 1)); + ~~~~~~~~~~~~~~ +!!! error TS7024: Function implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions. + } + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallbackArgument(strict=true).symbols b/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallbackArgument(strict=true).symbols new file mode 100644 index 0000000000000..6db3b443be191 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallbackArgument(strict=true).symbols @@ -0,0 +1,77 @@ +//// [tests/cases/compiler/circularReturnTypeThroughCallbackArgument.ts] //// + +=== circularReturnTypeThroughCallbackArgument.ts === +declare function fan(g: () => number): number; +>fan : Symbol(fan, Decl(circularReturnTypeThroughCallbackArgument.ts, 0, 0)) +>g : Symbol(g, Decl(circularReturnTypeThroughCallbackArgument.ts, 0, 21)) + +export function a(n: number) { +>a : Symbol(a, Decl(circularReturnTypeThroughCallbackArgument.ts, 0, 46)) +>n : Symbol(n, Decl(circularReturnTypeThroughCallbackArgument.ts, 2, 18)) + + return fan(() => a(n)); +>fan : Symbol(fan, Decl(circularReturnTypeThroughCallbackArgument.ts, 0, 0)) +>a : Symbol(a, Decl(circularReturnTypeThroughCallbackArgument.ts, 0, 46)) +>n : Symbol(n, Decl(circularReturnTypeThroughCallbackArgument.ts, 2, 18)) +} + +declare function fanAll(g: () => Promise<{ ok: boolean }>): Promise<{ ok: boolean }>; +>fanAll : Symbol(fanAll, Decl(circularReturnTypeThroughCallbackArgument.ts, 4, 1)) +>g : Symbol(g, Decl(circularReturnTypeThroughCallbackArgument.ts, 6, 24)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2018.promise.d.ts, --, --)) +>ok : Symbol(ok, Decl(circularReturnTypeThroughCallbackArgument.ts, 6, 42)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2018.promise.d.ts, --, --)) +>ok : Symbol(ok, Decl(circularReturnTypeThroughCallbackArgument.ts, 6, 69)) + +export async function b(n: number) { +>b : Symbol(b, Decl(circularReturnTypeThroughCallbackArgument.ts, 6, 85)) +>n : Symbol(n, Decl(circularReturnTypeThroughCallbackArgument.ts, 8, 24)) + + if (n > 0) { +>n : Symbol(n, Decl(circularReturnTypeThroughCallbackArgument.ts, 8, 24)) + + return fanAll(() => b(n - 1)); +>fanAll : Symbol(fanAll, Decl(circularReturnTypeThroughCallbackArgument.ts, 4, 1)) +>b : Symbol(b, Decl(circularReturnTypeThroughCallbackArgument.ts, 6, 85)) +>n : Symbol(n, Decl(circularReturnTypeThroughCallbackArgument.ts, 8, 24)) + } + return { ok: true }; +>ok : Symbol(ok, Decl(circularReturnTypeThroughCallbackArgument.ts, 12, 12)) +} + +type Result = { success: boolean; [key: string]: unknown }; +>Result : Symbol(Result, Decl(circularReturnTypeThroughCallbackArgument.ts, 13, 1)) +>success : Symbol(success, Decl(circularReturnTypeThroughCallbackArgument.ts, 15, 15)) +>key : Symbol(key, Decl(circularReturnTypeThroughCallbackArgument.ts, 15, 35)) + +interface Other { success: boolean; url: string } +>Other : Symbol(Other, Decl(circularReturnTypeThroughCallbackArgument.ts, 15, 59)) +>success : Symbol(Other.success, Decl(circularReturnTypeThroughCallbackArgument.ts, 16, 17)) +>url : Symbol(Other.url, Decl(circularReturnTypeThroughCallbackArgument.ts, 16, 35)) + +declare function fanOut(generateOne: () => Promise): Promise; +>fanOut : Symbol(fanOut, Decl(circularReturnTypeThroughCallbackArgument.ts, 16, 49)) +>generateOne : Symbol(generateOne, Decl(circularReturnTypeThroughCallbackArgument.ts, 17, 24)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2018.promise.d.ts, --, --)) +>Result : Symbol(Result, Decl(circularReturnTypeThroughCallbackArgument.ts, 13, 1)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2018.promise.d.ts, --, --)) +>Result : Symbol(Result, Decl(circularReturnTypeThroughCallbackArgument.ts, 13, 1)) + +declare const other: Other; +>other : Symbol(other, Decl(circularReturnTypeThroughCallbackArgument.ts, 18, 13)) +>Other : Symbol(Other, Decl(circularReturnTypeThroughCallbackArgument.ts, 15, 59)) + +export async function c(n: number) { +>c : Symbol(c, Decl(circularReturnTypeThroughCallbackArgument.ts, 18, 27)) +>n : Symbol(n, Decl(circularReturnTypeThroughCallbackArgument.ts, 20, 24)) + + if (n) return other; +>n : Symbol(n, Decl(circularReturnTypeThroughCallbackArgument.ts, 20, 24)) +>other : Symbol(other, Decl(circularReturnTypeThroughCallbackArgument.ts, 18, 13)) + + return fanOut(() => c(n - 1)); +>fanOut : Symbol(fanOut, Decl(circularReturnTypeThroughCallbackArgument.ts, 16, 49)) +>c : Symbol(c, Decl(circularReturnTypeThroughCallbackArgument.ts, 18, 27)) +>n : Symbol(n, Decl(circularReturnTypeThroughCallbackArgument.ts, 20, 24)) +} + diff --git a/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallbackArgument(strict=true).types b/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallbackArgument(strict=true).types new file mode 100644 index 0000000000000..fb9e85bf2b1d7 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallbackArgument(strict=true).types @@ -0,0 +1,86 @@ +//// [tests/cases/compiler/circularReturnTypeThroughCallbackArgument.ts] //// + +=== circularReturnTypeThroughCallbackArgument.ts === +declare function fan(g: () => number): number; +>fan : (g: () => number) => number +>g : () => number + +export function a(n: number) { +>a : (n: number) => any +>n : number + + return fan(() => a(n)); +>fan(() => a(n)) : number +>fan : (g: () => number) => number +>() => a(n) : () => any +>a(n) : any +>a : (n: number) => any +>n : number +} + +declare function fanAll(g: () => Promise<{ ok: boolean }>): Promise<{ ok: boolean }>; +>fanAll : (g: () => Promise<{ ok: boolean; }>) => Promise<{ ok: boolean; }> +>g : () => Promise<{ ok: boolean; }> +>ok : boolean +>ok : boolean + +export async function b(n: number) { +>b : (n: number) => any +>n : number + + if (n > 0) { +>n > 0 : boolean +>n : number +>0 : 0 + + return fanAll(() => b(n - 1)); +>fanAll(() => b(n - 1)) : Promise<{ ok: boolean; }> +>fanAll : (g: () => Promise<{ ok: boolean; }>) => Promise<{ ok: boolean; }> +>() => b(n - 1) : () => any +>b(n - 1) : any +>b : (n: number) => any +>n - 1 : number +>n : number +>1 : 1 + } + return { ok: true }; +>{ ok: true } : { ok: boolean; } +>ok : boolean +>true : true +} + +type Result = { success: boolean; [key: string]: unknown }; +>Result : Result +>success : boolean +>key : string + +interface Other { success: boolean; url: string } +>success : boolean +>url : string + +declare function fanOut(generateOne: () => Promise): Promise; +>fanOut : (generateOne: () => Promise) => Promise +>generateOne : () => Promise + +declare const other: Other; +>other : Other + +export async function c(n: number) { +>c : (n: number) => any +>n : number + + if (n) return other; +>n : number +>other : Other + + return fanOut(() => c(n - 1)); +>fanOut(() => c(n - 1)) : Promise +>fanOut : (generateOne: () => Promise) => Promise +>() => c(n - 1) : () => any +>c(n - 1) : any +>c : (n: number) => any +>n - 1 : number +>n : number +>1 : 1 +} + diff --git a/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughUncontextualCallbackArgument(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughUncontextualCallbackArgument(checkorder=default).symbols new file mode 100644 index 0000000000000..f53077d24860e --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughUncontextualCallbackArgument(checkorder=default).symbols @@ -0,0 +1,38 @@ +//// [tests/cases/compiler/circularReturnTypeThroughUncontextualCallbackArgument.ts] //// + +=== circularReturnTypeThroughUncontextualCallbackArgument.ts === +// `getCreds`'s return type depends on resolving `materialize({ next })`, whose +// argument check needs the return type of the (non-contextually typed) arrow +// `next`, which calls `getCreds` again. TypeScript never reports this cycle in +// any order: call resolution hides the resolutions below it, and the relation +// reads an in-progress return type as `any` without failing it. So no TS7023, +// and `getCreds` returns `number`. (Reduced from OmniRoute auth.ts +// getProviderCredentials/selectNextLeaseCandidate.) + +const x = getCreds(); +>x : Symbol(x, Decl(circularReturnTypeThroughUncontextualCallbackArgument.ts, 8, 5)) +>getCreds : Symbol(getCreds, Decl(circularReturnTypeThroughUncontextualCallbackArgument.ts, 10, 80)) + +declare function materialize(extra: { next?: (id: string) => unknown }): number; +>materialize : Symbol(materialize, Decl(circularReturnTypeThroughUncontextualCallbackArgument.ts, 8, 21)) +>extra : Symbol(extra, Decl(circularReturnTypeThroughUncontextualCallbackArgument.ts, 10, 29)) +>next : Symbol(next, Decl(circularReturnTypeThroughUncontextualCallbackArgument.ts, 10, 37)) +>id : Symbol(id, Decl(circularReturnTypeThroughUncontextualCallbackArgument.ts, 10, 46)) + +function getCreds() { +>getCreds : Symbol(getCreds, Decl(circularReturnTypeThroughUncontextualCallbackArgument.ts, 10, 80)) + + const next = (id: string) => getCreds(); +>next : Symbol(next, Decl(circularReturnTypeThroughUncontextualCallbackArgument.ts, 13, 9)) +>id : Symbol(id, Decl(circularReturnTypeThroughUncontextualCallbackArgument.ts, 13, 18)) +>getCreds : Symbol(getCreds, Decl(circularReturnTypeThroughUncontextualCallbackArgument.ts, 10, 80)) + + return materialize({ next }); +>materialize : Symbol(materialize, Decl(circularReturnTypeThroughUncontextualCallbackArgument.ts, 8, 21)) +>next : Symbol(next, Decl(circularReturnTypeThroughUncontextualCallbackArgument.ts, 14, 24)) +} + +const n: number = getCreds(); +>n : Symbol(n, Decl(circularReturnTypeThroughUncontextualCallbackArgument.ts, 17, 5)) +>getCreds : Symbol(getCreds, Decl(circularReturnTypeThroughUncontextualCallbackArgument.ts, 10, 80)) + diff --git a/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughUncontextualCallbackArgument(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughUncontextualCallbackArgument(checkorder=default).types new file mode 100644 index 0000000000000..5cf5a07fe7c0a --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughUncontextualCallbackArgument(checkorder=default).types @@ -0,0 +1,44 @@ +//// [tests/cases/compiler/circularReturnTypeThroughUncontextualCallbackArgument.ts] //// + +=== circularReturnTypeThroughUncontextualCallbackArgument.ts === +// `getCreds`'s return type depends on resolving `materialize({ next })`, whose +// argument check needs the return type of the (non-contextually typed) arrow +// `next`, which calls `getCreds` again. TypeScript never reports this cycle in +// any order: call resolution hides the resolutions below it, and the relation +// reads an in-progress return type as `any` without failing it. So no TS7023, +// and `getCreds` returns `number`. (Reduced from OmniRoute auth.ts +// getProviderCredentials/selectNextLeaseCandidate.) + +const x = getCreds(); +>x : number +>getCreds() : number +>getCreds : () => number + +declare function materialize(extra: { next?: (id: string) => unknown }): number; +>materialize : (extra: { next?: (id: string) => unknown; }) => number +>extra : { next?: (id: string) => unknown; } +>next : ((id: string) => unknown) | undefined +>id : string + +function getCreds() { +>getCreds : () => number + + const next = (id: string) => getCreds(); +>next : (id: string) => number +>(id: string) => getCreds() : (id: string) => number +>id : string +>getCreds() : number +>getCreds : () => number + + return materialize({ next }); +>materialize({ next }) : number +>materialize : (extra: { next?: (id: string) => unknown; }) => number +>{ next } : { next: (id: string) => number; } +>next : (id: string) => number +} + +const n: number = getCreds(); +>n : number +>getCreds() : number +>getCreds : () => number + diff --git a/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughUncontextualCallbackArgument(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughUncontextualCallbackArgument(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..f53077d24860e --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughUncontextualCallbackArgument(checkorder=typesfirst).symbols @@ -0,0 +1,38 @@ +//// [tests/cases/compiler/circularReturnTypeThroughUncontextualCallbackArgument.ts] //// + +=== circularReturnTypeThroughUncontextualCallbackArgument.ts === +// `getCreds`'s return type depends on resolving `materialize({ next })`, whose +// argument check needs the return type of the (non-contextually typed) arrow +// `next`, which calls `getCreds` again. TypeScript never reports this cycle in +// any order: call resolution hides the resolutions below it, and the relation +// reads an in-progress return type as `any` without failing it. So no TS7023, +// and `getCreds` returns `number`. (Reduced from OmniRoute auth.ts +// getProviderCredentials/selectNextLeaseCandidate.) + +const x = getCreds(); +>x : Symbol(x, Decl(circularReturnTypeThroughUncontextualCallbackArgument.ts, 8, 5)) +>getCreds : Symbol(getCreds, Decl(circularReturnTypeThroughUncontextualCallbackArgument.ts, 10, 80)) + +declare function materialize(extra: { next?: (id: string) => unknown }): number; +>materialize : Symbol(materialize, Decl(circularReturnTypeThroughUncontextualCallbackArgument.ts, 8, 21)) +>extra : Symbol(extra, Decl(circularReturnTypeThroughUncontextualCallbackArgument.ts, 10, 29)) +>next : Symbol(next, Decl(circularReturnTypeThroughUncontextualCallbackArgument.ts, 10, 37)) +>id : Symbol(id, Decl(circularReturnTypeThroughUncontextualCallbackArgument.ts, 10, 46)) + +function getCreds() { +>getCreds : Symbol(getCreds, Decl(circularReturnTypeThroughUncontextualCallbackArgument.ts, 10, 80)) + + const next = (id: string) => getCreds(); +>next : Symbol(next, Decl(circularReturnTypeThroughUncontextualCallbackArgument.ts, 13, 9)) +>id : Symbol(id, Decl(circularReturnTypeThroughUncontextualCallbackArgument.ts, 13, 18)) +>getCreds : Symbol(getCreds, Decl(circularReturnTypeThroughUncontextualCallbackArgument.ts, 10, 80)) + + return materialize({ next }); +>materialize : Symbol(materialize, Decl(circularReturnTypeThroughUncontextualCallbackArgument.ts, 8, 21)) +>next : Symbol(next, Decl(circularReturnTypeThroughUncontextualCallbackArgument.ts, 14, 24)) +} + +const n: number = getCreds(); +>n : Symbol(n, Decl(circularReturnTypeThroughUncontextualCallbackArgument.ts, 17, 5)) +>getCreds : Symbol(getCreds, Decl(circularReturnTypeThroughUncontextualCallbackArgument.ts, 10, 80)) + diff --git a/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughUncontextualCallbackArgument(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughUncontextualCallbackArgument(checkorder=typesfirst).types new file mode 100644 index 0000000000000..5cf5a07fe7c0a --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughUncontextualCallbackArgument(checkorder=typesfirst).types @@ -0,0 +1,44 @@ +//// [tests/cases/compiler/circularReturnTypeThroughUncontextualCallbackArgument.ts] //// + +=== circularReturnTypeThroughUncontextualCallbackArgument.ts === +// `getCreds`'s return type depends on resolving `materialize({ next })`, whose +// argument check needs the return type of the (non-contextually typed) arrow +// `next`, which calls `getCreds` again. TypeScript never reports this cycle in +// any order: call resolution hides the resolutions below it, and the relation +// reads an in-progress return type as `any` without failing it. So no TS7023, +// and `getCreds` returns `number`. (Reduced from OmniRoute auth.ts +// getProviderCredentials/selectNextLeaseCandidate.) + +const x = getCreds(); +>x : number +>getCreds() : number +>getCreds : () => number + +declare function materialize(extra: { next?: (id: string) => unknown }): number; +>materialize : (extra: { next?: (id: string) => unknown; }) => number +>extra : { next?: (id: string) => unknown; } +>next : ((id: string) => unknown) | undefined +>id : string + +function getCreds() { +>getCreds : () => number + + const next = (id: string) => getCreds(); +>next : (id: string) => number +>(id: string) => getCreds() : (id: string) => number +>id : string +>getCreds() : number +>getCreds : () => number + + return materialize({ next }); +>materialize({ next }) : number +>materialize : (extra: { next?: (id: string) => unknown; }) => number +>{ next } : { next: (id: string) => number; } +>next : (id: string) => number +} + +const n: number = getCreds(); +>n : number +>getCreds() : number +>getCreds : () => number + diff --git a/tsc/testdata/baselines/reference/compiler/circularScopeThunkReverseMapped(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/circularScopeThunkReverseMapped(checkorder=default).symbols new file mode 100644 index 0000000000000..cefed83354abf --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/circularScopeThunkReverseMapped(checkorder=default).symbols @@ -0,0 +1,121 @@ +//// [tests/cases/compiler/circularScopeThunkReverseMapped.ts] //// + +=== circularScopeThunkReverseMapped.ts === +type Resolve = T extends () => infer R ? R : T; +>Resolve : Symbol(Resolve, Decl(circularScopeThunkReverseMapped.ts, 0, 0)) +>T : Symbol(T, Decl(circularScopeThunkReverseMapped.ts, 0, 13)) +>T : Symbol(T, Decl(circularScopeThunkReverseMapped.ts, 0, 13)) +>R : Symbol(R, Decl(circularScopeThunkReverseMapped.ts, 0, 39)) +>R : Symbol(R, Decl(circularScopeThunkReverseMapped.ts, 0, 39)) +>T : Symbol(T, Decl(circularScopeThunkReverseMapped.ts, 0, 13)) + +type Validate = { [K in keyof def]: def[K] extends () => infer R ? () => R : def[K] }; +>Validate : Symbol(Validate, Decl(circularScopeThunkReverseMapped.ts, 0, 50)) +>def : Symbol(def, Decl(circularScopeThunkReverseMapped.ts, 1, 14)) +>K : Symbol(K, Decl(circularScopeThunkReverseMapped.ts, 1, 24)) +>def : Symbol(def, Decl(circularScopeThunkReverseMapped.ts, 1, 14)) +>def : Symbol(def, Decl(circularScopeThunkReverseMapped.ts, 1, 14)) +>K : Symbol(K, Decl(circularScopeThunkReverseMapped.ts, 1, 24)) +>R : Symbol(R, Decl(circularScopeThunkReverseMapped.ts, 1, 67)) +>R : Symbol(R, Decl(circularScopeThunkReverseMapped.ts, 1, 67)) +>def : Symbol(def, Decl(circularScopeThunkReverseMapped.ts, 1, 14)) +>K : Symbol(K, Decl(circularScopeThunkReverseMapped.ts, 1, 24)) + +interface Scope { +>Scope : Symbol(Scope, Decl(circularScopeThunkReverseMapped.ts, 1, 91)) +>def : Symbol(def, Decl(circularScopeThunkReverseMapped.ts, 2, 16)) + + type(k: k): Resolve; +>type : Symbol(Scope.type, Decl(circularScopeThunkReverseMapped.ts, 2, 22)) +>k : Symbol(k, Decl(circularScopeThunkReverseMapped.ts, 3, 9), Decl(circularScopeThunkReverseMapped.ts, 3, 30)) +>def : Symbol(def, Decl(circularScopeThunkReverseMapped.ts, 2, 16)) +>k : Symbol(k, Decl(circularScopeThunkReverseMapped.ts, 3, 9), Decl(circularScopeThunkReverseMapped.ts, 3, 30)) +>k : Symbol(k, Decl(circularScopeThunkReverseMapped.ts, 3, 9), Decl(circularScopeThunkReverseMapped.ts, 3, 30)) +>Resolve : Symbol(Resolve, Decl(circularScopeThunkReverseMapped.ts, 0, 0)) +>def : Symbol(def, Decl(circularScopeThunkReverseMapped.ts, 2, 16)) +>k : Symbol(k, Decl(circularScopeThunkReverseMapped.ts, 3, 9), Decl(circularScopeThunkReverseMapped.ts, 3, 30)) +} +interface Type { +>Type : Symbol(Type, Decl(circularScopeThunkReverseMapped.ts, 4, 1)) +>T : Symbol(T, Decl(circularScopeThunkReverseMapped.ts, 5, 15)) + + pipe(f: (x: T) => U): Type; +>pipe : Symbol(Type.pipe, Decl(circularScopeThunkReverseMapped.ts, 5, 19)) +>U : Symbol(U, Decl(circularScopeThunkReverseMapped.ts, 6, 9)) +>f : Symbol(f, Decl(circularScopeThunkReverseMapped.ts, 6, 12)) +>x : Symbol(x, Decl(circularScopeThunkReverseMapped.ts, 6, 16)) +>T : Symbol(T, Decl(circularScopeThunkReverseMapped.ts, 5, 15)) +>U : Symbol(U, Decl(circularScopeThunkReverseMapped.ts, 6, 9)) +>Type : Symbol(Type, Decl(circularScopeThunkReverseMapped.ts, 4, 1)) +>U : Symbol(U, Decl(circularScopeThunkReverseMapped.ts, 6, 9)) +} +declare function scope(def: Validate): Scope; +>scope : Symbol(scope, Decl(circularScopeThunkReverseMapped.ts, 7, 1)) +>def : Symbol(def, Decl(circularScopeThunkReverseMapped.ts, 8, 23), Decl(circularScopeThunkReverseMapped.ts, 8, 34)) +>def : Symbol(def, Decl(circularScopeThunkReverseMapped.ts, 8, 23), Decl(circularScopeThunkReverseMapped.ts, 8, 34)) +>Validate : Symbol(Validate, Decl(circularScopeThunkReverseMapped.ts, 0, 50)) +>def : Symbol(def, Decl(circularScopeThunkReverseMapped.ts, 8, 23), Decl(circularScopeThunkReverseMapped.ts, 8, 34)) +>Scope : Symbol(Scope, Decl(circularScopeThunkReverseMapped.ts, 1, 91)) +>def : Symbol(def, Decl(circularScopeThunkReverseMapped.ts, 8, 23), Decl(circularScopeThunkReverseMapped.ts, 8, 34)) + +declare function type(x: T): Type; +>type : Symbol(type, Decl(circularScopeThunkReverseMapped.ts, 8, 66)) +>T : Symbol(T, Decl(circularScopeThunkReverseMapped.ts, 9, 22)) +>x : Symbol(x, Decl(circularScopeThunkReverseMapped.ts, 9, 25)) +>T : Symbol(T, Decl(circularScopeThunkReverseMapped.ts, 9, 22)) +>Type : Symbol(Type, Decl(circularScopeThunkReverseMapped.ts, 4, 1)) +>T : Symbol(T, Decl(circularScopeThunkReverseMapped.ts, 9, 22)) + +export const $ = scope({ +>$ : Symbol($, Decl(circularScopeThunkReverseMapped.ts, 11, 12)) +>scope : Symbol(scope, Decl(circularScopeThunkReverseMapped.ts, 7, 1)) + + a: type("string").pipe(function (s) { return s.length; }), +>a : Symbol(a, Decl(circularScopeThunkReverseMapped.ts, 11, 24)) +>type("string").pipe : Symbol(Type.pipe, Decl(circularScopeThunkReverseMapped.ts, 5, 19)) +>type : Symbol(type, Decl(circularScopeThunkReverseMapped.ts, 8, 66)) +>pipe : Symbol(Type.pipe, Decl(circularScopeThunkReverseMapped.ts, 5, 19)) +>s : Symbol(s, Decl(circularScopeThunkReverseMapped.ts, 12, 37)) +>s.length : Symbol(String.length, Decl(lib.es5.d.ts, --, --)) +>s : Symbol(s, Decl(circularScopeThunkReverseMapped.ts, 12, 37)) +>length : Symbol(String.length, Decl(lib.es5.d.ts, --, --)) + + b: () => $.type("a").pipe(function (n) { return n === 0; }), +>b : Symbol(b, Decl(circularScopeThunkReverseMapped.ts, 12, 62)) +>$.type("a").pipe : Symbol(Type.pipe, Decl(circularScopeThunkReverseMapped.ts, 5, 19)) +>$.type : Symbol(Scope.type, Decl(circularScopeThunkReverseMapped.ts, 2, 22)) +>$ : Symbol($, Decl(circularScopeThunkReverseMapped.ts, 11, 12)) +>type : Symbol(Scope.type, Decl(circularScopeThunkReverseMapped.ts, 2, 22)) +>pipe : Symbol(Type.pipe, Decl(circularScopeThunkReverseMapped.ts, 5, 19)) +>n : Symbol(n, Decl(circularScopeThunkReverseMapped.ts, 13, 40)) +>n : Symbol(n, Decl(circularScopeThunkReverseMapped.ts, 13, 40)) + +}); + +// Entered from the function in the first property when queried in reverse +export const $2 = scope({ +>$2 : Symbol($2, Decl(circularScopeThunkReverseMapped.ts, 17, 12)) +>scope : Symbol(scope, Decl(circularScopeThunkReverseMapped.ts, 7, 1)) + + a: type("string").pipe(function (s) { return s.length; }), +>a : Symbol(a, Decl(circularScopeThunkReverseMapped.ts, 17, 25)) +>type("string").pipe : Symbol(Type.pipe, Decl(circularScopeThunkReverseMapped.ts, 5, 19)) +>type : Symbol(type, Decl(circularScopeThunkReverseMapped.ts, 8, 66)) +>pipe : Symbol(Type.pipe, Decl(circularScopeThunkReverseMapped.ts, 5, 19)) +>s : Symbol(s, Decl(circularScopeThunkReverseMapped.ts, 18, 37)) +>s.length : Symbol(String.length, Decl(lib.es5.d.ts, --, --)) +>s : Symbol(s, Decl(circularScopeThunkReverseMapped.ts, 18, 37)) +>length : Symbol(String.length, Decl(lib.es5.d.ts, --, --)) + + b: () => $2.type("a").pipe((n: number) => n === 0), +>b : Symbol(b, Decl(circularScopeThunkReverseMapped.ts, 18, 62)) +>$2.type("a").pipe : Symbol(Type.pipe, Decl(circularScopeThunkReverseMapped.ts, 5, 19)) +>$2.type : Symbol(Scope.type, Decl(circularScopeThunkReverseMapped.ts, 2, 22)) +>$2 : Symbol($2, Decl(circularScopeThunkReverseMapped.ts, 17, 12)) +>type : Symbol(Scope.type, Decl(circularScopeThunkReverseMapped.ts, 2, 22)) +>pipe : Symbol(Type.pipe, Decl(circularScopeThunkReverseMapped.ts, 5, 19)) +>n : Symbol(n, Decl(circularScopeThunkReverseMapped.ts, 19, 32)) +>n : Symbol(n, Decl(circularScopeThunkReverseMapped.ts, 19, 32)) + +}); + diff --git a/tsc/testdata/baselines/reference/compiler/circularScopeThunkReverseMapped(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/circularScopeThunkReverseMapped(checkorder=default).types new file mode 100644 index 0000000000000..41f30b7dbe3f2 --- /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: unknown; }> +>scope({ a: type("string").pipe(function (s) { return s.length; }), b: () => $.type("a").pipe(function (n) { return n === 0; }),}) : Scope<{ a: Type; b: unknown; }> +>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: unknown; }[k_1]> +>$ : Scope<{ a: Type; b: unknown; }> +>type : (k: k_1) => Resolve<{ a: Type; b: unknown; }[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: unknown; }> +>scope({ a: type("string").pipe(function (s) { return s.length; }), b: () => $2.type("a").pipe((n: number) => n === 0),}) : Scope<{ a: Type; b: unknown; }> +>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: unknown; }[k_1]> +>$2 : Scope<{ a: Type; b: unknown; }> +>type : (k: k_1) => Resolve<{ a: Type; b: unknown; }[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..41f30b7dbe3f2 --- /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: unknown; }> +>scope({ a: type("string").pipe(function (s) { return s.length; }), b: () => $.type("a").pipe(function (n) { return n === 0; }),}) : Scope<{ a: Type; b: unknown; }> +>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: unknown; }[k_1]> +>$ : Scope<{ a: Type; b: unknown; }> +>type : (k: k_1) => Resolve<{ a: Type; b: unknown; }[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: unknown; }> +>scope({ a: type("string").pipe(function (s) { return s.length; }), b: () => $2.type("a").pipe((n: number) => n === 0),}) : Scope<{ a: Type; b: unknown; }> +>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: unknown; }[k_1]> +>$2 : Scope<{ a: Type; b: unknown; }> +>type : (k: k_1) => Resolve<{ a: Type; b: unknown; }[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/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..487cdba50bc87 --- /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..487cdba50bc87 --- /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/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..280e75fb600cf --- /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 : false +>t : T +>true : true +>false : false + + type IsObject = { x: typeof t } extends { x: string } ? true : false; +>IsObject : 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 : false +>t : T +>true : true +>false : false + + type IsObject = { x: typeof t } extends { x: string } ? true : false; +>IsObject : 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 : false +>t : T +>true : true +>false : false + + type IsObject = { x: typeof t } extends { x: string } ? true : false; +>IsObject : false +>x : T +>t : T +>x : string +>true : true +>false : false + } +}; + +f(function self(t) { +>f(function self(t) { const s = self; type P = Parameters;}) : void +>f : (fun: (t: T) => void) => void +>function self(t) { const s = self; type P = Parameters;} : (t: T) => void +>self : (t: T) => void +>t : T + + const s = self; +>s : (t: T) => void +>self : (t: T) => void + + type P = Parameters; +>P : [t: unknown] +>s : (t: T) => void + +}); + diff --git a/tsc/testdata/baselines/reference/compiler/contextualParameterDefaultReferenceCheckOrder(checkorder=default).js b/tsc/testdata/baselines/reference/compiler/contextualParameterDefaultReferenceCheckOrder(checkorder=default).js new file mode 100644 index 0000000000000..a31e69f0899d0 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/contextualParameterDefaultReferenceCheckOrder(checkorder=default).js @@ -0,0 +1,16 @@ +//// [tests/cases/compiler/contextualParameterDefaultReferenceCheckOrder.ts] //// + +//// [contextualParameterDefaultReferenceCheckOrder.ts] +// x is contextually typed as 1, but its initializer widens it to number. The +// reference to x must have the same type whether it is queried before or +// after the function is checked. + +const f: (g: () => number, x: 1) => void = (g = () => x, x = 0) => {}; + + +//// [contextualParameterDefaultReferenceCheckOrder.js] +"use strict"; +// x is contextually typed as 1, but its initializer widens it to number. The +// reference to x must have the same type whether it is queried before or +// after the function is checked. +const f = (g = () => x, x = 0) => { }; diff --git a/tsc/testdata/baselines/reference/compiler/contextualParameterDefaultReferenceCheckOrder(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/contextualParameterDefaultReferenceCheckOrder(checkorder=default).symbols new file mode 100644 index 0000000000000..97bc4c3a2eae5 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/contextualParameterDefaultReferenceCheckOrder(checkorder=default).symbols @@ -0,0 +1,15 @@ +//// [tests/cases/compiler/contextualParameterDefaultReferenceCheckOrder.ts] //// + +=== contextualParameterDefaultReferenceCheckOrder.ts === +// x is contextually typed as 1, but its initializer widens it to number. The +// reference to x must have the same type whether it is queried before or +// after the function is checked. + +const f: (g: () => number, x: 1) => void = (g = () => x, x = 0) => {}; +>f : Symbol(f, Decl(contextualParameterDefaultReferenceCheckOrder.ts, 4, 5)) +>g : Symbol(g, Decl(contextualParameterDefaultReferenceCheckOrder.ts, 4, 10)) +>x : Symbol(x, Decl(contextualParameterDefaultReferenceCheckOrder.ts, 4, 26)) +>g : Symbol(g, Decl(contextualParameterDefaultReferenceCheckOrder.ts, 4, 44)) +>x : Symbol(x, Decl(contextualParameterDefaultReferenceCheckOrder.ts, 4, 56)) +>x : Symbol(x, Decl(contextualParameterDefaultReferenceCheckOrder.ts, 4, 56)) + diff --git a/tsc/testdata/baselines/reference/compiler/contextualParameterDefaultReferenceCheckOrder(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/contextualParameterDefaultReferenceCheckOrder(checkorder=default).types new file mode 100644 index 0000000000000..b977f7c29faff --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/contextualParameterDefaultReferenceCheckOrder(checkorder=default).types @@ -0,0 +1,18 @@ +//// [tests/cases/compiler/contextualParameterDefaultReferenceCheckOrder.ts] //// + +=== contextualParameterDefaultReferenceCheckOrder.ts === +// x is contextually typed as 1, but its initializer widens it to number. The +// reference to x must have the same type whether it is queried before or +// after the function is checked. + +const f: (g: () => number, x: 1) => void = (g = () => x, x = 0) => {}; +>f : (g: () => number, x: 1) => void +>g : () => number +>x : 1 +>(g = () => x, x = 0) => {} : (g?: () => number, x?: number) => void +>g : () => number +>() => x : () => 1 +>x : number +>x : number +>0 : 0 + diff --git a/tsc/testdata/baselines/reference/compiler/contextualParameterDefaultReferenceCheckOrder(checkorder=typesfirst).js b/tsc/testdata/baselines/reference/compiler/contextualParameterDefaultReferenceCheckOrder(checkorder=typesfirst).js new file mode 100644 index 0000000000000..a31e69f0899d0 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/contextualParameterDefaultReferenceCheckOrder(checkorder=typesfirst).js @@ -0,0 +1,16 @@ +//// [tests/cases/compiler/contextualParameterDefaultReferenceCheckOrder.ts] //// + +//// [contextualParameterDefaultReferenceCheckOrder.ts] +// x is contextually typed as 1, but its initializer widens it to number. The +// reference to x must have the same type whether it is queried before or +// after the function is checked. + +const f: (g: () => number, x: 1) => void = (g = () => x, x = 0) => {}; + + +//// [contextualParameterDefaultReferenceCheckOrder.js] +"use strict"; +// x is contextually typed as 1, but its initializer widens it to number. The +// reference to x must have the same type whether it is queried before or +// after the function is checked. +const f = (g = () => x, x = 0) => { }; diff --git a/tsc/testdata/baselines/reference/compiler/contextualParameterDefaultReferenceCheckOrder(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/contextualParameterDefaultReferenceCheckOrder(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..97bc4c3a2eae5 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/contextualParameterDefaultReferenceCheckOrder(checkorder=typesfirst).symbols @@ -0,0 +1,15 @@ +//// [tests/cases/compiler/contextualParameterDefaultReferenceCheckOrder.ts] //// + +=== contextualParameterDefaultReferenceCheckOrder.ts === +// x is contextually typed as 1, but its initializer widens it to number. The +// reference to x must have the same type whether it is queried before or +// after the function is checked. + +const f: (g: () => number, x: 1) => void = (g = () => x, x = 0) => {}; +>f : Symbol(f, Decl(contextualParameterDefaultReferenceCheckOrder.ts, 4, 5)) +>g : Symbol(g, Decl(contextualParameterDefaultReferenceCheckOrder.ts, 4, 10)) +>x : Symbol(x, Decl(contextualParameterDefaultReferenceCheckOrder.ts, 4, 26)) +>g : Symbol(g, Decl(contextualParameterDefaultReferenceCheckOrder.ts, 4, 44)) +>x : Symbol(x, Decl(contextualParameterDefaultReferenceCheckOrder.ts, 4, 56)) +>x : Symbol(x, Decl(contextualParameterDefaultReferenceCheckOrder.ts, 4, 56)) + diff --git a/tsc/testdata/baselines/reference/compiler/contextualParameterDefaultReferenceCheckOrder(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/contextualParameterDefaultReferenceCheckOrder(checkorder=typesfirst).types new file mode 100644 index 0000000000000..ef328c8e6e1bc --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/contextualParameterDefaultReferenceCheckOrder(checkorder=typesfirst).types @@ -0,0 +1,18 @@ +//// [tests/cases/compiler/contextualParameterDefaultReferenceCheckOrder.ts] //// + +=== contextualParameterDefaultReferenceCheckOrder.ts === +// x is contextually typed as 1, but its initializer widens it to number. The +// reference to x must have the same type whether it is queried before or +// after the function is checked. + +const f: (g: () => number, x: 1) => void = (g = () => x, x = 0) => {}; +>f : (g: () => number, x: 1) => void +>g : () => number +>x : 1 +>(g = () => x, x = 0) => {} : (g?: () => number, x?: number) => void +>g : () => number +>() => x : () => 1 +>x : 1 +>x : number +>0 : 0 + diff --git a/tsc/testdata/baselines/reference/compiler/contextualParameterInCircularVariableInitializer(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/contextualParameterInCircularVariableInitializer(checkorder=default).symbols new file mode 100644 index 0000000000000..c4969f0ef5812 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/contextualParameterInCircularVariableInitializer(checkorder=default).symbols @@ -0,0 +1,45 @@ +//// [tests/cases/compiler/contextualParameterInCircularVariableInitializer.ts] //// + +=== contextualParameterInCircularVariableInitializer.ts === +// The initializer of `store` refers to `store` from a callback, so resolving +// the type of `store` re-enters itself. `y` must still get its contextual +// type `string` from `Store` (zustand `create()(...)` pattern), with no +// TS7006, as in main and TS 6.0. + +declare function create(init: () => T): T; +>create : Symbol(create, Decl(contextualParameterInCircularVariableInitializer.ts, 0, 0)) +>T : Symbol(T, Decl(contextualParameterInCircularVariableInitializer.ts, 5, 24)) +>init : Symbol(init, Decl(contextualParameterInCircularVariableInitializer.ts, 5, 27)) +>T : Symbol(T, Decl(contextualParameterInCircularVariableInitializer.ts, 5, 24)) +>T : Symbol(T, Decl(contextualParameterInCircularVariableInitializer.ts, 5, 24)) + +interface Store { +>Store : Symbol(Store, Decl(contextualParameterInCircularVariableInitializer.ts, 5, 45)) + + a: (x: boolean) => void; +>a : Symbol(Store.a, Decl(contextualParameterInCircularVariableInitializer.ts, 7, 17)) +>x : Symbol(x, Decl(contextualParameterInCircularVariableInitializer.ts, 8, 8)) + + b: (y: string) => void; +>b : Symbol(Store.b, Decl(contextualParameterInCircularVariableInitializer.ts, 8, 28)) +>y : Symbol(y, Decl(contextualParameterInCircularVariableInitializer.ts, 9, 8)) +} + +const store = create(() => ({ +>store : Symbol(store, Decl(contextualParameterInCircularVariableInitializer.ts, 12, 5)) +>create : Symbol(create, Decl(contextualParameterInCircularVariableInitializer.ts, 0, 0)) +>Store : Symbol(Store, Decl(contextualParameterInCircularVariableInitializer.ts, 5, 45)) + + a: (x) => store.b(""), +>a : Symbol(a, Decl(contextualParameterInCircularVariableInitializer.ts, 12, 36)) +>x : Symbol(x, Decl(contextualParameterInCircularVariableInitializer.ts, 13, 8)) +>store.b : Symbol(Store.b, Decl(contextualParameterInCircularVariableInitializer.ts, 8, 28)) +>store : Symbol(store, Decl(contextualParameterInCircularVariableInitializer.ts, 12, 5)) +>b : Symbol(Store.b, Decl(contextualParameterInCircularVariableInitializer.ts, 8, 28)) + + b: (y) => {}, +>b : Symbol(b, Decl(contextualParameterInCircularVariableInitializer.ts, 13, 26)) +>y : Symbol(y, Decl(contextualParameterInCircularVariableInitializer.ts, 14, 8)) + +})); + diff --git a/tsc/testdata/baselines/reference/compiler/contextualParameterInCircularVariableInitializer(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/contextualParameterInCircularVariableInitializer(checkorder=default).types new file mode 100644 index 0000000000000..95dd171a5925d --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/contextualParameterInCircularVariableInitializer(checkorder=default).types @@ -0,0 +1,47 @@ +//// [tests/cases/compiler/contextualParameterInCircularVariableInitializer.ts] //// + +=== contextualParameterInCircularVariableInitializer.ts === +// The initializer of `store` refers to `store` from a callback, so resolving +// the type of `store` re-enters itself. `y` must still get its contextual +// type `string` from `Store` (zustand `create()(...)` pattern), with no +// TS7006, as in main and TS 6.0. + +declare function create(init: () => T): T; +>create : (init: () => T) => T +>init : () => T + +interface Store { + a: (x: boolean) => void; +>a : (x: boolean) => void +>x : boolean + + b: (y: string) => void; +>b : (y: string) => void +>y : string +} + +const store = create(() => ({ +>store : Store +>create(() => ({ a: (x) => store.b(""), b: (y) => {},})) : Store +>create : (init: () => T) => T +>() => ({ a: (x) => store.b(""), b: (y) => {},}) : () => { a: (x: boolean) => void; b: (y: string) => void; } +>({ a: (x) => store.b(""), b: (y) => {},}) : { a: (x: boolean) => void; b: (y: string) => void; } +>{ a: (x) => store.b(""), b: (y) => {},} : { a: (x: boolean) => void; b: (y: string) => void; } + + a: (x) => store.b(""), +>a : (x: boolean) => void +>(x) => store.b("") : (x: boolean) => void +>x : boolean +>store.b("") : void +>store.b : (y: string) => void +>store : Store +>b : (y: string) => void +>"" : "" + + b: (y) => {}, +>b : (y: string) => void +>(y) => {} : (y: string) => void +>y : string + +})); + diff --git a/tsc/testdata/baselines/reference/compiler/contextualParameterInCircularVariableInitializer(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/contextualParameterInCircularVariableInitializer(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..c4969f0ef5812 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/contextualParameterInCircularVariableInitializer(checkorder=typesfirst).symbols @@ -0,0 +1,45 @@ +//// [tests/cases/compiler/contextualParameterInCircularVariableInitializer.ts] //// + +=== contextualParameterInCircularVariableInitializer.ts === +// The initializer of `store` refers to `store` from a callback, so resolving +// the type of `store` re-enters itself. `y` must still get its contextual +// type `string` from `Store` (zustand `create()(...)` pattern), with no +// TS7006, as in main and TS 6.0. + +declare function create(init: () => T): T; +>create : Symbol(create, Decl(contextualParameterInCircularVariableInitializer.ts, 0, 0)) +>T : Symbol(T, Decl(contextualParameterInCircularVariableInitializer.ts, 5, 24)) +>init : Symbol(init, Decl(contextualParameterInCircularVariableInitializer.ts, 5, 27)) +>T : Symbol(T, Decl(contextualParameterInCircularVariableInitializer.ts, 5, 24)) +>T : Symbol(T, Decl(contextualParameterInCircularVariableInitializer.ts, 5, 24)) + +interface Store { +>Store : Symbol(Store, Decl(contextualParameterInCircularVariableInitializer.ts, 5, 45)) + + a: (x: boolean) => void; +>a : Symbol(Store.a, Decl(contextualParameterInCircularVariableInitializer.ts, 7, 17)) +>x : Symbol(x, Decl(contextualParameterInCircularVariableInitializer.ts, 8, 8)) + + b: (y: string) => void; +>b : Symbol(Store.b, Decl(contextualParameterInCircularVariableInitializer.ts, 8, 28)) +>y : Symbol(y, Decl(contextualParameterInCircularVariableInitializer.ts, 9, 8)) +} + +const store = create(() => ({ +>store : Symbol(store, Decl(contextualParameterInCircularVariableInitializer.ts, 12, 5)) +>create : Symbol(create, Decl(contextualParameterInCircularVariableInitializer.ts, 0, 0)) +>Store : Symbol(Store, Decl(contextualParameterInCircularVariableInitializer.ts, 5, 45)) + + a: (x) => store.b(""), +>a : Symbol(a, Decl(contextualParameterInCircularVariableInitializer.ts, 12, 36)) +>x : Symbol(x, Decl(contextualParameterInCircularVariableInitializer.ts, 13, 8)) +>store.b : Symbol(Store.b, Decl(contextualParameterInCircularVariableInitializer.ts, 8, 28)) +>store : Symbol(store, Decl(contextualParameterInCircularVariableInitializer.ts, 12, 5)) +>b : Symbol(Store.b, Decl(contextualParameterInCircularVariableInitializer.ts, 8, 28)) + + b: (y) => {}, +>b : Symbol(b, Decl(contextualParameterInCircularVariableInitializer.ts, 13, 26)) +>y : Symbol(y, Decl(contextualParameterInCircularVariableInitializer.ts, 14, 8)) + +})); + diff --git a/tsc/testdata/baselines/reference/compiler/contextualParameterInCircularVariableInitializer(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/contextualParameterInCircularVariableInitializer(checkorder=typesfirst).types new file mode 100644 index 0000000000000..95dd171a5925d --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/contextualParameterInCircularVariableInitializer(checkorder=typesfirst).types @@ -0,0 +1,47 @@ +//// [tests/cases/compiler/contextualParameterInCircularVariableInitializer.ts] //// + +=== contextualParameterInCircularVariableInitializer.ts === +// The initializer of `store` refers to `store` from a callback, so resolving +// the type of `store` re-enters itself. `y` must still get its contextual +// type `string` from `Store` (zustand `create()(...)` pattern), with no +// TS7006, as in main and TS 6.0. + +declare function create(init: () => T): T; +>create : (init: () => T) => T +>init : () => T + +interface Store { + a: (x: boolean) => void; +>a : (x: boolean) => void +>x : boolean + + b: (y: string) => void; +>b : (y: string) => void +>y : string +} + +const store = create(() => ({ +>store : Store +>create(() => ({ a: (x) => store.b(""), b: (y) => {},})) : Store +>create : (init: () => T) => T +>() => ({ a: (x) => store.b(""), b: (y) => {},}) : () => { a: (x: boolean) => void; b: (y: string) => void; } +>({ a: (x) => store.b(""), b: (y) => {},}) : { a: (x: boolean) => void; b: (y: string) => void; } +>{ a: (x) => store.b(""), b: (y) => {},} : { a: (x: boolean) => void; b: (y: string) => void; } + + a: (x) => store.b(""), +>a : (x: boolean) => void +>(x) => store.b("") : (x: boolean) => void +>x : boolean +>store.b("") : void +>store.b : (y: string) => void +>store : Store +>b : (y: string) => void +>"" : "" + + b: (y) => {}, +>b : (y: string) => void +>(y) => {} : (y: string) => void +>y : string + +})); + diff --git a/tsc/testdata/baselines/reference/compiler/contextualParameterInReturnTypeCycleOfGenericCall(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/contextualParameterInReturnTypeCycleOfGenericCall(checkorder=default).symbols new file mode 100644 index 0000000000000..e51b75113df82 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/contextualParameterInReturnTypeCycleOfGenericCall(checkorder=default).symbols @@ -0,0 +1,45 @@ +//// [tests/cases/compiler/contextualParameterInReturnTypeCycleOfGenericCall.ts] //// + +=== contextualParameterInReturnTypeCycleOfGenericCall.ts === +// Inferring `T` for `g` needs the return type of the arrow, whose body is a +// call to `f` that is contextually typed by that same return type, a cycle. +// `state` must still get the contextual type `number` (S inferred from +// `initialState`), as in main and TS 6.0 (redux-toolkit `createSlice` inside +// vitest `expect(() => ...)` pattern). + +declare function f S>>(options: { +>f : Symbol(f, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 0, 0)) +>S : Symbol(S, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 6, 19)) +>CR : Symbol(CR, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 6, 21)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) +>state : Symbol(state, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 6, 49)) +>S : Symbol(S, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 6, 19)) +>S : Symbol(S, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 6, 19)) +>options : Symbol(options, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 6, 66)) + + initialState: S; +>initialState : Symbol(initialState, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 6, 76)) +>S : Symbol(S, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 6, 19)) + + reducers: CR; +>reducers : Symbol(reducers, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 7, 20)) +>CR : Symbol(CR, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 6, 21)) + +}): CR; +>CR : Symbol(CR, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 6, 21)) + +declare function g(a: T): void; +>g : Symbol(g, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 9, 7)) +>T : Symbol(T, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 10, 19)) +>a : Symbol(a, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 10, 22)) +>T : Symbol(T, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 10, 19)) + +g(() => f({ reducers: { a: (state) => state + 1 }, initialState: 0 })); +>g : Symbol(g, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 9, 7)) +>f : Symbol(f, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 0, 0)) +>reducers : Symbol(reducers, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 12, 11)) +>a : Symbol(a, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 12, 23)) +>state : Symbol(state, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 12, 28)) +>state : Symbol(state, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 12, 28)) +>initialState : Symbol(initialState, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 12, 50)) + diff --git a/tsc/testdata/baselines/reference/compiler/contextualParameterInReturnTypeCycleOfGenericCall(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/contextualParameterInReturnTypeCycleOfGenericCall(checkorder=default).types new file mode 100644 index 0000000000000..4d0000d7f411b --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/contextualParameterInReturnTypeCycleOfGenericCall(checkorder=default).types @@ -0,0 +1,43 @@ +//// [tests/cases/compiler/contextualParameterInReturnTypeCycleOfGenericCall.ts] //// + +=== contextualParameterInReturnTypeCycleOfGenericCall.ts === +// Inferring `T` for `g` needs the return type of the arrow, whose body is a +// call to `f` that is contextually typed by that same return type, a cycle. +// `state` must still get the contextual type `number` (S inferred from +// `initialState`), as in main and TS 6.0 (redux-toolkit `createSlice` inside +// vitest `expect(() => ...)` pattern). + +declare function f S>>(options: { +>f : S>>(options: { initialState: S; reducers: CR; }) => CR +>state : S +>options : { initialState: S; reducers: CR; } + + initialState: S; +>initialState : S + + reducers: CR; +>reducers : CR + +}): CR; +declare function g(a: T): void; +>g : (a: T) => void +>a : T + +g(() => f({ reducers: { a: (state) => state + 1 }, initialState: 0 })); +>g(() => f({ reducers: { a: (state) => state + 1 }, initialState: 0 })) : void +>g : (a: T) => void +>() => f({ reducers: { a: (state) => state + 1 }, initialState: 0 }) : () => { a: (state: number) => number; } +>f({ reducers: { a: (state) => state + 1 }, initialState: 0 }) : { a: (state: number) => number; } +>f : S>>(options: { initialState: S; reducers: CR; }) => CR +>{ reducers: { a: (state) => state + 1 }, initialState: 0 } : { reducers: { a: (state: number) => number; }; initialState: number; } +>reducers : { a: (state: number) => number; } +>{ a: (state) => state + 1 } : { a: (state: number) => number; } +>a : (state: number) => number +>(state) => state + 1 : (state: number) => number +>state : number +>state + 1 : number +>state : number +>1 : 1 +>initialState : number +>0 : 0 + diff --git a/tsc/testdata/baselines/reference/compiler/contextualParameterInReturnTypeCycleOfGenericCall(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/contextualParameterInReturnTypeCycleOfGenericCall(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..e51b75113df82 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/contextualParameterInReturnTypeCycleOfGenericCall(checkorder=typesfirst).symbols @@ -0,0 +1,45 @@ +//// [tests/cases/compiler/contextualParameterInReturnTypeCycleOfGenericCall.ts] //// + +=== contextualParameterInReturnTypeCycleOfGenericCall.ts === +// Inferring `T` for `g` needs the return type of the arrow, whose body is a +// call to `f` that is contextually typed by that same return type, a cycle. +// `state` must still get the contextual type `number` (S inferred from +// `initialState`), as in main and TS 6.0 (redux-toolkit `createSlice` inside +// vitest `expect(() => ...)` pattern). + +declare function f S>>(options: { +>f : Symbol(f, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 0, 0)) +>S : Symbol(S, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 6, 19)) +>CR : Symbol(CR, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 6, 21)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) +>state : Symbol(state, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 6, 49)) +>S : Symbol(S, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 6, 19)) +>S : Symbol(S, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 6, 19)) +>options : Symbol(options, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 6, 66)) + + initialState: S; +>initialState : Symbol(initialState, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 6, 76)) +>S : Symbol(S, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 6, 19)) + + reducers: CR; +>reducers : Symbol(reducers, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 7, 20)) +>CR : Symbol(CR, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 6, 21)) + +}): CR; +>CR : Symbol(CR, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 6, 21)) + +declare function g(a: T): void; +>g : Symbol(g, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 9, 7)) +>T : Symbol(T, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 10, 19)) +>a : Symbol(a, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 10, 22)) +>T : Symbol(T, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 10, 19)) + +g(() => f({ reducers: { a: (state) => state + 1 }, initialState: 0 })); +>g : Symbol(g, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 9, 7)) +>f : Symbol(f, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 0, 0)) +>reducers : Symbol(reducers, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 12, 11)) +>a : Symbol(a, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 12, 23)) +>state : Symbol(state, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 12, 28)) +>state : Symbol(state, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 12, 28)) +>initialState : Symbol(initialState, Decl(contextualParameterInReturnTypeCycleOfGenericCall.ts, 12, 50)) + diff --git a/tsc/testdata/baselines/reference/compiler/contextualParameterInReturnTypeCycleOfGenericCall(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/contextualParameterInReturnTypeCycleOfGenericCall(checkorder=typesfirst).types new file mode 100644 index 0000000000000..4d0000d7f411b --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/contextualParameterInReturnTypeCycleOfGenericCall(checkorder=typesfirst).types @@ -0,0 +1,43 @@ +//// [tests/cases/compiler/contextualParameterInReturnTypeCycleOfGenericCall.ts] //// + +=== contextualParameterInReturnTypeCycleOfGenericCall.ts === +// Inferring `T` for `g` needs the return type of the arrow, whose body is a +// call to `f` that is contextually typed by that same return type, a cycle. +// `state` must still get the contextual type `number` (S inferred from +// `initialState`), as in main and TS 6.0 (redux-toolkit `createSlice` inside +// vitest `expect(() => ...)` pattern). + +declare function f S>>(options: { +>f : S>>(options: { initialState: S; reducers: CR; }) => CR +>state : S +>options : { initialState: S; reducers: CR; } + + initialState: S; +>initialState : S + + reducers: CR; +>reducers : CR + +}): CR; +declare function g(a: T): void; +>g : (a: T) => void +>a : T + +g(() => f({ reducers: { a: (state) => state + 1 }, initialState: 0 })); +>g(() => f({ reducers: { a: (state) => state + 1 }, initialState: 0 })) : void +>g : (a: T) => void +>() => f({ reducers: { a: (state) => state + 1 }, initialState: 0 }) : () => { a: (state: number) => number; } +>f({ reducers: { a: (state) => state + 1 }, initialState: 0 }) : { a: (state: number) => number; } +>f : S>>(options: { initialState: S; reducers: CR; }) => CR +>{ reducers: { a: (state) => state + 1 }, initialState: 0 } : { reducers: { a: (state: number) => number; }; initialState: number; } +>reducers : { a: (state: number) => number; } +>{ a: (state) => state + 1 } : { a: (state: number) => number; } +>a : (state: number) => number +>(state) => state + 1 : (state: number) => number +>state : number +>state + 1 : number +>state : number +>1 : 1 +>initialState : number +>0 : 0 + diff --git a/tsc/testdata/baselines/reference/compiler/contextualReturnArrayPatternCallback(checkorder=default).js b/tsc/testdata/baselines/reference/compiler/contextualReturnArrayPatternCallback(checkorder=default).js new file mode 100644 index 0000000000000..6772baec879f7 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/contextualReturnArrayPatternCallback(checkorder=default).js @@ -0,0 +1,32 @@ +//// [tests/cases/compiler/contextualReturnArrayPatternCallback.ts] //// + +//// [contextualReturnArrayPatternCallback.ts] +interface Matcher { + matcher(): { match(value: Input): boolean; value?: Value }; +} +type Pattern = Input | Matcher | { [Key in keyof Input]?: Pattern }; +type ArrayElement = Input extends readonly (infer Value)[] ? Value : unknown; +declare function array>>(value: Value): Matcher; +declare function when unknown>(callback: Callback): Matcher; +declare function accept>(value: Value): void; + +accept({ + list: array({ + prop: when(value => { + const text: string = value; + return true; + }), + }), +}); + + +//// [contextualReturnArrayPatternCallback.js] +"use strict"; +accept({ + list: array({ + prop: when(value => { + const text = value; + return true; + }), + }), +}); diff --git a/tsc/testdata/baselines/reference/compiler/contextualReturnArrayPatternCallback(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/contextualReturnArrayPatternCallback(checkorder=default).symbols new file mode 100644 index 0000000000000..2e6faa18727fd --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/contextualReturnArrayPatternCallback(checkorder=default).symbols @@ -0,0 +1,89 @@ +//// [tests/cases/compiler/contextualReturnArrayPatternCallback.ts] //// + +=== contextualReturnArrayPatternCallback.ts === +interface Matcher { +>Matcher : Symbol(Matcher, Decl(contextualReturnArrayPatternCallback.ts, 0, 0)) +>Input : Symbol(Input, Decl(contextualReturnArrayPatternCallback.ts, 0, 18)) +>Value : Symbol(Value, Decl(contextualReturnArrayPatternCallback.ts, 0, 24)) + + matcher(): { match(value: Input): boolean; value?: Value }; +>matcher : Symbol(Matcher.matcher, Decl(contextualReturnArrayPatternCallback.ts, 0, 43)) +>match : Symbol(match, Decl(contextualReturnArrayPatternCallback.ts, 1, 16)) +>value : Symbol(value, Decl(contextualReturnArrayPatternCallback.ts, 1, 23)) +>Input : Symbol(Input, Decl(contextualReturnArrayPatternCallback.ts, 0, 18)) +>value : Symbol(value, Decl(contextualReturnArrayPatternCallback.ts, 1, 46)) +>Value : Symbol(Value, Decl(contextualReturnArrayPatternCallback.ts, 0, 24)) +} +type Pattern = Input | Matcher | { [Key in keyof Input]?: Pattern }; +>Pattern : Symbol(Pattern, Decl(contextualReturnArrayPatternCallback.ts, 2, 1)) +>Input : Symbol(Input, Decl(contextualReturnArrayPatternCallback.ts, 3, 13)) +>Input : Symbol(Input, Decl(contextualReturnArrayPatternCallback.ts, 3, 13)) +>Matcher : Symbol(Matcher, Decl(contextualReturnArrayPatternCallback.ts, 0, 0)) +>Input : Symbol(Input, Decl(contextualReturnArrayPatternCallback.ts, 3, 13)) +>Key : Symbol(Key, Decl(contextualReturnArrayPatternCallback.ts, 3, 50)) +>Input : Symbol(Input, Decl(contextualReturnArrayPatternCallback.ts, 3, 13)) +>Pattern : Symbol(Pattern, Decl(contextualReturnArrayPatternCallback.ts, 2, 1)) +>Input : Symbol(Input, Decl(contextualReturnArrayPatternCallback.ts, 3, 13)) +>Key : Symbol(Key, Decl(contextualReturnArrayPatternCallback.ts, 3, 50)) + +type ArrayElement = Input extends readonly (infer Value)[] ? Value : unknown; +>ArrayElement : Symbol(ArrayElement, Decl(contextualReturnArrayPatternCallback.ts, 3, 94)) +>Input : Symbol(Input, Decl(contextualReturnArrayPatternCallback.ts, 4, 18)) +>Input : Symbol(Input, Decl(contextualReturnArrayPatternCallback.ts, 4, 18)) +>Value : Symbol(Value, Decl(contextualReturnArrayPatternCallback.ts, 4, 56)) +>Value : Symbol(Value, Decl(contextualReturnArrayPatternCallback.ts, 4, 56)) + +declare function array>>(value: Value): Matcher; +>array : Symbol(array, Decl(contextualReturnArrayPatternCallback.ts, 4, 84)) +>Input : Symbol(Input, Decl(contextualReturnArrayPatternCallback.ts, 5, 23)) +>Value : Symbol(Value, Decl(contextualReturnArrayPatternCallback.ts, 5, 29)) +>Pattern : Symbol(Pattern, Decl(contextualReturnArrayPatternCallback.ts, 2, 1)) +>ArrayElement : Symbol(ArrayElement, Decl(contextualReturnArrayPatternCallback.ts, 3, 94)) +>Input : Symbol(Input, Decl(contextualReturnArrayPatternCallback.ts, 5, 23)) +>value : Symbol(value, Decl(contextualReturnArrayPatternCallback.ts, 5, 74)) +>Value : Symbol(Value, Decl(contextualReturnArrayPatternCallback.ts, 5, 29)) +>Matcher : Symbol(Matcher, Decl(contextualReturnArrayPatternCallback.ts, 0, 0)) +>Input : Symbol(Input, Decl(contextualReturnArrayPatternCallback.ts, 5, 23)) +>Value : Symbol(Value, Decl(contextualReturnArrayPatternCallback.ts, 5, 29)) + +declare function when unknown>(callback: Callback): Matcher; +>when : Symbol(when, Decl(contextualReturnArrayPatternCallback.ts, 5, 111)) +>Input : Symbol(Input, Decl(contextualReturnArrayPatternCallback.ts, 6, 22)) +>Callback : Symbol(Callback, Decl(contextualReturnArrayPatternCallback.ts, 6, 28)) +>value : Symbol(value, Decl(contextualReturnArrayPatternCallback.ts, 6, 47)) +>Input : Symbol(Input, Decl(contextualReturnArrayPatternCallback.ts, 6, 22)) +>callback : Symbol(callback, Decl(contextualReturnArrayPatternCallback.ts, 6, 73)) +>Callback : Symbol(Callback, Decl(contextualReturnArrayPatternCallback.ts, 6, 28)) +>Matcher : Symbol(Matcher, Decl(contextualReturnArrayPatternCallback.ts, 0, 0)) +>Input : Symbol(Input, Decl(contextualReturnArrayPatternCallback.ts, 6, 22)) + +declare function accept>(value: Value): void; +>accept : Symbol(accept, Decl(contextualReturnArrayPatternCallback.ts, 6, 109)) +>Value : Symbol(Value, Decl(contextualReturnArrayPatternCallback.ts, 7, 24)) +>Pattern : Symbol(Pattern, Decl(contextualReturnArrayPatternCallback.ts, 2, 1)) +>list : Symbol(list, Decl(contextualReturnArrayPatternCallback.ts, 7, 47)) +>prop : Symbol(prop, Decl(contextualReturnArrayPatternCallback.ts, 7, 55)) +>value : Symbol(value, Decl(contextualReturnArrayPatternCallback.ts, 7, 77)) +>Value : Symbol(Value, Decl(contextualReturnArrayPatternCallback.ts, 7, 24)) + +accept({ +>accept : Symbol(accept, Decl(contextualReturnArrayPatternCallback.ts, 6, 109)) + + list: array({ +>list : Symbol(list, Decl(contextualReturnArrayPatternCallback.ts, 9, 8)) +>array : Symbol(array, Decl(contextualReturnArrayPatternCallback.ts, 4, 84)) + + prop: when(value => { +>prop : Symbol(prop, Decl(contextualReturnArrayPatternCallback.ts, 10, 17)) +>when : Symbol(when, Decl(contextualReturnArrayPatternCallback.ts, 5, 111)) +>value : Symbol(value, Decl(contextualReturnArrayPatternCallback.ts, 11, 19)) + + const text: string = value; +>text : Symbol(text, Decl(contextualReturnArrayPatternCallback.ts, 12, 17)) +>value : Symbol(value, Decl(contextualReturnArrayPatternCallback.ts, 11, 19)) + + return true; + }), + }), +}); + diff --git a/tsc/testdata/baselines/reference/compiler/contextualReturnArrayPatternCallback(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/contextualReturnArrayPatternCallback(checkorder=default).types new file mode 100644 index 0000000000000..8ae0e4c69acc3 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/contextualReturnArrayPatternCallback(checkorder=default).types @@ -0,0 +1,60 @@ +//// [tests/cases/compiler/contextualReturnArrayPatternCallback.ts] //// + +=== contextualReturnArrayPatternCallback.ts === +interface Matcher { + matcher(): { match(value: Input): boolean; value?: Value }; +>matcher : () => { match(value: Input): boolean; value?: Value; } +>match : (value: Input) => boolean +>value : Input +>value : Value | undefined +} +type Pattern = Input | Matcher | { [Key in keyof Input]?: Pattern }; +>Pattern : Pattern + +type ArrayElement = Input extends readonly (infer Value)[] ? Value : unknown; +>ArrayElement : ArrayElement + +declare function array>>(value: Value): Matcher; +>array : >>(value: Value) => Matcher +>value : Value + +declare function when unknown>(callback: Callback): Matcher; +>when : unknown>(callback: Callback) => Matcher +>value : Input +>callback : Callback + +declare function accept>(value: Value): void; +>accept : >(value: Value) => void +>list : { prop: string; }[] +>prop : string +>value : Value + +accept({ +>accept({ list: array({ prop: when(value => { const text: string = value; return true; }), }),}) : void +>accept : >(value: Value) => void +>{ list: array({ prop: when(value => { const text: string = value; return true; }), }),} : { list: Matcher<{ prop: string; }[], { prop: Matcher; }>; } + + list: array({ +>list : Matcher<{ prop: string; }[], { prop: Matcher; }> +>array({ prop: when(value => { const text: string = value; return true; }), }) : Matcher<{ prop: string; }[], { prop: Matcher; }> +>array : >>(value: Value) => Matcher +>{ prop: when(value => { const text: string = value; return true; }), } : { prop: Matcher; } + + prop: when(value => { +>prop : Matcher +>when(value => { const text: string = value; return true; }) : Matcher +>when : unknown>(callback: Callback) => Matcher +>value => { const text: string = value; return true; } : (value: string) => boolean +>value : string + + const text: string = value; +>text : string +>value : string + + return true; +>true : true + + }), + }), +}); + diff --git a/tsc/testdata/baselines/reference/compiler/contextualReturnArrayPatternCallback(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/contextualReturnArrayPatternCallback(checkorder=typesfirst).errors.txt new file mode 100644 index 0000000000000..0976f43f81f01 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/contextualReturnArrayPatternCallback(checkorder=typesfirst).errors.txt @@ -0,0 +1,24 @@ +contextualReturnArrayPatternCallback.ts(13,19): error TS2322: Type 'unknown' is not assignable to type 'string'. + + +==== contextualReturnArrayPatternCallback.ts (1 errors) ==== + 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; + ~~~~ +!!! error TS2322: Type 'unknown' is not assignable to type 'string'. + return true; + }), + }), + }); + \ No newline at end of file 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..68eb717e1e135 --- /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: unknown) => boolean +>value : unknown + + const text: string = value; +>text : string +>value : unknown + + return true; +>true : true + + }), + }), +}); + diff --git a/tsc/testdata/baselines/reference/compiler/cycleYieldThroughVarianceCheckOrder(checkorder=default).js b/tsc/testdata/baselines/reference/compiler/cycleYieldThroughVarianceCheckOrder(checkorder=default).js new file mode 100644 index 0000000000000..8b4161c226ae7 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/cycleYieldThroughVarianceCheckOrder(checkorder=default).js @@ -0,0 +1,24 @@ +//// [tests/cases/compiler/cycleYieldThroughVarianceCheckOrder.ts] //// + +//// [cycleYieldThroughVarianceCheckOrder.ts] +// Resolving the base of E measures the variances of B, which needs the type +// of p, which needs the members of E. Whether p is circular must not depend +// on whether B is checked before the type of arg is queried. + +declare class B { + p: E["p"]; +} +declare class E extends mix(Base) { + p: number; +} +declare function mix object>(x: T): T; +declare class Base { + constructor(arg?: InstanceType); +} + + +//// [cycleYieldThroughVarianceCheckOrder.js] +"use strict"; +// Resolving the base of E measures the variances of B, which needs the type +// of p, which needs the members of E. Whether p is circular must not depend +// on whether B is checked before the type of arg is queried. diff --git a/tsc/testdata/baselines/reference/compiler/cycleYieldThroughVarianceCheckOrder(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/cycleYieldThroughVarianceCheckOrder(checkorder=default).symbols new file mode 100644 index 0000000000000..38e787a55de34 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/cycleYieldThroughVarianceCheckOrder(checkorder=default).symbols @@ -0,0 +1,39 @@ +//// [tests/cases/compiler/cycleYieldThroughVarianceCheckOrder.ts] //// + +=== cycleYieldThroughVarianceCheckOrder.ts === +// Resolving the base of E measures the variances of B, which needs the type +// of p, which needs the members of E. Whether p is circular must not depend +// on whether B is checked before the type of arg is queried. + +declare class B { +>B : Symbol(B, Decl(cycleYieldThroughVarianceCheckOrder.ts, 0, 0)) +>T : Symbol(T, Decl(cycleYieldThroughVarianceCheckOrder.ts, 4, 16)) + + p: E["p"]; +>p : Symbol(B.p, Decl(cycleYieldThroughVarianceCheckOrder.ts, 4, 20)) +>E : Symbol(E, Decl(cycleYieldThroughVarianceCheckOrder.ts, 6, 1)) +} +declare class E extends mix(Base) { +>E : Symbol(E, Decl(cycleYieldThroughVarianceCheckOrder.ts, 6, 1)) +>mix : Symbol(mix, Decl(cycleYieldThroughVarianceCheckOrder.ts, 9, 1)) +>Base : Symbol(Base, Decl(cycleYieldThroughVarianceCheckOrder.ts, 10, 58)) + + p: number; +>p : Symbol(E.p, Decl(cycleYieldThroughVarianceCheckOrder.ts, 7, 35)) +} +declare function mix object>(x: T): T; +>mix : Symbol(mix, Decl(cycleYieldThroughVarianceCheckOrder.ts, 9, 1)) +>T : Symbol(T, Decl(cycleYieldThroughVarianceCheckOrder.ts, 10, 21)) +>x : Symbol(x, Decl(cycleYieldThroughVarianceCheckOrder.ts, 10, 49)) +>T : Symbol(T, Decl(cycleYieldThroughVarianceCheckOrder.ts, 10, 21)) +>T : Symbol(T, Decl(cycleYieldThroughVarianceCheckOrder.ts, 10, 21)) + +declare class Base { +>Base : Symbol(Base, Decl(cycleYieldThroughVarianceCheckOrder.ts, 10, 58)) + + constructor(arg?: InstanceType); +>arg : Symbol(arg, Decl(cycleYieldThroughVarianceCheckOrder.ts, 12, 16)) +>InstanceType : Symbol(InstanceType, Decl(lib.es5.d.ts, --, --)) +>B : Symbol(B, Decl(cycleYieldThroughVarianceCheckOrder.ts, 0, 0)) +} + diff --git a/tsc/testdata/baselines/reference/compiler/cycleYieldThroughVarianceCheckOrder(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/cycleYieldThroughVarianceCheckOrder(checkorder=default).types new file mode 100644 index 0000000000000..7c73b8e4d56be --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/cycleYieldThroughVarianceCheckOrder(checkorder=default).types @@ -0,0 +1,34 @@ +//// [tests/cases/compiler/cycleYieldThroughVarianceCheckOrder.ts] //// + +=== cycleYieldThroughVarianceCheckOrder.ts === +// Resolving the base of E measures the variances of B, which needs the type +// of p, which needs the members of E. Whether p is circular must not depend +// on whether B is checked before the type of arg is queried. + +declare class B { +>B : B + + p: E["p"]; +>p : number +} +declare class E extends mix(Base) { +>E : E +>mix(Base) : Base +>mix : object>(x: T) => T +>Base : typeof Base + + p: number; +>p : number +} +declare function mix object>(x: T): T; +>mix : object>(x: T) => T +>x : T + +declare class Base { +>Base : Base + + constructor(arg?: InstanceType); +>arg : B | undefined +>B : typeof B +} + diff --git a/tsc/testdata/baselines/reference/compiler/cycleYieldThroughVarianceCheckOrder(checkorder=typesfirst).js b/tsc/testdata/baselines/reference/compiler/cycleYieldThroughVarianceCheckOrder(checkorder=typesfirst).js new file mode 100644 index 0000000000000..8b4161c226ae7 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/cycleYieldThroughVarianceCheckOrder(checkorder=typesfirst).js @@ -0,0 +1,24 @@ +//// [tests/cases/compiler/cycleYieldThroughVarianceCheckOrder.ts] //// + +//// [cycleYieldThroughVarianceCheckOrder.ts] +// Resolving the base of E measures the variances of B, which needs the type +// of p, which needs the members of E. Whether p is circular must not depend +// on whether B is checked before the type of arg is queried. + +declare class B { + p: E["p"]; +} +declare class E extends mix(Base) { + p: number; +} +declare function mix object>(x: T): T; +declare class Base { + constructor(arg?: InstanceType); +} + + +//// [cycleYieldThroughVarianceCheckOrder.js] +"use strict"; +// Resolving the base of E measures the variances of B, which needs the type +// of p, which needs the members of E. Whether p is circular must not depend +// on whether B is checked before the type of arg is queried. diff --git a/tsc/testdata/baselines/reference/compiler/cycleYieldThroughVarianceCheckOrder(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/cycleYieldThroughVarianceCheckOrder(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..38e787a55de34 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/cycleYieldThroughVarianceCheckOrder(checkorder=typesfirst).symbols @@ -0,0 +1,39 @@ +//// [tests/cases/compiler/cycleYieldThroughVarianceCheckOrder.ts] //// + +=== cycleYieldThroughVarianceCheckOrder.ts === +// Resolving the base of E measures the variances of B, which needs the type +// of p, which needs the members of E. Whether p is circular must not depend +// on whether B is checked before the type of arg is queried. + +declare class B { +>B : Symbol(B, Decl(cycleYieldThroughVarianceCheckOrder.ts, 0, 0)) +>T : Symbol(T, Decl(cycleYieldThroughVarianceCheckOrder.ts, 4, 16)) + + p: E["p"]; +>p : Symbol(B.p, Decl(cycleYieldThroughVarianceCheckOrder.ts, 4, 20)) +>E : Symbol(E, Decl(cycleYieldThroughVarianceCheckOrder.ts, 6, 1)) +} +declare class E extends mix(Base) { +>E : Symbol(E, Decl(cycleYieldThroughVarianceCheckOrder.ts, 6, 1)) +>mix : Symbol(mix, Decl(cycleYieldThroughVarianceCheckOrder.ts, 9, 1)) +>Base : Symbol(Base, Decl(cycleYieldThroughVarianceCheckOrder.ts, 10, 58)) + + p: number; +>p : Symbol(E.p, Decl(cycleYieldThroughVarianceCheckOrder.ts, 7, 35)) +} +declare function mix object>(x: T): T; +>mix : Symbol(mix, Decl(cycleYieldThroughVarianceCheckOrder.ts, 9, 1)) +>T : Symbol(T, Decl(cycleYieldThroughVarianceCheckOrder.ts, 10, 21)) +>x : Symbol(x, Decl(cycleYieldThroughVarianceCheckOrder.ts, 10, 49)) +>T : Symbol(T, Decl(cycleYieldThroughVarianceCheckOrder.ts, 10, 21)) +>T : Symbol(T, Decl(cycleYieldThroughVarianceCheckOrder.ts, 10, 21)) + +declare class Base { +>Base : Symbol(Base, Decl(cycleYieldThroughVarianceCheckOrder.ts, 10, 58)) + + constructor(arg?: InstanceType); +>arg : Symbol(arg, Decl(cycleYieldThroughVarianceCheckOrder.ts, 12, 16)) +>InstanceType : Symbol(InstanceType, Decl(lib.es5.d.ts, --, --)) +>B : Symbol(B, Decl(cycleYieldThroughVarianceCheckOrder.ts, 0, 0)) +} + diff --git a/tsc/testdata/baselines/reference/compiler/cycleYieldThroughVarianceCheckOrder(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/cycleYieldThroughVarianceCheckOrder(checkorder=typesfirst).types new file mode 100644 index 0000000000000..7c73b8e4d56be --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/cycleYieldThroughVarianceCheckOrder(checkorder=typesfirst).types @@ -0,0 +1,34 @@ +//// [tests/cases/compiler/cycleYieldThroughVarianceCheckOrder.ts] //// + +=== cycleYieldThroughVarianceCheckOrder.ts === +// Resolving the base of E measures the variances of B, which needs the type +// of p, which needs the members of E. Whether p is circular must not depend +// on whether B is checked before the type of arg is queried. + +declare class B { +>B : B + + p: E["p"]; +>p : number +} +declare class E extends mix(Base) { +>E : E +>mix(Base) : Base +>mix : object>(x: T) => T +>Base : typeof Base + + p: number; +>p : number +} +declare function mix object>(x: T): T; +>mix : object>(x: T) => T +>x : T + +declare class Base { +>Base : Base + + constructor(arg?: InstanceType); +>arg : B | undefined +>B : typeof B +} + diff --git a/tsc/testdata/baselines/reference/compiler/deferredTypeReferenceCycleRollback.errors.txt b/tsc/testdata/baselines/reference/compiler/deferredTypeReferenceCycleRollback.errors.txt new file mode 100644 index 0000000000000..88bdce38b167c --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/deferredTypeReferenceCycleRollback.errors.txt @@ -0,0 +1,24 @@ +deferredTypeReferenceCycleRollback.ts(17,31): error TS2304: Cannot find name 'Missing'. + + +==== deferredTypeReferenceCycleRollback.ts (1 errors) ==== + // A cycle rollback used to reset the type of the Array> + // node while the deferred reference identified by that node survived, + // which crashed a later instantiation of it. + + declare function declare(): void; + + interface PluginObj { + visitor: Visit; + } + type Visit = VisitFn | VisitObj; + type VisitFn = (path: NodePath

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

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

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

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

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

+ +type Children = S["states"] extends Record ? S["states"] : Record; +>Children : Children + +type NeedsRecord> = T; +>NeedsRecord : T + +type ChildrenAt, P extends string> = NeedsRecord>>>; +>ChildrenAt : Children>> + diff --git a/tsc/testdata/baselines/reference/compiler/templateLiteralTypeExcessiveLength(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/templateLiteralTypeExcessiveLength(checkorder=default).errors.txt new file mode 100644 index 0000000000000..2c10283c820ef --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/templateLiteralTypeExcessiveLength(checkorder=default).errors.txt @@ -0,0 +1,48 @@ +templateLiteralTypeExcessiveLength.ts(15,11): 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(34,11): error TS2589: Type instantiation is excessively deep and possibly infinite. + + +==== templateLiteralTypeExcessiveLength.ts (3 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. + }; + + // 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. + }; + + // 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. + }; + \ 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..a7a577d5080f1 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/templateLiteralTypeExcessiveLength(checkorder=typesfirst).errors.txt @@ -0,0 +1,41 @@ +error TS2589: Type instantiation is excessively deep and possibly infinite. + + +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. +==== templateLiteralTypeExcessiveLength.ts (0 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; + }; + + // 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; + }; + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/templateLiteralTypeExcessiveLength(checkorder=typesfirst).js b/tsc/testdata/baselines/reference/compiler/templateLiteralTypeExcessiveLength(checkorder=typesfirst).js new file mode 100644 index 0000000000000..36fa92d4a5035 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/templateLiteralTypeExcessiveLength(checkorder=typesfirst).js @@ -0,0 +1,45 @@ +//// [tests/cases/compiler/templateLiteralTypeExcessiveLength.ts] //// + +//// [templateLiteralTypeExcessiveLength.ts] +// Regression test for #63271: `Dec<2>` is `any`, so `Recur` produces both conditional branches and +// keeps tail-recursing forever. The checker must report an error instead of building an unbounded +// template literal type. + +type Dec = + N extends 5 ? 4 : N extends 4 ? 3 : N extends 3 ? 2 : + N extends 2 ? any : + N extends 1 ? 0 : 0; + +type Recur = + N extends 0 ? S : Recur, `${S}_${S}`>; + +// The string literal doubles on every iteration. +type Explode = { + [P in Recur<5, "a"> as `${P}_key`]: any; +}; + +// The number of placeholders doubles on every iteration. +type ExplodeSpans = { + [P in Recur<5, string> as `${P}_key`]: any; +}; + +// Every text segment stays small, but the number of segments doubles on every iteration, +// so the combined text length grows without bound. +type A16 = "aaaaaaaaaaaaaaaa"; +type A64 = `${A16}${A16}${A16}${A16}`; +type A256 = `${A64}${A64}${A64}${A64}`; +type A1024 = `${A256}${A256}${A256}${A256}`; + +type RecurSegments = + N extends 0 ? S : RecurSegments, `${S}${string}${S}`>; + +type ExplodeSegments = { + [P in RecurSegments<5, A1024> as `${P}_key`]: any; +}; + + +//// [templateLiteralTypeExcessiveLength.js] +"use strict"; +// Regression test for #63271: `Dec<2>` is `any`, so `Recur` produces both conditional branches and +// keeps tail-recursing forever. The checker must report an error instead of building an unbounded +// template literal type. diff --git a/tsc/testdata/baselines/reference/compiler/templateLiteralTypeExcessiveLength(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/templateLiteralTypeExcessiveLength(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..2e85049b74921 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/templateLiteralTypeExcessiveLength(checkorder=typesfirst).symbols @@ -0,0 +1,109 @@ +//// [tests/cases/compiler/templateLiteralTypeExcessiveLength.ts] //// + +=== templateLiteralTypeExcessiveLength.ts === +// Regression test for #63271: `Dec<2>` is `any`, so `Recur` produces both conditional branches and +// keeps tail-recursing forever. The checker must report an error instead of building an unbounded +// template literal type. + +type Dec = +>Dec : Symbol(Dec, Decl(templateLiteralTypeExcessiveLength.ts, 0, 0)) +>N : Symbol(N, Decl(templateLiteralTypeExcessiveLength.ts, 4, 9)) + + N extends 5 ? 4 : N extends 4 ? 3 : N extends 3 ? 2 : +>N : Symbol(N, Decl(templateLiteralTypeExcessiveLength.ts, 4, 9)) +>N : Symbol(N, Decl(templateLiteralTypeExcessiveLength.ts, 4, 9)) +>N : Symbol(N, Decl(templateLiteralTypeExcessiveLength.ts, 4, 9)) + + N extends 2 ? any : +>N : Symbol(N, Decl(templateLiteralTypeExcessiveLength.ts, 4, 9)) + + N extends 1 ? 0 : 0; +>N : Symbol(N, Decl(templateLiteralTypeExcessiveLength.ts, 4, 9)) + +type Recur = +>Recur : Symbol(Recur, Decl(templateLiteralTypeExcessiveLength.ts, 7, 24)) +>N : Symbol(N, Decl(templateLiteralTypeExcessiveLength.ts, 9, 11)) +>S : Symbol(S, Decl(templateLiteralTypeExcessiveLength.ts, 9, 28)) + + N extends 0 ? S : Recur, `${S}_${S}`>; +>N : Symbol(N, Decl(templateLiteralTypeExcessiveLength.ts, 9, 11)) +>S : Symbol(S, Decl(templateLiteralTypeExcessiveLength.ts, 9, 28)) +>Recur : Symbol(Recur, Decl(templateLiteralTypeExcessiveLength.ts, 7, 24)) +>Dec : Symbol(Dec, Decl(templateLiteralTypeExcessiveLength.ts, 0, 0)) +>N : Symbol(N, Decl(templateLiteralTypeExcessiveLength.ts, 9, 11)) +>S : Symbol(S, Decl(templateLiteralTypeExcessiveLength.ts, 9, 28)) +>S : Symbol(S, Decl(templateLiteralTypeExcessiveLength.ts, 9, 28)) + +// The string literal doubles on every iteration. +type Explode = { +>Explode : Symbol(Explode, Decl(templateLiteralTypeExcessiveLength.ts, 10, 49)) + + [P in Recur<5, "a"> as `${P}_key`]: any; +>P : Symbol(P, Decl(templateLiteralTypeExcessiveLength.ts, 14, 5)) +>Recur : Symbol(Recur, Decl(templateLiteralTypeExcessiveLength.ts, 7, 24)) +>P : Symbol(P, Decl(templateLiteralTypeExcessiveLength.ts, 14, 5)) + +}; + +// The number of placeholders doubles on every iteration. +type ExplodeSpans = { +>ExplodeSpans : Symbol(ExplodeSpans, Decl(templateLiteralTypeExcessiveLength.ts, 15, 2)) + + [P in Recur<5, string> as `${P}_key`]: any; +>P : Symbol(P, Decl(templateLiteralTypeExcessiveLength.ts, 19, 5)) +>Recur : Symbol(Recur, Decl(templateLiteralTypeExcessiveLength.ts, 7, 24)) +>P : Symbol(P, Decl(templateLiteralTypeExcessiveLength.ts, 19, 5)) + +}; + +// Every text segment stays small, but the number of segments doubles on every iteration, +// so the combined text length grows without bound. +type A16 = "aaaaaaaaaaaaaaaa"; +>A16 : Symbol(A16, Decl(templateLiteralTypeExcessiveLength.ts, 20, 2)) + +type A64 = `${A16}${A16}${A16}${A16}`; +>A64 : Symbol(A64, Decl(templateLiteralTypeExcessiveLength.ts, 24, 30)) +>A16 : Symbol(A16, Decl(templateLiteralTypeExcessiveLength.ts, 20, 2)) +>A16 : Symbol(A16, Decl(templateLiteralTypeExcessiveLength.ts, 20, 2)) +>A16 : Symbol(A16, Decl(templateLiteralTypeExcessiveLength.ts, 20, 2)) +>A16 : Symbol(A16, Decl(templateLiteralTypeExcessiveLength.ts, 20, 2)) + +type A256 = `${A64}${A64}${A64}${A64}`; +>A256 : Symbol(A256, Decl(templateLiteralTypeExcessiveLength.ts, 25, 38)) +>A64 : Symbol(A64, Decl(templateLiteralTypeExcessiveLength.ts, 24, 30)) +>A64 : Symbol(A64, Decl(templateLiteralTypeExcessiveLength.ts, 24, 30)) +>A64 : Symbol(A64, Decl(templateLiteralTypeExcessiveLength.ts, 24, 30)) +>A64 : Symbol(A64, Decl(templateLiteralTypeExcessiveLength.ts, 24, 30)) + +type A1024 = `${A256}${A256}${A256}${A256}`; +>A1024 : Symbol(A1024, Decl(templateLiteralTypeExcessiveLength.ts, 26, 39)) +>A256 : Symbol(A256, Decl(templateLiteralTypeExcessiveLength.ts, 25, 38)) +>A256 : Symbol(A256, Decl(templateLiteralTypeExcessiveLength.ts, 25, 38)) +>A256 : Symbol(A256, Decl(templateLiteralTypeExcessiveLength.ts, 25, 38)) +>A256 : Symbol(A256, Decl(templateLiteralTypeExcessiveLength.ts, 25, 38)) + +type RecurSegments = +>RecurSegments : Symbol(RecurSegments, Decl(templateLiteralTypeExcessiveLength.ts, 27, 44)) +>N : Symbol(N, Decl(templateLiteralTypeExcessiveLength.ts, 29, 19)) +>S : Symbol(S, Decl(templateLiteralTypeExcessiveLength.ts, 29, 36)) + + N extends 0 ? S : RecurSegments, `${S}${string}${S}`>; +>N : Symbol(N, Decl(templateLiteralTypeExcessiveLength.ts, 29, 19)) +>S : Symbol(S, Decl(templateLiteralTypeExcessiveLength.ts, 29, 36)) +>RecurSegments : Symbol(RecurSegments, Decl(templateLiteralTypeExcessiveLength.ts, 27, 44)) +>Dec : Symbol(Dec, Decl(templateLiteralTypeExcessiveLength.ts, 0, 0)) +>N : Symbol(N, Decl(templateLiteralTypeExcessiveLength.ts, 29, 19)) +>S : Symbol(S, Decl(templateLiteralTypeExcessiveLength.ts, 29, 36)) +>S : Symbol(S, Decl(templateLiteralTypeExcessiveLength.ts, 29, 36)) + +type ExplodeSegments = { +>ExplodeSegments : Symbol(ExplodeSegments, Decl(templateLiteralTypeExcessiveLength.ts, 30, 65)) + + [P in RecurSegments<5, A1024> as `${P}_key`]: any; +>P : Symbol(P, Decl(templateLiteralTypeExcessiveLength.ts, 33, 5)) +>RecurSegments : Symbol(RecurSegments, Decl(templateLiteralTypeExcessiveLength.ts, 27, 44)) +>A1024 : Symbol(A1024, Decl(templateLiteralTypeExcessiveLength.ts, 26, 39)) +>P : Symbol(P, Decl(templateLiteralTypeExcessiveLength.ts, 33, 5)) + +}; + diff --git a/tsc/testdata/baselines/reference/compiler/templateLiteralTypeExcessiveLength(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/templateLiteralTypeExcessiveLength(checkorder=typesfirst).types new file mode 100644 index 0000000000000..e882332afbf78 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/templateLiteralTypeExcessiveLength(checkorder=typesfirst).types @@ -0,0 +1,58 @@ +//// [tests/cases/compiler/templateLiteralTypeExcessiveLength.ts] //// + +=== templateLiteralTypeExcessiveLength.ts === +// Regression test for #63271: `Dec<2>` is `any`, so `Recur` produces both conditional branches and +// keeps tail-recursing forever. The checker must report an error instead of building an unbounded +// template literal type. + +type Dec = +>Dec : Dec + + N extends 5 ? 4 : N extends 4 ? 3 : N extends 3 ? 2 : + N extends 2 ? any : + N extends 1 ? 0 : 0; + +type Recur = +>Recur : Recur + + N extends 0 ? S : Recur, `${S}_${S}`>; + +// The string literal doubles on every iteration. +type Explode = { +>Explode : Explode + + [P in Recur<5, "a"> as `${P}_key`]: any; +}; + +// The number of placeholders doubles on every iteration. +type ExplodeSpans = { +>ExplodeSpans : ExplodeSpans + + [P in Recur<5, string> as `${P}_key`]: any; +}; + +// Every text segment stays small, but the number of segments doubles on every iteration, +// so the combined text length grows without bound. +type A16 = "aaaaaaaaaaaaaaaa"; +>A16 : "aaaaaaaaaaaaaaaa" + +type A64 = `${A16}${A16}${A16}${A16}`; +>A64 : "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" + +type A256 = `${A64}${A64}${A64}${A64}`; +>A256 : "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" + +type A1024 = `${A256}${A256}${A256}${A256}`; +>A1024 : "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" + +type RecurSegments = +>RecurSegments : RecurSegments + + N extends 0 ? S : RecurSegments, `${S}${string}${S}`>; + +type ExplodeSegments = { +>ExplodeSegments : ExplodeSegments + + [P in RecurSegments<5, A1024> as `${P}_key`]: any; +}; + diff --git a/tsc/testdata/baselines/reference/compiler/typeParameterDefaultInCallInsideGenericCallback.errors.txt b/tsc/testdata/baselines/reference/compiler/typeParameterDefaultInCallInsideGenericCallback.errors.txt new file mode 100644 index 0000000000000..8c9d175baec15 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/typeParameterDefaultInCallInsideGenericCallback.errors.txt @@ -0,0 +1,28 @@ +typeParameterDefaultInCallInsideGenericCallback.ts(18,28): error TS2345: Argument of type '{ v: number; }' is not assignable to parameter of type 'undefined'. + + +==== typeParameterDefaultInCallInsideGenericCallback.ts (1 errors) ==== + // The default of T applies to the call inside the callback passed to another + // generic function as it does elsewhere, so data is accepted. + + declare function fetcher(cfg: unknown): Promise; + + type Routes = R extends 'x' ? { IN: { v: number }, OUT: string } : never; + + function executeFetch>( + route: R, + body?: T extends Record<'IN', any> ? T['IN'] : never + ) { + return fetcher ? T['OUT'] : T>({ route, body }); + } + + declare function useCallback(cb: T, deps: unknown[]): T; + + export const cb = useCallback((data: { v: number }) => { + return executeFetch('x', data); + ~~~~ +!!! error TS2345: Argument of type '{ v: number; }' is not assignable to parameter of type 'undefined'. + }, []); + + export const check: Promise = cb({ v: 1 }); + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/typeParameterDefaultInCallInsideGenericCallback.symbols b/tsc/testdata/baselines/reference/compiler/typeParameterDefaultInCallInsideGenericCallback.symbols new file mode 100644 index 0000000000000..f2753a2cd94e0 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/typeParameterDefaultInCallInsideGenericCallback.symbols @@ -0,0 +1,76 @@ +//// [tests/cases/compiler/typeParameterDefaultInCallInsideGenericCallback.ts] //// + +=== typeParameterDefaultInCallInsideGenericCallback.ts === +// The default of T applies to the call inside the callback passed to another +// generic function as it does elsewhere, so data is accepted. + +declare function fetcher(cfg: unknown): Promise; +>fetcher : Symbol(fetcher, Decl(typeParameterDefaultInCallInsideGenericCallback.ts, 0, 0)) +>D : Symbol(D, Decl(typeParameterDefaultInCallInsideGenericCallback.ts, 3, 25)) +>cfg : Symbol(cfg, Decl(typeParameterDefaultInCallInsideGenericCallback.ts, 3, 28)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2018.promise.d.ts, --, --)) +>D : Symbol(D, Decl(typeParameterDefaultInCallInsideGenericCallback.ts, 3, 25)) + +type Routes = R extends 'x' ? { IN: { v: number }, OUT: string } : never; +>Routes : Symbol(Routes, Decl(typeParameterDefaultInCallInsideGenericCallback.ts, 3, 54)) +>R : Symbol(R, Decl(typeParameterDefaultInCallInsideGenericCallback.ts, 5, 12)) +>R : Symbol(R, Decl(typeParameterDefaultInCallInsideGenericCallback.ts, 5, 12)) +>IN : Symbol(IN, Decl(typeParameterDefaultInCallInsideGenericCallback.ts, 5, 34)) +>v : Symbol(v, Decl(typeParameterDefaultInCallInsideGenericCallback.ts, 5, 40)) +>OUT : Symbol(OUT, Decl(typeParameterDefaultInCallInsideGenericCallback.ts, 5, 53)) + +function executeFetch>( +>executeFetch : Symbol(executeFetch, Decl(typeParameterDefaultInCallInsideGenericCallback.ts, 5, 76)) +>R : Symbol(R, Decl(typeParameterDefaultInCallInsideGenericCallback.ts, 7, 22)) +>T : Symbol(T, Decl(typeParameterDefaultInCallInsideGenericCallback.ts, 7, 39)) +>Routes : Symbol(Routes, Decl(typeParameterDefaultInCallInsideGenericCallback.ts, 3, 54)) +>R : Symbol(R, Decl(typeParameterDefaultInCallInsideGenericCallback.ts, 7, 22)) + + route: R, +>route : Symbol(route, Decl(typeParameterDefaultInCallInsideGenericCallback.ts, 7, 55)) +>R : Symbol(R, Decl(typeParameterDefaultInCallInsideGenericCallback.ts, 7, 22)) + + body?: T extends Record<'IN', any> ? T['IN'] : never +>body : Symbol(body, Decl(typeParameterDefaultInCallInsideGenericCallback.ts, 8, 11)) +>T : Symbol(T, Decl(typeParameterDefaultInCallInsideGenericCallback.ts, 7, 39)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) +>T : Symbol(T, Decl(typeParameterDefaultInCallInsideGenericCallback.ts, 7, 39)) + +) { + return fetcher ? T['OUT'] : T>({ route, body }); +>fetcher : Symbol(fetcher, Decl(typeParameterDefaultInCallInsideGenericCallback.ts, 0, 0)) +>T : Symbol(T, Decl(typeParameterDefaultInCallInsideGenericCallback.ts, 7, 39)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) +>T : Symbol(T, Decl(typeParameterDefaultInCallInsideGenericCallback.ts, 7, 39)) +>T : Symbol(T, Decl(typeParameterDefaultInCallInsideGenericCallback.ts, 7, 39)) +>route : Symbol(route, Decl(typeParameterDefaultInCallInsideGenericCallback.ts, 11, 63)) +>body : Symbol(body, Decl(typeParameterDefaultInCallInsideGenericCallback.ts, 11, 70)) +} + +declare function useCallback(cb: T, deps: unknown[]): T; +>useCallback : Symbol(useCallback, Decl(typeParameterDefaultInCallInsideGenericCallback.ts, 12, 1)) +>T : Symbol(T, Decl(typeParameterDefaultInCallInsideGenericCallback.ts, 14, 29)) +>Function : Symbol(Function, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.esnext.decorators.d.ts, --, --)) +>cb : Symbol(cb, Decl(typeParameterDefaultInCallInsideGenericCallback.ts, 14, 49)) +>T : Symbol(T, Decl(typeParameterDefaultInCallInsideGenericCallback.ts, 14, 29)) +>deps : Symbol(deps, Decl(typeParameterDefaultInCallInsideGenericCallback.ts, 14, 55)) +>T : Symbol(T, Decl(typeParameterDefaultInCallInsideGenericCallback.ts, 14, 29)) + +export const cb = useCallback((data: { v: number }) => { +>cb : Symbol(cb, Decl(typeParameterDefaultInCallInsideGenericCallback.ts, 16, 12)) +>useCallback : Symbol(useCallback, Decl(typeParameterDefaultInCallInsideGenericCallback.ts, 12, 1)) +>data : Symbol(data, Decl(typeParameterDefaultInCallInsideGenericCallback.ts, 16, 31)) +>v : Symbol(v, Decl(typeParameterDefaultInCallInsideGenericCallback.ts, 16, 38)) + + return executeFetch('x', data); +>executeFetch : Symbol(executeFetch, Decl(typeParameterDefaultInCallInsideGenericCallback.ts, 5, 76)) +>data : Symbol(data, Decl(typeParameterDefaultInCallInsideGenericCallback.ts, 16, 31)) + +}, []); + +export const check: Promise = cb({ v: 1 }); +>check : Symbol(check, Decl(typeParameterDefaultInCallInsideGenericCallback.ts, 20, 12)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2018.promise.d.ts, --, --)) +>cb : Symbol(cb, Decl(typeParameterDefaultInCallInsideGenericCallback.ts, 16, 12)) +>v : Symbol(v, Decl(typeParameterDefaultInCallInsideGenericCallback.ts, 20, 42)) + diff --git a/tsc/testdata/baselines/reference/compiler/typeParameterDefaultInCallInsideGenericCallback.types b/tsc/testdata/baselines/reference/compiler/typeParameterDefaultInCallInsideGenericCallback.types new file mode 100644 index 0000000000000..ed2acda45dd86 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/typeParameterDefaultInCallInsideGenericCallback.types @@ -0,0 +1,64 @@ +//// [tests/cases/compiler/typeParameterDefaultInCallInsideGenericCallback.ts] //// + +=== typeParameterDefaultInCallInsideGenericCallback.ts === +// The default of T applies to the call inside the callback passed to another +// generic function as it does elsewhere, so data is accepted. + +declare function fetcher(cfg: unknown): Promise; +>fetcher : (cfg: unknown) => Promise +>cfg : unknown + +type Routes = R extends 'x' ? { IN: { v: number }, OUT: string } : never; +>Routes : Routes +>IN : { v: number; } +>v : number +>OUT : string + +function executeFetch>( +>executeFetch : >(route: R, body?: T extends Record<'IN', any> ? T['IN'] : never) => Promise ? T["OUT"] : T> + + route: R, +>route : R + + body?: T extends Record<'IN', any> ? T['IN'] : never +>body : (T extends Record<"IN", any> ? T["IN"] : never) | undefined + +) { + return fetcher ? T['OUT'] : T>({ route, body }); +>fetcher ? T['OUT'] : T>({ route, body }) : Promise ? T["OUT"] : T> +>fetcher : (cfg: unknown) => Promise +>{ route, body } : { route: R; body: (T extends Record<"IN", any> ? T["IN"] : never) | undefined; } +>route : R +>body : (T extends Record<"IN", any> ? T["IN"] : never) | undefined +} + +declare function useCallback(cb: T, deps: unknown[]): T; +>useCallback : (cb: T, deps: unknown[]) => T +>cb : T +>deps : unknown[] + +export const cb = useCallback((data: { v: number }) => { +>cb : (data: { v: number; }) => Promise +>useCallback((data: { v: number }) => { return executeFetch('x', data);}, []) : (data: { v: number; }) => Promise +>useCallback : (cb: T, deps: unknown[]) => T +>(data: { v: number }) => { return executeFetch('x', data);} : (data: { v: number; }) => Promise +>data : { v: number; } +>v : number + + return executeFetch('x', data); +>executeFetch('x', data) : Promise +>executeFetch : >(route: R, body?: T extends Record<'IN', any> ? T['IN'] : never) => Promise ? T["OUT"] : T> +>'x' : "x" +>data : { v: number; } + +}, []); +>[] : never[] + +export const check: Promise = cb({ v: 1 }); +>check : Promise +>cb({ v: 1 }) : Promise +>cb : (data: { v: number; }) => Promise +>{ v: 1 } : { v: number; } +>v : number +>1 : 1 + diff --git a/tsc/testdata/baselines/reference/compiler/typeParameterHasSelfAsConstraint(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/typeParameterHasSelfAsConstraint(checkorder=default).errors.txt new file mode 100644 index 0000000000000..b7a0b982aceb6 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/typeParameterHasSelfAsConstraint(checkorder=default).errors.txt @@ -0,0 +1,15 @@ +typeParameterHasSelfAsConstraint.ts(1,24): error TS2313: Type parameter 'T' has a circular constraint. +typeParameterHasSelfAsConstraint.ts(2,5): error TS2322: Type 'T' is not assignable to type 'number'. + + +==== typeParameterHasSelfAsConstraint.ts (2 errors) ==== + function foo(x: T): number { + ~ +!!! error TS2313: Type parameter 'T' has a circular constraint. + return x; + ~~~~~~ +!!! error TS2322: Type 'T' is not assignable to type 'number'. +!!! related TS2208 typeParameterHasSelfAsConstraint.ts:1:14: This type parameter might need an `extends number` constraint. + } + + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/typeParameterHasSelfAsConstraint(checkorder=default).js b/tsc/testdata/baselines/reference/compiler/typeParameterHasSelfAsConstraint(checkorder=default).js new file mode 100644 index 0000000000000..2b6ae7f2bca3f --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/typeParameterHasSelfAsConstraint(checkorder=default).js @@ -0,0 +1,14 @@ +//// [tests/cases/compiler/typeParameterHasSelfAsConstraint.ts] //// + +//// [typeParameterHasSelfAsConstraint.ts] +function foo(x: T): number { + return x; +} + + + +//// [typeParameterHasSelfAsConstraint.js] +"use strict"; +function foo(x) { + return x; +} diff --git a/tsc/testdata/baselines/reference/compiler/typeParameterHasSelfAsConstraint(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/typeParameterHasSelfAsConstraint(checkorder=default).symbols new file mode 100644 index 0000000000000..e8a52432a83dc --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/typeParameterHasSelfAsConstraint(checkorder=default).symbols @@ -0,0 +1,15 @@ +//// [tests/cases/compiler/typeParameterHasSelfAsConstraint.ts] //// + +=== typeParameterHasSelfAsConstraint.ts === +function foo(x: T): number { +>foo : Symbol(foo, Decl(typeParameterHasSelfAsConstraint.ts, 0, 0)) +>T : Symbol(T, Decl(typeParameterHasSelfAsConstraint.ts, 0, 13)) +>T : Symbol(T, Decl(typeParameterHasSelfAsConstraint.ts, 0, 13)) +>x : Symbol(x, Decl(typeParameterHasSelfAsConstraint.ts, 0, 26)) +>T : Symbol(T, Decl(typeParameterHasSelfAsConstraint.ts, 0, 13)) + + return x; +>x : Symbol(x, Decl(typeParameterHasSelfAsConstraint.ts, 0, 26)) +} + + diff --git a/tsc/testdata/baselines/reference/compiler/typeParameterHasSelfAsConstraint(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/typeParameterHasSelfAsConstraint(checkorder=default).types new file mode 100644 index 0000000000000..dd8af60e8c209 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/typeParameterHasSelfAsConstraint(checkorder=default).types @@ -0,0 +1,12 @@ +//// [tests/cases/compiler/typeParameterHasSelfAsConstraint.ts] //// + +=== typeParameterHasSelfAsConstraint.ts === +function foo(x: T): number { +>foo : (x: T) => number +>x : T + + return x; +>x : T +} + + diff --git a/tsc/testdata/baselines/reference/compiler/typeParameterHasSelfAsConstraint(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/typeParameterHasSelfAsConstraint(checkorder=typesfirst).errors.txt new file mode 100644 index 0000000000000..83997ce99f298 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/typeParameterHasSelfAsConstraint(checkorder=typesfirst).errors.txt @@ -0,0 +1,16 @@ +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. +!!! related TS2751 typeParameterHasSelfAsConstraint.ts:2:12: Circularity originates in type at this location. + 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/typeReferenceRecursionIdentityCheckOrder(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/typeReferenceRecursionIdentityCheckOrder(checkorder=default).errors.txt new file mode 100644 index 0000000000000..2f05537ca40a0 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/typeReferenceRecursionIdentityCheckOrder(checkorder=default).errors.txt @@ -0,0 +1,35 @@ +typeReferenceRecursionIdentityCheckOrder.ts(11,7): error TS2322: Type 'never[]' is not assignable to type 'A<0>'. + The types returned by 'slice(...).every' are incompatible between these types. + Type '{ (predicate: (value: never, index: number, array: never[]) => value is S, thisArg?: any): this is S[]; (predicate: (value: never, index: number, array: never[]) => unknown, thisArg?: any): boolean; }' is not assignable to type '(predicate: (value: 0) => value is S) => this is A'. + Type predicate 'this is any[]' is not assignable to 'this is A'. + Type 'any[]' is not assignable to type 'A'. + The types returned by 'slice(...).flatMap(...)' are incompatible between these types. + Type '(U | A)[]' is not assignable to type 'U[]'. + Type 'U | A' is not assignable to type 'U'. + 'U' could be instantiated with an arbitrary type which could be unrelated to 'U | A'. + + +==== typeReferenceRecursionIdentityCheckOrder.ts (1 errors) ==== + // Comparing never[] to B<0> nests comparisons of the members of A and B. + // Whether they are cut short as deeply nested must not depend on whether the + // annotation of b is resolved before checking a instantiates slice. + + interface A { + slice(): B; + every(predicate: (value: T) => value is S): this is A; + flatMap(callback: (value: T) => U | readonly U[] | A): U[]; + } + interface B extends A {} + const a: A<0> = []; + ~ +!!! error TS2322: Type 'never[]' is not assignable to type 'A<0>'. +!!! error TS2322: The types returned by 'slice(...).every' are incompatible between these types. +!!! error TS2322: Type '{ (predicate: (value: never, index: number, array: never[]) => value is S, thisArg?: any): this is S[]; (predicate: (value: never, index: number, array: never[]) => unknown, thisArg?: any): boolean; }' is not assignable to type '(predicate: (value: 0) => value is S) => this is A'. +!!! error TS2322: Type predicate 'this is any[]' is not assignable to 'this is A'. +!!! error TS2322: Type 'any[]' is not assignable to type 'A'. +!!! error TS2322: The types returned by 'slice(...).flatMap(...)' are incompatible between these types. +!!! error TS2322: Type '(U | A)[]' is not assignable to type 'U[]'. +!!! error TS2322: Type 'U | A' is not assignable to type 'U'. +!!! error TS2322: 'U' could be instantiated with an arbitrary type which could be unrelated to 'U | A'. + const b: B<0> = []; + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/typeReferenceRecursionIdentityCheckOrder(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/typeReferenceRecursionIdentityCheckOrder(checkorder=default).symbols new file mode 100644 index 0000000000000..44770d906e0ac --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/typeReferenceRecursionIdentityCheckOrder(checkorder=default).symbols @@ -0,0 +1,54 @@ +//// [tests/cases/compiler/typeReferenceRecursionIdentityCheckOrder.ts] //// + +=== typeReferenceRecursionIdentityCheckOrder.ts === +// Comparing never[] to B<0> nests comparisons of the members of A and B. +// Whether they are cut short as deeply nested must not depend on whether the +// annotation of b is resolved before checking a instantiates slice. + +interface A { +>A : Symbol(A, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 0, 0)) +>T : Symbol(T, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 4, 12)) + + slice(): B; +>slice : Symbol(A.slice, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 4, 16)) +>B : Symbol(B, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 8, 1)) +>T : Symbol(T, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 4, 12)) + + every(predicate: (value: T) => value is S): this is A; +>every : Symbol(A.every, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 5, 18)) +>S : Symbol(S, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 6, 10)) +>T : Symbol(T, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 4, 12)) +>predicate : Symbol(predicate, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 6, 23)) +>value : Symbol(value, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 6, 35)) +>T : Symbol(T, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 4, 12)) +>value : Symbol(value, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 6, 35)) +>S : Symbol(S, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 6, 10)) +>A : Symbol(A, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 0, 0)) +>S : Symbol(S, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 6, 10)) + + flatMap(callback: (value: T) => U | readonly U[] | A): U[]; +>flatMap : Symbol(A.flatMap, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 6, 74)) +>U : Symbol(U, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 7, 12)) +>callback : Symbol(callback, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 7, 15)) +>value : Symbol(value, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 7, 26)) +>T : Symbol(T, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 4, 12)) +>U : Symbol(U, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 7, 12)) +>U : Symbol(U, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 7, 12)) +>A : Symbol(A, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 0, 0)) +>U : Symbol(U, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 7, 12)) +>U : Symbol(U, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 7, 12)) +} +interface B extends A {} +>B : Symbol(B, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 8, 1)) +>T : Symbol(T, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 9, 12)) +>A : Symbol(A, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 0, 0)) +>T : Symbol(T, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 9, 12)) + +const a: A<0> = []; +>a : Symbol(a, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 10, 5)) +>A : Symbol(A, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 0, 0)) + +const b: B<0> = []; +>b : Symbol(b, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 11, 5)) +>B : Symbol(B, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 8, 1)) + diff --git a/tsc/testdata/baselines/reference/compiler/typeReferenceRecursionIdentityCheckOrder(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/typeReferenceRecursionIdentityCheckOrder(checkorder=default).types new file mode 100644 index 0000000000000..bab8645e582b3 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/typeReferenceRecursionIdentityCheckOrder(checkorder=default).types @@ -0,0 +1,30 @@ +//// [tests/cases/compiler/typeReferenceRecursionIdentityCheckOrder.ts] //// + +=== typeReferenceRecursionIdentityCheckOrder.ts === +// Comparing never[] to B<0> nests comparisons of the members of A and B. +// Whether they are cut short as deeply nested must not depend on whether the +// annotation of b is resolved before checking a instantiates slice. + +interface A { + slice(): B; +>slice : () => B + + every(predicate: (value: T) => value is S): this is A; +>every : (predicate: (value: T) => value is S) => this is A +>predicate : (value: T) => value is S +>value : T + + flatMap(callback: (value: T) => U | readonly U[] | A): U[]; +>flatMap : (callback: (value: T) => U | readonly U[] | A) => U[] +>callback : (value: T) => U | readonly U[] | A +>value : T +} +interface B extends A {} +const a: A<0> = []; +>a : A<0> +>[] : never[] + +const b: B<0> = []; +>b : B<0> +>[] : never[] + diff --git a/tsc/testdata/baselines/reference/compiler/typeReferenceRecursionIdentityCheckOrder(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/typeReferenceRecursionIdentityCheckOrder(checkorder=typesfirst).errors.txt new file mode 100644 index 0000000000000..6e024512e0b5b --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/typeReferenceRecursionIdentityCheckOrder(checkorder=typesfirst).errors.txt @@ -0,0 +1,54 @@ +typeReferenceRecursionIdentityCheckOrder.ts(11,7): error TS2322: Type 'never[]' is not assignable to type 'A<0>'. + The types returned by 'slice(...).every' are incompatible between these types. + Type '{ (predicate: (value: never, index: number, array: never[]) => value is S, thisArg?: any): this is S[]; (predicate: (value: never, index: number, array: never[]) => unknown, thisArg?: any): boolean; }' is not assignable to type '(predicate: (value: 0) => value is S) => this is A'. + Type predicate 'this is any[]' is not assignable to 'this is A'. + Type 'any[]' is not assignable to type 'A'. + The types returned by 'slice(...).flatMap(...)' are incompatible between these types. + Type '(U | A)[]' is not assignable to type 'U[]'. + Type 'U | A' is not assignable to type 'U'. + 'U' could be instantiated with an arbitrary type which could be unrelated to 'U | A'. +typeReferenceRecursionIdentityCheckOrder.ts(12,7): error TS2322: Type 'never[]' is not assignable to type 'B<0>'. + The types returned by 'slice(...).every' are incompatible between these types. + Type '{ (predicate: (value: never, index: number, array: never[]) => value is S, thisArg?: any): this is S[]; (predicate: (value: never, index: number, array: never[]) => unknown, thisArg?: any): boolean; }' is not assignable to type '(predicate: (value: 0) => value is S) => this is A'. + Type predicate 'this is any[]' is not assignable to 'this is A'. + Type 'any[]' is not assignable to type 'A'. + The types returned by 'slice(...).flatMap(...)' are incompatible between these types. + Type '(U | A)[]' is not assignable to type 'U[]'. + Type 'U | A' is not assignable to type 'U'. + 'U' could be instantiated with an arbitrary type which could be unrelated to 'U | A'. + + +==== typeReferenceRecursionIdentityCheckOrder.ts (2 errors) ==== + // Comparing never[] to B<0> nests comparisons of the members of A and B. + // Whether they are cut short as deeply nested must not depend on whether the + // annotation of b is resolved before checking a instantiates slice. + + interface A { + slice(): B; + every(predicate: (value: T) => value is S): this is A; + flatMap(callback: (value: T) => U | readonly U[] | A): U[]; + } + interface B extends A {} + const a: A<0> = []; + ~ +!!! error TS2322: Type 'never[]' is not assignable to type 'A<0>'. +!!! error TS2322: The types returned by 'slice(...).every' are incompatible between these types. +!!! error TS2322: Type '{ (predicate: (value: never, index: number, array: never[]) => value is S, thisArg?: any): this is S[]; (predicate: (value: never, index: number, array: never[]) => unknown, thisArg?: any): boolean; }' is not assignable to type '(predicate: (value: 0) => value is S) => this is A'. +!!! error TS2322: Type predicate 'this is any[]' is not assignable to 'this is A'. +!!! error TS2322: Type 'any[]' is not assignable to type 'A'. +!!! error TS2322: The types returned by 'slice(...).flatMap(...)' are incompatible between these types. +!!! error TS2322: Type '(U | A)[]' is not assignable to type 'U[]'. +!!! error TS2322: Type 'U | A' is not assignable to type 'U'. +!!! error TS2322: 'U' could be instantiated with an arbitrary type which could be unrelated to 'U | A'. + const b: B<0> = []; + ~ +!!! error TS2322: Type 'never[]' is not assignable to type 'B<0>'. +!!! error TS2322: The types returned by 'slice(...).every' are incompatible between these types. +!!! error TS2322: Type '{ (predicate: (value: never, index: number, array: never[]) => value is S, thisArg?: any): this is S[]; (predicate: (value: never, index: number, array: never[]) => unknown, thisArg?: any): boolean; }' is not assignable to type '(predicate: (value: 0) => value is S) => this is A'. +!!! error TS2322: Type predicate 'this is any[]' is not assignable to 'this is A'. +!!! error TS2322: Type 'any[]' is not assignable to type 'A'. +!!! error TS2322: The types returned by 'slice(...).flatMap(...)' are incompatible between these types. +!!! error TS2322: Type '(U | A)[]' is not assignable to type 'U[]'. +!!! error TS2322: Type 'U | A' is not assignable to type 'U'. +!!! error TS2322: 'U' could be instantiated with an arbitrary type which could be unrelated to 'U | A'. + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/typeReferenceRecursionIdentityCheckOrder(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/typeReferenceRecursionIdentityCheckOrder(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..44770d906e0ac --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/typeReferenceRecursionIdentityCheckOrder(checkorder=typesfirst).symbols @@ -0,0 +1,54 @@ +//// [tests/cases/compiler/typeReferenceRecursionIdentityCheckOrder.ts] //// + +=== typeReferenceRecursionIdentityCheckOrder.ts === +// Comparing never[] to B<0> nests comparisons of the members of A and B. +// Whether they are cut short as deeply nested must not depend on whether the +// annotation of b is resolved before checking a instantiates slice. + +interface A { +>A : Symbol(A, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 0, 0)) +>T : Symbol(T, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 4, 12)) + + slice(): B; +>slice : Symbol(A.slice, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 4, 16)) +>B : Symbol(B, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 8, 1)) +>T : Symbol(T, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 4, 12)) + + every(predicate: (value: T) => value is S): this is A; +>every : Symbol(A.every, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 5, 18)) +>S : Symbol(S, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 6, 10)) +>T : Symbol(T, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 4, 12)) +>predicate : Symbol(predicate, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 6, 23)) +>value : Symbol(value, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 6, 35)) +>T : Symbol(T, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 4, 12)) +>value : Symbol(value, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 6, 35)) +>S : Symbol(S, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 6, 10)) +>A : Symbol(A, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 0, 0)) +>S : Symbol(S, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 6, 10)) + + flatMap(callback: (value: T) => U | readonly U[] | A): U[]; +>flatMap : Symbol(A.flatMap, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 6, 74)) +>U : Symbol(U, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 7, 12)) +>callback : Symbol(callback, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 7, 15)) +>value : Symbol(value, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 7, 26)) +>T : Symbol(T, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 4, 12)) +>U : Symbol(U, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 7, 12)) +>U : Symbol(U, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 7, 12)) +>A : Symbol(A, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 0, 0)) +>U : Symbol(U, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 7, 12)) +>U : Symbol(U, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 7, 12)) +} +interface B extends A {} +>B : Symbol(B, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 8, 1)) +>T : Symbol(T, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 9, 12)) +>A : Symbol(A, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 0, 0)) +>T : Symbol(T, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 9, 12)) + +const a: A<0> = []; +>a : Symbol(a, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 10, 5)) +>A : Symbol(A, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 0, 0)) + +const b: B<0> = []; +>b : Symbol(b, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 11, 5)) +>B : Symbol(B, Decl(typeReferenceRecursionIdentityCheckOrder.ts, 8, 1)) + diff --git a/tsc/testdata/baselines/reference/compiler/typeReferenceRecursionIdentityCheckOrder(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/typeReferenceRecursionIdentityCheckOrder(checkorder=typesfirst).types new file mode 100644 index 0000000000000..bab8645e582b3 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/typeReferenceRecursionIdentityCheckOrder(checkorder=typesfirst).types @@ -0,0 +1,30 @@ +//// [tests/cases/compiler/typeReferenceRecursionIdentityCheckOrder.ts] //// + +=== typeReferenceRecursionIdentityCheckOrder.ts === +// Comparing never[] to B<0> nests comparisons of the members of A and B. +// Whether they are cut short as deeply nested must not depend on whether the +// annotation of b is resolved before checking a instantiates slice. + +interface A { + slice(): B; +>slice : () => B + + every(predicate: (value: T) => value is S): this is A; +>every : (predicate: (value: T) => value is S) => this is A +>predicate : (value: T) => value is S +>value : T + + flatMap(callback: (value: T) => U | readonly U[] | A): U[]; +>flatMap : (callback: (value: T) => U | readonly U[] | A) => U[] +>callback : (value: T) => U | readonly U[] | A +>value : T +} +interface B extends A {} +const a: A<0> = []; +>a : A<0> +>[] : never[] + +const b: B<0> = []; +>b : B<0> +>[] : never[] + diff --git a/tsc/testdata/baselines/reference/compiler/unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1(checkorder=default).errors.txt new file mode 100644 index 0000000000000..f2bff262ffc44 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1(checkorder=default).errors.txt @@ -0,0 +1,28 @@ +unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1.ts(1,18): error TS6133: 'person' is declared but its value is never read. +unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1.ts(1,34): error TS6133: 'person2' is declared but its value is never read. +unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1.ts(2,9): error TS6133: 'unused' is declared but its value is never read. +unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1.ts(3,14): error TS6133: 'maker' is declared but its value is never read. +unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1.ts(3,20): error TS6133: 'child' is declared but its value is never read. +unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1.ts(4,13): error TS6133: 'unused2' is declared but its value is never read. + + +==== unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1.ts (6 errors) ==== + function greeter(person: string, person2: string) { + ~~~~~~ +!!! error TS6133: 'person' is declared but its value is never read. + ~~~~~~~ +!!! error TS6133: 'person2' is declared but its value is never read. + var unused = 20; + ~~~~~~ +!!! error TS6133: 'unused' is declared but its value is never read. + function maker(child: string): void { + ~~~~~ +!!! error TS6133: 'maker' is declared but its value is never read. + ~~~~~ +!!! error TS6133: 'child' is declared but its value is never read. + var unused2 = 22; + ~~~~~~~ +!!! error TS6133: 'unused2' is declared but its value is never read. + } + person2 = "dummy value"; + } \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1(checkorder=default).js b/tsc/testdata/baselines/reference/compiler/unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1(checkorder=default).js new file mode 100644 index 0000000000000..9457d5135a002 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1(checkorder=default).js @@ -0,0 +1,20 @@ +//// [tests/cases/compiler/unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1.ts] //// + +//// [unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1.ts] +function greeter(person: string, person2: string) { + var unused = 20; + function maker(child: string): void { + var unused2 = 22; + } + person2 = "dummy value"; +} + +//// [unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1.js] +"use strict"; +function greeter(person, person2) { + var unused = 20; + function maker(child) { + var unused2 = 22; + } + person2 = "dummy value"; +} diff --git a/tsc/testdata/baselines/reference/compiler/unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1(checkorder=default).symbols new file mode 100644 index 0000000000000..7f6c7e03b1461 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1(checkorder=default).symbols @@ -0,0 +1,21 @@ +//// [tests/cases/compiler/unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1.ts] //// + +=== unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1.ts === +function greeter(person: string, person2: string) { +>greeter : Symbol(greeter, Decl(unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1.ts, 0, 0)) +>person : Symbol(person, Decl(unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1.ts, 0, 17)) +>person2 : Symbol(person2, Decl(unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1.ts, 0, 32)) + + var unused = 20; +>unused : Symbol(unused, Decl(unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1.ts, 1, 7)) + + function maker(child: string): void { +>maker : Symbol(maker, Decl(unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1.ts, 1, 20)) +>child : Symbol(child, Decl(unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1.ts, 2, 19)) + + var unused2 = 22; +>unused2 : Symbol(unused2, Decl(unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1.ts, 3, 11)) + } + person2 = "dummy value"; +>person2 : Symbol(person2, Decl(unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1.ts, 0, 32)) +} diff --git a/tsc/testdata/baselines/reference/compiler/unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1(checkorder=default).types new file mode 100644 index 0000000000000..0a0c9a1359a5f --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1(checkorder=default).types @@ -0,0 +1,25 @@ +//// [tests/cases/compiler/unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1.ts] //// + +=== unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1.ts === +function greeter(person: string, person2: string) { +>greeter : (person: string, person2: string) => void +>person : string +>person2 : string + + var unused = 20; +>unused : number +>20 : 20 + + function maker(child: string): void { +>maker : (child: string) => void +>child : string + + var unused2 = 22; +>unused2 : number +>22 : 22 + } + person2 = "dummy value"; +>person2 = "dummy value" : "dummy value" +>person2 : string +>"dummy value" : "dummy value" +} diff --git a/tsc/testdata/baselines/reference/compiler/unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1(checkorder=typesfirst).errors.txt new file mode 100644 index 0000000000000..387fe2f14d0be --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1(checkorder=typesfirst).errors.txt @@ -0,0 +1,25 @@ +unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1.ts(1,18): error TS6133: 'person' 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 (5 errors) ==== + function greeter(person: string, person2: string) { + ~~~~~~ +!!! error TS6133: 'person' 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/unusedTypeParameterQueryOrder(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/unusedTypeParameterQueryOrder(checkorder=default).errors.txt new file mode 100644 index 0000000000000..55aecda78cdca --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/unusedTypeParameterQueryOrder(checkorder=default).errors.txt @@ -0,0 +1,12 @@ +unusedTypeParameterQueryOrder.ts(3,17): error TS6196: 'T' is declared but never used. + + +==== unusedTypeParameterQueryOrder.ts (1 errors) ==== + class A { + f() { + return () => {}; + ~ +!!! error TS6196: 'T' is declared but never used. + } + } + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/unusedTypeParameterQueryOrder(checkorder=default).js b/tsc/testdata/baselines/reference/compiler/unusedTypeParameterQueryOrder(checkorder=default).js new file mode 100644 index 0000000000000..7bbfd20d663d7 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/unusedTypeParameterQueryOrder(checkorder=default).js @@ -0,0 +1,17 @@ +//// [tests/cases/compiler/unusedTypeParameterQueryOrder.ts] //// + +//// [unusedTypeParameterQueryOrder.ts] +class A { + f() { + return () => {}; + } +} + + +//// [unusedTypeParameterQueryOrder.js] +"use strict"; +class A { + f() { + return () => { }; + } +} diff --git a/tsc/testdata/baselines/reference/compiler/unusedTypeParameterQueryOrder(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/unusedTypeParameterQueryOrder(checkorder=default).symbols new file mode 100644 index 0000000000000..827db0c67998a --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/unusedTypeParameterQueryOrder(checkorder=default).symbols @@ -0,0 +1,14 @@ +//// [tests/cases/compiler/unusedTypeParameterQueryOrder.ts] //// + +=== unusedTypeParameterQueryOrder.ts === +class A { +>A : Symbol(A, Decl(unusedTypeParameterQueryOrder.ts, 0, 0)) + + f() { +>f : Symbol(A.f, Decl(unusedTypeParameterQueryOrder.ts, 0, 9)) + + return () => {}; +>T : Symbol(T, Decl(unusedTypeParameterQueryOrder.ts, 2, 16)) + } +} + diff --git a/tsc/testdata/baselines/reference/compiler/unusedTypeParameterQueryOrder(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/unusedTypeParameterQueryOrder(checkorder=default).types new file mode 100644 index 0000000000000..0f1b46b9de35e --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/unusedTypeParameterQueryOrder(checkorder=default).types @@ -0,0 +1,14 @@ +//// [tests/cases/compiler/unusedTypeParameterQueryOrder.ts] //// + +=== unusedTypeParameterQueryOrder.ts === +class A { +>A : A + + f() { +>f : () => () => void + + return () => {}; +>() => {} : () => void + } +} + diff --git a/tsc/testdata/baselines/reference/compiler/unusedTypeParameterQueryOrder(checkorder=editorfirst).js b/tsc/testdata/baselines/reference/compiler/unusedTypeParameterQueryOrder(checkorder=editorfirst).js new file mode 100644 index 0000000000000..7bbfd20d663d7 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/unusedTypeParameterQueryOrder(checkorder=editorfirst).js @@ -0,0 +1,17 @@ +//// [tests/cases/compiler/unusedTypeParameterQueryOrder.ts] //// + +//// [unusedTypeParameterQueryOrder.ts] +class A { + f() { + return () => {}; + } +} + + +//// [unusedTypeParameterQueryOrder.js] +"use strict"; +class A { + f() { + return () => { }; + } +} diff --git a/tsc/testdata/baselines/reference/compiler/unusedTypeParameterQueryOrder(checkorder=editorfirst).symbols b/tsc/testdata/baselines/reference/compiler/unusedTypeParameterQueryOrder(checkorder=editorfirst).symbols new file mode 100644 index 0000000000000..827db0c67998a --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/unusedTypeParameterQueryOrder(checkorder=editorfirst).symbols @@ -0,0 +1,14 @@ +//// [tests/cases/compiler/unusedTypeParameterQueryOrder.ts] //// + +=== unusedTypeParameterQueryOrder.ts === +class A { +>A : Symbol(A, Decl(unusedTypeParameterQueryOrder.ts, 0, 0)) + + f() { +>f : Symbol(A.f, Decl(unusedTypeParameterQueryOrder.ts, 0, 9)) + + return () => {}; +>T : Symbol(T, Decl(unusedTypeParameterQueryOrder.ts, 2, 16)) + } +} + diff --git a/tsc/testdata/baselines/reference/compiler/unusedTypeParameterQueryOrder(checkorder=editorfirst).types b/tsc/testdata/baselines/reference/compiler/unusedTypeParameterQueryOrder(checkorder=editorfirst).types new file mode 100644 index 0000000000000..0f1b46b9de35e --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/unusedTypeParameterQueryOrder(checkorder=editorfirst).types @@ -0,0 +1,14 @@ +//// [tests/cases/compiler/unusedTypeParameterQueryOrder.ts] //// + +=== unusedTypeParameterQueryOrder.ts === +class A { +>A : A + + f() { +>f : () => () => void + + return () => {}; +>() => {} : () => void + } +} + diff --git a/tsc/testdata/baselines/reference/compiler/varianceCircularConsistency.errors.txt b/tsc/testdata/baselines/reference/compiler/varianceCircularConsistency.errors.txt new file mode 100644 index 0000000000000..a4725d41bf2bf --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/varianceCircularConsistency.errors.txt @@ -0,0 +1,48 @@ +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 (1 errors) ==== + // Variances of these mutually recursive generics must not depend on values + // measured mid-cycle. Assigning `e` to `EntryPoint` must agree with + // assigning `e.root` to `EntryPoint["root"]`. + + interface Query {} + type Component

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

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

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

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

+ +// This is intersected with methods/properties. +type MaybeCallableProvider = T extends ((...args: any[]) => any) ? MethodOrProperty : unknown; +>MaybeCallableProvider : MaybeCallableProvider +>args : any[] + +type TupleIndexKeys> = Extract; +>TupleIndexKeys : TupleIndexKeys + +type MapCallbackValue = // `Omit` removes call signatures, so re-intersect callable provider behavior. +>MapCallbackValue : MapCallbackValue + +T extends unknown ? Omit, keyof Promise> & MaybeCallableProvider & MapValuePlaceholder : never; +type InvalidNativePromiseInMapResult = T extends unknown ? InvalidNativePromiseInMapResultImpl : never; +>InvalidNativePromiseInMapResult : InvalidNativePromiseInMapResult + +type InvalidNativePromiseInMapResultImpl = [T] extends [Seen] ? never // RpcPromise is modeled as Promise & StubBase, so allow promise-like stub values. +>InvalidNativePromiseInMapResultImpl : InvalidNativePromiseInMapResultImpl + +: T extends StubBase ? never // Native thenables cannot be represented in map recordings, even when typed as PromiseLike. +: T extends PromiseLike ? T : T extends Map ? InvalidNativePromiseInMapResult | InvalidNativePromiseInMapResult : T extends Set ? InvalidNativePromiseInMapResult : T extends readonly [] ? never : T extends readonly [infer Head, ...infer Tail] ? InvalidNativePromiseInMapResult | InvalidNativePromiseInMapResult : T extends ReadonlyArray ? InvalidNativePromiseInMapResult : T extends { + [key: string | number]: unknown; +>key : string | number + +} ? InvalidNativePromiseInMapResult], Seen | T> : never; +type MapCallbackReturn = InvalidNativePromiseInMapResult extends never ? T : never; +>MapCallbackReturn : MapCallbackReturn + +type ArrayProvider = { [K in number]: MethodOrProperty } & { +>ArrayProvider : ArrayProvider + + map(callback: (elem: MapCallbackValue) => MapCallbackReturn): Result>; +>map : (callback: (elem: MapCallbackValue) => MapCallbackReturn) => Result> +>callback : (elem: MapCallbackValue) => MapCallbackReturn +>elem : MapCallbackValue + +}; +type TupleProvider> = { [K in TupleIndexKeys]: MethodOrProperty } & ArrayProvider; // Base type for all other types providing RPC-like interfaces. +>TupleProvider : TupleProvider + +// Rewrites all methods/properties to be `MethodOrProperty`s, while preserving callable types. +// `__RPC_TARGET_BRAND` deliberately flows through the key mapping (as a `never` property) so +// stubs of branded targets stay assignable to workers-types' `Stubable`. Such stubs match our +// `Stubable` too — harmless, since all machinery checks `StubBase` before `Stubable`. +type Provider = MaybeCallableProvider & (T extends ReadonlyArray ? number extends T["length"] ? ArrayProvider : TupleProvider : { [K in Exclude>]: MethodOrProperty } & { +>Provider : Provider + + map(callback: (value: MapCallbackValue>) => MapCallbackReturn): Result>; +>map : (callback: (value: MapCallbackValue>) => MapCallbackReturn) => Result> +>callback : (value: MapCallbackValue>) => MapCallbackReturn +>value : MapCallbackValue> + +}); +export type RpcStub> = Stub; +>RpcStub : RpcStub + +=== main.ts === +import type { RpcStub } from "./capnweb"; +>RpcStub : RpcStub + +declare const api: RpcStub<{ sub(): Promise> }>; +>api : { sub: () => Promise<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}> & Disposable> & { map: any; } & {} & import("./capnweb").StubBase<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}>>; } & { map(callback: (value: Omit Promise<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}> & Disposable> & { map: any; } & {} & import("./capnweb").StubBase<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}>>) & {} & { map(callback: (value: Omit Promise<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}> & Disposable> & { map: any; } & {} & import("./capnweb").StubBase<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}>>) & {} & any & import("./capnweb").StubBase<() => Promise>>> & (() => Promise<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}> & Disposable> & { map: any; } & {} & import("./capnweb").StubBase<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}>>) & {} & any & import("./capnweb").StubBase<() => Promise>>, keyof Promise> & (() => Promise<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}> & Disposable> & { map: any; } & {} & import("./capnweb").StubBase<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}>>) & import("./capnweb").MapValuePlaceholder<() => Promise>>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & any & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & Disposable> & any & any & import("./capnweb").StubBase, keyof Promise> & import("./capnweb").MapValuePlaceholder) => import("./capnweb").MapCallbackReturn): any & any & import("./capnweb").StubBase; } & import("./capnweb").StubBase +>sub : () => Promise> + +export async function f() { +>f : () => Promise + + await api.sub(); +>await api.sub() : Promise<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}> & Disposable> & { map: any; } & {} & import("./capnweb").StubBase<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}>> +>api.sub() : Promise<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}> & Disposable> & { map: any; } & {} & import("./capnweb").StubBase<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}>> +>api.sub : () => Promise<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}> & Disposable> & { map: any; } & {} & import("./capnweb").StubBase<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}>> +>api : { sub: () => Promise<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}> & Disposable> & { map: any; } & {} & import("./capnweb").StubBase<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}>>; } & { map(callback: (value: Omit Promise<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}> & Disposable> & { map: any; } & {} & import("./capnweb").StubBase<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}>>) & {} & { map(callback: (value: Omit Promise<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}> & Disposable> & { map: any; } & {} & import("./capnweb").StubBase<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}>>) & {} & any & import("./capnweb").StubBase<() => Promise>>> & (() => Promise<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}> & Disposable> & { map: any; } & {} & import("./capnweb").StubBase<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}>>) & {} & any & import("./capnweb").StubBase<() => Promise>>, keyof Promise> & (() => Promise<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}> & Disposable> & { map: any; } & {} & import("./capnweb").StubBase<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}>>) & import("./capnweb").MapValuePlaceholder<() => Promise>>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & any & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & Disposable> & any & any & import("./capnweb").StubBase, keyof Promise> & import("./capnweb").MapValuePlaceholder) => import("./capnweb").MapCallbackReturn): any & any & import("./capnweb").StubBase; } & import("./capnweb").StubBase +>sub : () => Promise<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}> & Disposable> & { map: any; } & {} & import("./capnweb").StubBase<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}>> + + api.sub().then(s => s); +>api.sub().then(s => s) : any +>api.sub().then : any +>api.sub() : Promise<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}> & Disposable> & { map: any; } & {} & import("./capnweb").StubBase<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}>> +>api.sub : () => Promise<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}> & Disposable> & { map: any; } & {} & import("./capnweb").StubBase<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}>> +>api : { sub: () => Promise<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}> & Disposable> & { map: any; } & {} & import("./capnweb").StubBase<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}>>; } & { map(callback: (value: Omit Promise<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}> & Disposable> & { map: any; } & {} & import("./capnweb").StubBase<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}>>) & {} & { map(callback: (value: Omit Promise<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}> & Disposable> & { map: any; } & {} & import("./capnweb").StubBase<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}>>) & {} & any & import("./capnweb").StubBase<() => Promise>>> & (() => Promise<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}> & Disposable> & { map: any; } & {} & import("./capnweb").StubBase<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}>>) & {} & any & import("./capnweb").StubBase<() => Promise>>, keyof Promise> & (() => Promise<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}> & Disposable> & { map: any; } & {} & import("./capnweb").StubBase<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}>>) & import("./capnweb").MapValuePlaceholder<() => Promise>>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & any & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & Disposable> & any & any & import("./capnweb").StubBase, keyof Promise> & import("./capnweb").MapValuePlaceholder) => import("./capnweb").MapCallbackReturn): any & any & import("./capnweb").StubBase; } & import("./capnweb").StubBase +>sub : () => Promise<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}> & Disposable> & { map: any; } & {} & import("./capnweb").StubBase<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}>> +>then : any +>s => s : (s: any) => any +>s : any +>s : any +} + 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..570f693fae100 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/varianceCycleDiscardedDiagnostics.errors.txt @@ -0,0 +1,31 @@ +varianceCycleDiscardedDiagnostics.ts(14,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. + + +==== 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 TS7022: 'Value' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. + } + + 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..437eb30b0dc81 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/varianceCycleDiscardedDiagnostics.symbols @@ -0,0 +1,73 @@ +//// [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(new Foo(this)).foo : Symbol(B.foo, Decl(varianceCycleDiscardedDiagnostics.ts, 7, 13)) +>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)) +>foo : Symbol(B.foo, Decl(varianceCycleDiscardedDiagnostics.ts, 7, 13)) +} + +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..6d56cf12120d4 --- /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 : string +>pick(new Foo(this)) : B +>pick : { (x: Foo): A; (x: object): B; } +>new Foo(this) : Foo +>Foo : typeof Foo +>this : this +>foo : string +} + +class Foo { +>Foo : Foo + + bar!: Bar; +>bar : Bar + + constructor(bar: Bar) { +>bar : Bar + + this.bar = bar; +>this.bar = bar : Bar +>this.bar : Bar +>this : this +>bar : Bar +>bar : Bar + } +} + +const v: number = new Bar().Value; +>v : number +>new Bar().Value : any +>new Bar() : Bar +>Bar : typeof Bar +>Value : any + diff --git a/tsc/testdata/baselines/reference/compiler/varianceCycleEnteredAfterCanonicalEntry(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/varianceCycleEnteredAfterCanonicalEntry(checkorder=default).symbols new file mode 100644 index 0000000000000..b6711c2e9b95b --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/varianceCycleEnteredAfterCanonicalEntry(checkorder=default).symbols @@ -0,0 +1,132 @@ +//// [tests/cases/compiler/varianceCycleEnteredAfterCanonicalEntry.ts] //// + +=== varianceCycleEnteredAfterCanonicalEntry.ts === +// Reduced from capnweb's RpcStub types (cloudflare-os). Measuring the variance +// of Stubify enters a circularity (Stubify -> Stub -> Provider -> +// MethodOrProperty -> Result -> RpcPromise -> Stubify) whose canonical entry is +// Stub, so the measurement from Stubify is discarded and the circularity +// measured again from Stub. The discarded measurement once ran to completion, +// which on the full types took long enough to exceed the instantiation limit. + +interface StubBase { +>StubBase : Symbol(StubBase, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 0, 0)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 7, 19)) + + brand: T; +>brand : Symbol(StubBase.brand, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 7, 33)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 7, 19)) +} +type Stub = T extends object ? Provider & StubBase : StubBase; +>Stub : Symbol(Stub, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 9, 1)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 10, 10)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 10, 10)) +>Provider : Symbol(Provider, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 14, 125)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 10, 10)) +>StubBase : Symbol(StubBase, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 0, 0)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 10, 10)) +>StubBase : Symbol(StubBase, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 0, 0)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 10, 10)) + +type Stubify = T extends StubBase ? T : T extends Function ? Stub : T; +>Stubify : Symbol(Stubify, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 10, 74)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 11, 13)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 11, 13)) +>StubBase : Symbol(StubBase, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 0, 0)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 11, 13)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 11, 13)) +>Function : Symbol(Function, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.esnext.decorators.d.ts, --, --)) +>Stub : Symbol(Stub, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 9, 1)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 11, 13)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 11, 13)) + +type RpcPromise = Promise> & Provider & StubBase; +>RpcPromise : Symbol(RpcPromise, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 11, 81)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 12, 16)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2018.promise.d.ts, --, --)) +>Stubify : Symbol(Stubify, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 10, 74)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 12, 16)) +>Provider : Symbol(Provider, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 14, 125)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 12, 16)) +>StubBase : Symbol(StubBase, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 0, 0)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 12, 16)) + +type Result = R extends StubBase ? Result : RpcPromise; +>Result : Symbol(Result, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 12, 69)) +>R : Symbol(R, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 13, 12)) +>R : Symbol(R, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 13, 12)) +>StubBase : Symbol(StubBase, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 0, 0)) +>U : Symbol(U, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 13, 41)) +>Result : Symbol(Result, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 12, 69)) +>U : Symbol(U, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 13, 41)) +>RpcPromise : Symbol(RpcPromise, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 11, 81)) +>R : Symbol(R, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 13, 12)) + +type MethodOrProperty = V extends (...args: infer P) => infer R ? (...args: P) => Result> : Result>; +>MethodOrProperty : Symbol(MethodOrProperty, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 13, 73)) +>V : Symbol(V, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 14, 22)) +>V : Symbol(V, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 14, 22)) +>args : Symbol(args, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 14, 38)) +>P : Symbol(P, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 14, 52)) +>R : Symbol(R, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 14, 64)) +>args : Symbol(args, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 14, 70)) +>P : Symbol(P, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 14, 52)) +>Result : Symbol(Result, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 12, 69)) +>Awaited : Symbol(Awaited, Decl(lib.es5.d.ts, --, --)) +>R : Symbol(R, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 14, 64)) +>Result : Symbol(Result, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 12, 69)) +>Awaited : Symbol(Awaited, Decl(lib.es5.d.ts, --, --)) +>V : Symbol(V, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 14, 22)) + +type Provider = { [K in keyof T]: MethodOrProperty }; +>Provider : Symbol(Provider, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 14, 125)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 15, 14)) +>K : Symbol(K, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 15, 22)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 15, 14)) +>MethodOrProperty : Symbol(MethodOrProperty, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 13, 73)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 15, 14)) +>K : Symbol(K, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 15, 22)) + +function f(x: Stubify, y: Stubify) { +>f : Symbol(f, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 15, 62)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 17, 11)) +>x : Symbol(x, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 17, 14)) +>Stubify : Symbol(Stubify, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 10, 74)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 17, 11)) +>y : Symbol(y, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 17, 28)) +>Stubify : Symbol(Stubify, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 10, 74)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 17, 11)) + + y = x; +>y : Symbol(y, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 17, 28)) +>x : Symbol(x, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 17, 14)) + + x = y; +>x : Symbol(x, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 17, 14)) +>y : Symbol(y, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 17, 28)) +} + +declare const api: Stub<{ sub(): Promise> }>; +>api : Symbol(api, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 22, 13)) +>Stub : Symbol(Stub, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 9, 1)) +>sub : Symbol(sub, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 22, 25)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2018.promise.d.ts, --, --)) +>Stub : Symbol(Stub, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 9, 1)) + +export async function g() { +>g : Symbol(g, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 22, 54)) + + await api.sub(); +>api.sub : Symbol(sub, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 22, 25)) +>api : Symbol(api, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 22, 13)) +>sub : Symbol(sub, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 22, 25)) + + api.sub().then(s => s); +>api.sub().then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --)) +>api.sub : Symbol(sub, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 22, 25)) +>api : Symbol(api, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 22, 13)) +>sub : Symbol(sub, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 22, 25)) +>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --)) +>s : Symbol(s, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 25, 17)) +>s : Symbol(s, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 25, 17)) +} + diff --git a/tsc/testdata/baselines/reference/compiler/varianceCycleEnteredAfterCanonicalEntry(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/varianceCycleEnteredAfterCanonicalEntry(checkorder=default).types new file mode 100644 index 0000000000000..41efe3567475b --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/varianceCycleEnteredAfterCanonicalEntry(checkorder=default).types @@ -0,0 +1,77 @@ +//// [tests/cases/compiler/varianceCycleEnteredAfterCanonicalEntry.ts] //// + +=== varianceCycleEnteredAfterCanonicalEntry.ts === +// Reduced from capnweb's RpcStub types (cloudflare-os). Measuring the variance +// of Stubify enters a circularity (Stubify -> Stub -> Provider -> +// MethodOrProperty -> Result -> RpcPromise -> Stubify) whose canonical entry is +// Stub, so the measurement from Stubify is discarded and the circularity +// measured again from Stub. The discarded measurement once ran to completion, +// which on the full types took long enough to exceed the instantiation limit. + +interface StubBase { + brand: T; +>brand : T +} +type Stub = T extends object ? Provider & StubBase : StubBase; +>Stub : Stub + +type Stubify = T extends StubBase ? T : T extends Function ? Stub : T; +>Stubify : Stubify + +type RpcPromise = Promise> & Provider & StubBase; +>RpcPromise : RpcPromise + +type Result = R extends StubBase ? Result : RpcPromise; +>Result : Result + +type MethodOrProperty = V extends (...args: infer P) => infer R ? (...args: P) => Result> : Result>; +>MethodOrProperty : MethodOrProperty +>args : P +>args : P + +type Provider = { [K in keyof T]: MethodOrProperty }; +>Provider : Provider + +function f(x: Stubify, y: Stubify) { +>f : (x: Stubify, y: Stubify) => void +>x : Stubify +>y : Stubify | undefined + + y = x; +>y = x : Stubify +>y : Stubify | undefined +>x : Stubify + + x = y; +>x = y : Stubify +>x : Stubify +>y : Stubify +} + +declare const api: Stub<{ sub(): Promise> }>; +>api : Provider<{ sub(): Promise>; }> & StubBase<{ sub(): Promise>; }> +>sub : () => Promise> + +export async function g() { +>g : () => Promise + + await api.sub(); +>await api.sub() : {} +>api.sub() : RpcPromise<{}> +>api.sub : () => RpcPromise<{}> +>api : Provider<{ sub(): Promise>; }> & StubBase<{ sub(): Promise>; }> +>sub : () => RpcPromise<{}> + + api.sub().then(s => s); +>api.sub().then(s => s) : Promise<{}> +>api.sub().then : (onfulfilled?: ((value: {}) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +>api.sub() : RpcPromise<{}> +>api.sub : () => RpcPromise<{}> +>api : Provider<{ sub(): Promise>; }> & StubBase<{ sub(): Promise>; }> +>sub : () => RpcPromise<{}> +>then : (onfulfilled?: ((value: {}) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +>s => s : (s: {}) => {} +>s : {} +>s : {} +} + diff --git a/tsc/testdata/baselines/reference/compiler/varianceCycleEnteredAfterCanonicalEntry(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/varianceCycleEnteredAfterCanonicalEntry(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..b6711c2e9b95b --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/varianceCycleEnteredAfterCanonicalEntry(checkorder=typesfirst).symbols @@ -0,0 +1,132 @@ +//// [tests/cases/compiler/varianceCycleEnteredAfterCanonicalEntry.ts] //// + +=== varianceCycleEnteredAfterCanonicalEntry.ts === +// Reduced from capnweb's RpcStub types (cloudflare-os). Measuring the variance +// of Stubify enters a circularity (Stubify -> Stub -> Provider -> +// MethodOrProperty -> Result -> RpcPromise -> Stubify) whose canonical entry is +// Stub, so the measurement from Stubify is discarded and the circularity +// measured again from Stub. The discarded measurement once ran to completion, +// which on the full types took long enough to exceed the instantiation limit. + +interface StubBase { +>StubBase : Symbol(StubBase, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 0, 0)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 7, 19)) + + brand: T; +>brand : Symbol(StubBase.brand, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 7, 33)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 7, 19)) +} +type Stub = T extends object ? Provider & StubBase : StubBase; +>Stub : Symbol(Stub, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 9, 1)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 10, 10)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 10, 10)) +>Provider : Symbol(Provider, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 14, 125)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 10, 10)) +>StubBase : Symbol(StubBase, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 0, 0)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 10, 10)) +>StubBase : Symbol(StubBase, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 0, 0)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 10, 10)) + +type Stubify = T extends StubBase ? T : T extends Function ? Stub : T; +>Stubify : Symbol(Stubify, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 10, 74)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 11, 13)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 11, 13)) +>StubBase : Symbol(StubBase, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 0, 0)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 11, 13)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 11, 13)) +>Function : Symbol(Function, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.esnext.decorators.d.ts, --, --)) +>Stub : Symbol(Stub, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 9, 1)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 11, 13)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 11, 13)) + +type RpcPromise = Promise> & Provider & StubBase; +>RpcPromise : Symbol(RpcPromise, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 11, 81)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 12, 16)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2018.promise.d.ts, --, --)) +>Stubify : Symbol(Stubify, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 10, 74)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 12, 16)) +>Provider : Symbol(Provider, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 14, 125)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 12, 16)) +>StubBase : Symbol(StubBase, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 0, 0)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 12, 16)) + +type Result = R extends StubBase ? Result : RpcPromise; +>Result : Symbol(Result, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 12, 69)) +>R : Symbol(R, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 13, 12)) +>R : Symbol(R, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 13, 12)) +>StubBase : Symbol(StubBase, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 0, 0)) +>U : Symbol(U, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 13, 41)) +>Result : Symbol(Result, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 12, 69)) +>U : Symbol(U, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 13, 41)) +>RpcPromise : Symbol(RpcPromise, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 11, 81)) +>R : Symbol(R, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 13, 12)) + +type MethodOrProperty = V extends (...args: infer P) => infer R ? (...args: P) => Result> : Result>; +>MethodOrProperty : Symbol(MethodOrProperty, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 13, 73)) +>V : Symbol(V, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 14, 22)) +>V : Symbol(V, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 14, 22)) +>args : Symbol(args, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 14, 38)) +>P : Symbol(P, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 14, 52)) +>R : Symbol(R, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 14, 64)) +>args : Symbol(args, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 14, 70)) +>P : Symbol(P, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 14, 52)) +>Result : Symbol(Result, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 12, 69)) +>Awaited : Symbol(Awaited, Decl(lib.es5.d.ts, --, --)) +>R : Symbol(R, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 14, 64)) +>Result : Symbol(Result, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 12, 69)) +>Awaited : Symbol(Awaited, Decl(lib.es5.d.ts, --, --)) +>V : Symbol(V, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 14, 22)) + +type Provider = { [K in keyof T]: MethodOrProperty }; +>Provider : Symbol(Provider, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 14, 125)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 15, 14)) +>K : Symbol(K, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 15, 22)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 15, 14)) +>MethodOrProperty : Symbol(MethodOrProperty, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 13, 73)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 15, 14)) +>K : Symbol(K, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 15, 22)) + +function f(x: Stubify, y: Stubify) { +>f : Symbol(f, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 15, 62)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 17, 11)) +>x : Symbol(x, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 17, 14)) +>Stubify : Symbol(Stubify, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 10, 74)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 17, 11)) +>y : Symbol(y, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 17, 28)) +>Stubify : Symbol(Stubify, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 10, 74)) +>T : Symbol(T, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 17, 11)) + + y = x; +>y : Symbol(y, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 17, 28)) +>x : Symbol(x, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 17, 14)) + + x = y; +>x : Symbol(x, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 17, 14)) +>y : Symbol(y, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 17, 28)) +} + +declare const api: Stub<{ sub(): Promise> }>; +>api : Symbol(api, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 22, 13)) +>Stub : Symbol(Stub, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 9, 1)) +>sub : Symbol(sub, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 22, 25)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2018.promise.d.ts, --, --)) +>Stub : Symbol(Stub, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 9, 1)) + +export async function g() { +>g : Symbol(g, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 22, 54)) + + await api.sub(); +>api.sub : Symbol(sub, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 22, 25)) +>api : Symbol(api, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 22, 13)) +>sub : Symbol(sub, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 22, 25)) + + api.sub().then(s => s); +>api.sub().then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --)) +>api.sub : Symbol(sub, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 22, 25)) +>api : Symbol(api, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 22, 13)) +>sub : Symbol(sub, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 22, 25)) +>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --)) +>s : Symbol(s, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 25, 17)) +>s : Symbol(s, Decl(varianceCycleEnteredAfterCanonicalEntry.ts, 25, 17)) +} + diff --git a/tsc/testdata/baselines/reference/compiler/varianceCycleEnteredAfterCanonicalEntry(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/varianceCycleEnteredAfterCanonicalEntry(checkorder=typesfirst).types new file mode 100644 index 0000000000000..41efe3567475b --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/varianceCycleEnteredAfterCanonicalEntry(checkorder=typesfirst).types @@ -0,0 +1,77 @@ +//// [tests/cases/compiler/varianceCycleEnteredAfterCanonicalEntry.ts] //// + +=== varianceCycleEnteredAfterCanonicalEntry.ts === +// Reduced from capnweb's RpcStub types (cloudflare-os). Measuring the variance +// of Stubify enters a circularity (Stubify -> Stub -> Provider -> +// MethodOrProperty -> Result -> RpcPromise -> Stubify) whose canonical entry is +// Stub, so the measurement from Stubify is discarded and the circularity +// measured again from Stub. The discarded measurement once ran to completion, +// which on the full types took long enough to exceed the instantiation limit. + +interface StubBase { + brand: T; +>brand : T +} +type Stub = T extends object ? Provider & StubBase : StubBase; +>Stub : Stub + +type Stubify = T extends StubBase ? T : T extends Function ? Stub : T; +>Stubify : Stubify + +type RpcPromise = Promise> & Provider & StubBase; +>RpcPromise : RpcPromise + +type Result = R extends StubBase ? Result : RpcPromise; +>Result : Result + +type MethodOrProperty = V extends (...args: infer P) => infer R ? (...args: P) => Result> : Result>; +>MethodOrProperty : MethodOrProperty +>args : P +>args : P + +type Provider = { [K in keyof T]: MethodOrProperty }; +>Provider : Provider + +function f(x: Stubify, y: Stubify) { +>f : (x: Stubify, y: Stubify) => void +>x : Stubify +>y : Stubify | undefined + + y = x; +>y = x : Stubify +>y : Stubify | undefined +>x : Stubify + + x = y; +>x = y : Stubify +>x : Stubify +>y : Stubify +} + +declare const api: Stub<{ sub(): Promise> }>; +>api : Provider<{ sub(): Promise>; }> & StubBase<{ sub(): Promise>; }> +>sub : () => Promise> + +export async function g() { +>g : () => Promise + + await api.sub(); +>await api.sub() : {} +>api.sub() : RpcPromise<{}> +>api.sub : () => RpcPromise<{}> +>api : Provider<{ sub(): Promise>; }> & StubBase<{ sub(): Promise>; }> +>sub : () => RpcPromise<{}> + + api.sub().then(s => s); +>api.sub().then(s => s) : Promise<{}> +>api.sub().then : (onfulfilled?: ((value: {}) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +>api.sub() : RpcPromise<{}> +>api.sub : () => RpcPromise<{}> +>api : Provider<{ sub(): Promise>; }> & StubBase<{ sub(): Promise>; }> +>sub : () => RpcPromise<{}> +>then : (onfulfilled?: ((value: {}) => TResult1 | PromiseLike) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike) | null | undefined) => Promise +>s => s : (s: {}) => {} +>s : {} +>s : {} +} + diff --git a/tsc/testdata/baselines/reference/compiler/varianceCycleEntryOrder.errors.txt b/tsc/testdata/baselines/reference/compiler/varianceCycleEntryOrder.errors.txt new file mode 100644 index 0000000000000..3093fe2786a2e --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/varianceCycleEntryOrder.errors.txt @@ -0,0 +1,78 @@ +barFirst.ts(9,1): error TS2322: Type 'Bar<"lit">' is not assignable to type 'Bar'. + Type 'string' is not assignable to type '"lit"'. +barFirst.ts(10,1): error TS2322: Type 'Foo' is not assignable to type 'Foo<"lit">'. + Types of property 'x' are incompatible. + Type 'string' is not assignable to type '"lit"'. +barFirst.ts(11,1): error TS2322: Type 'Foo<"lit">' is not assignable to type 'Foo'. + Types of property 'b' are incompatible. + Type 'Bar>' is not assignable to type 'Bar>'. + Type 'Foo' is not assignable to type 'Foo<"lit">'. + Types of property 'x' are incompatible. + Type 'string' is not assignable to type '"lit"'. +fooFirst.ts(8,1): error TS2322: Type 'Foo' is not assignable to type 'Foo<"lit">'. + Types of property 'x' are incompatible. + Type 'string' is not assignable to type '"lit"'. +fooFirst.ts(9,1): error TS2322: Type 'Foo<"lit">' is not assignable to type 'Foo'. + Types of property 'b' are incompatible. + Type 'Bar>' is not assignable to type 'Bar>'. + Type 'Foo' is not assignable to type 'Foo<"lit">'. + Types of property 'x' are incompatible. + Type 'string' is not assignable to type '"lit"'. +fooFirst.ts(11,1): error TS2322: Type 'Bar<"lit">' is not assignable to type 'Bar'. + Type 'string' is not assignable to type '"lit"'. + + +==== fooFirst.ts (3 errors) ==== + export {}; + + interface Foo { x: T; b: Bar> } + interface Bar { f: (u: U) => void; foo: Foo> } + + declare let fs: Foo, fl: Foo<"lit">; + declare let bs: Bar, bl: Bar<"lit">; + fl = fs; // Error + ~~ +!!! error TS2322: Type 'Foo' is not assignable to type 'Foo<"lit">'. +!!! error TS2322: Types of property 'x' are incompatible. +!!! error TS2322: Type 'string' is not assignable to type '"lit"'. + fs = fl; // Error + ~~ +!!! error TS2322: Type 'Foo<"lit">' is not assignable to type 'Foo'. +!!! error TS2322: Types of property 'b' are incompatible. +!!! error TS2322: Type 'Bar>' is not assignable to type 'Bar>'. +!!! error TS2322: Type 'Foo' is not assignable to type 'Foo<"lit">'. +!!! error TS2322: Types of property 'x' are incompatible. +!!! error TS2322: Type 'string' is not assignable to type '"lit"'. + bl = bs; // Error + bs = bl; // Error + ~~ +!!! error TS2322: Type 'Bar<"lit">' is not assignable to type 'Bar'. +!!! error TS2322: Type 'string' is not assignable to type '"lit"'. + +==== barFirst.ts (3 errors) ==== + export {}; + + interface Foo { x: T; b: Bar> } + interface Bar { f: (u: U) => void; foo: Foo> } + + declare let fs: Foo, fl: Foo<"lit">; + declare let bs: Bar, bl: Bar<"lit">; + bl = bs; // Error + bs = bl; // Error + ~~ +!!! error TS2322: Type 'Bar<"lit">' is not assignable to type 'Bar'. +!!! error TS2322: Type 'string' is not assignable to type '"lit"'. + fl = fs; // Error + ~~ +!!! error TS2322: Type 'Foo' is not assignable to type 'Foo<"lit">'. +!!! error TS2322: Types of property 'x' are incompatible. +!!! error TS2322: Type 'string' is not assignable to type '"lit"'. + fs = fl; // Error + ~~ +!!! error TS2322: Type 'Foo<"lit">' is not assignable to type 'Foo'. +!!! error TS2322: Types of property 'b' are incompatible. +!!! error TS2322: Type 'Bar>' is not assignable to type 'Bar>'. +!!! error TS2322: Type 'Foo' is not assignable to type 'Foo<"lit">'. +!!! error TS2322: Types of property 'x' are incompatible. +!!! error TS2322: Type 'string' is not assignable to type '"lit"'. + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/varianceCycleEntryOrder.symbols b/tsc/testdata/baselines/reference/compiler/varianceCycleEntryOrder.symbols new file mode 100644 index 0000000000000..478f02d4a04a7 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/varianceCycleEntryOrder.symbols @@ -0,0 +1,106 @@ +//// [tests/cases/compiler/varianceCycleEntryOrder.ts] //// + +=== fooFirst.ts === +export {}; + +interface Foo { x: T; b: Bar> } +>Foo : Symbol(Foo, Decl(fooFirst.ts, 0, 10)) +>T : Symbol(T, Decl(fooFirst.ts, 2, 14)) +>x : Symbol(Foo.x, Decl(fooFirst.ts, 2, 18)) +>T : Symbol(T, Decl(fooFirst.ts, 2, 14)) +>b : Symbol(Foo.b, Decl(fooFirst.ts, 2, 24)) +>Bar : Symbol(Bar, Decl(fooFirst.ts, 2, 41)) +>Foo : Symbol(Foo, Decl(fooFirst.ts, 0, 10)) +>T : Symbol(T, Decl(fooFirst.ts, 2, 14)) + +interface Bar { f: (u: U) => void; foo: Foo> } +>Bar : Symbol(Bar, Decl(fooFirst.ts, 2, 41)) +>U : Symbol(U, Decl(fooFirst.ts, 3, 14)) +>f : Symbol(Bar.f, Decl(fooFirst.ts, 3, 18)) +>u : Symbol(u, Decl(fooFirst.ts, 3, 23)) +>U : Symbol(U, Decl(fooFirst.ts, 3, 14)) +>foo : Symbol(Bar.foo, Decl(fooFirst.ts, 3, 37)) +>Foo : Symbol(Foo, Decl(fooFirst.ts, 0, 10)) +>Bar : Symbol(Bar, Decl(fooFirst.ts, 2, 41)) +>U : Symbol(U, Decl(fooFirst.ts, 3, 14)) + +declare let fs: Foo, fl: Foo<"lit">; +>fs : Symbol(fs, Decl(fooFirst.ts, 5, 11)) +>Foo : Symbol(Foo, Decl(fooFirst.ts, 0, 10)) +>fl : Symbol(fl, Decl(fooFirst.ts, 5, 28)) +>Foo : Symbol(Foo, Decl(fooFirst.ts, 0, 10)) + +declare let bs: Bar, bl: Bar<"lit">; +>bs : Symbol(bs, Decl(fooFirst.ts, 6, 11)) +>Bar : Symbol(Bar, Decl(fooFirst.ts, 2, 41)) +>bl : Symbol(bl, Decl(fooFirst.ts, 6, 28)) +>Bar : Symbol(Bar, Decl(fooFirst.ts, 2, 41)) + +fl = fs; // Error +>fl : Symbol(fl, Decl(fooFirst.ts, 5, 28)) +>fs : Symbol(fs, Decl(fooFirst.ts, 5, 11)) + +fs = fl; // Error +>fs : Symbol(fs, Decl(fooFirst.ts, 5, 11)) +>fl : Symbol(fl, Decl(fooFirst.ts, 5, 28)) + +bl = bs; // Error +>bl : Symbol(bl, Decl(fooFirst.ts, 6, 28)) +>bs : Symbol(bs, Decl(fooFirst.ts, 6, 11)) + +bs = bl; // Error +>bs : Symbol(bs, Decl(fooFirst.ts, 6, 11)) +>bl : Symbol(bl, Decl(fooFirst.ts, 6, 28)) + +=== barFirst.ts === +export {}; + +interface Foo { x: T; b: Bar> } +>Foo : Symbol(Foo, Decl(barFirst.ts, 0, 10)) +>T : Symbol(T, Decl(barFirst.ts, 2, 14)) +>x : Symbol(Foo.x, Decl(barFirst.ts, 2, 18)) +>T : Symbol(T, Decl(barFirst.ts, 2, 14)) +>b : Symbol(Foo.b, Decl(barFirst.ts, 2, 24)) +>Bar : Symbol(Bar, Decl(barFirst.ts, 2, 41)) +>Foo : Symbol(Foo, Decl(barFirst.ts, 0, 10)) +>T : Symbol(T, Decl(barFirst.ts, 2, 14)) + +interface Bar { f: (u: U) => void; foo: Foo> } +>Bar : Symbol(Bar, Decl(barFirst.ts, 2, 41)) +>U : Symbol(U, Decl(barFirst.ts, 3, 14)) +>f : Symbol(Bar.f, Decl(barFirst.ts, 3, 18)) +>u : Symbol(u, Decl(barFirst.ts, 3, 23)) +>U : Symbol(U, Decl(barFirst.ts, 3, 14)) +>foo : Symbol(Bar.foo, Decl(barFirst.ts, 3, 37)) +>Foo : Symbol(Foo, Decl(barFirst.ts, 0, 10)) +>Bar : Symbol(Bar, Decl(barFirst.ts, 2, 41)) +>U : Symbol(U, Decl(barFirst.ts, 3, 14)) + +declare let fs: Foo, fl: Foo<"lit">; +>fs : Symbol(fs, Decl(barFirst.ts, 5, 11)) +>Foo : Symbol(Foo, Decl(barFirst.ts, 0, 10)) +>fl : Symbol(fl, Decl(barFirst.ts, 5, 28)) +>Foo : Symbol(Foo, Decl(barFirst.ts, 0, 10)) + +declare let bs: Bar, bl: Bar<"lit">; +>bs : Symbol(bs, Decl(barFirst.ts, 6, 11)) +>Bar : Symbol(Bar, Decl(barFirst.ts, 2, 41)) +>bl : Symbol(bl, Decl(barFirst.ts, 6, 28)) +>Bar : Symbol(Bar, Decl(barFirst.ts, 2, 41)) + +bl = bs; // Error +>bl : Symbol(bl, Decl(barFirst.ts, 6, 28)) +>bs : Symbol(bs, Decl(barFirst.ts, 6, 11)) + +bs = bl; // Error +>bs : Symbol(bs, Decl(barFirst.ts, 6, 11)) +>bl : Symbol(bl, Decl(barFirst.ts, 6, 28)) + +fl = fs; // Error +>fl : Symbol(fl, Decl(barFirst.ts, 5, 28)) +>fs : Symbol(fs, Decl(barFirst.ts, 5, 11)) + +fs = fl; // Error +>fs : Symbol(fs, Decl(barFirst.ts, 5, 11)) +>fl : Symbol(fl, Decl(barFirst.ts, 5, 28)) + diff --git a/tsc/testdata/baselines/reference/compiler/varianceCycleEntryOrder.types b/tsc/testdata/baselines/reference/compiler/varianceCycleEntryOrder.types new file mode 100644 index 0000000000000..3e1522dd51543 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/varianceCycleEntryOrder.types @@ -0,0 +1,82 @@ +//// [tests/cases/compiler/varianceCycleEntryOrder.ts] //// + +=== fooFirst.ts === +export {}; + +interface Foo { x: T; b: Bar> } +>x : T +>b : Bar> + +interface Bar { f: (u: U) => void; foo: Foo> } +>f : (u: U) => void +>u : U +>foo : Foo> + +declare let fs: Foo, fl: Foo<"lit">; +>fs : Foo +>fl : Foo<"lit"> + +declare let bs: Bar, bl: Bar<"lit">; +>bs : Bar +>bl : Bar<"lit"> + +fl = fs; // Error +>fl = fs : Foo +>fl : Foo<"lit"> +>fs : Foo + +fs = fl; // Error +>fs = fl : Foo<"lit"> +>fs : Foo +>fl : Foo<"lit"> + +bl = bs; // Error +>bl = bs : Bar +>bl : Bar<"lit"> +>bs : Bar + +bs = bl; // Error +>bs = bl : Bar<"lit"> +>bs : Bar +>bl : Bar<"lit"> + +=== barFirst.ts === +export {}; + +interface Foo { x: T; b: Bar> } +>x : T +>b : Bar> + +interface Bar { f: (u: U) => void; foo: Foo> } +>f : (u: U) => void +>u : U +>foo : Foo> + +declare let fs: Foo, fl: Foo<"lit">; +>fs : Foo +>fl : Foo<"lit"> + +declare let bs: Bar, bl: Bar<"lit">; +>bs : Bar +>bl : Bar<"lit"> + +bl = bs; // Error +>bl = bs : Bar +>bl : Bar<"lit"> +>bs : Bar + +bs = bl; // Error +>bs = bl : Bar<"lit"> +>bs : Bar +>bl : Bar<"lit"> + +fl = fs; // Error +>fl = fs : Foo +>fl : Foo<"lit"> +>fs : Foo + +fs = fl; // Error +>fs = fl : Foo<"lit"> +>fs : Foo +>fl : Foo<"lit"> + diff --git a/tsc/testdata/baselines/reference/compiler/varianceCycleRedoKeepsDiscardLog.symbols b/tsc/testdata/baselines/reference/compiler/varianceCycleRedoKeepsDiscardLog.symbols new file mode 100644 index 0000000000000..eb4907af8e1b1 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/varianceCycleRedoKeepsDiscardLog.symbols @@ -0,0 +1,999 @@ +//// [tests/cases/compiler/varianceCycleRedoKeepsDiscardLog.ts] //// + +=== json-logic-js.d.ts === +export as namespace jsonFactory; +>jsonFactory : Symbol(jsonFactory, Decl(json-logic-js.d.ts, 0, 0)) + +// Disable auto-export +export {}; + +type RenameToIn = { +>RenameToIn : Symbol(RenameToIn, Decl(json-logic-js.d.ts, 3, 10)) +>T : Symbol(T, Decl(json-logic-js.d.ts, 5, 16)) + + [K in keyof T as K extends `in${Uppercase}${Lowercase}` ? `in` : K]: T[K]; +>K : Symbol(K, Decl(json-logic-js.d.ts, 6, 5)) +>T : Symbol(T, Decl(json-logic-js.d.ts, 5, 16)) +>K : Symbol(K, Decl(json-logic-js.d.ts, 6, 5)) +>Uppercase : Symbol(Uppercase, Decl(lib.es5.d.ts, --, --)) +>Lowercase : Symbol(Lowercase, Decl(lib.es5.d.ts, --, --)) +>K : Symbol(K, Decl(json-logic-js.d.ts, 6, 5)) +>T : Symbol(T, Decl(json-logic-js.d.ts, 5, 16)) +>K : Symbol(K, Decl(json-logic-js.d.ts, 6, 5)) + +}; + +/** + * This is a utility type used below for the "if" operation. + * Original: https://stackoverflow.com/a/68373774/765987 + */ +type MAXIMUM_ALLOWED_BOUNDARY = 80; +>MAXIMUM_ALLOWED_BOUNDARY : Symbol(MAXIMUM_ALLOWED_BOUNDARY, Decl(json-logic-js.d.ts, 7, 2)) + +type Mapped< +>Mapped : Symbol(Mapped, Decl(json-logic-js.d.ts, 13, 35)) + + Tuple extends unknown[], +>Tuple : Symbol(Tuple, Decl(json-logic-js.d.ts, 14, 12)) + + Result extends unknown[] = [], +>Result : Symbol(Result, Decl(json-logic-js.d.ts, 15, 28)) + + Count extends readonly number[] = [], +>Count : Symbol(Count, Decl(json-logic-js.d.ts, 16, 34)) + +> = Count["length"] extends MAXIMUM_ALLOWED_BOUNDARY ? Result +>Count : Symbol(Count, Decl(json-logic-js.d.ts, 16, 34)) +>MAXIMUM_ALLOWED_BOUNDARY : Symbol(MAXIMUM_ALLOWED_BOUNDARY, Decl(json-logic-js.d.ts, 7, 2)) +>Result : Symbol(Result, Decl(json-logic-js.d.ts, 15, 28)) + + : Tuple extends [] ? [] +>Tuple : Symbol(Tuple, Decl(json-logic-js.d.ts, 14, 12)) + + : Result extends [] ? Mapped +>Result : Symbol(Result, Decl(json-logic-js.d.ts, 15, 28)) +>Mapped : Symbol(Mapped, Decl(json-logic-js.d.ts, 13, 35)) +>Tuple : Symbol(Tuple, Decl(json-logic-js.d.ts, 14, 12)) +>Tuple : Symbol(Tuple, Decl(json-logic-js.d.ts, 14, 12)) +>Count : Symbol(Count, Decl(json-logic-js.d.ts, 16, 34)) + + : Mapped; +>Mapped : Symbol(Mapped, Decl(json-logic-js.d.ts, 13, 35)) +>Tuple : Symbol(Tuple, Decl(json-logic-js.d.ts, 14, 12)) +>Result : Symbol(Result, Decl(json-logic-js.d.ts, 15, 28)) +>Result : Symbol(Result, Decl(json-logic-js.d.ts, 15, 28)) +>Tuple : Symbol(Tuple, Decl(json-logic-js.d.ts, 14, 12)) +>Count : Symbol(Count, Decl(json-logic-js.d.ts, 16, 34)) + +/** + * Used for the "if" operation, which takes an array of odd length + * and a minimum of three (3) elements. + */ +type AnyArrayOfOddLengthMin3 = [any, ...Mapped<[any, any]>]; +>AnyArrayOfOddLengthMin3 : Symbol(AnyArrayOfOddLengthMin3, Decl(json-logic-js.d.ts, 21, 67)) +>Mapped : Symbol(Mapped, Decl(json-logic-js.d.ts, 13, 35)) + +export type ReservedOperations = +>ReservedOperations : Symbol(ReservedOperations, Decl(json-logic-js.d.ts, 26, 60)) + + | "var" + | "missing" + | "missing_some" + | "if" + | "==" + | "===" + | "!=" + | "!==" + | "!" + | "!!" + | "or" + | "and" + | ">" + | ">=" + | "<" + | "<=" + | "max" + | "min" + | "+" + | "-" + | "*" + | "/" + | "%" + | "map" + | "filter" + | "reduce" + | "all" + | "none" + | "some" + | "merge" + | "in" + | "cat" + | "substr" + | "log"; + +/** + * This can be an object with any key except the reserved keys. + * TODO: Find a way to limit this type to exactly one (1) key, since + * json-logic-js enforces it. See: + * https://github.com/jwadhams/json-logic-js/blob/2.0.2/logic.js#L180 + */ +export type AdditionalOperation = Partial> & { [k: string]: any }; +>AdditionalOperation : Symbol(AdditionalOperation, Decl(json-logic-js.d.ts, 62, 12)) +>Partial : Symbol(Partial, Decl(lib.es5.d.ts, --, --)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) +>ReservedOperations : Symbol(ReservedOperations, Decl(json-logic-js.d.ts, 26, 60)) +>k : Symbol(k, Decl(json-logic-js.d.ts, 70, 82)) + +export interface AllReservedOperationsInterface { +>AllReservedOperationsInterface : Symbol(AllReservedOperationsInterface, Decl(json-logic-js.d.ts, 70, 100)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) +>AdditionalOperation : Symbol(AdditionalOperation, Decl(json-logic-js.d.ts, 62, 12)) + + var: RulesLogic | [RulesLogic] | [RulesLogic, any] | [RulesLogic, any]; +>var : Symbol(AllReservedOperationsInterface.var, Decl(json-logic-js.d.ts, 72, 93)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) + + missing: RulesLogic | any[]; +>missing : Symbol(AllReservedOperationsInterface.missing, Decl(json-logic-js.d.ts, 73, 107)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) + + missing_some: [RulesLogic, RulesLogic | any[]]; +>missing_some : Symbol(AllReservedOperationsInterface.missing_some, Decl(json-logic-js.d.ts, 74, 40)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) + + if: AnyArrayOfOddLengthMin3; +>if : Symbol(AllReservedOperationsInterface.if, Decl(json-logic-js.d.ts, 75, 67)) +>AnyArrayOfOddLengthMin3 : Symbol(AnyArrayOfOddLengthMin3, Decl(json-logic-js.d.ts, 21, 67)) + + "==": [any, any]; +>"==" : Symbol(AllReservedOperationsInterface["=="], Decl(json-logic-js.d.ts, 76, 32)) + + "===": [any, any]; +>"===" : Symbol(AllReservedOperationsInterface["==="], Decl(json-logic-js.d.ts, 77, 21)) + + "!=": [any, any]; +>"!=" : Symbol(AllReservedOperationsInterface["!="], Decl(json-logic-js.d.ts, 78, 22)) + + "!==": [any, any]; +>"!==" : Symbol(AllReservedOperationsInterface["!=="], Decl(json-logic-js.d.ts, 79, 21)) + + "!": any; +>"!" : Symbol(AllReservedOperationsInterface["!"], Decl(json-logic-js.d.ts, 80, 22)) + + "!!": any; +>"!!" : Symbol(AllReservedOperationsInterface["!!"], Decl(json-logic-js.d.ts, 81, 13)) + + or: Array>; +>or : Symbol(AllReservedOperationsInterface.or, Decl(json-logic-js.d.ts, 82, 14)) +>Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --) ... and 4 more) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) + + and: Array>; +>and : Symbol(AllReservedOperationsInterface.and, Decl(json-logic-js.d.ts, 83, 34)) +>Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --) ... and 4 more) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) + + ">": [RulesLogic, RulesLogic]; +>">" : Symbol(AllReservedOperationsInterface[">"], Decl(json-logic-js.d.ts, 84, 35)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) + + ">=": [RulesLogic, RulesLogic]; +>">=" : Symbol(AllReservedOperationsInterface[">="], Decl(json-logic-js.d.ts, 85, 50)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) + + "<": [RulesLogic, RulesLogic] | [RulesLogic, RulesLogic, RulesLogic]; +>"<" : Symbol(AllReservedOperationsInterface["<"], Decl(json-logic-js.d.ts, 86, 51)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) + + "<=": [RulesLogic, RulesLogic] | [RulesLogic, RulesLogic, RulesLogic]; +>"<=" : Symbol(AllReservedOperationsInterface["<="], Decl(json-logic-js.d.ts, 87, 113)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) + + max: Array>; +>max : Symbol(AllReservedOperationsInterface.max, Decl(json-logic-js.d.ts, 88, 114)) +>Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --) ... and 4 more) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) + + min: Array>; +>min : Symbol(AllReservedOperationsInterface.min, Decl(json-logic-js.d.ts, 89, 35)) +>Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --) ... and 4 more) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) + + "+": Array> | RulesLogic; +>"+" : Symbol(AllReservedOperationsInterface["+"], Decl(json-logic-js.d.ts, 90, 35)) +>Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --) ... and 4 more) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) + + "-": Array> | RulesLogic; +>"-" : Symbol(AllReservedOperationsInterface["-"], Decl(json-logic-js.d.ts, 91, 56)) +>Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --) ... and 4 more) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) + + "*": Array> | RulesLogic; +>"*" : Symbol(AllReservedOperationsInterface["*"], Decl(json-logic-js.d.ts, 92, 56)) +>Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --) ... and 4 more) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) + + "/": Array> | RulesLogic; +>"/" : Symbol(AllReservedOperationsInterface["/"], Decl(json-logic-js.d.ts, 93, 56)) +>Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --) ... and 4 more) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) + + "%": [RulesLogic, RulesLogic]; +>"%" : Symbol(AllReservedOperationsInterface["%"], Decl(json-logic-js.d.ts, 94, 56)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) + + map: [RulesLogic, RulesLogic]; +>map : Symbol(AllReservedOperationsInterface.map, Decl(json-logic-js.d.ts, 95, 50)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) + + filter: [RulesLogic, RulesLogic]; +>filter : Symbol(AllReservedOperationsInterface.filter, Decl(json-logic-js.d.ts, 96, 50)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) + + reduce: [RulesLogic, RulesLogic, RulesLogic]; +>reduce : Symbol(AllReservedOperationsInterface.reduce, Decl(json-logic-js.d.ts, 97, 53)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) + + all: [Array>, RulesLogic] | [RulesLogic, RulesLogic]; +>all : Symbol(AllReservedOperationsInterface.all, Decl(json-logic-js.d.ts, 98, 73)) +>Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --) ... and 4 more) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) + + none: [Array>, RulesLogic] | [RulesLogic, RulesLogic]; +>none : Symbol(AllReservedOperationsInterface.none, Decl(json-logic-js.d.ts, 99, 100)) +>Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --) ... and 4 more) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) + + some: [Array>, RulesLogic] | [RulesLogic, RulesLogic]; +>some : Symbol(AllReservedOperationsInterface.some, Decl(json-logic-js.d.ts, 100, 101)) +>Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --) ... and 4 more) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) + + merge: Array> | RulesLogic>; +>merge : Symbol(AllReservedOperationsInterface.merge, Decl(json-logic-js.d.ts, 101, 101)) +>Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --) ... and 4 more) +>Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --) ... and 4 more) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) + + inArray: [RulesLogic, Array>]; +>inArray : Symbol(AllReservedOperationsInterface.inArray, Decl(json-logic-js.d.ts, 102, 65)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) +>Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --) ... and 4 more) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) + + inString: [RulesLogic, RulesLogic]; +>inString : Symbol(AllReservedOperationsInterface.inString, Decl(json-logic-js.d.ts, 103, 61)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) + + cat: Array>; +>cat : Symbol(AllReservedOperationsInterface.cat, Decl(json-logic-js.d.ts, 104, 55)) +>Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --) ... and 4 more) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) + + substr: [RulesLogic, RulesLogic] | [RulesLogic, RulesLogic, RulesLogic]; +>substr : Symbol(AllReservedOperationsInterface.substr, Decl(json-logic-js.d.ts, 105, 35)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) + + log: RulesLogic; +>log : Symbol(AllReservedOperationsInterface.log, Decl(json-logic-js.d.ts, 106, 116)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 72, 48)) +} + +export type JsonLogicVar = Pick< +>JsonLogicVar : Symbol(JsonLogicVar, Decl(json-logic-js.d.ts, 108, 1)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 110, 25)) +>AdditionalOperation : Symbol(AdditionalOperation, Decl(json-logic-js.d.ts, 62, 12)) +>Pick : Symbol(Pick, Decl(lib.es5.d.ts, --, --)) + + AllReservedOperationsInterface, +>AllReservedOperationsInterface : Symbol(AllReservedOperationsInterface, Decl(json-logic-js.d.ts, 70, 100)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 110, 25)) + + "var" +>; +export type JsonLogicMissing = Pick< +>JsonLogicMissing : Symbol(JsonLogicMissing, Decl(json-logic-js.d.ts, 113, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 114, 29)) +>AdditionalOperation : Symbol(AdditionalOperation, Decl(json-logic-js.d.ts, 62, 12)) +>Pick : Symbol(Pick, Decl(lib.es5.d.ts, --, --)) + + AllReservedOperationsInterface, +>AllReservedOperationsInterface : Symbol(AllReservedOperationsInterface, Decl(json-logic-js.d.ts, 70, 100)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 114, 29)) + + "missing" +>; +export type JsonLogicMissingSome = Pick< +>JsonLogicMissingSome : Symbol(JsonLogicMissingSome, Decl(json-logic-js.d.ts, 117, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 118, 33)) +>AdditionalOperation : Symbol(AdditionalOperation, Decl(json-logic-js.d.ts, 62, 12)) +>Pick : Symbol(Pick, Decl(lib.es5.d.ts, --, --)) + + AllReservedOperationsInterface, +>AllReservedOperationsInterface : Symbol(AllReservedOperationsInterface, Decl(json-logic-js.d.ts, 70, 100)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 118, 33)) + + "missing_some" +>; +export type JsonLogicIf = Pick; +>JsonLogicIf : Symbol(JsonLogicIf, Decl(json-logic-js.d.ts, 121, 2)) +>Pick : Symbol(Pick, Decl(lib.es5.d.ts, --, --)) +>AllReservedOperationsInterface : Symbol(AllReservedOperationsInterface, Decl(json-logic-js.d.ts, 70, 100)) + +export type JsonLogicEqual = Pick; +>JsonLogicEqual : Symbol(JsonLogicEqual, Decl(json-logic-js.d.ts, 122, 69)) +>Pick : Symbol(Pick, Decl(lib.es5.d.ts, --, --)) +>AllReservedOperationsInterface : Symbol(AllReservedOperationsInterface, Decl(json-logic-js.d.ts, 70, 100)) + +export type JsonLogicStrictEqual = Pick; +>JsonLogicStrictEqual : Symbol(JsonLogicStrictEqual, Decl(json-logic-js.d.ts, 123, 72)) +>Pick : Symbol(Pick, Decl(lib.es5.d.ts, --, --)) +>AllReservedOperationsInterface : Symbol(AllReservedOperationsInterface, Decl(json-logic-js.d.ts, 70, 100)) + +export type JsonLogicNotEqual = Pick; +>JsonLogicStrictNotEqual : Symbol(JsonLogicStrictNotEqual, Decl(json-logic-js.d.ts, 125, 75)) +>Pick : Symbol(Pick, Decl(lib.es5.d.ts, --, --)) +>AllReservedOperationsInterface : Symbol(AllReservedOperationsInterface, Decl(json-logic-js.d.ts, 70, 100)) + +export type JsonLogicNegation = Pick; +>JsonLogicNegation : Symbol(JsonLogicNegation, Decl(json-logic-js.d.ts, 126, 82)) +>Pick : Symbol(Pick, Decl(lib.es5.d.ts, --, --)) +>AllReservedOperationsInterface : Symbol(AllReservedOperationsInterface, Decl(json-logic-js.d.ts, 70, 100)) + +export type JsonLogicDoubleNegation = Pick; +>JsonLogicDoubleNegation : Symbol(JsonLogicDoubleNegation, Decl(json-logic-js.d.ts, 127, 74)) +>Pick : Symbol(Pick, Decl(lib.es5.d.ts, --, --)) +>AllReservedOperationsInterface : Symbol(AllReservedOperationsInterface, Decl(json-logic-js.d.ts, 70, 100)) + +export type JsonLogicOr = Pick< +>JsonLogicOr : Symbol(JsonLogicOr, Decl(json-logic-js.d.ts, 128, 81)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 129, 24)) +>AdditionalOperation : Symbol(AdditionalOperation, Decl(json-logic-js.d.ts, 62, 12)) +>Pick : Symbol(Pick, Decl(lib.es5.d.ts, --, --)) + + AllReservedOperationsInterface, +>AllReservedOperationsInterface : Symbol(AllReservedOperationsInterface, Decl(json-logic-js.d.ts, 70, 100)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 129, 24)) + + "or" +>; +export type JsonLogicAnd = Pick< +>JsonLogicAnd : Symbol(JsonLogicAnd, Decl(json-logic-js.d.ts, 132, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 133, 25)) +>AdditionalOperation : Symbol(AdditionalOperation, Decl(json-logic-js.d.ts, 62, 12)) +>Pick : Symbol(Pick, Decl(lib.es5.d.ts, --, --)) + + AllReservedOperationsInterface, +>AllReservedOperationsInterface : Symbol(AllReservedOperationsInterface, Decl(json-logic-js.d.ts, 70, 100)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 133, 25)) + + "and" +>; +export type JsonLogicGreaterThan = Pick< +>JsonLogicGreaterThan : Symbol(JsonLogicGreaterThan, Decl(json-logic-js.d.ts, 136, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 137, 33)) +>AdditionalOperation : Symbol(AdditionalOperation, Decl(json-logic-js.d.ts, 62, 12)) +>Pick : Symbol(Pick, Decl(lib.es5.d.ts, --, --)) + + AllReservedOperationsInterface, +>AllReservedOperationsInterface : Symbol(AllReservedOperationsInterface, Decl(json-logic-js.d.ts, 70, 100)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 137, 33)) + + ">" +>; +export type JsonLogicGreaterThanOrEqual = Pick< +>JsonLogicGreaterThanOrEqual : Symbol(JsonLogicGreaterThanOrEqual, Decl(json-logic-js.d.ts, 140, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 141, 40)) +>AdditionalOperation : Symbol(AdditionalOperation, Decl(json-logic-js.d.ts, 62, 12)) +>Pick : Symbol(Pick, Decl(lib.es5.d.ts, --, --)) + + AllReservedOperationsInterface, +>AllReservedOperationsInterface : Symbol(AllReservedOperationsInterface, Decl(json-logic-js.d.ts, 70, 100)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 141, 40)) + + ">=" +>; +export type JsonLogicLessThan = Pick< +>JsonLogicLessThan : Symbol(JsonLogicLessThan, Decl(json-logic-js.d.ts, 144, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 145, 30)) +>AdditionalOperation : Symbol(AdditionalOperation, Decl(json-logic-js.d.ts, 62, 12)) +>Pick : Symbol(Pick, Decl(lib.es5.d.ts, --, --)) + + AllReservedOperationsInterface, +>AllReservedOperationsInterface : Symbol(AllReservedOperationsInterface, Decl(json-logic-js.d.ts, 70, 100)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 145, 30)) + + "<" +>; +export type JsonLogicLessThanOrEqual = Pick< +>JsonLogicLessThanOrEqual : Symbol(JsonLogicLessThanOrEqual, Decl(json-logic-js.d.ts, 148, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 149, 37)) +>AdditionalOperation : Symbol(AdditionalOperation, Decl(json-logic-js.d.ts, 62, 12)) +>Pick : Symbol(Pick, Decl(lib.es5.d.ts, --, --)) + + AllReservedOperationsInterface, +>AllReservedOperationsInterface : Symbol(AllReservedOperationsInterface, Decl(json-logic-js.d.ts, 70, 100)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 149, 37)) + + "<=" +>; +export type JsonLogicMax = Pick< +>JsonLogicMax : Symbol(JsonLogicMax, Decl(json-logic-js.d.ts, 152, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 153, 25)) +>AdditionalOperation : Symbol(AdditionalOperation, Decl(json-logic-js.d.ts, 62, 12)) +>Pick : Symbol(Pick, Decl(lib.es5.d.ts, --, --)) + + AllReservedOperationsInterface, +>AllReservedOperationsInterface : Symbol(AllReservedOperationsInterface, Decl(json-logic-js.d.ts, 70, 100)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 153, 25)) + + "max" +>; +export type JsonLogicMin = Pick< +>JsonLogicMin : Symbol(JsonLogicMin, Decl(json-logic-js.d.ts, 156, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 157, 25)) +>AdditionalOperation : Symbol(AdditionalOperation, Decl(json-logic-js.d.ts, 62, 12)) +>Pick : Symbol(Pick, Decl(lib.es5.d.ts, --, --)) + + AllReservedOperationsInterface, +>AllReservedOperationsInterface : Symbol(AllReservedOperationsInterface, Decl(json-logic-js.d.ts, 70, 100)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 157, 25)) + + "min" +>; +export type JsonLogicSum = Pick< +>JsonLogicSum : Symbol(JsonLogicSum, Decl(json-logic-js.d.ts, 160, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 161, 25)) +>AdditionalOperation : Symbol(AdditionalOperation, Decl(json-logic-js.d.ts, 62, 12)) +>Pick : Symbol(Pick, Decl(lib.es5.d.ts, --, --)) + + AllReservedOperationsInterface, +>AllReservedOperationsInterface : Symbol(AllReservedOperationsInterface, Decl(json-logic-js.d.ts, 70, 100)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 161, 25)) + + "+" +>; +export type JsonLogicDifference = Pick< +>JsonLogicDifference : Symbol(JsonLogicDifference, Decl(json-logic-js.d.ts, 164, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 165, 32)) +>AdditionalOperation : Symbol(AdditionalOperation, Decl(json-logic-js.d.ts, 62, 12)) +>Pick : Symbol(Pick, Decl(lib.es5.d.ts, --, --)) + + AllReservedOperationsInterface, +>AllReservedOperationsInterface : Symbol(AllReservedOperationsInterface, Decl(json-logic-js.d.ts, 70, 100)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 165, 32)) + + "-" +>; +export type JsonLogicProduct = Pick< +>JsonLogicProduct : Symbol(JsonLogicProduct, Decl(json-logic-js.d.ts, 168, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 169, 29)) +>AdditionalOperation : Symbol(AdditionalOperation, Decl(json-logic-js.d.ts, 62, 12)) +>Pick : Symbol(Pick, Decl(lib.es5.d.ts, --, --)) + + AllReservedOperationsInterface, +>AllReservedOperationsInterface : Symbol(AllReservedOperationsInterface, Decl(json-logic-js.d.ts, 70, 100)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 169, 29)) + + "*" +>; +export type JsonLogicQuotient = Pick< +>JsonLogicQuotient : Symbol(JsonLogicQuotient, Decl(json-logic-js.d.ts, 172, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 173, 30)) +>AdditionalOperation : Symbol(AdditionalOperation, Decl(json-logic-js.d.ts, 62, 12)) +>Pick : Symbol(Pick, Decl(lib.es5.d.ts, --, --)) + + AllReservedOperationsInterface, +>AllReservedOperationsInterface : Symbol(AllReservedOperationsInterface, Decl(json-logic-js.d.ts, 70, 100)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 173, 30)) + + "/" +>; +export type JsonLogicRemainder = Pick< +>JsonLogicRemainder : Symbol(JsonLogicRemainder, Decl(json-logic-js.d.ts, 176, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 177, 31)) +>AdditionalOperation : Symbol(AdditionalOperation, Decl(json-logic-js.d.ts, 62, 12)) +>Pick : Symbol(Pick, Decl(lib.es5.d.ts, --, --)) + + AllReservedOperationsInterface, +>AllReservedOperationsInterface : Symbol(AllReservedOperationsInterface, Decl(json-logic-js.d.ts, 70, 100)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 177, 31)) + + "%" +>; +export type JsonLogicMap = Pick< +>JsonLogicMap : Symbol(JsonLogicMap, Decl(json-logic-js.d.ts, 180, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 181, 25)) +>AdditionalOperation : Symbol(AdditionalOperation, Decl(json-logic-js.d.ts, 62, 12)) +>Pick : Symbol(Pick, Decl(lib.es5.d.ts, --, --)) + + AllReservedOperationsInterface, +>AllReservedOperationsInterface : Symbol(AllReservedOperationsInterface, Decl(json-logic-js.d.ts, 70, 100)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 181, 25)) + + "map" +>; +export type JsonLogicFilter = Pick< +>JsonLogicFilter : Symbol(JsonLogicFilter, Decl(json-logic-js.d.ts, 184, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 185, 28)) +>AdditionalOperation : Symbol(AdditionalOperation, Decl(json-logic-js.d.ts, 62, 12)) +>Pick : Symbol(Pick, Decl(lib.es5.d.ts, --, --)) + + AllReservedOperationsInterface, +>AllReservedOperationsInterface : Symbol(AllReservedOperationsInterface, Decl(json-logic-js.d.ts, 70, 100)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 185, 28)) + + "filter" +>; +export type JsonLogicReduce = Pick< +>JsonLogicReduce : Symbol(JsonLogicReduce, Decl(json-logic-js.d.ts, 188, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 189, 28)) +>AdditionalOperation : Symbol(AdditionalOperation, Decl(json-logic-js.d.ts, 62, 12)) +>Pick : Symbol(Pick, Decl(lib.es5.d.ts, --, --)) + + AllReservedOperationsInterface, +>AllReservedOperationsInterface : Symbol(AllReservedOperationsInterface, Decl(json-logic-js.d.ts, 70, 100)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 189, 28)) + + "reduce" +>; +export type JsonLogicAll = Pick< +>JsonLogicAll : Symbol(JsonLogicAll, Decl(json-logic-js.d.ts, 192, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 193, 25)) +>AdditionalOperation : Symbol(AdditionalOperation, Decl(json-logic-js.d.ts, 62, 12)) +>Pick : Symbol(Pick, Decl(lib.es5.d.ts, --, --)) + + AllReservedOperationsInterface, +>AllReservedOperationsInterface : Symbol(AllReservedOperationsInterface, Decl(json-logic-js.d.ts, 70, 100)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 193, 25)) + + "all" +>; +export type JsonLogicNone = Pick< +>JsonLogicNone : Symbol(JsonLogicNone, Decl(json-logic-js.d.ts, 196, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 197, 26)) +>AdditionalOperation : Symbol(AdditionalOperation, Decl(json-logic-js.d.ts, 62, 12)) +>Pick : Symbol(Pick, Decl(lib.es5.d.ts, --, --)) + + AllReservedOperationsInterface, +>AllReservedOperationsInterface : Symbol(AllReservedOperationsInterface, Decl(json-logic-js.d.ts, 70, 100)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 197, 26)) + + "none" +>; +export type JsonLogicSome = Pick< +>JsonLogicSome : Symbol(JsonLogicSome, Decl(json-logic-js.d.ts, 200, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 201, 26)) +>AdditionalOperation : Symbol(AdditionalOperation, Decl(json-logic-js.d.ts, 62, 12)) +>Pick : Symbol(Pick, Decl(lib.es5.d.ts, --, --)) + + AllReservedOperationsInterface, +>AllReservedOperationsInterface : Symbol(AllReservedOperationsInterface, Decl(json-logic-js.d.ts, 70, 100)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 201, 26)) + + "some" +>; +export type JsonLogicMerge = Pick< +>JsonLogicMerge : Symbol(JsonLogicMerge, Decl(json-logic-js.d.ts, 204, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 205, 27)) +>AdditionalOperation : Symbol(AdditionalOperation, Decl(json-logic-js.d.ts, 62, 12)) +>Pick : Symbol(Pick, Decl(lib.es5.d.ts, --, --)) + + AllReservedOperationsInterface, +>AllReservedOperationsInterface : Symbol(AllReservedOperationsInterface, Decl(json-logic-js.d.ts, 70, 100)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 205, 27)) + + "merge" +>; +export type JsonLogicInArray = RenameToIn< +>JsonLogicInArray : Symbol(JsonLogicInArray, Decl(json-logic-js.d.ts, 208, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 209, 29)) +>AdditionalOperation : Symbol(AdditionalOperation, Decl(json-logic-js.d.ts, 62, 12)) +>RenameToIn : Symbol(RenameToIn, Decl(json-logic-js.d.ts, 3, 10)) + + Pick, "inArray"> +>Pick : Symbol(Pick, Decl(lib.es5.d.ts, --, --)) +>AllReservedOperationsInterface : Symbol(AllReservedOperationsInterface, Decl(json-logic-js.d.ts, 70, 100)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 209, 29)) + +>; +export type JsonLogicInString = RenameToIn< +>JsonLogicInString : Symbol(JsonLogicInString, Decl(json-logic-js.d.ts, 211, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 212, 30)) +>AdditionalOperation : Symbol(AdditionalOperation, Decl(json-logic-js.d.ts, 62, 12)) +>RenameToIn : Symbol(RenameToIn, Decl(json-logic-js.d.ts, 3, 10)) + + Pick, "inString"> +>Pick : Symbol(Pick, Decl(lib.es5.d.ts, --, --)) +>AllReservedOperationsInterface : Symbol(AllReservedOperationsInterface, Decl(json-logic-js.d.ts, 70, 100)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 212, 30)) + +>; +export type JsonLogicCat = Pick< +>JsonLogicCat : Symbol(JsonLogicCat, Decl(json-logic-js.d.ts, 214, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 215, 25)) +>AdditionalOperation : Symbol(AdditionalOperation, Decl(json-logic-js.d.ts, 62, 12)) +>Pick : Symbol(Pick, Decl(lib.es5.d.ts, --, --)) + + AllReservedOperationsInterface, +>AllReservedOperationsInterface : Symbol(AllReservedOperationsInterface, Decl(json-logic-js.d.ts, 70, 100)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 215, 25)) + + "cat" +>; +export type JsonLogicSubstr = Pick< +>JsonLogicSubstr : Symbol(JsonLogicSubstr, Decl(json-logic-js.d.ts, 218, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 219, 28)) +>AdditionalOperation : Symbol(AdditionalOperation, Decl(json-logic-js.d.ts, 62, 12)) +>Pick : Symbol(Pick, Decl(lib.es5.d.ts, --, --)) + + AllReservedOperationsInterface, +>AllReservedOperationsInterface : Symbol(AllReservedOperationsInterface, Decl(json-logic-js.d.ts, 70, 100)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 219, 28)) + + "substr" +>; +export type JsonLogicLog = Pick< +>JsonLogicLog : Symbol(JsonLogicLog, Decl(json-logic-js.d.ts, 222, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 223, 25)) +>AdditionalOperation : Symbol(AdditionalOperation, Decl(json-logic-js.d.ts, 62, 12)) +>Pick : Symbol(Pick, Decl(lib.es5.d.ts, --, --)) + + AllReservedOperationsInterface, +>AllReservedOperationsInterface : Symbol(AllReservedOperationsInterface, Decl(json-logic-js.d.ts, 70, 100)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 223, 25)) + + "log" +>; + +export type RulesLogic = +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 228, 23)) +>AdditionalOperation : Symbol(AdditionalOperation, Decl(json-logic-js.d.ts, 62, 12)) + + | boolean + | string + | number + | null + // Accessing Data - https://jsonlogic.com/operations.html#accessing-data + | JsonLogicVar +>JsonLogicVar : Symbol(JsonLogicVar, Decl(json-logic-js.d.ts, 108, 1)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 228, 23)) + + | JsonLogicMissing +>JsonLogicMissing : Symbol(JsonLogicMissing, Decl(json-logic-js.d.ts, 113, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 228, 23)) + + | JsonLogicMissingSome +>JsonLogicMissingSome : Symbol(JsonLogicMissingSome, Decl(json-logic-js.d.ts, 117, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 228, 23)) + + // Logic and Boolean Operations - https://jsonlogic.com/operations.html#logic-and-boolean-operations + | JsonLogicIf +>JsonLogicIf : Symbol(JsonLogicIf, Decl(json-logic-js.d.ts, 121, 2)) + + | JsonLogicEqual +>JsonLogicEqual : Symbol(JsonLogicEqual, Decl(json-logic-js.d.ts, 122, 69)) + + | JsonLogicStrictEqual +>JsonLogicStrictEqual : Symbol(JsonLogicStrictEqual, Decl(json-logic-js.d.ts, 123, 72)) + + | JsonLogicNotEqual +>JsonLogicNotEqual : Symbol(JsonLogicNotEqual, Decl(json-logic-js.d.ts, 124, 79)) + + | JsonLogicStrictNotEqual +>JsonLogicStrictNotEqual : Symbol(JsonLogicStrictNotEqual, Decl(json-logic-js.d.ts, 125, 75)) + + | JsonLogicNegation +>JsonLogicNegation : Symbol(JsonLogicNegation, Decl(json-logic-js.d.ts, 126, 82)) + + | JsonLogicDoubleNegation +>JsonLogicDoubleNegation : Symbol(JsonLogicDoubleNegation, Decl(json-logic-js.d.ts, 127, 74)) + + | JsonLogicOr +>JsonLogicOr : Symbol(JsonLogicOr, Decl(json-logic-js.d.ts, 128, 81)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 228, 23)) + + | JsonLogicAnd +>JsonLogicAnd : Symbol(JsonLogicAnd, Decl(json-logic-js.d.ts, 132, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 228, 23)) + + // Numeric Operations - https://jsonlogic.com/operations.html#numeric-operations + | JsonLogicGreaterThan +>JsonLogicGreaterThan : Symbol(JsonLogicGreaterThan, Decl(json-logic-js.d.ts, 136, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 228, 23)) + + | JsonLogicGreaterThanOrEqual +>JsonLogicGreaterThanOrEqual : Symbol(JsonLogicGreaterThanOrEqual, Decl(json-logic-js.d.ts, 140, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 228, 23)) + + | JsonLogicLessThan +>JsonLogicLessThan : Symbol(JsonLogicLessThan, Decl(json-logic-js.d.ts, 144, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 228, 23)) + + | JsonLogicLessThanOrEqual +>JsonLogicLessThanOrEqual : Symbol(JsonLogicLessThanOrEqual, Decl(json-logic-js.d.ts, 148, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 228, 23)) + + | JsonLogicMax +>JsonLogicMax : Symbol(JsonLogicMax, Decl(json-logic-js.d.ts, 152, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 228, 23)) + + | JsonLogicMin +>JsonLogicMin : Symbol(JsonLogicMin, Decl(json-logic-js.d.ts, 156, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 228, 23)) + + | JsonLogicSum +>JsonLogicSum : Symbol(JsonLogicSum, Decl(json-logic-js.d.ts, 160, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 228, 23)) + + | JsonLogicDifference +>JsonLogicDifference : Symbol(JsonLogicDifference, Decl(json-logic-js.d.ts, 164, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 228, 23)) + + | JsonLogicProduct +>JsonLogicProduct : Symbol(JsonLogicProduct, Decl(json-logic-js.d.ts, 168, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 228, 23)) + + | JsonLogicQuotient +>JsonLogicQuotient : Symbol(JsonLogicQuotient, Decl(json-logic-js.d.ts, 172, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 228, 23)) + + | JsonLogicRemainder +>JsonLogicRemainder : Symbol(JsonLogicRemainder, Decl(json-logic-js.d.ts, 176, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 228, 23)) + + // Array Operations - https://jsonlogic.com/operations.html#array-operations + | JsonLogicMap +>JsonLogicMap : Symbol(JsonLogicMap, Decl(json-logic-js.d.ts, 180, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 228, 23)) + + | JsonLogicFilter +>JsonLogicFilter : Symbol(JsonLogicFilter, Decl(json-logic-js.d.ts, 184, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 228, 23)) + + | JsonLogicReduce +>JsonLogicReduce : Symbol(JsonLogicReduce, Decl(json-logic-js.d.ts, 188, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 228, 23)) + + | JsonLogicAll +>JsonLogicAll : Symbol(JsonLogicAll, Decl(json-logic-js.d.ts, 192, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 228, 23)) + + | JsonLogicNone +>JsonLogicNone : Symbol(JsonLogicNone, Decl(json-logic-js.d.ts, 196, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 228, 23)) + + | JsonLogicSome +>JsonLogicSome : Symbol(JsonLogicSome, Decl(json-logic-js.d.ts, 200, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 228, 23)) + + | JsonLogicMerge +>JsonLogicMerge : Symbol(JsonLogicMerge, Decl(json-logic-js.d.ts, 204, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 228, 23)) + + | JsonLogicInArray +>JsonLogicInArray : Symbol(JsonLogicInArray, Decl(json-logic-js.d.ts, 208, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 228, 23)) + + // String Operations - https://jsonlogic.com/operations.html#string-operations + | JsonLogicInString +>JsonLogicInString : Symbol(JsonLogicInString, Decl(json-logic-js.d.ts, 211, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 228, 23)) + + | JsonLogicCat +>JsonLogicCat : Symbol(JsonLogicCat, Decl(json-logic-js.d.ts, 214, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 228, 23)) + + | JsonLogicSubstr +>JsonLogicSubstr : Symbol(JsonLogicSubstr, Decl(json-logic-js.d.ts, 218, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 228, 23)) + + // Miscellaneous - https://jsonlogic.com/operations.html#miscellaneous + | JsonLogicLog +>JsonLogicLog : Symbol(JsonLogicLog, Decl(json-logic-js.d.ts, 222, 2)) +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 228, 23)) + + // Adding Operations (https://jsonlogic.com/add_operation.html) + | AddOps; +>AddOps : Symbol(AddOps, Decl(json-logic-js.d.ts, 228, 23)) + +export function add_operation(name: string, code: (...args: any[]) => any): void; +>add_operation : Symbol(add_operation, Decl(json-logic-js.d.ts, 275, 13)) +>name : Symbol(name, Decl(json-logic-js.d.ts, 277, 30)) +>code : Symbol(code, Decl(json-logic-js.d.ts, 277, 43)) +>args : Symbol(args, Decl(json-logic-js.d.ts, 277, 51)) + +export function apply(logic: RulesLogic, data?: unknown): any; +>apply : Symbol(apply, Decl(json-logic-js.d.ts, 277, 81)) +>logic : Symbol(logic, Decl(json-logic-js.d.ts, 278, 22)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>AdditionalOperation : Symbol(AdditionalOperation, Decl(json-logic-js.d.ts, 62, 12)) +>data : Symbol(data, Decl(json-logic-js.d.ts, 278, 61)) + +export function rm_operation(name: string): void; +>rm_operation : Symbol(rm_operation, Decl(json-logic-js.d.ts, 278, 83)) +>name : Symbol(name, Decl(json-logic-js.d.ts, 279, 29)) + +// These functions are undocumented, but are exported by the real package +// so they're typed here for completeness. +export function is_logic(logic: any): logic is RulesLogic; +>is_logic : Symbol(is_logic, Decl(json-logic-js.d.ts, 279, 49)) +>logic : Symbol(logic, Decl(json-logic-js.d.ts, 283, 25)) +>logic : Symbol(logic, Decl(json-logic-js.d.ts, 283, 25)) +>RulesLogic : Symbol(RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) + +export function truthy(value: any): boolean; +>truthy : Symbol(truthy, Decl(json-logic-js.d.ts, 283, 58)) +>value : Symbol(value, Decl(json-logic-js.d.ts, 284, 23)) + +export function get_operator(logic: Record): string; +>get_operator : Symbol(get_operator, Decl(json-logic-js.d.ts, 284, 44)) +>logic : Symbol(logic, Decl(json-logic-js.d.ts, 285, 29)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) + +export function get_values(logic: Record): any; +>get_values : Symbol(get_values, Decl(json-logic-js.d.ts, 285, 65)) +>logic : Symbol(logic, Decl(json-logic-js.d.ts, 286, 27)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) + +export function uses_data(logic: Record): any[]; +>uses_data : Symbol(uses_data, Decl(json-logic-js.d.ts, 286, 60)) +>logic : Symbol(logic, Decl(json-logic-js.d.ts, 287, 26)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) + +export function rule_like(rule: any, pattern: any): boolean; +>rule_like : Symbol(rule_like, Decl(json-logic-js.d.ts, 287, 61)) +>rule : Symbol(rule, Decl(json-logic-js.d.ts, 288, 26)) +>pattern : Symbol(pattern, Decl(json-logic-js.d.ts, 288, 36)) + +=== main.ts === +import * as jsonLogic from "./json-logic-js"; +>jsonLogic : Symbol(jsonLogic, Decl(main.ts, 0, 6)) + +type StartsWithAndEndsWith = +>StartsWithAndEndsWith : Symbol(StartsWithAndEndsWith, Decl(main.ts, 0, 45)) + + | { startsWith: [JsonLogicWithAdditionalOperations, JsonLogicWithAdditionalOperations] } +>startsWith : Symbol(startsWith, Decl(main.ts, 3, 7)) +>JsonLogicWithAdditionalOperations : Symbol(JsonLogicWithAdditionalOperations, Decl(main.ts, 4, 91)) +>JsonLogicWithAdditionalOperations : Symbol(JsonLogicWithAdditionalOperations, Decl(main.ts, 4, 91)) + + | { endsWith: [JsonLogicWithAdditionalOperations, JsonLogicWithAdditionalOperations] }; +>endsWith : Symbol(endsWith, Decl(main.ts, 4, 7)) +>JsonLogicWithAdditionalOperations : Symbol(JsonLogicWithAdditionalOperations, Decl(main.ts, 4, 91)) +>JsonLogicWithAdditionalOperations : Symbol(JsonLogicWithAdditionalOperations, Decl(main.ts, 4, 91)) + +type JsonLogicWithAdditionalOperations = jsonLogic.RulesLogic; +>JsonLogicWithAdditionalOperations : Symbol(JsonLogicWithAdditionalOperations, Decl(main.ts, 4, 91)) +>jsonLogic : Symbol(jsonLogic, Decl(main.ts, 0, 6)) +>RulesLogic : Symbol(jsonLogic.RulesLogic, Decl(json-logic-js.d.ts, 226, 2)) +>StartsWithAndEndsWith : Symbol(StartsWithAndEndsWith, Decl(main.ts, 0, 45)) + +const jsonExtendedLogic: JsonLogicWithAdditionalOperations = { +>jsonExtendedLogic : Symbol(jsonExtendedLogic, Decl(main.ts, 6, 5)) +>JsonLogicWithAdditionalOperations : Symbol(JsonLogicWithAdditionalOperations, Decl(main.ts, 4, 91)) + + and: [{ startsWith: ["Springfield", "Spring"] }, { endsWith: ["Springfield", "field"] }], +>and : Symbol(and, Decl(main.ts, 6, 62)) +>startsWith : Symbol(startsWith, Decl(main.ts, 7, 11)) +>endsWith : Symbol(endsWith, Decl(main.ts, 7, 54)) + +}; +jsonLogic.apply(jsonExtendedLogic); +>jsonLogic.apply : Symbol(jsonLogic.apply, Decl(json-logic-js.d.ts, 277, 81)) +>jsonLogic : Symbol(jsonLogic, Decl(main.ts, 0, 6)) +>apply : Symbol(jsonLogic.apply, Decl(json-logic-js.d.ts, 277, 81)) +>jsonExtendedLogic : Symbol(jsonExtendedLogic, Decl(main.ts, 6, 5)) + diff --git a/tsc/testdata/baselines/reference/compiler/varianceCycleRedoKeepsDiscardLog.types b/tsc/testdata/baselines/reference/compiler/varianceCycleRedoKeepsDiscardLog.types new file mode 100644 index 0000000000000..0d5ee0db7b1f7 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/varianceCycleRedoKeepsDiscardLog.types @@ -0,0 +1,518 @@ +//// [tests/cases/compiler/varianceCycleRedoKeepsDiscardLog.ts] //// + +=== json-logic-js.d.ts === +export as namespace jsonFactory; +>jsonFactory : typeof import("./json-logic-js") + +// Disable auto-export +export {}; + +type RenameToIn = { +>RenameToIn : RenameToIn + + [K in keyof T as K extends `in${Uppercase}${Lowercase}` ? `in` : K]: T[K]; +}; + +/** + * This is a utility type used below for the "if" operation. + * Original: https://stackoverflow.com/a/68373774/765987 + */ +type MAXIMUM_ALLOWED_BOUNDARY = 80; +>MAXIMUM_ALLOWED_BOUNDARY : 80 + +type Mapped< +>Mapped : Mapped + + Tuple extends unknown[], + Result extends unknown[] = [], + Count extends readonly number[] = [], +> = Count["length"] extends MAXIMUM_ALLOWED_BOUNDARY ? Result + : Tuple extends [] ? [] + : Result extends [] ? Mapped + : Mapped; +/** + * Used for the "if" operation, which takes an array of odd length + * and a minimum of three (3) elements. + */ +type AnyArrayOfOddLengthMin3 = [any, ...Mapped<[any, any]>]; +>AnyArrayOfOddLengthMin3 : [any, any, any] | [any, any, any, any, any] | [any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] + +export type ReservedOperations = +>ReservedOperations : ReservedOperations + + | "var" + | "missing" + | "missing_some" + | "if" + | "==" + | "===" + | "!=" + | "!==" + | "!" + | "!!" + | "or" + | "and" + | ">" + | ">=" + | "<" + | "<=" + | "max" + | "min" + | "+" + | "-" + | "*" + | "/" + | "%" + | "map" + | "filter" + | "reduce" + | "all" + | "none" + | "some" + | "merge" + | "in" + | "cat" + | "substr" + | "log"; + +/** + * This can be an object with any key except the reserved keys. + * TODO: Find a way to limit this type to exactly one (1) key, since + * json-logic-js enforces it. See: + * https://github.com/jwadhams/json-logic-js/blob/2.0.2/logic.js#L180 + */ +export type AdditionalOperation = Partial> & { [k: string]: any }; +>AdditionalOperation : AdditionalOperation +>k : string + +export interface AllReservedOperationsInterface { + var: RulesLogic | [RulesLogic] | [RulesLogic, any] | [RulesLogic, any]; +>var : [RulesLogic] | [RulesLogic, any] | RulesLogic + + missing: RulesLogic | any[]; +>missing : any[] | RulesLogic + + missing_some: [RulesLogic, RulesLogic | any[]]; +>missing_some : [RulesLogic, any[] | RulesLogic] + + if: AnyArrayOfOddLengthMin3; +>if : [any, any, any] | [any, any, any, any, any] | [any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] | [any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any] + + "==": [any, any]; +>"==" : [any, any] + + "===": [any, any]; +>"===" : [any, any] + + "!=": [any, any]; +>"!=" : [any, any] + + "!==": [any, any]; +>"!==" : [any, any] + + "!": any; +>"!" : any + + "!!": any; +>"!!" : any + + or: Array>; +>or : RulesLogic[] + + and: Array>; +>and : RulesLogic[] + + ">": [RulesLogic, RulesLogic]; +>">" : [RulesLogic, RulesLogic] + + ">=": [RulesLogic, RulesLogic]; +>">=" : [RulesLogic, RulesLogic] + + "<": [RulesLogic, RulesLogic] | [RulesLogic, RulesLogic, RulesLogic]; +>"<" : [RulesLogic, RulesLogic] | [RulesLogic, RulesLogic, RulesLogic] + + "<=": [RulesLogic, RulesLogic] | [RulesLogic, RulesLogic, RulesLogic]; +>"<=" : [RulesLogic, RulesLogic] | [RulesLogic, RulesLogic, RulesLogic] + + max: Array>; +>max : RulesLogic[] + + min: Array>; +>min : RulesLogic[] + + "+": Array> | RulesLogic; +>"+" : RulesLogic[] | RulesLogic + + "-": Array> | RulesLogic; +>"-" : RulesLogic[] | RulesLogic + + "*": Array> | RulesLogic; +>"*" : RulesLogic[] | RulesLogic + + "/": Array> | RulesLogic; +>"/" : RulesLogic[] | RulesLogic + + "%": [RulesLogic, RulesLogic]; +>"%" : [RulesLogic, RulesLogic] + + map: [RulesLogic, RulesLogic]; +>map : [RulesLogic, RulesLogic] + + filter: [RulesLogic, RulesLogic]; +>filter : [RulesLogic, RulesLogic] + + reduce: [RulesLogic, RulesLogic, RulesLogic]; +>reduce : [RulesLogic, RulesLogic, RulesLogic] + + all: [Array>, RulesLogic] | [RulesLogic, RulesLogic]; +>all : [RulesLogic[], RulesLogic] | [RulesLogic, RulesLogic] + + none: [Array>, RulesLogic] | [RulesLogic, RulesLogic]; +>none : [RulesLogic[], RulesLogic] | [RulesLogic, RulesLogic] + + some: [Array>, RulesLogic] | [RulesLogic, RulesLogic]; +>some : [RulesLogic[], RulesLogic] | [RulesLogic, RulesLogic] + + merge: Array> | RulesLogic>; +>merge : (RulesLogic[] | RulesLogic)[] + + inArray: [RulesLogic, Array>]; +>inArray : [RulesLogic, RulesLogic[]] + + inString: [RulesLogic, RulesLogic]; +>inString : [RulesLogic, RulesLogic] + + cat: Array>; +>cat : RulesLogic[] + + substr: [RulesLogic, RulesLogic] | [RulesLogic, RulesLogic, RulesLogic]; +>substr : [RulesLogic, RulesLogic] | [RulesLogic, RulesLogic, RulesLogic] + + log: RulesLogic; +>log : RulesLogic +} + +export type JsonLogicVar = Pick< +>JsonLogicVar : JsonLogicVar + + AllReservedOperationsInterface, + "var" +>; +export type JsonLogicMissing = Pick< +>JsonLogicMissing : JsonLogicMissing + + AllReservedOperationsInterface, + "missing" +>; +export type JsonLogicMissingSome = Pick< +>JsonLogicMissingSome : JsonLogicMissingSome + + AllReservedOperationsInterface, + "missing_some" +>; +export type JsonLogicIf = Pick; +>JsonLogicIf : JsonLogicIf + +export type JsonLogicEqual = Pick; +>JsonLogicEqual : JsonLogicEqual + +export type JsonLogicStrictEqual = Pick; +>JsonLogicStrictEqual : JsonLogicStrictEqual + +export type JsonLogicNotEqual = Pick; +>JsonLogicStrictNotEqual : JsonLogicStrictNotEqual + +export type JsonLogicNegation = Pick; +>JsonLogicNegation : JsonLogicNegation + +export type JsonLogicDoubleNegation = Pick; +>JsonLogicDoubleNegation : JsonLogicDoubleNegation + +export type JsonLogicOr = Pick< +>JsonLogicOr : JsonLogicOr + + AllReservedOperationsInterface, + "or" +>; +export type JsonLogicAnd = Pick< +>JsonLogicAnd : JsonLogicAnd + + AllReservedOperationsInterface, + "and" +>; +export type JsonLogicGreaterThan = Pick< +>JsonLogicGreaterThan : JsonLogicGreaterThan + + AllReservedOperationsInterface, + ">" +>; +export type JsonLogicGreaterThanOrEqual = Pick< +>JsonLogicGreaterThanOrEqual : JsonLogicGreaterThanOrEqual + + AllReservedOperationsInterface, + ">=" +>; +export type JsonLogicLessThan = Pick< +>JsonLogicLessThan : JsonLogicLessThan + + AllReservedOperationsInterface, + "<" +>; +export type JsonLogicLessThanOrEqual = Pick< +>JsonLogicLessThanOrEqual : JsonLogicLessThanOrEqual + + AllReservedOperationsInterface, + "<=" +>; +export type JsonLogicMax = Pick< +>JsonLogicMax : JsonLogicMax + + AllReservedOperationsInterface, + "max" +>; +export type JsonLogicMin = Pick< +>JsonLogicMin : JsonLogicMin + + AllReservedOperationsInterface, + "min" +>; +export type JsonLogicSum = Pick< +>JsonLogicSum : JsonLogicSum + + AllReservedOperationsInterface, + "+" +>; +export type JsonLogicDifference = Pick< +>JsonLogicDifference : JsonLogicDifference + + AllReservedOperationsInterface, + "-" +>; +export type JsonLogicProduct = Pick< +>JsonLogicProduct : JsonLogicProduct + + AllReservedOperationsInterface, + "*" +>; +export type JsonLogicQuotient = Pick< +>JsonLogicQuotient : JsonLogicQuotient + + AllReservedOperationsInterface, + "/" +>; +export type JsonLogicRemainder = Pick< +>JsonLogicRemainder : JsonLogicRemainder + + AllReservedOperationsInterface, + "%" +>; +export type JsonLogicMap = Pick< +>JsonLogicMap : JsonLogicMap + + AllReservedOperationsInterface, + "map" +>; +export type JsonLogicFilter = Pick< +>JsonLogicFilter : JsonLogicFilter + + AllReservedOperationsInterface, + "filter" +>; +export type JsonLogicReduce = Pick< +>JsonLogicReduce : JsonLogicReduce + + AllReservedOperationsInterface, + "reduce" +>; +export type JsonLogicAll = Pick< +>JsonLogicAll : JsonLogicAll + + AllReservedOperationsInterface, + "all" +>; +export type JsonLogicNone = Pick< +>JsonLogicNone : JsonLogicNone + + AllReservedOperationsInterface, + "none" +>; +export type JsonLogicSome = Pick< +>JsonLogicSome : JsonLogicSome + + AllReservedOperationsInterface, + "some" +>; +export type JsonLogicMerge = Pick< +>JsonLogicMerge : JsonLogicMerge + + AllReservedOperationsInterface, + "merge" +>; +export type JsonLogicInArray = RenameToIn< +>JsonLogicInArray : RenameToIn, "inArray">> + + Pick, "inArray"> +>; +export type JsonLogicInString = RenameToIn< +>JsonLogicInString : RenameToIn, "inString">> + + Pick, "inString"> +>; +export type JsonLogicCat = Pick< +>JsonLogicCat : JsonLogicCat + + AllReservedOperationsInterface, + "cat" +>; +export type JsonLogicSubstr = Pick< +>JsonLogicSubstr : JsonLogicSubstr + + AllReservedOperationsInterface, + "substr" +>; +export type JsonLogicLog = Pick< +>JsonLogicLog : JsonLogicLog + + AllReservedOperationsInterface, + "log" +>; + +export type RulesLogic = +>RulesLogic : RulesLogic + + | boolean + | string + | number + | null + // Accessing Data - https://jsonlogic.com/operations.html#accessing-data + | JsonLogicVar + | JsonLogicMissing + | JsonLogicMissingSome + // Logic and Boolean Operations - https://jsonlogic.com/operations.html#logic-and-boolean-operations + | JsonLogicIf + | JsonLogicEqual + | JsonLogicStrictEqual + | JsonLogicNotEqual + | JsonLogicStrictNotEqual + | JsonLogicNegation + | JsonLogicDoubleNegation + | JsonLogicOr + | JsonLogicAnd + // Numeric Operations - https://jsonlogic.com/operations.html#numeric-operations + | JsonLogicGreaterThan + | JsonLogicGreaterThanOrEqual + | JsonLogicLessThan + | JsonLogicLessThanOrEqual + | JsonLogicMax + | JsonLogicMin + | JsonLogicSum + | JsonLogicDifference + | JsonLogicProduct + | JsonLogicQuotient + | JsonLogicRemainder + // Array Operations - https://jsonlogic.com/operations.html#array-operations + | JsonLogicMap + | JsonLogicFilter + | JsonLogicReduce + | JsonLogicAll + | JsonLogicNone + | JsonLogicSome + | JsonLogicMerge + | JsonLogicInArray + // String Operations - https://jsonlogic.com/operations.html#string-operations + | JsonLogicInString + | JsonLogicCat + | JsonLogicSubstr + // Miscellaneous - https://jsonlogic.com/operations.html#miscellaneous + | JsonLogicLog + // Adding Operations (https://jsonlogic.com/add_operation.html) + | AddOps; + +export function add_operation(name: string, code: (...args: any[]) => any): void; +>add_operation : (name: string, code: (...args: any[]) => any) => void +>name : string +>code : (...args: any[]) => any +>args : any[] + +export function apply(logic: RulesLogic, data?: unknown): any; +>apply : (logic: RulesLogic, data?: unknown) => any +>logic : RulesLogic +>data : unknown + +export function rm_operation(name: string): void; +>rm_operation : (name: string) => void +>name : string + +// These functions are undocumented, but are exported by the real package +// so they're typed here for completeness. +export function is_logic(logic: any): logic is RulesLogic; +>is_logic : (logic: any) => logic is RulesLogic +>logic : any + +export function truthy(value: any): boolean; +>truthy : (value: any) => boolean +>value : any + +export function get_operator(logic: Record): string; +>get_operator : (logic: Record) => string +>logic : Record + +export function get_values(logic: Record): any; +>get_values : (logic: Record) => any +>logic : Record + +export function uses_data(logic: Record): any[]; +>uses_data : (logic: Record) => any[] +>logic : Record + +export function rule_like(rule: any, pattern: any): boolean; +>rule_like : (rule: any, pattern: any) => boolean +>rule : any +>pattern : any + +=== main.ts === +import * as jsonLogic from "./json-logic-js"; +>jsonLogic : typeof jsonLogic + +type StartsWithAndEndsWith = +>StartsWithAndEndsWith : StartsWithAndEndsWith + + | { startsWith: [JsonLogicWithAdditionalOperations, JsonLogicWithAdditionalOperations] } +>startsWith : [JsonLogicWithAdditionalOperations, JsonLogicWithAdditionalOperations] + + | { endsWith: [JsonLogicWithAdditionalOperations, JsonLogicWithAdditionalOperations] }; +>endsWith : [JsonLogicWithAdditionalOperations, JsonLogicWithAdditionalOperations] + +type JsonLogicWithAdditionalOperations = jsonLogic.RulesLogic; +>JsonLogicWithAdditionalOperations : JsonLogicWithAdditionalOperations +>jsonLogic : any + +const jsonExtendedLogic: JsonLogicWithAdditionalOperations = { +>jsonExtendedLogic : JsonLogicWithAdditionalOperations +>{ and: [{ startsWith: ["Springfield", "Spring"] }, { endsWith: ["Springfield", "field"] }],} : { and: ({ startsWith: [string, string]; } | { endsWith: [string, string]; })[]; } + + and: [{ startsWith: ["Springfield", "Spring"] }, { endsWith: ["Springfield", "field"] }], +>and : ({ startsWith: [string, string]; } | { endsWith: [string, string]; })[] +>[{ startsWith: ["Springfield", "Spring"] }, { endsWith: ["Springfield", "field"] }] : ({ startsWith: [string, string]; } | { endsWith: [string, string]; })[] +>{ startsWith: ["Springfield", "Spring"] } : { startsWith: [string, string]; } +>startsWith : [string, string] +>["Springfield", "Spring"] : [string, string] +>"Springfield" : "Springfield" +>"Spring" : "Spring" +>{ endsWith: ["Springfield", "field"] } : { endsWith: [string, string]; } +>endsWith : [string, string] +>["Springfield", "field"] : [string, string] +>"Springfield" : "Springfield" +>"field" : "field" + +}; +jsonLogic.apply(jsonExtendedLogic); +>jsonLogic.apply(jsonExtendedLogic) : any +>jsonLogic.apply : (logic: jsonLogic.RulesLogic, data?: unknown) => any +>jsonLogic : typeof jsonLogic +>apply : (logic: jsonLogic.RulesLogic, data?: unknown) => any +>jsonExtendedLogic : jsonLogic.JsonLogicAnd + diff --git a/tsc/testdata/baselines/reference/compiler/varianceCycleStructuralFallback.errors.txt b/tsc/testdata/baselines/reference/compiler/varianceCycleStructuralFallback.errors.txt new file mode 100644 index 0000000000000..85a24505357b2 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/varianceCycleStructuralFallback.errors.txt @@ -0,0 +1,86 @@ +maFirst.ts(8,1): error TS2322: Type 'MA<{ p: string; }>' is not assignable to type 'MA<{ p: "lit"; }>'. + The types of 'x.p' are incompatible between these types. + Type 'string' is not assignable to type '"lit"'. +maFirst.ts(9,1): error TS2322: Type 'MA<{ p: "lit"; }>' is not assignable to type 'MA<{ p: string; }>'. + Types of property 'b' are incompatible. + Type 'MB>' is not assignable to type 'MB>'. + Type 'MA<{ p: string; }>' is not assignable to type 'MA<{ p: "lit"; }>'. + The types of 'x.p' are incompatible between these types. + Type 'string' is not assignable to type '"lit"'. +maFirst.ts(11,1): error TS2322: Type 'MB<{ p: "lit"; }>' is not assignable to type 'MB<{ p: string; }>'. + Type '{ p: string; }' is not assignable to type '{ p: "lit"; }'. + Types of property 'p' are incompatible. + Type 'string' is not assignable to type '"lit"'. +mbFirst.ts(9,1): error TS2322: Type 'MB<{ p: "lit"; }>' is not assignable to type 'MB<{ p: string; }>'. + Type '{ p: string; }' is not assignable to type '{ p: "lit"; }'. + Types of property 'p' are incompatible. + Type 'string' is not assignable to type '"lit"'. +mbFirst.ts(10,1): error TS2322: Type 'MA<{ p: string; }>' is not assignable to type 'MA<{ p: "lit"; }>'. + The types of 'x.p' are incompatible between these types. + Type 'string' is not assignable to type '"lit"'. +mbFirst.ts(11,1): error TS2322: Type 'MA<{ p: "lit"; }>' is not assignable to type 'MA<{ p: string; }>'. + Types of property 'b' are incompatible. + Type 'MB>' is not assignable to type 'MB>'. + Type 'MA<{ p: string; }>' is not assignable to type 'MA<{ p: "lit"; }>'. + The types of 'x.p' are incompatible between these types. + Type 'string' is not assignable to type '"lit"'. + + +==== maFirst.ts (3 errors) ==== + export {}; + + type MA = { x: { [K in keyof T]-?: T[K] }; b: MB> }; + type MB = { f: (u: U) => void; a: MA> }; + + declare let as: MA<{ p: string }>, al: MA<{ p: "lit" }>; + declare let bs: MB<{ p: string }>, bl: MB<{ p: "lit" }>; + al = as; + ~~ +!!! error TS2322: Type 'MA<{ p: string; }>' is not assignable to type 'MA<{ p: "lit"; }>'. +!!! error TS2322: The types of 'x.p' are incompatible between these types. +!!! error TS2322: Type 'string' is not assignable to type '"lit"'. + as = al; + ~~ +!!! error TS2322: Type 'MA<{ p: "lit"; }>' is not assignable to type 'MA<{ p: string; }>'. +!!! error TS2322: Types of property 'b' are incompatible. +!!! error TS2322: Type 'MB>' is not assignable to type 'MB>'. +!!! error TS2322: Type 'MA<{ p: string; }>' is not assignable to type 'MA<{ p: "lit"; }>'. +!!! error TS2322: The types of 'x.p' are incompatible between these types. +!!! error TS2322: Type 'string' is not assignable to type '"lit"'. + bl = bs; + bs = bl; + ~~ +!!! error TS2322: Type 'MB<{ p: "lit"; }>' is not assignable to type 'MB<{ p: string; }>'. +!!! error TS2322: Type '{ p: string; }' is not assignable to type '{ p: "lit"; }'. +!!! error TS2322: Types of property 'p' are incompatible. +!!! error TS2322: Type 'string' is not assignable to type '"lit"'. + +==== mbFirst.ts (3 errors) ==== + export {}; + + type MA = { x: { [K in keyof T]-?: T[K] }; b: MB> }; + type MB = { f: (u: U) => void; a: MA> }; + + declare let as: MA<{ p: string }>, al: MA<{ p: "lit" }>; + declare let bs: MB<{ p: string }>, bl: MB<{ p: "lit" }>; + bl = bs; + bs = bl; + ~~ +!!! error TS2322: Type 'MB<{ p: "lit"; }>' is not assignable to type 'MB<{ p: string; }>'. +!!! error TS2322: Type '{ p: string; }' is not assignable to type '{ p: "lit"; }'. +!!! error TS2322: Types of property 'p' are incompatible. +!!! error TS2322: Type 'string' is not assignable to type '"lit"'. + al = as; + ~~ +!!! error TS2322: Type 'MA<{ p: string; }>' is not assignable to type 'MA<{ p: "lit"; }>'. +!!! error TS2322: The types of 'x.p' are incompatible between these types. +!!! error TS2322: Type 'string' is not assignable to type '"lit"'. + as = al; + ~~ +!!! error TS2322: Type 'MA<{ p: "lit"; }>' is not assignable to type 'MA<{ p: string; }>'. +!!! error TS2322: Types of property 'b' are incompatible. +!!! error TS2322: Type 'MB>' is not assignable to type 'MB>'. +!!! error TS2322: Type 'MA<{ p: string; }>' is not assignable to type 'MA<{ p: "lit"; }>'. +!!! error TS2322: The types of 'x.p' are incompatible between these types. +!!! error TS2322: Type 'string' is not assignable to type '"lit"'. + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/varianceCycleStructuralFallback.symbols b/tsc/testdata/baselines/reference/compiler/varianceCycleStructuralFallback.symbols new file mode 100644 index 0000000000000..6859a8dde928b --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/varianceCycleStructuralFallback.symbols @@ -0,0 +1,120 @@ +//// [tests/cases/compiler/varianceCycleStructuralFallback.ts] //// + +=== maFirst.ts === +export {}; + +type MA = { x: { [K in keyof T]-?: T[K] }; b: MB> }; +>MA : Symbol(MA, Decl(maFirst.ts, 0, 10)) +>T : Symbol(T, Decl(maFirst.ts, 2, 8)) +>x : Symbol(x, Decl(maFirst.ts, 2, 14)) +>K : Symbol(K, Decl(maFirst.ts, 2, 21)) +>T : Symbol(T, Decl(maFirst.ts, 2, 8)) +>T : Symbol(T, Decl(maFirst.ts, 2, 8)) +>K : Symbol(K, Decl(maFirst.ts, 2, 21)) +>b : Symbol(b, Decl(maFirst.ts, 2, 45)) +>MB : Symbol(MB, Decl(maFirst.ts, 2, 61)) +>MA : Symbol(MA, Decl(maFirst.ts, 0, 10)) +>T : Symbol(T, Decl(maFirst.ts, 2, 8)) + +type MB = { f: (u: U) => void; a: MA> }; +>MB : Symbol(MB, Decl(maFirst.ts, 2, 61)) +>U : Symbol(U, Decl(maFirst.ts, 3, 8)) +>f : Symbol(f, Decl(maFirst.ts, 3, 14)) +>u : Symbol(u, Decl(maFirst.ts, 3, 19)) +>U : Symbol(U, Decl(maFirst.ts, 3, 8)) +>a : Symbol(a, Decl(maFirst.ts, 3, 33)) +>MA : Symbol(MA, Decl(maFirst.ts, 0, 10)) +>MB : Symbol(MB, Decl(maFirst.ts, 2, 61)) +>U : Symbol(U, Decl(maFirst.ts, 3, 8)) + +declare let as: MA<{ p: string }>, al: MA<{ p: "lit" }>; +>as : Symbol(as, Decl(maFirst.ts, 5, 11)) +>MA : Symbol(MA, Decl(maFirst.ts, 0, 10)) +>p : Symbol(p, Decl(maFirst.ts, 5, 20)) +>al : Symbol(al, Decl(maFirst.ts, 5, 34)) +>MA : Symbol(MA, Decl(maFirst.ts, 0, 10)) +>p : Symbol(p, Decl(maFirst.ts, 5, 43)) + +declare let bs: MB<{ p: string }>, bl: MB<{ p: "lit" }>; +>bs : Symbol(bs, Decl(maFirst.ts, 6, 11)) +>MB : Symbol(MB, Decl(maFirst.ts, 2, 61)) +>p : Symbol(p, Decl(maFirst.ts, 6, 20)) +>bl : Symbol(bl, Decl(maFirst.ts, 6, 34)) +>MB : Symbol(MB, Decl(maFirst.ts, 2, 61)) +>p : Symbol(p, Decl(maFirst.ts, 6, 43)) + +al = as; +>al : Symbol(al, Decl(maFirst.ts, 5, 34)) +>as : Symbol(as, Decl(maFirst.ts, 5, 11)) + +as = al; +>as : Symbol(as, Decl(maFirst.ts, 5, 11)) +>al : Symbol(al, Decl(maFirst.ts, 5, 34)) + +bl = bs; +>bl : Symbol(bl, Decl(maFirst.ts, 6, 34)) +>bs : Symbol(bs, Decl(maFirst.ts, 6, 11)) + +bs = bl; +>bs : Symbol(bs, Decl(maFirst.ts, 6, 11)) +>bl : Symbol(bl, Decl(maFirst.ts, 6, 34)) + +=== mbFirst.ts === +export {}; + +type MA = { x: { [K in keyof T]-?: T[K] }; b: MB> }; +>MA : Symbol(MA, Decl(mbFirst.ts, 0, 10)) +>T : Symbol(T, Decl(mbFirst.ts, 2, 8)) +>x : Symbol(x, Decl(mbFirst.ts, 2, 14)) +>K : Symbol(K, Decl(mbFirst.ts, 2, 21)) +>T : Symbol(T, Decl(mbFirst.ts, 2, 8)) +>T : Symbol(T, Decl(mbFirst.ts, 2, 8)) +>K : Symbol(K, Decl(mbFirst.ts, 2, 21)) +>b : Symbol(b, Decl(mbFirst.ts, 2, 45)) +>MB : Symbol(MB, Decl(mbFirst.ts, 2, 61)) +>MA : Symbol(MA, Decl(mbFirst.ts, 0, 10)) +>T : Symbol(T, Decl(mbFirst.ts, 2, 8)) + +type MB = { f: (u: U) => void; a: MA> }; +>MB : Symbol(MB, Decl(mbFirst.ts, 2, 61)) +>U : Symbol(U, Decl(mbFirst.ts, 3, 8)) +>f : Symbol(f, Decl(mbFirst.ts, 3, 14)) +>u : Symbol(u, Decl(mbFirst.ts, 3, 19)) +>U : Symbol(U, Decl(mbFirst.ts, 3, 8)) +>a : Symbol(a, Decl(mbFirst.ts, 3, 33)) +>MA : Symbol(MA, Decl(mbFirst.ts, 0, 10)) +>MB : Symbol(MB, Decl(mbFirst.ts, 2, 61)) +>U : Symbol(U, Decl(mbFirst.ts, 3, 8)) + +declare let as: MA<{ p: string }>, al: MA<{ p: "lit" }>; +>as : Symbol(as, Decl(mbFirst.ts, 5, 11)) +>MA : Symbol(MA, Decl(mbFirst.ts, 0, 10)) +>p : Symbol(p, Decl(mbFirst.ts, 5, 20)) +>al : Symbol(al, Decl(mbFirst.ts, 5, 34)) +>MA : Symbol(MA, Decl(mbFirst.ts, 0, 10)) +>p : Symbol(p, Decl(mbFirst.ts, 5, 43)) + +declare let bs: MB<{ p: string }>, bl: MB<{ p: "lit" }>; +>bs : Symbol(bs, Decl(mbFirst.ts, 6, 11)) +>MB : Symbol(MB, Decl(mbFirst.ts, 2, 61)) +>p : Symbol(p, Decl(mbFirst.ts, 6, 20)) +>bl : Symbol(bl, Decl(mbFirst.ts, 6, 34)) +>MB : Symbol(MB, Decl(mbFirst.ts, 2, 61)) +>p : Symbol(p, Decl(mbFirst.ts, 6, 43)) + +bl = bs; +>bl : Symbol(bl, Decl(mbFirst.ts, 6, 34)) +>bs : Symbol(bs, Decl(mbFirst.ts, 6, 11)) + +bs = bl; +>bs : Symbol(bs, Decl(mbFirst.ts, 6, 11)) +>bl : Symbol(bl, Decl(mbFirst.ts, 6, 34)) + +al = as; +>al : Symbol(al, Decl(mbFirst.ts, 5, 34)) +>as : Symbol(as, Decl(mbFirst.ts, 5, 11)) + +as = al; +>as : Symbol(as, Decl(mbFirst.ts, 5, 11)) +>al : Symbol(al, Decl(mbFirst.ts, 5, 34)) + diff --git a/tsc/testdata/baselines/reference/compiler/varianceCycleStructuralFallback.types b/tsc/testdata/baselines/reference/compiler/varianceCycleStructuralFallback.types new file mode 100644 index 0000000000000..e40fcb80e2fea --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/varianceCycleStructuralFallback.types @@ -0,0 +1,94 @@ +//// [tests/cases/compiler/varianceCycleStructuralFallback.ts] //// + +=== maFirst.ts === +export {}; + +type MA = { x: { [K in keyof T]-?: T[K] }; b: MB> }; +>MA : MA +>x : { [K in keyof T]-?: T[K]; } +>b : MB> + +type MB = { f: (u: U) => void; a: MA> }; +>MB : MB +>f : (u: U) => void +>u : U +>a : MA> + +declare let as: MA<{ p: string }>, al: MA<{ p: "lit" }>; +>as : MA<{ p: string; }> +>p : string +>al : MA<{ p: "lit"; }> +>p : "lit" + +declare let bs: MB<{ p: string }>, bl: MB<{ p: "lit" }>; +>bs : MB<{ p: string; }> +>p : string +>bl : MB<{ p: "lit"; }> +>p : "lit" + +al = as; +>al = as : MA<{ p: string; }> +>al : MA<{ p: "lit"; }> +>as : MA<{ p: string; }> + +as = al; +>as = al : MA<{ p: "lit"; }> +>as : MA<{ p: string; }> +>al : MA<{ p: "lit"; }> + +bl = bs; +>bl = bs : MB<{ p: string; }> +>bl : MB<{ p: "lit"; }> +>bs : MB<{ p: string; }> + +bs = bl; +>bs = bl : MB<{ p: "lit"; }> +>bs : MB<{ p: string; }> +>bl : MB<{ p: "lit"; }> + +=== mbFirst.ts === +export {}; + +type MA = { x: { [K in keyof T]-?: T[K] }; b: MB> }; +>MA : MA +>x : { [K in keyof T]-?: T[K]; } +>b : MB> + +type MB = { f: (u: U) => void; a: MA> }; +>MB : MB +>f : (u: U) => void +>u : U +>a : MA> + +declare let as: MA<{ p: string }>, al: MA<{ p: "lit" }>; +>as : MA<{ p: string; }> +>p : string +>al : MA<{ p: "lit"; }> +>p : "lit" + +declare let bs: MB<{ p: string }>, bl: MB<{ p: "lit" }>; +>bs : MB<{ p: string; }> +>p : string +>bl : MB<{ p: "lit"; }> +>p : "lit" + +bl = bs; +>bl = bs : MB<{ p: string; }> +>bl : MB<{ p: "lit"; }> +>bs : MB<{ p: string; }> + +bs = bl; +>bs = bl : MB<{ p: "lit"; }> +>bs : MB<{ p: string; }> +>bl : MB<{ p: "lit"; }> + +al = as; +>al = as : MA<{ p: string; }> +>al : MA<{ p: "lit"; }> +>as : MA<{ p: string; }> + +as = al; +>as = al : MA<{ p: "lit"; }> +>as : MA<{ p: string; }> +>al : MA<{ p: "lit"; }> + diff --git a/tsc/testdata/baselines/reference/compiler/varianceDeclarationOrder.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/compiler/varianceSupersededMeasurementKeepsOtherComparisons(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/varianceSupersededMeasurementKeepsOtherComparisons(checkorder=default).symbols new file mode 100644 index 0000000000000..c191ffdb6c463 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/varianceSupersededMeasurementKeepsOtherComparisons(checkorder=default).symbols @@ -0,0 +1,51 @@ +//// [tests/cases/compiler/varianceSupersededMeasurementKeepsOtherComparisons.ts] //// + +=== varianceSupersededMeasurementKeepsOtherComparisons.ts === +// Reduced from zod v4 with LangGraph's `register` augmentation +// (langchain-ai/openwiki). Measuring the variance of B reaches A, which is +// smaller, so the measurement is superseded and measured again from A. While +// it finishes, comparing the parameters of `m` re-enters B, and its return +// type resolves `Check>`, whose comparison is not part of the +// measurement. It must still compare as it would from scratch, as the +// resolved conditional type is kept. + +declare let b1: B; +>b1 : Symbol(b1, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 8, 11)) +>B : Symbol(B, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 12, 48)) + +declare let b2: B<"s">; +>b2 : Symbol(b2, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 9, 11)) +>B : Symbol(B, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 12, 48)) + +b1 = b2; +>b1 : Symbol(b1, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 8, 11)) +>b2 : Symbol(b2, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 9, 11)) + +interface A { m(x: B): Check>; } +>A : Symbol(A, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 10, 8)) +>T : Symbol(T, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 12, 12)) +>m : Symbol(A.m, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 12, 16)) +>x : Symbol(x, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 12, 19)) +>B : Symbol(B, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 12, 48)) +>T : Symbol(T, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 12, 12)) +>Check : Symbol(Check, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 13, 27)) +>B : Symbol(B, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 12, 48)) + +interface B { a: A; } +>B : Symbol(B, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 12, 48)) +>T : Symbol(T, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 13, 12)) +>a : Symbol(B.a, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 13, 16)) +>A : Symbol(A, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 10, 8)) +>T : Symbol(T, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 13, 12)) + +type Check = U extends { a: unknown } ? "yes" : "no"; +>Check : Symbol(Check, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 13, 27)) +>U : Symbol(U, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 14, 11)) +>U : Symbol(U, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 14, 11)) +>a : Symbol(a, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 14, 27)) + +const v: Check> = "yes"; +>v : Symbol(v, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 16, 5)) +>Check : Symbol(Check, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 13, 27)) +>B : Symbol(B, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 12, 48)) + diff --git a/tsc/testdata/baselines/reference/compiler/varianceSupersededMeasurementKeepsOtherComparisons(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/varianceSupersededMeasurementKeepsOtherComparisons(checkorder=default).types new file mode 100644 index 0000000000000..0e07b1ec22a18 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/varianceSupersededMeasurementKeepsOtherComparisons(checkorder=default).types @@ -0,0 +1,37 @@ +//// [tests/cases/compiler/varianceSupersededMeasurementKeepsOtherComparisons.ts] //// + +=== varianceSupersededMeasurementKeepsOtherComparisons.ts === +// Reduced from zod v4 with LangGraph's `register` augmentation +// (langchain-ai/openwiki). Measuring the variance of B reaches A, which is +// smaller, so the measurement is superseded and measured again from A. While +// it finishes, comparing the parameters of `m` re-enters B, and its return +// type resolves `Check>`, whose comparison is not part of the +// measurement. It must still compare as it would from scratch, as the +// resolved conditional type is kept. + +declare let b1: B; +>b1 : B + +declare let b2: B<"s">; +>b2 : B<"s"> + +b1 = b2; +>b1 = b2 : B<"s"> +>b1 : B +>b2 : B<"s"> + +interface A { m(x: B): Check>; } +>m : (x: B) => Check> +>x : B + +interface B { a: A; } +>a : A + +type Check = U extends { a: unknown } ? "yes" : "no"; +>Check : Check +>a : unknown + +const v: Check> = "yes"; +>v : "yes" +>"yes" : "yes" + diff --git a/tsc/testdata/baselines/reference/compiler/varianceSupersededMeasurementKeepsOtherComparisons(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/varianceSupersededMeasurementKeepsOtherComparisons(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..c191ffdb6c463 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/varianceSupersededMeasurementKeepsOtherComparisons(checkorder=typesfirst).symbols @@ -0,0 +1,51 @@ +//// [tests/cases/compiler/varianceSupersededMeasurementKeepsOtherComparisons.ts] //// + +=== varianceSupersededMeasurementKeepsOtherComparisons.ts === +// Reduced from zod v4 with LangGraph's `register` augmentation +// (langchain-ai/openwiki). Measuring the variance of B reaches A, which is +// smaller, so the measurement is superseded and measured again from A. While +// it finishes, comparing the parameters of `m` re-enters B, and its return +// type resolves `Check>`, whose comparison is not part of the +// measurement. It must still compare as it would from scratch, as the +// resolved conditional type is kept. + +declare let b1: B; +>b1 : Symbol(b1, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 8, 11)) +>B : Symbol(B, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 12, 48)) + +declare let b2: B<"s">; +>b2 : Symbol(b2, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 9, 11)) +>B : Symbol(B, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 12, 48)) + +b1 = b2; +>b1 : Symbol(b1, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 8, 11)) +>b2 : Symbol(b2, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 9, 11)) + +interface A { m(x: B): Check>; } +>A : Symbol(A, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 10, 8)) +>T : Symbol(T, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 12, 12)) +>m : Symbol(A.m, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 12, 16)) +>x : Symbol(x, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 12, 19)) +>B : Symbol(B, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 12, 48)) +>T : Symbol(T, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 12, 12)) +>Check : Symbol(Check, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 13, 27)) +>B : Symbol(B, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 12, 48)) + +interface B { a: A; } +>B : Symbol(B, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 12, 48)) +>T : Symbol(T, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 13, 12)) +>a : Symbol(B.a, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 13, 16)) +>A : Symbol(A, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 10, 8)) +>T : Symbol(T, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 13, 12)) + +type Check = U extends { a: unknown } ? "yes" : "no"; +>Check : Symbol(Check, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 13, 27)) +>U : Symbol(U, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 14, 11)) +>U : Symbol(U, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 14, 11)) +>a : Symbol(a, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 14, 27)) + +const v: Check> = "yes"; +>v : Symbol(v, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 16, 5)) +>Check : Symbol(Check, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 13, 27)) +>B : Symbol(B, Decl(varianceSupersededMeasurementKeepsOtherComparisons.ts, 12, 48)) + diff --git a/tsc/testdata/baselines/reference/compiler/varianceSupersededMeasurementKeepsOtherComparisons(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/varianceSupersededMeasurementKeepsOtherComparisons(checkorder=typesfirst).types new file mode 100644 index 0000000000000..0e07b1ec22a18 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/varianceSupersededMeasurementKeepsOtherComparisons(checkorder=typesfirst).types @@ -0,0 +1,37 @@ +//// [tests/cases/compiler/varianceSupersededMeasurementKeepsOtherComparisons.ts] //// + +=== varianceSupersededMeasurementKeepsOtherComparisons.ts === +// Reduced from zod v4 with LangGraph's `register` augmentation +// (langchain-ai/openwiki). Measuring the variance of B reaches A, which is +// smaller, so the measurement is superseded and measured again from A. While +// it finishes, comparing the parameters of `m` re-enters B, and its return +// type resolves `Check>`, whose comparison is not part of the +// measurement. It must still compare as it would from scratch, as the +// resolved conditional type is kept. + +declare let b1: B; +>b1 : B + +declare let b2: B<"s">; +>b2 : B<"s"> + +b1 = b2; +>b1 = b2 : B<"s"> +>b1 : B +>b2 : B<"s"> + +interface A { m(x: B): Check>; } +>m : (x: B) => Check> +>x : B + +interface B { a: A; } +>a : A + +type Check = U extends { a: unknown } ? "yes" : "no"; +>Check : Check +>a : unknown + +const v: Check> = "yes"; +>v : "yes" +>"yes" : "yes" + diff --git a/tsc/testdata/baselines/reference/conformance/dependentDestructuredVariablesReferenceInDeclaration1(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/conformance/dependentDestructuredVariablesReferenceInDeclaration1(checkorder=default).errors.txt new file mode 100644 index 0000000000000..5529a3e5e68c6 --- /dev/null +++ b/tsc/testdata/baselines/reference/conformance/dependentDestructuredVariablesReferenceInDeclaration1(checkorder=default).errors.txt @@ -0,0 +1,149 @@ +dependentDestructuredVariablesReferenceInDeclaration1.ts(4,9): error TS2322: Type '{ c: number; f: any; }' is not assignable to type 'string | number'. +dependentDestructuredVariablesReferenceInDeclaration1.ts(4,11): error TS2339: Property 'c' does not exist on type 'string | number'. +dependentDestructuredVariablesReferenceInDeclaration1.ts(4,14): error TS2339: Property 'f' does not exist on type 'string | number'. +dependentDestructuredVariablesReferenceInDeclaration1.ts(4,14): error TS7022: 'f' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. +dependentDestructuredVariablesReferenceInDeclaration1.ts(4,45): error TS2448: Block-scoped variable 'f' used before its declaration. +dependentDestructuredVariablesReferenceInDeclaration1.ts(9,9): error TS2322: Type '{ c: number; f: () => any; }' is not assignable to type 'string | number'. +dependentDestructuredVariablesReferenceInDeclaration1.ts(9,11): error TS2339: Property 'c' does not exist on type 'string | number'. +dependentDestructuredVariablesReferenceInDeclaration1.ts(9,14): error TS2339: Property 'f' does not exist on type 'string | number'. +dependentDestructuredVariablesReferenceInDeclaration1.ts(14,9): error TS2322: Type '{ c: number; f: number; g: number; }' is not assignable to type 'string | number'. +dependentDestructuredVariablesReferenceInDeclaration1.ts(14,11): error TS2339: Property 'c' does not exist on type 'string | number'. +dependentDestructuredVariablesReferenceInDeclaration1.ts(14,14): error TS2339: Property 'f' does not exist on type 'string | number'. +dependentDestructuredVariablesReferenceInDeclaration1.ts(14,17): error TS2339: Property 'g' does not exist on type 'string | number'. +dependentDestructuredVariablesReferenceInDeclaration1.ts(20,9): error TS2322: Type '{ c: number; f: number; }' is not assignable to type 'string | number'. +dependentDestructuredVariablesReferenceInDeclaration1.ts(20,11): error TS2339: Property 'c' does not exist on type 'string | number'. +dependentDestructuredVariablesReferenceInDeclaration1.ts(20,14): error TS2339: Property 'f' does not exist on type 'string | number'. +dependentDestructuredVariablesReferenceInDeclaration1.ts(20,14): error TS2451: Cannot redeclare block-scoped variable 'f'. +dependentDestructuredVariablesReferenceInDeclaration1.ts(20,17): error TS2339: Property 'f' does not exist on type 'string | number'. +dependentDestructuredVariablesReferenceInDeclaration1.ts(20,17): error TS2451: Cannot redeclare block-scoped variable 'f'. +dependentDestructuredVariablesReferenceInDeclaration1.ts(25,9): error TS2322: Type '{ c: number; f: number; }' is not assignable to type 'string | number'. +dependentDestructuredVariablesReferenceInDeclaration1.ts(25,11): error TS2339: Property 'c' does not exist on type 'string | number'. +dependentDestructuredVariablesReferenceInDeclaration1.ts(25,14): error TS2339: Property 'f' does not exist on type 'string | number'. +dependentDestructuredVariablesReferenceInDeclaration1.ts(25,17): error TS2339: Property 'f' does not exist on type 'string | number'. +dependentDestructuredVariablesReferenceInDeclaration1.ts(30,14): error TS7022: 'f' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. +dependentDestructuredVariablesReferenceInDeclaration1.ts(30,71): error TS2448: Block-scoped variable 'f' used before its declaration. +dependentDestructuredVariablesReferenceInDeclaration1.ts(58,14): error TS2451: Cannot redeclare block-scoped variable 'f'. +dependentDestructuredVariablesReferenceInDeclaration1.ts(58,17): error TS2451: Cannot redeclare block-scoped variable 'f'. + + +==== dependentDestructuredVariablesReferenceInDeclaration1.ts (26 errors) ==== + // https://github.com/microsoft/TypeScript/issues/62993 + + { + const { c, f }: string | number = { c: 0, f }; + ~~~~~~~~ +!!! error TS2322: Type '{ c: number; f: any; }' is not assignable to type 'string | number'. + ~ +!!! error TS2339: Property 'c' does not exist on type 'string | number'. + ~ +!!! error TS2339: Property 'f' does not exist on type 'string | number'. + ~ +!!! error TS7022: 'f' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. + ~ +!!! error TS2448: Block-scoped variable 'f' used before its declaration. +!!! related TS2728 dependentDestructuredVariablesReferenceInDeclaration1.ts:4:14: 'f' is declared here. + f; + } + + { + const { c, f }: string | number = { c: 0, f: () => f }; + ~~~~~~~~ +!!! error TS2322: Type '{ c: number; f: () => any; }' is not assignable to type 'string | number'. + ~ +!!! error TS2339: Property 'c' does not exist on type 'string | number'. + ~ +!!! error TS2339: Property 'f' does not exist on type 'string | number'. + f; + } + + { + const { c, f, g = f }: string | number = { c: 0, f: 0, g: 0 }; + ~~~~~~~~~~~~~~~ +!!! error TS2322: Type '{ c: number; f: number; g: number; }' is not assignable to type 'string | number'. + ~ +!!! error TS2339: Property 'c' does not exist on type 'string | number'. + ~ +!!! error TS2339: Property 'f' does not exist on type 'string | number'. + ~ +!!! error TS2339: Property 'g' does not exist on type 'string | number'. + f; + g; + } + + { + const { c, f, f }: string | number = { c: 0, f: 0 }; + ~~~~~~~~~~~ +!!! error TS2322: Type '{ c: number; f: number; }' is not assignable to type 'string | number'. + ~ +!!! error TS2339: Property 'c' does not exist on type 'string | number'. + ~ +!!! error TS2339: Property 'f' does not exist on type 'string | number'. + ~ +!!! error TS2451: Cannot redeclare block-scoped variable 'f'. + ~ +!!! error TS2339: Property 'f' does not exist on type 'string | number'. + ~ +!!! error TS2451: Cannot redeclare block-scoped variable 'f'. + f; + } + + { + const { c, f, f: g }: string | number = { c: 0, f: 0 }; + ~~~~~~~~~~~~~~ +!!! error TS2322: Type '{ c: number; f: number; }' is not assignable to type 'string | number'. + ~ +!!! error TS2339: Property 'c' does not exist on type 'string | number'. + ~ +!!! error TS2339: Property 'f' does not exist on type 'string | number'. + ~ +!!! error TS2339: Property 'f' does not exist on type 'string | number'. + g; + } + + { + const { c, f }: { c: 0; f: number } | { c: 1; f: string } = { c: 0, f }; + ~ +!!! error TS7022: 'f' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. + ~ +!!! error TS2448: Block-scoped variable 'f' used before its declaration. +!!! related TS2728 dependentDestructuredVariablesReferenceInDeclaration1.ts:30:14: 'f' is declared here. + f; + } + + { + const { c, f }: { c: 0; f: () => unknown } | { c: 1; f: string } = { + c: 0, + f: () => f, + }; + f; + } + + { + const { + c, + f, + g = f, + }: + | { c: 0; f: bigint; g?: bigint | number } + | { c: 1; f: number; g: string } = { + c: 0, + f: 10n, + }; + f; + g; + } + + { + const { c, f, f }: { c: 0; f: number } | { c: 1; f: string } = { c: 0, f: 0 }; + ~ +!!! error TS2451: Cannot redeclare block-scoped variable 'f'. + ~ +!!! error TS2451: Cannot redeclare block-scoped variable 'f'. + f; + } + + { + const { c, f, f: g }: { c: 0; f: number } | { c: 1; f: string } = { c: 0, f: 0 }; + g; + } + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/conformance/dependentDestructuredVariablesReferenceInDeclaration1(checkorder=default).symbols b/tsc/testdata/baselines/reference/conformance/dependentDestructuredVariablesReferenceInDeclaration1(checkorder=default).symbols new file mode 100644 index 0000000000000..dd70a6b10cfe7 --- /dev/null +++ b/tsc/testdata/baselines/reference/conformance/dependentDestructuredVariablesReferenceInDeclaration1(checkorder=default).symbols @@ -0,0 +1,175 @@ +//// [tests/cases/conformance/controlFlow/dependentDestructuredVariablesReferenceInDeclaration1.ts] //// + +=== dependentDestructuredVariablesReferenceInDeclaration1.ts === +// https://github.com/microsoft/TypeScript/issues/62993 + +{ + const { c, f }: string | number = { c: 0, f }; +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 3, 9)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 3, 12)) +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 3, 37)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 3, 43)) + + f; +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 3, 12)) +} + +{ + const { c, f }: string | number = { c: 0, f: () => f }; +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 8, 9)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 8, 12)) +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 8, 37)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 8, 43)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 8, 12)) + + f; +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 8, 12)) +} + +{ + const { c, f, g = f }: string | number = { c: 0, f: 0, g: 0 }; +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 13, 9)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 13, 12)) +>g : Symbol(g, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 13, 15)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 13, 12)) +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 13, 44)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 13, 50)) +>g : Symbol(g, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 13, 56)) + + f; +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 13, 12)) + + g; +>g : Symbol(g, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 13, 15)) +} + +{ + const { c, f, f }: string | number = { c: 0, f: 0 }; +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 19, 9)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 19, 12)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 19, 15)) +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 19, 40)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 19, 46)) + + f; +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 19, 12)) +} + +{ + const { c, f, f: g }: string | number = { c: 0, f: 0 }; +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 24, 9)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 24, 12)) +>g : Symbol(g, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 24, 15)) +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 24, 43)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 24, 49)) + + g; +>g : Symbol(g, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 24, 15)) +} + +{ + const { c, f }: { c: 0; f: number } | { c: 1; f: string } = { c: 0, f }; +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 29, 9)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 29, 12)) +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 29, 19)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 29, 25)) +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 29, 41)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 29, 47)) +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 29, 63)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 29, 69)) + + f; +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 29, 12)) +} + +{ + const { c, f }: { c: 0; f: () => unknown } | { c: 1; f: string } = { +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 34, 9)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 34, 12)) +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 34, 19)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 34, 25)) +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 34, 48)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 34, 54)) + + c: 0, +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 34, 70)) + + f: () => f, +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 35, 9)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 34, 12)) + + }; + f; +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 34, 12)) +} + +{ + const { + c, +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 42, 9)) + + f, +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 43, 6)) + + g = f, +>g : Symbol(g, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 44, 6)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 43, 6)) + + }: + | { c: 0; f: bigint; g?: bigint | number } +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 47, 7)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 47, 13)) +>g : Symbol(g, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 47, 24)) + + | { c: 1; f: number; g: string } = { +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 48, 7)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 48, 13)) +>g : Symbol(g, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 48, 24)) + + c: 0, +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 48, 40)) + + f: 10n, +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 49, 9)) + + }; + f; +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 43, 6)) + + g; +>g : Symbol(g, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 44, 6)) +} + +{ + const { c, f, f }: { c: 0; f: number } | { c: 1; f: string } = { c: 0, f: 0 }; +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 57, 9)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 57, 12)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 57, 15)) +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 57, 22)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 57, 28)) +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 57, 44)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 57, 50)) +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 57, 66)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 57, 72)) + + f; +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 57, 12)) +} + +{ + const { c, f, f: g }: { c: 0; f: number } | { c: 1; f: string } = { c: 0, f: 0 }; +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 62, 9)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 62, 12)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 62, 31), Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 62, 53)) +>g : Symbol(g, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 62, 15)) +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 62, 25)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 62, 31)) +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 62, 47)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 62, 53)) +>c : Symbol(c, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 62, 69)) +>f : Symbol(f, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 62, 75)) + + g; +>g : Symbol(g, Decl(dependentDestructuredVariablesReferenceInDeclaration1.ts, 62, 15)) +} + diff --git a/tsc/testdata/baselines/reference/conformance/dependentDestructuredVariablesReferenceInDeclaration1(checkorder=default).types b/tsc/testdata/baselines/reference/conformance/dependentDestructuredVariablesReferenceInDeclaration1(checkorder=default).types new file mode 100644 index 0000000000000..1e1c61a26976d --- /dev/null +++ b/tsc/testdata/baselines/reference/conformance/dependentDestructuredVariablesReferenceInDeclaration1(checkorder=default).types @@ -0,0 +1,205 @@ +//// [tests/cases/conformance/controlFlow/dependentDestructuredVariablesReferenceInDeclaration1.ts] //// + +=== dependentDestructuredVariablesReferenceInDeclaration1.ts === +// https://github.com/microsoft/TypeScript/issues/62993 + +{ + const { c, f }: string | number = { c: 0, f }; +>c : any +>f : any +>{ c: 0, f } : { c: number; f: any; } +>c : number +>0 : 0 +>f : any + + f; +>f : any +} + +{ + const { c, f }: string | number = { c: 0, f: () => f }; +>c : any +>f : any +>{ c: 0, f: () => f } : { c: number; f: () => any; } +>c : number +>0 : 0 +>f : () => any +>() => f : () => any +>f : any + + f; +>f : any +} + +{ + const { c, f, g = f }: string | number = { c: 0, f: 0, g: 0 }; +>c : any +>f : any +>g : any +>f : any +>{ c: 0, f: 0, g: 0 } : { c: number; f: number; g: number; } +>c : number +>0 : 0 +>f : number +>0 : 0 +>g : number +>0 : 0 + + f; +>f : any + + g; +>g : any +} + +{ + const { c, f, f }: string | number = { c: 0, f: 0 }; +>c : any +>f : any +>f : any +>{ c: 0, f: 0 } : { c: number; f: number; } +>c : number +>0 : 0 +>f : number +>0 : 0 + + f; +>f : any +} + +{ + const { c, f, f: g }: string | number = { c: 0, f: 0 }; +>c : any +>f : any +>f : any +>g : any +>{ c: 0, f: 0 } : { c: number; f: number; } +>c : number +>0 : 0 +>f : number +>0 : 0 + + g; +>g : any +} + +{ + const { c, f }: { c: 0; f: number } | { c: 1; f: string } = { c: 0, f }; +>c : 0 | 1 +>f : any +>c : 0 +>f : number +>c : 1 +>f : string +>{ c: 0, f } : { c: 0; f: any; } +>c : 0 +>0 : 0 +>f : any + + f; +>f : string | number +} + +{ + const { c, f }: { c: 0; f: () => unknown } | { c: 1; f: string } = { +>c : 0 | 1 +>f : string | (() => unknown) +>c : 0 +>f : () => unknown +>c : 1 +>f : string +>{ c: 0, f: () => f, } : { c: 0; f: () => string | (() => unknown); } + + c: 0, +>c : 0 +>0 : 0 + + f: () => f, +>f : () => string | (() => unknown) +>() => f : () => string | (() => unknown) +>f : string | (() => unknown) + + }; + f; +>f : () => unknown +} + +{ + const { + c, +>c : 0 | 1 + + f, +>f : number | bigint + + g = f, +>g : string | number | bigint +>f : number | bigint + + }: + | { c: 0; f: bigint; g?: bigint | number } +>c : 0 +>f : bigint +>g : number | bigint | undefined + + | { c: 1; f: number; g: string } = { +>c : 1 +>f : number +>g : string +>{ c: 0, f: 10n, } : { c: 0; f: bigint; } + + c: 0, +>c : 0 +>0 : 0 + + f: 10n, +>f : bigint +>10n : 10n + + }; + f; +>f : bigint + + g; +>g : string | number | bigint +} + +{ + const { c, f, f }: { c: 0; f: number } | { c: 1; f: string } = { c: 0, f: 0 }; +>c : 0 | 1 +>f : string | number +>f : string | number +>c : 0 +>f : number +>c : 1 +>f : string +>{ c: 0, f: 0 } : { c: 0; f: number; } +>c : 0 +>0 : 0 +>f : number +>0 : 0 + + f; +>f : number +} + +{ + const { c, f, f: g }: { c: 0; f: number } | { c: 1; f: string } = { c: 0, f: 0 }; +>c : 0 | 1 +>f : string | number +>f : any +>g : string | number +>c : 0 +>f : number +>c : 1 +>f : string +>{ c: 0, f: 0 } : { c: 0; f: number; } +>c : 0 +>0 : 0 +>f : number +>0 : 0 + + g; +>g : number +} + diff --git a/tsc/testdata/baselines/reference/conformance/dependentDestructuredVariablesReferenceInDeclaration1(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/conformance/dependentDestructuredVariablesReferenceInDeclaration1(checkorder=typesfirst).errors.txt new file mode 100644 index 0000000000000..981a83e22c019 --- /dev/null +++ b/tsc/testdata/baselines/reference/conformance/dependentDestructuredVariablesReferenceInDeclaration1(checkorder=typesfirst).errors.txt @@ -0,0 +1,152 @@ +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(35,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(58,14): error TS2451: Cannot redeclare block-scoped variable 'f'. +dependentDestructuredVariablesReferenceInDeclaration1.ts(58,17): error TS2451: Cannot redeclare block-scoped variable 'f'. + + +==== dependentDestructuredVariablesReferenceInDeclaration1.ts (27 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 } = { + ~ +!!! 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. + 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..fda8b5b052297 --- /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 : any +>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).errors.txt b/tsc/testdata/baselines/reference/conformance/destructuringWithLiteralInitializers(checkorder=typesfirst).errors.txt new file mode 100644 index 0000000000000..ee3b06edc611c --- /dev/null +++ b/tsc/testdata/baselines/reference/conformance/destructuringWithLiteralInitializers(checkorder=typesfirst).errors.txt @@ -0,0 +1,75 @@ +destructuringWithLiteralInitializers.ts(37,20): error TS2339: Property 'x' does not exist on type '{}'. +destructuringWithLiteralInitializers.ts(37,27): error TS2339: Property 'y' does not exist on type '{}'. + + +==== destructuringWithLiteralInitializers.ts (2 errors) ==== + // (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: {} }) { } + ~ +!!! error TS2339: Property 'x' does not exist on type '{}'. + ~ +!!! error TS2339: Property 'y' does not exist on type '{}'. + 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]); + \ No newline at end of file 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..45f5edceff50e --- /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 : any +>0 : 0 +>y : any +>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..de660063858df --- /dev/null +++ b/tsc/testdata/baselines/reference/conformance/importTag13(checkorder=typesfirst).errors.txt @@ -0,0 +1,19 @@ +/foo.js(1,15): error TS1005: 'from' expected. +/foo.js(1,15): error TS1141: String literal expected. +/foo.js(1,25): error TS2307: Cannot find module 'types' or its corresponding type declarations. + + +==== /foo.js (3 errors) ==== + /** @import x = require("types") */ + ~ +!!! error TS1005: 'from' expected. + ~~~~~~~~~~~~~~~~~~ +!!! error TS1141: String literal expected. + ~~~~~~~ +!!! error TS2307: Cannot find module 'types' or its corresponding type declarations. + +==== /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..d4d3aede55faf --- /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 TS18018 privateNameNestedClassFieldShadowing.ts:2:5: The declaration of '#x' that you probably intended to use is defined here +!!! related TS18017 privateNameNestedClassFieldShadowing.ts:5:13: The shadowing declaration of '#x' 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/tests/cases/compiler/baseConstraintDepthCheckOrder.ts b/tsc/testdata/tests/cases/compiler/baseConstraintDepthCheckOrder.ts new file mode 100644 index 0000000000000..967a50184dd64 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/baseConstraintDepthCheckOrder.ts @@ -0,0 +1,13 @@ +// @strict: true +// @noEmit: true +// @checkOrder: default, typesfirst + +// The base constraint of 'T0' is 60 type parameters deep and gives up after +// 50, while that of 'T20' is found 40 deep. Neither may depend on which was +// computed first: computing 'T0' first must not leave 'T20' without its +// constraint, and computing 'T20' first must not let 'T0' reuse it. + +function f(x: T0, y: T20) { + x.length; + y.length; +} diff --git a/tsc/testdata/tests/cases/compiler/bigintArbirtraryIdentifier.ts b/tsc/testdata/tests/cases/compiler/bigintArbirtraryIdentifier.ts index 9b281534212e8..63dfdce226f74 100644 --- a/tsc/testdata/tests/cases/compiler/bigintArbirtraryIdentifier.ts +++ b/tsc/testdata/tests/cases/compiler/bigintArbirtraryIdentifier.ts @@ -1,3 +1,4 @@ +// @checkOrder: default, typesfirst // @target: esnext // @module: esnext diff --git a/tsc/testdata/tests/cases/compiler/boundedRecursiveTypeInferredThroughClosure.ts b/tsc/testdata/tests/cases/compiler/boundedRecursiveTypeInferredThroughClosure.ts new file mode 100644 index 0000000000000..a2bf3a650cc06 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/boundedRecursiveTypeInferredThroughClosure.ts @@ -0,0 +1,83 @@ +// @strict: true +// @noEmit: true +// @target: esnext + +// The recursion of InferData and UnpackKeyValue is bounded by Next, so +// inferring it through a closure must not report it as infinite. + +type Prettify = { [K in keyof T]: T[K] } & {}; +type ExtractUndefined = { [K in keyof T]: undefined extends T[K] ? K : never }[keyof T]; +type ExtractDefined = { [K in keyof T]: undefined extends T[K] ? never : K }[keyof T]; +type Next = [1, 2, 3, 4, 5, 6]; +type JSONPrimitives = string | number | bigint | boolean | null | undefined; +type JSONValues = JSONPrimitives | CanBeSerialized; +type CanBeSerialized = { + toJSON(): T; +}; +type JSONDataTypes = JSONValues | JSONDataTypes[] | { + [key: string]: JSONDataTypes; +}; +type SerializeJSONObject = { + [K in ExtractDefined]: SerializeJSONTypes; +} & { + [K in ExtractUndefined]?: SerializeJSONTypes; +}; +interface ExtendedJSONTypes { +} +type NonAllowedJSTypes = Map | Set; +type ForcefullyAllowedTypes = { + [K in keyof ExtendedJSONTypes]: ExtendedJSONTypes[K]; +}[keyof ExtendedJSONTypes]; +type SerializeJSONOwnTypes = T extends JSONPrimitives ? T : T extends ForcefullyAllowedTypes ? T : T extends NonAllowedJSTypes ? never : T extends Array ? Array> : T extends object ? Prettify> : never; +type SerializeJSONTypes = T extends ForcefullyAllowedTypes ? T : T extends CanBeSerialized ? SerializeJSONOwnTypes : SerializeJSONOwnTypes; +interface ItemContract, MaxDepth extends Next[number], Variant extends string> { + $type: 'item'; + transformer: { + new (...args: any[]): Transformer; + }; + maxDepth: MaxDepth; + variant: Variant; +} +type UnpackKeyValue = [Value[0]] extends [never] ? SerializeJSONTypes : Value[0] extends ItemContract ? InferData | SerializeJSONTypes : SerializeJSONTypes; +type LimitDepth = [ + Value +] extends [never] ? Key : Value extends ItemContract ? MaxDepth extends Depth ? never : Key : Key; +type UnpackOptionalValues = { + [O in { + [K in keyof Data]: [undefined] extends [Data[K]] ? LimitDepth[0], MaxDepth, Depth> : never; + }[keyof Data]]?: UnpackKeyValue, MaxDepth, Depth>; +}; +type UnpackRequiredValues = { + [O in { + [K in keyof Data]: [undefined] extends [Data[K]] ? never : LimitDepth[0], MaxDepth, Depth>; + }[keyof Data]]: UnpackKeyValue, MaxDepth, Depth>; +}; +type SplitItm = [ + Extract>, + Exclude> +]; +type UnpackAsTopLevelItem = T extends ItemContract ? InferData : never; +type UnpackValues = Prettify & UnpackOptionalValues>; +type InferData = Transformer extends { + [K in Variant]: (...args: any[]) => unknown; +} ? UnpackValues>, MaxDepth, Depth> : never; +declare class Item, MaxDepth extends Next[number], Variant extends string> { + transformer: { new (...args: any[]): Transformer }; + maxDepth: MaxDepth; + variant: Variant; + $type: 'item'; + resolve(): Promise>; +} +type Ctor = { new (resource: any, ...rest: any[]): any }; +declare abstract class BaseTransformer { + static transform(this: Self, data: ConstructorParameters[0]): Item, 1, 'toObject'>; + constructor(resource: T); +} +class Size { +} +class SizeTransformer extends BaseTransformer { + toObject() { + } +} +declare function once(value: T): T; +once(() => SizeTransformer.transform(new Size())); diff --git a/tsc/testdata/tests/cases/compiler/checkIndexConstraintOfJavascriptClassExpression.ts b/tsc/testdata/tests/cases/compiler/checkIndexConstraintOfJavascriptClassExpression.ts index 9455c0156930f..bb7452f273d4f 100644 --- a/tsc/testdata/tests/cases/compiler/checkIndexConstraintOfJavascriptClassExpression.ts +++ b/tsc/testdata/tests/cases/compiler/checkIndexConstraintOfJavascriptClassExpression.ts @@ -1,3 +1,4 @@ +// @checkOrder: default, typesfirst // @target: es2015 // @Filename: weird.js // @allowJs: true diff --git a/tsc/testdata/tests/cases/compiler/checkOrderAwaitedCycle.ts b/tsc/testdata/tests/cases/compiler/checkOrderAwaitedCycle.ts new file mode 100644 index 0000000000000..f39f63e9c1f54 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/checkOrderAwaitedCycle.ts @@ -0,0 +1,21 @@ +// @strict: true +// @target: esnext +// @lib: esnext +// @noEmit: true +// @checkOrder: default, reverse, isolated, typesfirst + +// Awaiting a promise whose promised type refers back to it reports a +// circularity wherever it is awaited, whichever is awaited first. + +// @filename: a.ts +type S = string | Promise; +declare const s: S; +declare const p: Promise; +async function f1() { + const a: number = await p; +} + +// @filename: b.ts +async function f2() { + const b: number = await s; +} diff --git a/tsc/testdata/tests/cases/compiler/checkOrderCircularConstraint.ts b/tsc/testdata/tests/cases/compiler/checkOrderCircularConstraint.ts new file mode 100644 index 0000000000000..efca8e2390569 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/checkOrderCircularConstraint.ts @@ -0,0 +1,14 @@ +// @checkOrder: default, reverse, isolated, typesfirst + +// A circular constraint of a declared type parameter is reported at its +// declaration, regardless of which use resolves the constraint first. + +class A { + foo() { + var x!: T; + var a = x.foo(); + var b = new x(123); + var c = x[1]; + var d = x(); + } +} diff --git a/tsc/testdata/tests/cases/compiler/checkOrderCircularDefaults.ts b/tsc/testdata/tests/cases/compiler/checkOrderCircularDefaults.ts new file mode 100644 index 0000000000000..0232579d1f4f7 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/checkOrderCircularDefaults.ts @@ -0,0 +1,16 @@ +// @strict: true +// @declaration: true +// @checkOrder: default, reverse, isolated, typesfirst + +// Which type parameter of a cycle of defaults is circular must not depend +// on which default is resolved first. + +// @filename: a.ts +import type { B } from "./b"; +export interface A { a: T } +export declare const a: A; + +// @filename: b.ts +import type { A } from "./a"; +export interface B { b: U } +export declare const b: B; diff --git a/tsc/testdata/tests/cases/compiler/checkOrderEmitBeforeCheck.ts b/tsc/testdata/tests/cases/compiler/checkOrderEmitBeforeCheck.ts new file mode 100644 index 0000000000000..fd86103b859d3 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/checkOrderEmitBeforeCheck.ts @@ -0,0 +1,19 @@ +// @target: es2015 +// @declaration: true +// @checkOrder: default, isolated + +// The circularity in the mapped type is found by checking the annotation of +// "each". Emitting first must not instead report it at the use import +// elision visits, nor cache the result without the error. +type NonOptionalKeys = { [P in keyof T]: undefined extends T[P] ? never : P }[keyof T]; +type Child = { [P in NonOptionalKeys]: T[P] } + +export interface ListWidget { + "type": "list", + "each": Child; +} + +type ListChild = Child + +declare let x: ListChild; +x.type; diff --git a/tsc/testdata/tests/cases/compiler/checkOrderEnumComputedMember.ts b/tsc/testdata/tests/cases/compiler/checkOrderEnumComputedMember.ts new file mode 100644 index 0000000000000..caaa6629db492 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/checkOrderEnumComputedMember.ts @@ -0,0 +1,12 @@ +// @checkOrder: default, reverse, isolated, typesfirst +// @target: esnext +// @strict: true +// @declaration: true + +enum E { + A = 0, + B = E.A.valueOf(), + C = 1, +} + +const member: Extract = E.C; diff --git a/tsc/testdata/tests/cases/compiler/checkOrderLateBoundMembers.ts b/tsc/testdata/tests/cases/compiler/checkOrderLateBoundMembers.ts new file mode 100644 index 0000000000000..a0e4fa51e4348 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/checkOrderLateBoundMembers.ts @@ -0,0 +1,13 @@ +// @strict: true +// @noEmit: true +// @checkOrder: default, reverse, isolated, typesfirst + +// Resolving the name in a computed property name looks it up in the members +// of the enclosing interface. That must not late-bind those same members, +// or the accessors would not merge with the property when asked first. +const foo = "foo" +interface I { + get [foo](): number; + foo: number; + set [foo](value: number); +} diff --git a/tsc/testdata/tests/cases/compiler/checkOrderModuleExportsAlias.ts b/tsc/testdata/tests/cases/compiler/checkOrderModuleExportsAlias.ts new file mode 100644 index 0000000000000..08d9142ed1bff --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/checkOrderModuleExportsAlias.ts @@ -0,0 +1,8 @@ +// @checkOrder: default, reverse, isolated, typesfirst +// @allowJs: true +// @checkJs: true +// @declaration: true +// @outDir: ./out +// @filename: index.js +module.exports.i = function i() {} +module.exports.ii = module.exports.i; diff --git a/tsc/testdata/tests/cases/compiler/checkOrderParameterInTypeQuery.ts b/tsc/testdata/tests/cases/compiler/checkOrderParameterInTypeQuery.ts new file mode 100644 index 0000000000000..627a5ec7db84d --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/checkOrderParameterInTypeQuery.ts @@ -0,0 +1,19 @@ +// @strict: true +// @target: esnext +// @checkOrder: default, reverse, isolated, typesfirst + +// Whether a parameter named in a reused return type annotation is the same +// symbol in the printed signature must not depend on whether the type of +// the parameter was resolved before the signature was instantiated. + +export class C2 { + #a = 1; + test1() { + class C { + test1(a: C2): typeof a.#a { + return 1; + } + } + return new C().test1(this); + } +} diff --git a/tsc/testdata/tests/cases/compiler/checkOrderRecursiveIndexedAccess.ts b/tsc/testdata/tests/cases/compiler/checkOrderRecursiveIndexedAccess.ts new file mode 100644 index 0000000000000..68f93ef70343d --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/checkOrderRecursiveIndexedAccess.ts @@ -0,0 +1,21 @@ +// @noEmit: true +// @strict: true +// @checkOrder: default, reverse, isolated, typesfirst + +// @filename: recur.ts +export type Recur = + (T extends (unknown[]) ? {} : { [K in keyof T]?: Recur}) | + [...Recur[number][]]; + +// @filename: join.ts +import { Recur } from "./recur"; +export function join(l: Recur[]): Recur { + return ['marker', ...l]; +} + +// @filename: a.ts +import { Recur } from "./recur"; +import { join } from "./join"; +function a(l: Recur[]): void { + const x: Recur | undefined = join(l); +} diff --git a/tsc/testdata/tests/cases/compiler/checkOrderSpreadCycle.ts b/tsc/testdata/tests/cases/compiler/checkOrderSpreadCycle.ts new file mode 100644 index 0000000000000..b9c220019d68b --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/checkOrderSpreadCycle.ts @@ -0,0 +1,31 @@ +// @checkOrder: default, reverse, isolated, typesfirst +// @strict: true +// @module: commonjs +// @target: es2020 +// @allowJs: true +// @declaration: true +// @outDir: /out +// @noImplicitReferences: true + +// @Filename: /ma.js +export { v as pa } from "./xa"; +export const ma = 1; + +// @Filename: /mb.js +export { v as pb } from "./xb"; +export const mb = 1; + +// @Filename: /xa.js +/** @type {typeof import("./mb")} */ +const M = /** @type {any} */ (null); +module.exports = { v: { ...M } }; + +// @Filename: /xb.js +/** @type {typeof import("./ma")} */ +const M = /** @type {any} */ (null); +module.exports = { v: { ...M } }; + +// @Filename: /ia.js +/** @type {typeof import("./ma")} */ +const M = /** @type {any} */ (null); +module.exports = { v: { ...M } }; diff --git a/tsc/testdata/tests/cases/compiler/checkOrderStableInstantiationErrors.ts b/tsc/testdata/tests/cases/compiler/checkOrderStableInstantiationErrors.ts new file mode 100644 index 0000000000000..1cdffd661c908 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/checkOrderStableInstantiationErrors.ts @@ -0,0 +1,30 @@ +// @checkOrder: default, reverse, typesfirst +// @filename: lib.ts +export type Dec = + N extends 5 ? 4 : N extends 4 ? 3 : N extends 3 ? 2 : + N extends 2 ? any : + N extends 1 ? 0 : 0; +export type Recur = + N extends 0 ? S : Recur, `${S}_${S}`>; + +// @filename: a.ts +import { Recur } from "./lib"; +export let a: Recur<5, "a">; + +// @filename: b.ts +import { Recur } from "./lib"; +export let b: Recur<5, "a">; + +// @filename: c.ts +class T { + declare a: A; + declare b: any; +} +class L extends T {} +export class X extends L { + declare a: 'a' | 'b'; + declare b: number; + m() { + this.a; + } +} diff --git a/tsc/testdata/tests/cases/compiler/circularAccessorAnnotations.ts b/tsc/testdata/tests/cases/compiler/circularAccessorAnnotations.ts index 01a0d10ffe3d7..76a644bb35537 100644 --- a/tsc/testdata/tests/cases/compiler/circularAccessorAnnotations.ts +++ b/tsc/testdata/tests/cases/compiler/circularAccessorAnnotations.ts @@ -1,3 +1,4 @@ +// @checkOrder: default, typesfirst // @target: es2015 // @strict: true // @declaration: true diff --git a/tsc/testdata/tests/cases/compiler/circularIndexedPropertyInstantiation.ts b/tsc/testdata/tests/cases/compiler/circularIndexedPropertyInstantiation.ts new file mode 100644 index 0000000000000..3aa2e3f2b6f02 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/circularIndexedPropertyInstantiation.ts @@ -0,0 +1,6 @@ +// @target: es2015 +// Repro from #14837 + +type Foo = { "true": Foo> }[T]; +let f1: Foo<"true", {}>; +let f2: Foo<"false", {}>; \ No newline at end of file diff --git a/tsc/testdata/tests/cases/compiler/circularInitializerInference.ts b/tsc/testdata/tests/cases/compiler/circularInitializerInference.ts new file mode 100644 index 0000000000000..727b206a54e83 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/circularInitializerInference.ts @@ -0,0 +1,31 @@ +// @target: es2015 +// @strict: true, false + +export {}; + +type IsAny = 0 extends (1 & Type) ? true : false; +type Assert = Condition; + +var comma = (comma, 3); +type CommaInference = Assert>; + +var nestedComma = (comma, nestedComma, comma); +type NestedCommaInference = Assert>; + +var assignment = (assignment = 2); +type AssignmentInference = Assert>; + +var nestedAssignment = (nestedAssignment = nestedAssignment = 2); +type NestedAssignmentInference = Assert>; + +var conditional = conditional ? 0 : 1; +type ConditionalInference = Assert>; + +var logicalAnd = logicalAnd && ""; +type LogicalAndInference = Assert>; + +var propertyAccess = { member: propertyAccess.member }; +type PropertyAccessInference = Assert>; + +const nonCircular: number = 3; +type NonCircularInference = Assert extends false ? true : false>; \ No newline at end of file diff --git a/tsc/testdata/tests/cases/compiler/circularInlineMappedGenericTupleTypeNoCrash.ts b/tsc/testdata/tests/cases/compiler/circularInlineMappedGenericTupleTypeNoCrash.ts index 2bc4f70704151..251464912be0f 100644 --- a/tsc/testdata/tests/cases/compiler/circularInlineMappedGenericTupleTypeNoCrash.ts +++ b/tsc/testdata/tests/cases/compiler/circularInlineMappedGenericTupleTypeNoCrash.ts @@ -1,3 +1,4 @@ +// @checkOrder: default, typesfirst // @target: es2015 // @strict: true // @noEmit: true diff --git a/tsc/testdata/tests/cases/compiler/circularReturnTypeSubtypeReductionOrder.ts b/tsc/testdata/tests/cases/compiler/circularReturnTypeSubtypeReductionOrder.ts new file mode 100644 index 0000000000000..76e977a6505b1 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/circularReturnTypeSubtypeReductionOrder.ts @@ -0,0 +1,42 @@ +// @strict: true +// @target: esnext +// @noEmit: true + +// @filename: expression.ts +// Subtype reduction of rebuild's return type relates the class to A, +// which needs b's return type, which needs rebuild's: a cycle. Both +// members report it, whichever return type is requested first, as if +// rebuild's, declared first, were requested first. +interface A { + b(): A; + c: A; +} +declare const flag: boolean; +const A: new () => A = class { + rebuild() { + return flag ? this : new A(); + } + b() { + return this.rebuild(); + } + c() { + return this.rebuild; + } +}; +export {}; + +// @filename: declaration.ts +interface B { + b(): B; +} +declare const flag: boolean; +class K { + rebuild() { + return flag ? this : new B(); + } + b() { + return this.rebuild(); + } +} +const B: new () => B = K; +export {}; diff --git a/tsc/testdata/tests/cases/compiler/circularReturnTypeThroughCallArgumentRelation.ts b/tsc/testdata/tests/cases/compiler/circularReturnTypeThroughCallArgumentRelation.ts new file mode 100644 index 0000000000000..14bc012218d93 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/circularReturnTypeThroughCallArgumentRelation.ts @@ -0,0 +1,44 @@ +// @strict: true +// @noEmit: true +// @checkOrder: default,typesfirst + +// Inferring a method's return type resolves a call whose argument check +// relates the method's own class to an interface containing that method, so +// the relation compares the method while its return type is in progress. +// TypeScript reads the in-progress return type as `any` there without failing +// it, and call resolution hides the resolutions below it, so no TS7023 is +// reported in any check order and the method gets the call's return type. +// (Reduced from meta/lexical HeadingNode.$config and effect SchemaAST getParser.) + +// Through a callback returning an instance (lexical). +interface Base { m(): unknown } +declare function config(config: { f?: () => Base }): void; + +declare const h: Heading; +const b: Base = h; + +class Heading { + m() { + return config({ f: () => create() }); + } +} + +declare function create(): Heading; + +const r: void = new Heading().m(); + +// Passing `this` directly (effect). +type Parser = (input: unknown) => unknown; +interface NullNode { readonly _tag: "Null"; getParser(): Parser } +interface UndefinedNode { readonly _tag: "Undefined"; getParser(): Parser } +type AST = NullNode | UndefinedNode; +declare function fromConst(ast: AST, value: unknown): Parser; + +const NullNode: new () => NullNode = class { + readonly _tag = "Null"; + getParser() { + return fromConst(this, null); + } +}; + +const p: Parser = new NullNode().getParser(); diff --git a/tsc/testdata/tests/cases/compiler/circularReturnTypeThroughCallbackArgument.ts b/tsc/testdata/tests/cases/compiler/circularReturnTypeThroughCallbackArgument.ts new file mode 100644 index 0000000000000..209bc9616d71d --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/circularReturnTypeThroughCallbackArgument.ts @@ -0,0 +1,27 @@ +// @strict: true,false +// @noEmit: true + +declare function fan(g: () => number): number; + +export function a(n: number) { + return fan(() => a(n)); +} + +declare function fanAll(g: () => Promise<{ ok: boolean }>): Promise<{ ok: boolean }>; + +export async function b(n: number) { + if (n > 0) { + return fanAll(() => b(n - 1)); + } + return { ok: true }; +} + +type Result = { success: boolean; [key: string]: unknown }; +interface Other { success: boolean; url: string } +declare function fanOut(generateOne: () => Promise): Promise; +declare const other: Other; + +export async function c(n: number) { + if (n) return other; + return fanOut(() => c(n - 1)); +} diff --git a/tsc/testdata/tests/cases/compiler/circularReturnTypeThroughUncontextualCallbackArgument.ts b/tsc/testdata/tests/cases/compiler/circularReturnTypeThroughUncontextualCallbackArgument.ts new file mode 100644 index 0000000000000..cd367b30e1c03 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/circularReturnTypeThroughUncontextualCallbackArgument.ts @@ -0,0 +1,22 @@ +// @strict: true +// @noEmit: true +// @checkOrder: default,typesfirst + +// `getCreds`'s return type depends on resolving `materialize({ next })`, whose +// argument check needs the return type of the (non-contextually typed) arrow +// `next`, which calls `getCreds` again. TypeScript never reports this cycle in +// any order: call resolution hides the resolutions below it, and the relation +// reads an in-progress return type as `any` without failing it. So no TS7023, +// and `getCreds` returns `number`. (Reduced from OmniRoute auth.ts +// getProviderCredentials/selectNextLeaseCandidate.) + +const x = getCreds(); + +declare function materialize(extra: { next?: (id: string) => unknown }): number; + +function getCreds() { + const next = (id: string) => getCreds(); + return materialize({ next }); +} + +const n: number = getCreds(); diff --git a/tsc/testdata/tests/cases/compiler/circularScopeThunkReverseMapped.ts b/tsc/testdata/tests/cases/compiler/circularScopeThunkReverseMapped.ts new file mode 100644 index 0000000000000..273d8a44b93d3 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/circularScopeThunkReverseMapped.ts @@ -0,0 +1,26 @@ +// @strict: true +// @target: esnext +// @noEmit: true +// @checkOrder: default, typesfirst + +type Resolve = T extends () => infer R ? R : T; +type Validate = { [K in keyof def]: def[K] extends () => infer R ? () => R : def[K] }; +interface Scope { + type(k: k): Resolve; +} +interface Type { + pipe(f: (x: T) => U): Type; +} +declare function scope(def: Validate): Scope; +declare function type(x: T): Type; + +export const $ = scope({ + a: type("string").pipe(function (s) { return s.length; }), + b: () => $.type("a").pipe(function (n) { return n === 0; }), +}); + +// Entered from the function in the first property when queried in reverse +export const $2 = scope({ + a: type("string").pipe(function (s) { return s.length; }), + b: () => $2.type("a").pipe((n: number) => n === 0), +}); diff --git a/tsc/testdata/tests/cases/compiler/classCircularityDiagnostics.ts b/tsc/testdata/tests/cases/compiler/classCircularityDiagnostics.ts new file mode 100644 index 0000000000000..34977b5df2a3d --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/classCircularityDiagnostics.ts @@ -0,0 +1,48 @@ +// @target: esnext +// @noImplicitAny: true, false + +class Direct extends Direct { + static value = 1; + value = 2; +} + +const staticValue = Direct.value; +const instanceValue = new Direct().value; + +class First extends Second {} +class Second extends First {} + +const Expression = class Named extends Named {}; + +class NestedBase extends (class { + static value = 1; + value = 2; +}) {} + +const nestedStaticValue: number = NestedBase.value; +const nestedInstanceValue: number = new NestedBase().value; + +const SelfReferencingBase = class extends (class { + static self = SelfReferencingBase; +}) {}; + +const selfConstructor = SelfReferencingBase.self; + +function mixin {}>(base: Base) { + return class extends base { + static value = 1; + value = 2; + }; +} + +class Mixed extends mixin(NestedBase) {} + +const mixedStaticValue: number = Mixed.value; +const mixedInstanceValue: number = new Mixed().value; + +declare function makeBase(value: number): typeof NestedBase; +class InvalidBaseArgument extends makeBase("invalid") {} +const InvalidExpressionArgument = class extends makeBase("invalid") {}; + +declare function makeInvalidBase(value: number): number; +class InvalidConstructor extends makeInvalidBase("invalid") {} \ No newline at end of file diff --git a/tsc/testdata/tests/cases/compiler/clonedTypeParameterUnionOrder.ts b/tsc/testdata/tests/cases/compiler/clonedTypeParameterUnionOrder.ts new file mode 100644 index 0000000000000..3bfa464b30bde --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/clonedTypeParameterUnionOrder.ts @@ -0,0 +1,15 @@ +// @strict: true +// @noEmit: true +// @checkOrder: default, reverse, typesfirst + +// @filename: a.ts +interface Pair { a: A; b: B } +interface Box { m(x: T): Pair } +declare function call(f: (x: A) => R): (x: A) => R; +declare const bs: Box; +declare const bn: Box; +const n = call(bn.m); + +// @filename: b.ts +declare const c: boolean; +const r = c ? call(bs.m) : call(bn.m); diff --git a/tsc/testdata/tests/cases/compiler/constAssertionBindingPatternQueryOrder.ts b/tsc/testdata/tests/cases/compiler/constAssertionBindingPatternQueryOrder.ts new file mode 100644 index 0000000000000..42517d7d60024 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/constAssertionBindingPatternQueryOrder.ts @@ -0,0 +1,11 @@ +// @strict: true +// @target: esnext +// @lib: esnext +// @noEmit: true +// @checkOrder: default, typesfirst + +declare function settle(fn: () => T): Promise<{ [K in keyof T]: [Awaited] }>; + +async function f() { + const [[a], b] = await settle(() => [Promise.resolve(0), Promise.reject(1)] as const); +} diff --git a/tsc/testdata/tests/cases/compiler/contextualCheckReentryFromOuterTypeParameters.ts b/tsc/testdata/tests/cases/compiler/contextualCheckReentryFromOuterTypeParameters.ts new file mode 100644 index 0000000000000..4d185d6668c8a --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/contextualCheckReentryFromOuterTypeParameters.ts @@ -0,0 +1,17 @@ +// @strict: true +// @noEmit: true + +interface Argv { + command(builder: (args: Argv) => Argv, handler: (args: Arguments) => void): Argv; + option(key: K, options: O): Argv<{ [key in K]: O } & Check>; +} +type Arguments = { [key in keyof T]: T[key] } & { [key: string]: unknown }; +type Check = O extends {} ? {} : {}; +declare const yargs: Argv; + +yargs.command( + (yargs) => yargs.option("a", { type: "string" }), + (argv) => { + const a: { type: string } = argv.a; + }, +); diff --git a/tsc/testdata/tests/cases/compiler/contextualOuterTypeParameters.ts b/tsc/testdata/tests/cases/compiler/contextualOuterTypeParameters.ts index a6ff9ae0a6e48..3ca7c15a2d58c 100644 --- a/tsc/testdata/tests/cases/compiler/contextualOuterTypeParameters.ts +++ b/tsc/testdata/tests/cases/compiler/contextualOuterTypeParameters.ts @@ -1,3 +1,4 @@ +// @checkOrder: default, typesfirst // @target: es2015 // @strict: true // @noemit: true @@ -27,3 +28,8 @@ const obj: { f: (x: T) => void } = { type IsObject = { x: typeof t } extends { x: string } ? true : false; } }; + +f(function self(t) { + const s = self; + type P = Parameters; +}); diff --git a/tsc/testdata/tests/cases/compiler/contextualParameterDefaultReferenceCheckOrder.ts b/tsc/testdata/tests/cases/compiler/contextualParameterDefaultReferenceCheckOrder.ts new file mode 100644 index 0000000000000..9fd41e7b8b38e --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/contextualParameterDefaultReferenceCheckOrder.ts @@ -0,0 +1,7 @@ +// @checkOrder: default, typesfirst + +// x is contextually typed as 1, but its initializer widens it to number. The +// reference to x must have the same type whether it is queried before or +// after the function is checked. + +const f: (g: () => number, x: 1) => void = (g = () => x, x = 0) => {}; diff --git a/tsc/testdata/tests/cases/compiler/contextualParameterInCircularVariableInitializer.ts b/tsc/testdata/tests/cases/compiler/contextualParameterInCircularVariableInitializer.ts new file mode 100644 index 0000000000000..778d3f13cf9b3 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/contextualParameterInCircularVariableInitializer.ts @@ -0,0 +1,20 @@ +// @strict: true +// @noEmit: true +// @checkOrder: default,typesfirst + +// The initializer of `store` refers to `store` from a callback, so resolving +// the type of `store` re-enters itself. `y` must still get its contextual +// type `string` from `Store` (zustand `create()(...)` pattern), with no +// TS7006, as in main and TS 6.0. + +declare function create(init: () => T): T; + +interface Store { + a: (x: boolean) => void; + b: (y: string) => void; +} + +const store = create(() => ({ + a: (x) => store.b(""), + b: (y) => {}, +})); diff --git a/tsc/testdata/tests/cases/compiler/contextualParameterInReturnTypeCycleOfGenericCall.ts b/tsc/testdata/tests/cases/compiler/contextualParameterInReturnTypeCycleOfGenericCall.ts new file mode 100644 index 0000000000000..aeec88e3ef5b1 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/contextualParameterInReturnTypeCycleOfGenericCall.ts @@ -0,0 +1,17 @@ +// @strict: true +// @noEmit: true +// @checkOrder: default,typesfirst + +// Inferring `T` for `g` needs the return type of the arrow, whose body is a +// call to `f` that is contextually typed by that same return type, a cycle. +// `state` must still get the contextual type `number` (S inferred from +// `initialState`), as in main and TS 6.0 (redux-toolkit `createSlice` inside +// vitest `expect(() => ...)` pattern). + +declare function f S>>(options: { + initialState: S; + reducers: CR; +}): CR; +declare function g(a: T): void; + +g(() => f({ reducers: { a: (state) => state + 1 }, initialState: 0 })); diff --git a/tsc/testdata/tests/cases/compiler/contextualReturnArrayPatternCallback.ts b/tsc/testdata/tests/cases/compiler/contextualReturnArrayPatternCallback.ts index 04519047a9dc7..62b911890c1ed 100644 --- a/tsc/testdata/tests/cases/compiler/contextualReturnArrayPatternCallback.ts +++ b/tsc/testdata/tests/cases/compiler/contextualReturnArrayPatternCallback.ts @@ -1,3 +1,4 @@ +// @checkOrder: default, typesfirst // @strict: true interface Matcher { diff --git a/tsc/testdata/tests/cases/compiler/cycleYieldThroughVarianceCheckOrder.ts b/tsc/testdata/tests/cases/compiler/cycleYieldThroughVarianceCheckOrder.ts new file mode 100644 index 0000000000000..7a15bdde8b6f7 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/cycleYieldThroughVarianceCheckOrder.ts @@ -0,0 +1,16 @@ +// @checkOrder: default, typesfirst + +// Resolving the base of E measures the variances of B, which needs the type +// of p, which needs the members of E. Whether p is circular must not depend +// on whether B is checked before the type of arg is queried. + +declare class B { + p: E["p"]; +} +declare class E extends mix(Base) { + p: number; +} +declare function mix object>(x: T): T; +declare class Base { + constructor(arg?: InstanceType); +} diff --git a/tsc/testdata/tests/cases/compiler/deferredTypeReferenceCycleRollback.ts b/tsc/testdata/tests/cases/compiler/deferredTypeReferenceCycleRollback.ts new file mode 100644 index 0000000000000..a33318012116f --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/deferredTypeReferenceCycleRollback.ts @@ -0,0 +1,20 @@ +// @strict: true +// @noEmit: true + +// A cycle rollback used to reset the type of the Array> +// node while the deferred reference identified by that node survived, +// which crashed a later instantiation of it. + +declare function declare(): void; + +interface PluginObj { + visitor: Visit; +} +type Visit = VisitFn | VisitObj; +type VisitFn = (path: NodePath

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

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

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

) => Result> : Result>; // Type for the callable part of an `Provider` if `T` is callable. +// This is intersected with methods/properties. +type MaybeCallableProvider = T extends ((...args: any[]) => any) ? MethodOrProperty : unknown; +type TupleIndexKeys> = Extract; +type MapCallbackValue = // `Omit` removes call signatures, so re-intersect callable provider behavior. +T extends unknown ? Omit, keyof Promise> & MaybeCallableProvider & MapValuePlaceholder : never; +type InvalidNativePromiseInMapResult = T extends unknown ? InvalidNativePromiseInMapResultImpl : never; +type InvalidNativePromiseInMapResultImpl = [T] extends [Seen] ? never // RpcPromise is modeled as Promise & StubBase, so allow promise-like stub values. +: T extends StubBase ? never // Native thenables cannot be represented in map recordings, even when typed as PromiseLike. +: T extends PromiseLike ? T : T extends Map ? InvalidNativePromiseInMapResult | InvalidNativePromiseInMapResult : T extends Set ? InvalidNativePromiseInMapResult : T extends readonly [] ? never : T extends readonly [infer Head, ...infer Tail] ? InvalidNativePromiseInMapResult | InvalidNativePromiseInMapResult : T extends ReadonlyArray ? InvalidNativePromiseInMapResult : T extends { + [key: string | number]: unknown; +} ? InvalidNativePromiseInMapResult], Seen | T> : never; +type MapCallbackReturn = InvalidNativePromiseInMapResult extends never ? T : never; +type ArrayProvider = { [K in number]: MethodOrProperty } & { + map(callback: (elem: MapCallbackValue) => MapCallbackReturn): Result>; +}; +type TupleProvider> = { [K in TupleIndexKeys]: MethodOrProperty } & ArrayProvider; // Base type for all other types providing RPC-like interfaces. +// Rewrites all methods/properties to be `MethodOrProperty`s, while preserving callable types. +// `__RPC_TARGET_BRAND` deliberately flows through the key mapping (as a `never` property) so +// stubs of branded targets stay assignable to workers-types' `Stubable`. Such stubs match our +// `Stubable` too — harmless, since all machinery checks `StubBase` before `Stubable`. +type Provider = MaybeCallableProvider & (T extends ReadonlyArray ? number extends T["length"] ? ArrayProvider : TupleProvider : { [K in Exclude>]: MethodOrProperty } & { + map(callback: (value: MapCallbackValue>) => MapCallbackReturn): Result>; +}); +export type RpcStub> = Stub; + +// @filename: main.ts +import type { RpcStub } from "./capnweb"; + +declare const api: RpcStub<{ sub(): Promise> }>; +export async function f() { + await api.sub(); + api.sub().then(s => s); +} diff --git a/tsc/testdata/tests/cases/compiler/varianceCycleDiscardedDiagnostics.ts b/tsc/testdata/tests/cases/compiler/varianceCycleDiscardedDiagnostics.ts new file mode 100644 index 0000000000000..9b61b16136fc2 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/varianceCycleDiscardedDiagnostics.ts @@ -0,0 +1,28 @@ +// @strict: true +// @target: es2022 +// @noEmit: true + +// Measuring the variances of Bar resolves the type of Value, which picks an +// overload by relating Foo to Foo while the variances of Bar are +// still being measured. Diagnostics from that attempt must not outlive it, +// and the result must not depend on whether Value or the variances of Bar +// are needed first. + +interface A { a: string } +interface B { foo: string } +declare function pick(x: Foo): A; +declare function pick(x: object): B; + +class Bar { + x!: T; + Value = pick(new Foo(this)).foo; +} + +class Foo { + bar!: Bar; + constructor(bar: Bar) { + this.bar = bar; + } +} + +const v: number = new Bar().Value; diff --git a/tsc/testdata/tests/cases/compiler/varianceCycleEnteredAfterCanonicalEntry.ts b/tsc/testdata/tests/cases/compiler/varianceCycleEnteredAfterCanonicalEntry.ts new file mode 100644 index 0000000000000..6ac9f01d74269 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/varianceCycleEnteredAfterCanonicalEntry.ts @@ -0,0 +1,32 @@ +// @strict: true +// @target: esnext +// @noEmit: true +// @checkOrder: default,typesfirst + +// Reduced from capnweb's RpcStub types (cloudflare-os). Measuring the variance +// of Stubify enters a circularity (Stubify -> Stub -> Provider -> +// MethodOrProperty -> Result -> RpcPromise -> Stubify) whose canonical entry is +// Stub, so the measurement from Stubify is discarded and the circularity +// measured again from Stub. The discarded measurement once ran to completion, +// which on the full types took long enough to exceed the instantiation limit. + +interface StubBase { + brand: T; +} +type Stub = T extends object ? Provider & StubBase : StubBase; +type Stubify = T extends StubBase ? T : T extends Function ? Stub : T; +type RpcPromise = Promise> & Provider & StubBase; +type Result = R extends StubBase ? Result : RpcPromise; +type MethodOrProperty = V extends (...args: infer P) => infer R ? (...args: P) => Result> : Result>; +type Provider = { [K in keyof T]: MethodOrProperty }; + +function f(x: Stubify, y: Stubify) { + y = x; + x = y; +} + +declare const api: Stub<{ sub(): Promise> }>; +export async function g() { + await api.sub(); + api.sub().then(s => s); +} diff --git a/tsc/testdata/tests/cases/compiler/varianceCycleEntryOrder.ts b/tsc/testdata/tests/cases/compiler/varianceCycleEntryOrder.ts new file mode 100644 index 0000000000000..e7d881c167dcf --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/varianceCycleEntryOrder.ts @@ -0,0 +1,32 @@ +// @strict: true +// @noEmit: true + +// Foo and Bar are both invariant: Foo through x and the contravariant +// use of Foo in Bar, and Bar through f and the invariant Foo>. +// Their variances should not depend on which is measured first. + +// @filename: fooFirst.ts +export {}; + +interface Foo { x: T; b: Bar> } +interface Bar { f: (u: U) => void; foo: Foo> } + +declare let fs: Foo, fl: Foo<"lit">; +declare let bs: Bar, bl: Bar<"lit">; +fl = fs; // Error +fs = fl; // Error +bl = bs; // Error +bs = bl; // Error + +// @filename: barFirst.ts +export {}; + +interface Foo { x: T; b: Bar> } +interface Bar { f: (u: U) => void; foo: Foo> } + +declare let fs: Foo, fl: Foo<"lit">; +declare let bs: Bar, bl: Bar<"lit">; +bl = bs; // Error +bs = bl; // Error +fl = fs; // Error +fs = fl; // Error diff --git a/tsc/testdata/tests/cases/compiler/varianceCycleRedoKeepsDiscardLog.ts b/tsc/testdata/tests/cases/compiler/varianceCycleRedoKeepsDiscardLog.ts new file mode 100644 index 0000000000000..201c3c562d110 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/varianceCycleRedoKeepsDiscardLog.ts @@ -0,0 +1,312 @@ +// @strict: true +// @module: node16 +// @noEmit: true + +// The types of DefinitelyTyped's json-logic-js (MIT license). Measuring the +// variances of the RulesLogic circularity again from its canonical entry +// re-enters measurements whose own circularities may still be discarded, so +// what is cached while it is re-entered must be logged, or a discarded +// measurement leaves results behind and `apply` rejects its argument. + +// @filename: json-logic-js.d.ts +export as namespace jsonFactory; + +// Disable auto-export +export {}; + +type RenameToIn = { + [K in keyof T as K extends `in${Uppercase}${Lowercase}` ? `in` : K]: T[K]; +}; + +/** + * This is a utility type used below for the "if" operation. + * Original: https://stackoverflow.com/a/68373774/765987 + */ +type MAXIMUM_ALLOWED_BOUNDARY = 80; +type Mapped< + Tuple extends unknown[], + Result extends unknown[] = [], + Count extends readonly number[] = [], +> = Count["length"] extends MAXIMUM_ALLOWED_BOUNDARY ? Result + : Tuple extends [] ? [] + : Result extends [] ? Mapped + : Mapped; +/** + * Used for the "if" operation, which takes an array of odd length + * and a minimum of three (3) elements. + */ +type AnyArrayOfOddLengthMin3 = [any, ...Mapped<[any, any]>]; + +export type ReservedOperations = + | "var" + | "missing" + | "missing_some" + | "if" + | "==" + | "===" + | "!=" + | "!==" + | "!" + | "!!" + | "or" + | "and" + | ">" + | ">=" + | "<" + | "<=" + | "max" + | "min" + | "+" + | "-" + | "*" + | "/" + | "%" + | "map" + | "filter" + | "reduce" + | "all" + | "none" + | "some" + | "merge" + | "in" + | "cat" + | "substr" + | "log"; + +/** + * This can be an object with any key except the reserved keys. + * TODO: Find a way to limit this type to exactly one (1) key, since + * json-logic-js enforces it. See: + * https://github.com/jwadhams/json-logic-js/blob/2.0.2/logic.js#L180 + */ +export type AdditionalOperation = Partial> & { [k: string]: any }; + +export interface AllReservedOperationsInterface { + var: RulesLogic | [RulesLogic] | [RulesLogic, any] | [RulesLogic, any]; + missing: RulesLogic | any[]; + missing_some: [RulesLogic, RulesLogic | any[]]; + if: AnyArrayOfOddLengthMin3; + "==": [any, any]; + "===": [any, any]; + "!=": [any, any]; + "!==": [any, any]; + "!": any; + "!!": any; + or: Array>; + and: Array>; + ">": [RulesLogic, RulesLogic]; + ">=": [RulesLogic, RulesLogic]; + "<": [RulesLogic, RulesLogic] | [RulesLogic, RulesLogic, RulesLogic]; + "<=": [RulesLogic, RulesLogic] | [RulesLogic, RulesLogic, RulesLogic]; + max: Array>; + min: Array>; + "+": Array> | RulesLogic; + "-": Array> | RulesLogic; + "*": Array> | RulesLogic; + "/": Array> | RulesLogic; + "%": [RulesLogic, RulesLogic]; + map: [RulesLogic, RulesLogic]; + filter: [RulesLogic, RulesLogic]; + reduce: [RulesLogic, RulesLogic, RulesLogic]; + all: [Array>, RulesLogic] | [RulesLogic, RulesLogic]; + none: [Array>, RulesLogic] | [RulesLogic, RulesLogic]; + some: [Array>, RulesLogic] | [RulesLogic, RulesLogic]; + merge: Array> | RulesLogic>; + inArray: [RulesLogic, Array>]; + inString: [RulesLogic, RulesLogic]; + cat: Array>; + substr: [RulesLogic, RulesLogic] | [RulesLogic, RulesLogic, RulesLogic]; + log: RulesLogic; +} + +export type JsonLogicVar = Pick< + AllReservedOperationsInterface, + "var" +>; +export type JsonLogicMissing = Pick< + AllReservedOperationsInterface, + "missing" +>; +export type JsonLogicMissingSome = Pick< + AllReservedOperationsInterface, + "missing_some" +>; +export type JsonLogicIf = Pick; +export type JsonLogicEqual = Pick; +export type JsonLogicStrictEqual = Pick; +export type JsonLogicNotEqual = Pick; +export type JsonLogicNegation = Pick; +export type JsonLogicDoubleNegation = Pick; +export type JsonLogicOr = Pick< + AllReservedOperationsInterface, + "or" +>; +export type JsonLogicAnd = Pick< + AllReservedOperationsInterface, + "and" +>; +export type JsonLogicGreaterThan = Pick< + AllReservedOperationsInterface, + ">" +>; +export type JsonLogicGreaterThanOrEqual = Pick< + AllReservedOperationsInterface, + ">=" +>; +export type JsonLogicLessThan = Pick< + AllReservedOperationsInterface, + "<" +>; +export type JsonLogicLessThanOrEqual = Pick< + AllReservedOperationsInterface, + "<=" +>; +export type JsonLogicMax = Pick< + AllReservedOperationsInterface, + "max" +>; +export type JsonLogicMin = Pick< + AllReservedOperationsInterface, + "min" +>; +export type JsonLogicSum = Pick< + AllReservedOperationsInterface, + "+" +>; +export type JsonLogicDifference = Pick< + AllReservedOperationsInterface, + "-" +>; +export type JsonLogicProduct = Pick< + AllReservedOperationsInterface, + "*" +>; +export type JsonLogicQuotient = Pick< + AllReservedOperationsInterface, + "/" +>; +export type JsonLogicRemainder = Pick< + AllReservedOperationsInterface, + "%" +>; +export type JsonLogicMap = Pick< + AllReservedOperationsInterface, + "map" +>; +export type JsonLogicFilter = Pick< + AllReservedOperationsInterface, + "filter" +>; +export type JsonLogicReduce = Pick< + AllReservedOperationsInterface, + "reduce" +>; +export type JsonLogicAll = Pick< + AllReservedOperationsInterface, + "all" +>; +export type JsonLogicNone = Pick< + AllReservedOperationsInterface, + "none" +>; +export type JsonLogicSome = Pick< + AllReservedOperationsInterface, + "some" +>; +export type JsonLogicMerge = Pick< + AllReservedOperationsInterface, + "merge" +>; +export type JsonLogicInArray = RenameToIn< + Pick, "inArray"> +>; +export type JsonLogicInString = RenameToIn< + Pick, "inString"> +>; +export type JsonLogicCat = Pick< + AllReservedOperationsInterface, + "cat" +>; +export type JsonLogicSubstr = Pick< + AllReservedOperationsInterface, + "substr" +>; +export type JsonLogicLog = Pick< + AllReservedOperationsInterface, + "log" +>; + +export type RulesLogic = + | boolean + | string + | number + | null + // Accessing Data - https://jsonlogic.com/operations.html#accessing-data + | JsonLogicVar + | JsonLogicMissing + | JsonLogicMissingSome + // Logic and Boolean Operations - https://jsonlogic.com/operations.html#logic-and-boolean-operations + | JsonLogicIf + | JsonLogicEqual + | JsonLogicStrictEqual + | JsonLogicNotEqual + | JsonLogicStrictNotEqual + | JsonLogicNegation + | JsonLogicDoubleNegation + | JsonLogicOr + | JsonLogicAnd + // Numeric Operations - https://jsonlogic.com/operations.html#numeric-operations + | JsonLogicGreaterThan + | JsonLogicGreaterThanOrEqual + | JsonLogicLessThan + | JsonLogicLessThanOrEqual + | JsonLogicMax + | JsonLogicMin + | JsonLogicSum + | JsonLogicDifference + | JsonLogicProduct + | JsonLogicQuotient + | JsonLogicRemainder + // Array Operations - https://jsonlogic.com/operations.html#array-operations + | JsonLogicMap + | JsonLogicFilter + | JsonLogicReduce + | JsonLogicAll + | JsonLogicNone + | JsonLogicSome + | JsonLogicMerge + | JsonLogicInArray + // String Operations - https://jsonlogic.com/operations.html#string-operations + | JsonLogicInString + | JsonLogicCat + | JsonLogicSubstr + // Miscellaneous - https://jsonlogic.com/operations.html#miscellaneous + | JsonLogicLog + // Adding Operations (https://jsonlogic.com/add_operation.html) + | AddOps; + +export function add_operation(name: string, code: (...args: any[]) => any): void; +export function apply(logic: RulesLogic, data?: unknown): any; +export function rm_operation(name: string): void; + +// These functions are undocumented, but are exported by the real package +// so they're typed here for completeness. +export function is_logic(logic: any): logic is RulesLogic; +export function truthy(value: any): boolean; +export function get_operator(logic: Record): string; +export function get_values(logic: Record): any; +export function uses_data(logic: Record): any[]; +export function rule_like(rule: any, pattern: any): boolean; + +// @filename: main.ts +import * as jsonLogic from "./json-logic-js"; + +type StartsWithAndEndsWith = + | { startsWith: [JsonLogicWithAdditionalOperations, JsonLogicWithAdditionalOperations] } + | { endsWith: [JsonLogicWithAdditionalOperations, JsonLogicWithAdditionalOperations] }; +type JsonLogicWithAdditionalOperations = jsonLogic.RulesLogic; +const jsonExtendedLogic: JsonLogicWithAdditionalOperations = { + and: [{ startsWith: ["Springfield", "Spring"] }, { endsWith: ["Springfield", "field"] }], +}; +jsonLogic.apply(jsonExtendedLogic); diff --git a/tsc/testdata/tests/cases/compiler/varianceCycleStructuralFallback.ts b/tsc/testdata/tests/cases/compiler/varianceCycleStructuralFallback.ts new file mode 100644 index 0000000000000..e3d0f7deff7f5 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/varianceCycleStructuralFallback.ts @@ -0,0 +1,33 @@ +// @strict: true +// @noEmit: true + +// The -? mapped type makes the variance of MA unmeasurable, so comparisons +// of instantiations of MA made while measuring the variances of MA and MB +// fall back to structural comparisons. The variances should not depend on +// which type is measured first. + +// @filename: maFirst.ts +export {}; + +type MA = { x: { [K in keyof T]-?: T[K] }; b: MB> }; +type MB = { f: (u: U) => void; a: MA> }; + +declare let as: MA<{ p: string }>, al: MA<{ p: "lit" }>; +declare let bs: MB<{ p: string }>, bl: MB<{ p: "lit" }>; +al = as; +as = al; +bl = bs; +bs = bl; + +// @filename: mbFirst.ts +export {}; + +type MA = { x: { [K in keyof T]-?: T[K] }; b: MB> }; +type MB = { f: (u: U) => void; a: MA> }; + +declare let as: MA<{ p: string }>, al: MA<{ p: "lit" }>; +declare let bs: MB<{ p: string }>, bl: MB<{ p: "lit" }>; +bl = bs; +bs = bl; +al = as; +as = al; diff --git a/tsc/testdata/tests/cases/compiler/varianceDeclarationOrder.ts b/tsc/testdata/tests/cases/compiler/varianceDeclarationOrder.ts new file mode 100644 index 0000000000000..077b736ce3fb4 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/varianceDeclarationOrder.ts @@ -0,0 +1,30 @@ +// @strict: true +// @noEmit: true + +// https://github.com/microsoft/TypeScript/issues/64891 +// The variances of DS must not depend on whether Ref, which mentions DS, +// is declared first. + +// @filename: refFirst.ts +type M = { kind: "m" }; +type Filtered = { [K in keyof T as T[K] extends M ? K : never]: T[K] }; +interface Config { measure: keyof T } +interface Ref { dataset: DS, N> } +interface DS { + a(config: Config>): void; + b: Ref; +} +declare const x: DS<{ total: M }, string>; +export const y: DS, string> = x; + +// @filename: dsFirst.ts +type M = { kind: "m" }; +type Filtered = { [K in keyof T as T[K] extends M ? K : never]: T[K] }; +interface Config { measure: keyof T } +interface DS { + a(config: Config>): void; + b: Ref; +} +interface Ref { dataset: DS, N> } +declare const x: DS<{ total: M }, string>; +export const y: DS, string> = x; diff --git a/tsc/testdata/tests/cases/compiler/varianceMeasuredWithinCircularity.ts b/tsc/testdata/tests/cases/compiler/varianceMeasuredWithinCircularity.ts new file mode 100644 index 0000000000000..712ee43f4f782 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/varianceMeasuredWithinCircularity.ts @@ -0,0 +1,30 @@ +// @strict: true +// @noEmit: true + +// The variances of Selection and TransitionLike depend on each other. +// The callback of `data` requires Selection to be covariant in P, while +// `join` passes Selection to a callback, which then requires it to +// be contravariant in P, so Selection is invariant in P. TransitionLike +// reaches P of a Selection through `selection().children()`, so it is +// invariant in G. Both must hold whichever variance is measured first. + +export {}; + +interface Base { base: string } +interface Derived extends Base { derived: string } + +interface Selection { + data(key: (parent: P) => string): Selection; + join(enter: string | ((elem: Selection) => Selection | TransitionLike)): Selection; + children(): Selection; +} + +interface TransitionLike { + selection(): Selection; +} + +declare let s1: Selection; +let s2: Selection = s1; + +declare let t1: TransitionLike; +let t2: TransitionLike = t1; diff --git a/tsc/testdata/tests/cases/compiler/varianceSupersededMeasurementKeepsOtherComparisons.ts b/tsc/testdata/tests/cases/compiler/varianceSupersededMeasurementKeepsOtherComparisons.ts new file mode 100644 index 0000000000000..c17ed38541bc4 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/varianceSupersededMeasurementKeepsOtherComparisons.ts @@ -0,0 +1,21 @@ +// @strict: true +// @noEmit: true +// @checkOrder: default,typesfirst + +// Reduced from zod v4 with LangGraph's `register` augmentation +// (langchain-ai/openwiki). Measuring the variance of B reaches A, which is +// smaller, so the measurement is superseded and measured again from A. While +// it finishes, comparing the parameters of `m` re-enters B, and its return +// type resolves `Check>`, whose comparison is not part of the +// measurement. It must still compare as it would from scratch, as the +// resolved conditional type is kept. + +declare let b1: B; +declare let b2: B<"s">; +b1 = b2; + +interface A { m(x: B): Check>; } +interface B { a: A; } +type Check = U extends { a: unknown } ? "yes" : "no"; + +const v: Check> = "yes"; diff --git a/tsc/testdata/tests/cases/conformance/classes/members/privateNames/privateNameNestedClassFieldShadowing.ts b/tsc/testdata/tests/cases/conformance/classes/members/privateNames/privateNameNestedClassFieldShadowing.ts index 45e3ab2f45218..598881ff0189c 100644 --- a/tsc/testdata/tests/cases/conformance/classes/members/privateNames/privateNameNestedClassFieldShadowing.ts +++ b/tsc/testdata/tests/cases/conformance/classes/members/privateNames/privateNameNestedClassFieldShadowing.ts @@ -1,3 +1,4 @@ +// @checkOrder: default, typesfirst // @strict: false // @target: es2015 diff --git a/tsc/testdata/tests/cases/conformance/controlFlow/dependentDestructuredVariablesReferenceInDeclaration1.ts b/tsc/testdata/tests/cases/conformance/controlFlow/dependentDestructuredVariablesReferenceInDeclaration1.ts index d72cb1553711e..d3f2b2d3c8455 100644 --- a/tsc/testdata/tests/cases/conformance/controlFlow/dependentDestructuredVariablesReferenceInDeclaration1.ts +++ b/tsc/testdata/tests/cases/conformance/controlFlow/dependentDestructuredVariablesReferenceInDeclaration1.ts @@ -1,6 +1,7 @@ // @strict: true // @target: esnext // @noEmit: true +// @checkOrder: default, typesfirst // https://github.com/microsoft/TypeScript/issues/62993 diff --git a/tsc/testdata/tests/cases/conformance/es6/destructuring/destructuringWithLiteralInitializers.ts b/tsc/testdata/tests/cases/conformance/es6/destructuring/destructuringWithLiteralInitializers.ts index 613a3966e161f..ff48d5a86f727 100644 --- a/tsc/testdata/tests/cases/conformance/es6/destructuring/destructuringWithLiteralInitializers.ts +++ b/tsc/testdata/tests/cases/conformance/es6/destructuring/destructuringWithLiteralInitializers.ts @@ -1,3 +1,4 @@ +// @checkOrder: default, typesfirst // @target: es2015 // @strict: false // (arg: { x: any, y: any }) => void diff --git a/tsc/testdata/tests/cases/conformance/jsdoc/importTag13.ts b/tsc/testdata/tests/cases/conformance/jsdoc/importTag13.ts index 7ad42b8c9fee2..d811998b4c3c5 100644 --- a/tsc/testdata/tests/cases/conformance/jsdoc/importTag13.ts +++ b/tsc/testdata/tests/cases/conformance/jsdoc/importTag13.ts @@ -1,3 +1,4 @@ +// @checkOrder: default, typesfirst // @target: es2015 // @checkJs: true // @allowJs: true From e830558d968e9acc7af7d6085ee83d1df9415f37 Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Mon, 2 Nov 2026 17:12:16 -0800 Subject: [PATCH 07/60] Don't crash reporting a too large tuple outside of checking A spread that produces a tuple too large to represent reports the error at the node being checked. When the type is first requested through the API, before checking has begun, there is no such node and reporting the error crashed instead. (seen in excessivelyLargeTupleSpread) --- tsc/internal/checker/checker.go | 2 +- ...TupleSpread(checkorder=default).errors.txt | 51 +++++ ...elyLargeTupleSpread(checkorder=default).js | 61 ++++++ ...rgeTupleSpread(checkorder=default).symbols | 184 +++++++++++++++++ ...LargeTupleSpread(checkorder=default).types | 190 ++++++++++++++++++ ...leSpread(checkorder=typesfirst).errors.txt | 47 +++++ ...LargeTupleSpread(checkorder=typesfirst).js | 61 ++++++ ...TupleSpread(checkorder=typesfirst).symbols | 184 +++++++++++++++++ ...geTupleSpread(checkorder=typesfirst).types | 190 ++++++++++++++++++ .../compiler/excessivelyLargeTupleSpread.ts | 1 + 10 files changed, 970 insertions(+), 1 deletion(-) create mode 100644 tsc/testdata/baselines/reference/compiler/excessivelyLargeTupleSpread(checkorder=default).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/excessivelyLargeTupleSpread(checkorder=default).js create mode 100644 tsc/testdata/baselines/reference/compiler/excessivelyLargeTupleSpread(checkorder=default).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/excessivelyLargeTupleSpread(checkorder=default).types create mode 100644 tsc/testdata/baselines/reference/compiler/excessivelyLargeTupleSpread(checkorder=typesfirst).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/excessivelyLargeTupleSpread(checkorder=typesfirst).js create mode 100644 tsc/testdata/baselines/reference/compiler/excessivelyLargeTupleSpread(checkorder=typesfirst).symbols create mode 100644 tsc/testdata/baselines/reference/compiler/excessivelyLargeTupleSpread(checkorder=typesfirst).types diff --git a/tsc/internal/checker/checker.go b/tsc/internal/checker/checker.go index 14f8356152d83..6d809f8fadb81 100644 --- a/tsc/internal/checker/checker.go +++ b/tsc/internal/checker/checker.go @@ -24170,7 +24170,7 @@ 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), + message := core.IfElse(c.currentNode != nil && 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) 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..5bb90d57b8a95 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/excessivelyLargeTupleSpread(checkorder=typesfirst).errors.txt @@ -0,0 +1,47 @@ +error TS2800: Expression 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. + + +!!! error TS2800: Expression produces a tuple type that is too large to represent. +==== excessivelyLargeTupleSpread.ts (1 errors) ==== + // #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 + ~~~~~~~~~~~~~~~~ +!!! 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/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 From 064e56cda10d2d03c4a720df907e0a980614b969 Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Sun, 18 Oct 2026 22:16:35 -0700 Subject: [PATCH 08/60] Check assertion operands once, with their normal type checkAssertion runs in several check modes, such as when a call is first checked without its context sensitive arguments, and each run overwrote the operand type kept for the deferred comparability check. That check used whichever was stored last, so its result depended on the order in which the assertion was checked. The deferred check now uses the cached normal type of the operand. The assertion itself only needs the operand type for `as const`, and the operand of a non-const assertion is contextually typed by the asserted type alone, so in any check mode the assertion computes the cached type the deferred check will read, with inference for an enclosing call hidden from the operand. This is the result the deferred check would produce on its own, and checks each operand once rather than again with fresh flow analysis in the deferred check. --- tsc/internal/checker/checker.go | 31 +++++++++++++++---- tsc/internal/checker/types.go | 6 ---- ...AssertionCallNoHang(checkorder=default).js | 24 ++++++++++++++ ...ssertionCallNoHang(checkorder=isolated).js | 24 ++++++++++++++ ...AssertionCallNoHang(checkorder=reverse).js | 24 ++++++++++++++ ...ertionCallNoHang(checkorder=typesfirst).js | 24 ++++++++++++++ ...ryOrder(checkorder=editorfirst).errors.txt | 18 ----------- ...peQueryOrder(checkorder=editorfirst).types | 2 +- ...sertionOperandInLoopAssertionCallNoHang.ts | 15 +++++++++ 9 files changed, 137 insertions(+), 31 deletions(-) create mode 100644 tsc/testdata/baselines/reference/compiler/assertionOperandInLoopAssertionCallNoHang(checkorder=default).js create mode 100644 tsc/testdata/baselines/reference/compiler/assertionOperandInLoopAssertionCallNoHang(checkorder=isolated).js create mode 100644 tsc/testdata/baselines/reference/compiler/assertionOperandInLoopAssertionCallNoHang(checkorder=reverse).js create mode 100644 tsc/testdata/baselines/reference/compiler/assertionOperandInLoopAssertionCallNoHang(checkorder=typesfirst).js delete mode 100644 tsc/testdata/baselines/reference/compiler/getterReturnTypeQueryOrder(checkorder=editorfirst).errors.txt create mode 100644 tsc/testdata/tests/cases/compiler/assertionOperandInLoopAssertionCallNoHang.ts diff --git a/tsc/internal/checker/checker.go b/tsc/internal/checker/checker.go index 6d809f8fadb81..176191e4d01e6 100644 --- a/tsc/internal/checker/checker.go +++ b/tsc/internal/checker/checker.go @@ -660,6 +660,7 @@ type Checker struct { memberLayoutCache map[CacheHashKey]*MemberLayout markerTypes collections.Set[*Type] resolvingExplicitTypeOfSymbol collections.Set[*ast.Symbol] + resolvingAssertionOperands collections.Set[*ast.Node] constructorOrFunctionChecked collections.Set[*ast.Symbol] undefinedSymbol *ast.Symbol argumentsSymbol *ast.Symbol @@ -714,7 +715,6 @@ type Checker struct { 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] @@ -12568,26 +12568,45 @@ 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.resolvingAssertionOperands.AddIfAbsent(node) { + // 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.pushInferenceContext(node.Expression(), nil) + c.checkExpressionCached(node.Expression()) + c.popInferenceContext() + c.resolvingAssertionOperands.Delete(node) + } // 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) diff --git a/tsc/internal/checker/types.go b/tsc/internal/checker/types.go index bfa846b876822..39af516a37c68 100644 --- a/tsc/internal/checker/types.go +++ b/tsc/internal/checker/types.go @@ -478,12 +478,6 @@ 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 { 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/getterReturnTypeQueryOrder(checkorder=editorfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/getterReturnTypeQueryOrder(checkorder=editorfirst).errors.txt deleted file mode 100644 index 4f28621217936..0000000000000 --- a/tsc/testdata/baselines/reference/compiler/getterReturnTypeQueryOrder(checkorder=editorfirst).errors.txt +++ /dev/null @@ -1,18 +0,0 @@ -getterReturnTypeQueryOrder.ts(4,9): error TS7023: 'options' implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions. - - -==== getterReturnTypeQueryOrder.ts (1 errors) ==== - declare const props: Options; - - class Container { - get options() { - ~~~~~~~ -!!! error TS7023: 'options' implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions. - return { container: this, ...props } as Options; - } - } - - interface Options { - container?: Container; - } - \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/getterReturnTypeQueryOrder(checkorder=editorfirst).types b/tsc/testdata/baselines/reference/compiler/getterReturnTypeQueryOrder(checkorder=editorfirst).types index df84cc21241ea..903243eef9cb7 100644 --- a/tsc/testdata/baselines/reference/compiler/getterReturnTypeQueryOrder(checkorder=editorfirst).types +++ b/tsc/testdata/baselines/reference/compiler/getterReturnTypeQueryOrder(checkorder=editorfirst).types @@ -8,7 +8,7 @@ class Container { >Container : Container get options() { ->options : any +>options : Options return { container: this, ...props } as Options; >{ container: this, ...props } as Options : Options 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); + } +}); From fdd93bc6fce7c7e703d01ffcb22594223248d704 Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Mon, 19 Oct 2026 04:44:54 -0700 Subject: [PATCH 09/60] Derive binding pattern parent types without peeking at caches The type of a destructured parameter's binding elements depended on whether the parameter's type happened to be cached already. For example, in non-strict mode (({ [a()?.d]: c = "" }) => {})(); reported TS2537 when 'c' was queried before the IIFE call resolved the parameter (its declared type is the undefined widening type), but not otherwise. Conversely, in f7({ a: {} }); function f7({ a: { x = 0, y = 0 } } = { a: {} }) {} calling f7 first made 'x' and 'y' errors of type any. Make the choice depend only on the declaration. Parameters of context-sensitive functions take their type from contextual assignment, so ask for the parameter's type. Everything else uses the type derived from the declaration, as it did when nothing was cached. Asking for the parameter's type unconditionally instead introduces circularities in patterns whose initializers reference sibling elements. --- tsc/internal/checker/checker.go | 4 +- ...ializers(checkorder=typesfirst).errors.txt | 75 ------------------- ...lInitializers(checkorder=typesfirst).types | 4 +- 3 files changed, 4 insertions(+), 79 deletions(-) delete mode 100644 tsc/testdata/baselines/reference/conformance/destructuringWithLiteralInitializers(checkorder=typesfirst).errors.txt diff --git a/tsc/internal/checker/checker.go b/tsc/internal/checker/checker.go index 176191e4d01e6..243794096f811 100644 --- a/tsc/internal/checker/checker.go +++ b/tsc/internal/checker/checker.go @@ -18235,8 +18235,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) } } } diff --git a/tsc/testdata/baselines/reference/conformance/destructuringWithLiteralInitializers(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/conformance/destructuringWithLiteralInitializers(checkorder=typesfirst).errors.txt deleted file mode 100644 index ee3b06edc611c..0000000000000 --- a/tsc/testdata/baselines/reference/conformance/destructuringWithLiteralInitializers(checkorder=typesfirst).errors.txt +++ /dev/null @@ -1,75 +0,0 @@ -destructuringWithLiteralInitializers.ts(37,20): error TS2339: Property 'x' does not exist on type '{}'. -destructuringWithLiteralInitializers.ts(37,27): error TS2339: Property 'y' does not exist on type '{}'. - - -==== destructuringWithLiteralInitializers.ts (2 errors) ==== - // (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: {} }) { } - ~ -!!! error TS2339: Property 'x' does not exist on type '{}'. - ~ -!!! error TS2339: Property 'y' does not exist on type '{}'. - 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]); - \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/conformance/destructuringWithLiteralInitializers(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/conformance/destructuringWithLiteralInitializers(checkorder=typesfirst).types index 45f5edceff50e..d46ab82876d40 100644 --- a/tsc/testdata/baselines/reference/conformance/destructuringWithLiteralInitializers(checkorder=typesfirst).types +++ b/tsc/testdata/baselines/reference/conformance/destructuringWithLiteralInitializers(checkorder=typesfirst).types @@ -174,9 +174,9 @@ f6({ x: 1, y: 1 }); function f7({ a: { x = 0, y = 0 } } = { a: {} }) { } >f7 : ({ a: { x, y } }?: { a: {}; }) => void >a : any ->x : any +>x : number >0 : 0 ->y : any +>y : number >0 : 0 >{ a: {} } : { a: {}; } >a : {} From 21c451bdd90581e7bbaa81c4c0d5b49b96872bea Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Mon, 19 Oct 2026 04:53:14 -0700 Subject: [PATCH 10/60] Make contextual typing of functions independent of query order A context-sensitive function is typed in parts: the enclosing call assigns its parameters their contextual types, completes its signature with the type parameters of a generic contextual signature, and checks it. Queries that reached the function before or during those steps saw it incomplete and cached the types they derived from it. The first query of such a parameter returned the type it computed itself from the final signature, while every later query returned the type the enclosing call assigned. In declare function fun(g: (x: T) => T, h: (y: T) => T, x: T): T; fun((Math.random() < 0.5 ? (x => x) : (x => undefined)), x => x, 10); the last 'x' was number when the call was checked first, but any when 'x' was queried first. The assigned type is now returned whenever one exists, as the original comment intended. Type aliases in the body read the signature's type parameters as outer type parameters, so querying such an alias first resolved its conditional types eagerly. In declare function f(fun: (t: T) => void): void f(function self(t) { const s = self; type P = Parameters; }); P was [t: unknown] when the call was checked first, but [t: T] when P was asked for first. Assigning the contextual parameter types, which completes the signature, is now split from the rest of the contextual check, and every way to obtain the signature requests it: the type of the function's symbol, before anything resolves its members, and the signature of its declaration. Contextual typing can reach the enclosing call while the signature is being created, so the signature created there is kept rather than replacing the one that was contextually typed. When resolving a function expression's members reached the function again through its enclosing call, the contextual check saw an empty signature list and gave up, yet left the node marked as checked, so implicit any errors could be lost depending on which query got there first. The deferred function check now requests the contextual check, so it is performed at least once. --- tsc/internal/checker/checker.go | 76 ++++++++++++++----- tsc/internal/checker/types.go | 1 + ...pression(checkorder=typesfirst).errors.txt | 5 +- ...ypeParameters(checkorder=typesfirst).types | 12 +-- ...nference(checkorder=typesfirst).errors.txt | 8 +- ...eatedly2(checkorder=typesfirst).errors.txt | 7 +- ...rsRepeatedly2(checkorder=typesfirst).types | 4 +- ...eTagOnContextuallyTypedFunction.errors.txt | 12 ++- ...TypeTagOnContextuallyTypedFunction.symbols | 8 +- ...ocTypeTagOnContextuallyTypedFunction.types | 30 ++++---- ...Deferred(checkorder=typesfirst).errors.txt | 6 +- ...ckingDeferred(checkorder=typesfirst).types | 6 +- ...e-with-multiple-files-and-complex-types.js | 10 +-- 13 files changed, 115 insertions(+), 70 deletions(-) diff --git a/tsc/internal/checker/checker.go b/tsc/internal/checker/checker.go index 243794096f811..793ee8d2ca951 100644 --- a/tsc/internal/checker/checker.go +++ b/tsc/internal/checker/checker.go @@ -10413,8 +10413,32 @@ func (c *Checker) checkFunctionExpressionOrObjectLiteralMethod(node *ast.Node, c } func (c *Checker) contextuallyCheckFunctionExpressionOrObjectLiteralMethod(node *ast.Node, checkMode CheckMode) { + c.assignContextualParameterTypesOfFunction(node, checkMode) + links := c.nodeLinks.Get(node) + if links.flags&NodeCheckFlagsContextChecked == 0 || links.flags&NodeCheckFlagsSignatureContextChecked != 0 { + return + } + links.flags |= NodeCheckFlagsSignatureContextChecked + signature := c.getSignatureFromDeclarationUncontextual(node) + contextualSignature := c.getContextualSignature(node) + 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) +} + +// 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) { 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 @@ -10422,10 +10446,7 @@ func (c *Checker) contextuallyCheckFunctionExpressionOrObjectLiteralMethod(node // already assigned contextual types. if links.flags&NodeCheckFlagsContextChecked == 0 { links.flags |= NodeCheckFlagsContextChecked - signature := core.FirstOrNil(c.getSignaturesOfType(c.getTypeOfSymbol(c.getSymbolOfDeclaration(node)), SignatureKindCall)) - if signature == nil { - return - } + signature := c.getSignatureFromDeclarationUncontextual(node) if c.isContextSensitive(node) { if contextualSignature != nil { inferenceContext := c.getInferenceContext(node) @@ -10455,20 +10476,14 @@ 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) } } } 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) @@ -17068,7 +17083,10 @@ 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) { + if assigned := links.resolvedType; assigned != nil { + return assigned + } + if !c.isParameterOfContextSensitiveSignature(symbol) { links.resolvedType = t } return t @@ -17422,6 +17440,12 @@ func (c *Checker) getTypeOfFuncClassEnumModule(symbol *ast.Symbol) *Type { if links.resolvedType == nil { links.resolvedType = c.getTypeOfFuncClassEnumModuleWorker(symbol) } + if declaration := symbol.ValueDeclaration(); declaration != nil && c.isContextSensitiveFunctionOrObjectLiteralMethod(declaration) { + // Complete the signature before anything resolves the members of the + // type: doing so may check the enclosing call, which needs the + // members of the type. + c.assignContextualParameterTypesOfFunction(declaration, CheckModeNormal) + } return links.resolvedType } @@ -20542,6 +20566,17 @@ 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 @@ -20613,6 +20648,12 @@ 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 } + if links.resolvedSignature != 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 links.resolvedSignature + } links.resolvedSignature = c.newSignature(flags, declaration, typeParameters, thisParameter, parameters, nil /*resolvedReturnType*/, nil /*resolvedTypePredicate*/, minArgumentCount) return links.resolvedSignature } @@ -24588,9 +24629,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 { diff --git a/tsc/internal/checker/types.go b/tsc/internal/checker/types.go index 39af516a37c68..6eb2dd8a5b3c5 100644 --- a/tsc/internal/checker/types.go +++ b/tsc/internal/checker/types.go @@ -423,6 +423,7 @@ 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. diff --git a/tsc/testdata/baselines/reference/compiler/checkIndexConstraintOfJavascriptClassExpression(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/checkIndexConstraintOfJavascriptClassExpression(checkorder=typesfirst).errors.txt index a15bd4d38db0d..fa22beceb33e2 100644 --- a/tsc/testdata/baselines/reference/compiler/checkIndexConstraintOfJavascriptClassExpression(checkorder=typesfirst).errors.txt +++ b/tsc/testdata/baselines/reference/compiler/checkIndexConstraintOfJavascriptClassExpression(checkorder=typesfirst).errors.txt @@ -1,12 +1,15 @@ 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 (2 errors) ==== +==== 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 { diff --git a/tsc/testdata/baselines/reference/compiler/contextualOuterTypeParameters(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/contextualOuterTypeParameters(checkorder=typesfirst).types index 280e75fb600cf..3be38bfec4e31 100644 --- a/tsc/testdata/baselines/reference/compiler/contextualOuterTypeParameters(checkorder=typesfirst).types +++ b/tsc/testdata/baselines/reference/compiler/contextualOuterTypeParameters(checkorder=typesfirst).types @@ -37,13 +37,13 @@ const fn1: (x: T) => void = t => { >t : T type isArray = (typeof t)[] extends string[] ? true : false; ->isArray : false +>isArray : T[] extends string[] ? true : false >t : T >true : true >false : false type IsObject = { x: typeof t } extends { x: string } ? true : false; ->IsObject : false +>IsObject : { x: typeof t; } extends { x: string; } ? true : false >x : T >t : T >x : string @@ -60,13 +60,13 @@ const fn2: (x: T) => void = function test(t) { >t : T type isArray = (typeof t)[] extends string[] ? true : false; ->isArray : false +>isArray : T[] extends string[] ? true : false >t : T >true : true >false : false type IsObject = { x: typeof t } extends { x: string } ? true : false; ->IsObject : false +>IsObject : { x: typeof t; } extends { x: string; } ? true : false >x : T >t : T >x : string @@ -86,13 +86,13 @@ const obj: { f: (x: T) => void } = { >t : T type isArray = (typeof t)[] extends string[] ? true : false; ->isArray : false +>isArray : T[] extends string[] ? true : false >t : T >true : true >false : false type IsObject = { x: typeof t } extends { x: string } ? true : false; ->IsObject : false +>IsObject : { x: typeof t; } extends { x: string; } ? true : false >x : T >t : T >x : string diff --git a/tsc/testdata/baselines/reference/compiler/fallbackToBindingPatternForTypeInference(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/fallbackToBindingPatternForTypeInference(checkorder=typesfirst).errors.txt index 37a59b2d11dea..9a04ca00910e5 100644 --- a/tsc/testdata/baselines/reference/compiler/fallbackToBindingPatternForTypeInference(checkorder=typesfirst).errors.txt +++ b/tsc/testdata/baselines/reference/compiler/fallbackToBindingPatternForTypeInference(checkorder=typesfirst).errors.txt @@ -1,7 +1,6 @@ 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(2,9): error TS2339: Property 'a' does not exist on type 'unknown'. 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]'. @@ -14,18 +13,15 @@ fallbackToBindingPatternForTypeInference.ts(5,7): error TS2345: Argument of type 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(6,9): error TS2339: Property 'a' does not exist on type 'unknown'. -==== fallbackToBindingPatternForTypeInference.ts (7 errors) ==== +==== 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; }'. - ~ -!!! error TS2339: Property 'a' does not exist on type 'unknown'. trans(([b,c]) => 'foo'); ~~~~~~~~~~~~~~~~ !!! error TS2345: Argument of type '([b, c]: [any, any]) => string' is not assignable to parameter of type '(x: unknown) => string'. @@ -46,6 +42,4 @@ fallbackToBindingPatternForTypeInference.ts(6,9): error TS2339: Property 'a' doe !!! 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; }'. - ~ -!!! error TS2339: Property 'a' does not exist on type 'unknown'. \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/fixingTypeParametersRepeatedly2(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/fixingTypeParametersRepeatedly2(checkorder=typesfirst).errors.txt index eaf9da009a413..29a93731f366b 100644 --- a/tsc/testdata/baselines/reference/compiler/fixingTypeParametersRepeatedly2(checkorder=typesfirst).errors.txt +++ b/tsc/testdata/baselines/reference/compiler/fixingTypeParametersRepeatedly2(checkorder=typesfirst).errors.txt @@ -1,9 +1,8 @@ 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(17,34): error TS2339: Property 'toBase' does not exist on type 'Base'. -==== fixingTypeParametersRepeatedly2.ts (3 errors) ==== +==== fixingTypeParametersRepeatedly2.ts (2 errors) ==== interface Base { baseProp; } @@ -27,6 +26,4 @@ fixingTypeParametersRepeatedly2.ts(17,34): error TS2339: Property 'toBase' does 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. - ~~~~~~ -!!! error TS2339: Property 'toBase' does not exist on type 'Base'. \ No newline at end of file +!!! 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).types b/tsc/testdata/baselines/reference/compiler/fixingTypeParametersRepeatedly2(checkorder=typesfirst).types index a94614635d95a..0a8fca14e9475 100644 --- a/tsc/testdata/baselines/reference/compiler/fixingTypeParametersRepeatedly2(checkorder=typesfirst).types +++ b/tsc/testdata/baselines/reference/compiler/fixingTypeParametersRepeatedly2(checkorder=typesfirst).types @@ -53,7 +53,7 @@ var result = bar(derived, d => d.toBase()); >d => d.toBase() : (d: Derived) => Base >d : Derived >d.toBase() : Base ->d.toBase : any +>d.toBase : () => Base >d : Derived ->toBase : any +>toBase : () => Base diff --git a/tsc/testdata/baselines/reference/compiler/jsdocTypeTagOnContextuallyTypedFunction.errors.txt b/tsc/testdata/baselines/reference/compiler/jsdocTypeTagOnContextuallyTypedFunction.errors.txt index f9f9a2d8d5885..f19e5b3afede1 100644 --- a/tsc/testdata/baselines/reference/compiler/jsdocTypeTagOnContextuallyTypedFunction.errors.txt +++ b/tsc/testdata/baselines/reference/compiler/jsdocTypeTagOnContextuallyTypedFunction.errors.txt @@ -2,13 +2,17 @@ a.js(4,1): error TS2322: Type '(content: string, rest_0?: boolean | undefined) = 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(6,35): error TS2339: Property 'toUpperCase' does not exist on type 'string | number'. + Property 'toUpperCase' does not exist on type 'number'. 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(11,26): error TS2339: Property 'toUpperCase' does not exist on type 'string | number'. + Property 'toUpperCase' does not exist on type 'number'. -==== a.js (2 errors) ==== +==== a.js (4 errors) ==== /** @type {{ f: (a: string | number, ...rest: unknown[]) => string }} */ const context = { f: (a) => "" }; @@ -20,6 +24,9 @@ a.js(9,7): error TS2322: Type '(content: string) => string' is not assignable to !!! error TS2322: Type 'number' is not assignable to type 'string'. /** @type {(content: string, ...rest: [boolean?]) => string} */ (content, ...rest) => content.toUpperCase() + rest.length; + ~~~~~~~~~~~ +!!! error TS2339: Property 'toUpperCase' does not exist on type 'string | number'. +!!! error TS2339: Property 'toUpperCase' does not exist on type 'number'. /** @type {(content: string | number) => string} */ const g = @@ -30,4 +37,7 @@ a.js(9,7): error TS2322: Type '(content: string) => string' is not assignable to !!! error TS2322: Type 'number' is not assignable to type 'string'. /** @type {(content: string) => string} */ (content) => content.toUpperCase(); + ~~~~~~~~~~~ +!!! error TS2339: Property 'toUpperCase' does not exist on type 'string | number'. +!!! error TS2339: Property 'toUpperCase' does not exist on type 'number'. \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/jsdocTypeTagOnContextuallyTypedFunction.symbols b/tsc/testdata/baselines/reference/compiler/jsdocTypeTagOnContextuallyTypedFunction.symbols index 15ffe15bb65e2..17ba749362f25 100644 --- a/tsc/testdata/baselines/reference/compiler/jsdocTypeTagOnContextuallyTypedFunction.symbols +++ b/tsc/testdata/baselines/reference/compiler/jsdocTypeTagOnContextuallyTypedFunction.symbols @@ -16,12 +16,10 @@ context.f = (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.length : Symbol(Array.length, Decl(lib.es5.d.ts, --, --)) >rest : Symbol(rest, Decl(a.js, 5, 13)) ->length : Symbol(length) +>length : Symbol(Array.length, Decl(lib.es5.d.ts, --, --)) /** @type {(content: string | number) => string} */ const g = @@ -30,7 +28,5 @@ const g = /** @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 index 6defe743de587..7511697864aa1 100644 --- a/tsc/testdata/baselines/reference/compiler/jsdocTypeTagOnContextuallyTypedFunction.types +++ b/tsc/testdata/baselines/reference/compiler/jsdocTypeTagOnContextuallyTypedFunction.types @@ -19,16 +19,16 @@ context.f = /** @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 +>content : string | number +>rest : unknown[] +>content.toUpperCase() + rest.length : any +>content.toUpperCase() : any +>content.toUpperCase : any +>content : string | number +>toUpperCase : any +>rest.length : number +>rest : unknown[] +>length : number /** @type {(content: string | number) => string} */ const g = @@ -37,9 +37,9 @@ const g = /** @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 +>content : string | number +>content.toUpperCase() : any +>content.toUpperCase : any +>content : string | number +>toUpperCase : any diff --git a/tsc/testdata/baselines/reference/compiler/overloadresolutionWithConstraintCheckingDeferred(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/overloadresolutionWithConstraintCheckingDeferred(checkorder=typesfirst).errors.txt index e93dbcc6cad6b..47be7df4a2a28 100644 --- a/tsc/testdata/baselines/reference/compiler/overloadresolutionWithConstraintCheckingDeferred(checkorder=typesfirst).errors.txt +++ b/tsc/testdata/baselines/reference/compiler/overloadresolutionWithConstraintCheckingDeferred(checkorder=typesfirst).errors.txt @@ -15,10 +15,11 @@ overloadresolutionWithConstraintCheckingDeferred.ts(18,27): error TS2769: No ove 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 (6 errors) ==== +==== overloadresolutionWithConstraintCheckingDeferred.ts (7 errors) ==== interface A { x } interface B { x; y } interface C { z } @@ -68,6 +69,9 @@ overloadresolutionWithConstraintCheckingDeferred.ts(19,32): error TS2741: Proper !!! 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. diff --git a/tsc/testdata/baselines/reference/compiler/overloadresolutionWithConstraintCheckingDeferred(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/overloadresolutionWithConstraintCheckingDeferred(checkorder=typesfirst).types index 7eb08e3ac8acb..df9ec39e7e837 100644 --- a/tsc/testdata/baselines/reference/compiler/overloadresolutionWithConstraintCheckingDeferred(checkorder=typesfirst).types +++ b/tsc/testdata/baselines/reference/compiler/overloadresolutionWithConstraintCheckingDeferred(checkorder=typesfirst).types @@ -44,7 +44,7 @@ var result: number = foo(x => new G(x)); // x has type D, new G(x) fails, so fir >x : D >new G(x) : G >G : typeof G ->x : any +>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 @@ -55,7 +55,7 @@ var result2: number = foo(x => new G(x)); // x has type D, new G(x) fa >new G(x) : G >G : typeof G >x : D ->x : any +>x : D var result3: string = foo(x => { // x has type D >result3 : string @@ -72,7 +72,7 @@ var result3: string = foo(x => { // x has type D >x : D return y; ->y : G +>y : G }); diff --git a/tsc/testdata/baselines/reference/tsc/generateTrace/generateTrace-with-multiple-files-and-complex-types.js b/tsc/testdata/baselines/reference/tsc/generateTrace/generateTrace-with-multiple-files-and-complex-types.js index 5d958c51b03c7..37b9f7c034fcb 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"}, From 0abfa12c44915f759ecfb683313e4a41c31d4069 Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Mon, 19 Oct 2026 05:15:56 -0700 Subject: [PATCH 11/60] Resolve calls in source order and locate their errors at the call Generic calls nested in the arguments of other generic calls, or in context-sensitive functions passed to them, depend on the enclosing call for their contextual type and parameter types, and the enclosing call infers from them in turn. When the inner call was queried first, it was already marked as resolving by the time its contextual type resolved the enclosing call, so the enclosing inference saw a placeholder and both calls cached results that a check in source order never produces. Computing the contextual type of a call nested in an argument of an enclosing call before resolving it resolves the enclosing call first, as source order does. Other contexts are not resolved ahead of time, since computing them may evaluate expressions that checking does not, such as the target of a destructuring assignment. Resolving a call's signature can also be requested while checking one of its arguments. Errors that resolution reports at the current node, such as an instantiation depth error, were located at whichever node asked first, so checking an argument ahead of its call moved the error onto the argument. Resolution is now located at the call. --- tsc/internal/checker/checker.go | 87 +++++++++++++++++++ ...eNoCrash(checkorder=typesfirst).errors.txt | 7 +- ...Callback(checkorder=typesfirst).errors.txt | 24 ----- ...tternCallback(checkorder=typesfirst).types | 18 ++-- ...ceNotTooBroad(checkorder=typesfirst).types | 16 ++-- 5 files changed, 108 insertions(+), 44 deletions(-) delete mode 100644 tsc/testdata/baselines/reference/compiler/contextualReturnArrayPatternCallback(checkorder=typesfirst).errors.txt diff --git a/tsc/internal/checker/checker.go b/tsc/internal/checker/checker.go index 793ee8d2ca951..8301f70247938 100644 --- a/tsc/internal/checker/checker.go +++ b/tsc/internal/checker/checker.go @@ -8637,6 +8637,68 @@ func (c *Checker) isSymbolOrSymbolForCall(node *ast.Node) bool { return globalESSymbol == c.resolveName(left, "Symbol", ast.SymbolFlagsValue, nil /*nameNotFoundMessage*/, false /*isUse*/, false) } +// isContextuallyTypedByEnclosingCall reports whether the contextual type of +// an expression may come from an argument of an enclosing call. Other +// contexts are not resolved ahead of the expression, since computing them +// may evaluate expressions that checking only evaluates otherwise, such as +// the target of a destructuring assignment. +func isContextuallyTypedByEnclosingCall(node *ast.Node) bool { + for { + parent := node.Parent + switch parent.Kind { + case ast.KindCallExpression, ast.KindNewExpression: + return node != parent.Expression() + case ast.KindTemplateSpan: + // A substitution of a tagged template is an argument of its tag. + return ast.IsTaggedTemplateExpression(parent.Parent.Parent) + case ast.KindJsxOpeningElement, ast.KindJsxSelfClosingElement: + // The attributes are the argument of the element. + return true + case ast.KindJsxElement: + if node == parent.AsJsxElement().OpeningElement { + node = parent + continue + } + // A child is part of the attributes of the element. + return true + case ast.KindParenthesizedExpression, ast.KindNonNullExpression, ast.KindSpreadElement, ast.KindArrayLiteralExpression, + ast.KindObjectLiteralExpression, ast.KindPropertyAssignment, ast.KindSpreadAssignment, ast.KindAwaitExpression, + ast.KindJsxExpression, ast.KindJsxAttribute, ast.KindJsxSpreadAttribute, ast.KindJsxAttributes: + node = parent + continue + case ast.KindAsExpression, ast.KindTypeAssertionExpression: + if !ast.IsConstAssertion(parent) { + return false + } + case ast.KindConditionalExpression: + if node == parent.AsConditionalExpression().Condition { + return false + } + case ast.KindBinaryExpression: + switch parent.AsBinaryExpression().OperatorToken.Kind { + case ast.KindBarBarToken, ast.KindAmpersandAmpersandToken, ast.KindQuestionQuestionToken, ast.KindCommaToken: + if node != parent.AsBinaryExpression().Right { + return false + } + default: + return false + } + case ast.KindArrowFunction: + if node != parent.Body() { + return false + } + case ast.KindReturnStatement, ast.KindYieldExpression: + parent = ast.GetContainingFunction(parent) + if parent == nil || !ast.IsFunctionExpressionOrArrowFunction(parent) { + return false + } + default: + return false + } + node = parent + } +} + /** * Resolve a signature of a given call-like expression. * @param node a call-like expression to try resolve a signature for @@ -8645,6 +8707,17 @@ 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 := c.currentNode + c.currentNode = node + result := c.resolveSignatureOfCall(node, candidatesOutArray, checkMode) + c.currentNode = saveCurrentNode + return result +} + +func (c *Checker) resolveSignatureOfCall(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, @@ -8654,6 +8727,20 @@ func (c *Checker) getResolvedSignature(node *ast.Node, candidatesOutArray *[]*Si if cached != nil && cached != c.resolvingSignature && candidatesOutArray == nil { return cached } + if cached == nil { + // Resolve an enclosing call providing the contextual type of this one + // first, as checking in source order would. The enclosing call may also + // type parameters this call references. Resolved from within this call + // instead, the enclosing call sees this one marked as resolving, and + // the result depends on which call was queried first. + if (ast.IsCallExpression(node) || ast.IsNewExpression(node) || ast.IsTaggedTemplateExpression(node) || ast.IsJsxOpeningLikeElement(node)) && isContextuallyTypedByEnclosingCall(node) { + c.getContextualType(node, ContextFlagsNone) + } + cached = links.resolvedSignature + 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 diff --git a/tsc/testdata/baselines/reference/compiler/circularInlineMappedGenericTupleTypeNoCrash(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/circularInlineMappedGenericTupleTypeNoCrash(checkorder=typesfirst).errors.txt index e78f397fc931f..8d568d19a5373 100644 --- a/tsc/testdata/baselines/reference/compiler/circularInlineMappedGenericTupleTypeNoCrash(checkorder=typesfirst).errors.txt +++ b/tsc/testdata/baselines/reference/compiler/circularInlineMappedGenericTupleTypeNoCrash(checkorder=typesfirst).errors.txt @@ -1,8 +1,7 @@ -error TS2589: Type instantiation is excessively deep and possibly infinite. +circularInlineMappedGenericTupleTypeNoCrash.ts(11,12): error TS2589: Type instantiation is excessively deep and possibly infinite. -!!! error TS2589: Type instantiation is excessively deep and possibly infinite. -==== circularInlineMappedGenericTupleTypeNoCrash.ts (0 errors) ==== +==== circularInlineMappedGenericTupleTypeNoCrash.ts (1 errors) ==== class Foo { public readonly elements: { [P in keyof Elements]: { bar: Elements[P] } }; @@ -14,6 +13,8 @@ error TS2589: Type instantiation is excessively deep and possibly infinite. public add(): Foo<[...Elements, "abc"]> { return new Foo<[...Elements, "abc"]>(...this.elements, { bar: "abc" }); + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. } } \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/contextualReturnArrayPatternCallback(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/contextualReturnArrayPatternCallback(checkorder=typesfirst).errors.txt deleted file mode 100644 index 0976f43f81f01..0000000000000 --- a/tsc/testdata/baselines/reference/compiler/contextualReturnArrayPatternCallback(checkorder=typesfirst).errors.txt +++ /dev/null @@ -1,24 +0,0 @@ -contextualReturnArrayPatternCallback.ts(13,19): error TS2322: Type 'unknown' is not assignable to type 'string'. - - -==== contextualReturnArrayPatternCallback.ts (1 errors) ==== - 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; - ~~~~ -!!! error TS2322: Type 'unknown' is not assignable to type 'string'. - return true; - }), - }), - }); - \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/contextualReturnArrayPatternCallback(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/contextualReturnArrayPatternCallback(checkorder=typesfirst).types index 68eb717e1e135..8ae0e4c69acc3 100644 --- a/tsc/testdata/baselines/reference/compiler/contextualReturnArrayPatternCallback(checkorder=typesfirst).types +++ b/tsc/testdata/baselines/reference/compiler/contextualReturnArrayPatternCallback(checkorder=typesfirst).types @@ -32,24 +32,24 @@ declare function accept>(val 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({ 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; }> +>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 => { const text: string = value; return true; }), } : { prop: Matcher; } prop: when(value => { ->prop : Matcher ->when(value => { const text: string = value; return true; }) : Matcher +>prop : Matcher +>when(value => { const text: string = value; return true; }) : Matcher >when : unknown>(callback: Callback) => Matcher ->value => { const text: string = value; return true; } : (value: unknown) => boolean ->value : unknown +>value => { const text: string = value; return true; } : (value: string) => boolean +>value : string const text: string = value; >text : string ->value : unknown +>value : string return true; >true : true diff --git a/tsc/testdata/baselines/reference/compiler/returnTypeInferenceNotTooBroad(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/returnTypeInferenceNotTooBroad(checkorder=typesfirst).types index 1f07d04ed8463..94962df020556 100644 --- a/tsc/testdata/baselines/reference/compiler/returnTypeInferenceNotTooBroad(checkorder=typesfirst).types +++ b/tsc/testdata/baselines/reference/compiler/returnTypeInferenceNotTooBroad(checkorder=typesfirst).types @@ -50,18 +50,18 @@ export const yun = unwrap(y); // $ExpectType { kind: "a"; a: 3; } export const yone = unwrap(sepsis({ low: 1, sign: { kind: 'a', a: 3 }})); ->yone : { kind: string; a: number; } ->unwrap(sepsis({ low: 1, sign: { kind: 'a', a: 3 }})) : { kind: string; a: number; } +>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: string; a: number; }> +>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: string; a: number; }; } +>{ low: 1, sign: { kind: 'a', a: 3 }} : { low: number; sign: { kind: "a"; a: 3; }; } >low : number >1 : 1 ->sign : { kind: string; a: number; } ->{ kind: 'a', a: 3 } : { kind: string; a: number; } ->kind : string +>sign : { kind: "a"; a: 3; } +>{ kind: 'a', a: 3 } : { kind: "a"; a: 3; } +>kind : "a" >'a' : "a" ->a : number +>a : 3 >3 : 3 From e939031f9952fbf5c133806b4e0f7e6aa6b27293 Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Mon, 19 Oct 2026 05:18:04 -0700 Subject: [PATCH 12/60] Do not cache results that depend on who asked first Asking for the symbol of a property access that hits an index signature stored the index symbol as the access's resolved symbol. Checking a delete expression reads that link to decide whether the operand must be optional, so a prior symbol query turned `delete a.x` on an index signature into an error that a plain check does not report. The type of the index symbol at such an access, which hovers show, now looks the index symbol up again rather than reading it from links. A single signature type produced by higher order inference is instantiated with the full mapper combined in, since its signature can reference type parameters other than the outer type parameters of its declaration. The instantiation cache was keyed only by the mapped outer type parameters, so two instantiations differing in another type parameter (here the this type) shared whichever result was computed first, and checking `outer.log` gave it the type of `inner.log`. Such instantiations are no longer cached. --- tsc/internal/checker/checker.go | 47 +++++++++++++------ ...ckorder=typesfirst,strict=true).errors.txt | 8 +--- ...acheReuseAfterMappedTypeApplication1.types | 8 ++-- 3 files changed, 38 insertions(+), 25 deletions(-) diff --git a/tsc/internal/checker/checker.go b/tsc/internal/checker/checker.go index 8301f70247938..4c303df537c61 100644 --- a/tsc/internal/checker/checker.go +++ b/tsc/internal/checker/checker.go @@ -17087,7 +17087,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) } } @@ -17107,6 +17107,18 @@ 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 + 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 { if symbol.CheckFlags()&ast.CheckFlagsDeferredType != 0 { return c.getTypeOfSymbolWithDeferredType(symbol) @@ -23265,6 +23277,22 @@ func (c *Checker) getObjectTypeInstantiation(t *Type, m *TypeMapper, alias *Type if newAlias == nil { newAlias = c.instantiateTypeAlias(t.alias, m) } + instantiate := func(newMapper *TypeMapper) *Type { + switch { + case target.objectFlags&ObjectFlagsReference != 0: + return c.createDeferredTypeReference(t.Target(), t.AsTypeReference().node, newMapper, newAlias) + case target.objectFlags&ObjectFlagsMapped != 0: + return c.instantiateMappedType(target, newMapper, newAlias) + default: + return c.instantiateAnonymousType(target, newMapper, newAlias) + } + } + if target.objectFlags&ObjectFlagsSingleSignatureType != 0 && m != nil { + // The signature may reference type parameters other than the outer + // type parameters of its declaration, so the instantiation is not + // determined by the type arguments and cannot be cached by them. + return instantiate(c.combineTypeMappers(newTypeMapper(typeParameters, typeArguments), m)) + } data := target.AsObjectType() key := getTypeInstantiationKey(typeArguments, newAlias, t.objectFlags&ObjectFlagsSingleSignatureType != 0) if data.instantiations == nil { @@ -23273,18 +23301,7 @@ func (c *Checker) getObjectTypeInstantiation(t *Type, m *TypeMapper, alias *Type } result := data.instantiations[key] if result == nil { - newMapper := newTypeMapper(typeParameters, typeArguments) - if target.objectFlags&ObjectFlagsSingleSignatureType != 0 && m != nil { - newMapper = c.combineTypeMappers(newMapper, m) - } - switch { - case target.objectFlags&ObjectFlagsReference != 0: - result = c.createDeferredTypeReference(t.Target(), t.AsTypeReference().node, newMapper, newAlias) - case target.objectFlags&ObjectFlagsMapped != 0: - result = c.instantiateMappedType(target, newMapper, newAlias) - default: - result = c.instantiateAnonymousType(target, newMapper, newAlias) - } + result = instantiate(newTypeMapper(typeParameters, typeArguments)) data.instantiations[key] = result 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 @@ -32900,7 +32917,9 @@ func (c *Checker) getSymbolOfNameOrPropertyAccessExpression(name *ast.Node) *ast if ast.IsPropertyAccessExpression(name) { c.checkPropertyAccessExpression(name, CheckModeNormal, false /*writeOnly*/) if links.resolvedSymbol == nil && !ast.IsPrivateIdentifier(name.Name()) { - links.resolvedSymbol = c.getApplicableIndexSymbol( + // 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()), ) 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 index d3c1fd53cc93f..f3abcf0386f5b 100644 --- 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 @@ -1,11 +1,9 @@ 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(36,8): error TS2790: The operand of a 'delete' operator must be optional. -deleteExpressionMustBeOptional.ts(37,8): error TS2790: The operand of a 'delete' operator must be optional. -==== deleteExpressionMustBeOptional.ts (5 errors) ==== +==== deleteExpressionMustBeOptional.ts (3 errors) ==== interface Foo { a: number b: number | undefined @@ -48,11 +46,7 @@ deleteExpressionMustBeOptional.ts(37,8): error TS2790: The operand of a 'delete' !!! error TS2339: Property 'j' does not exist on type 'Foo'. delete a.a - ~~~ -!!! error TS2790: The operand of a 'delete' operator must be optional. delete a.b - ~~~ -!!! error TS2790: The operand of a 'delete' operator must be optional. delete b.a delete b.b 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 From 54ea913f1d35d61197ae5fce6708f8fe7ddaf8e5 Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Mon, 19 Oct 2026 09:25:26 -0700 Subject: [PATCH 13/60] Report unresolved names after resolution completes Explaining why a name failed to resolve looks up other symbols, for example to find a spelling suggestion, and that can resolve aliases. When the failed name was the target of an alias, the suggestion lookup re-entered the alias being resolved, or skipped it, depending on which aliases were already in progress. In declarationEmitUnknownImport that decided whether two "Circular definition of import alias" errors were reported: they appeared when the import was checked first, and not when the export specifier was resolved first. Defer the explanation until no resolution is in progress, so it only observes finished results. The circularity errors that were artifacts of the suggestion lookup are no longer reported. --- tsc/internal/checker/checker.go | 11 +++++++++++ ...arationEmitUnknownImport(target=es2015).errors.txt | 10 ++-------- ...rationEmitUnknownImport2(target=es2015).errors.txt | 10 ++-------- ...FlakyDiagnosticsSpellingSuggestionOrder.errors.txt | 4 ++-- .../noFlakyDiagnosticsSpellingSuggestionOrder.types | 2 +- 5 files changed, 18 insertions(+), 19 deletions(-) diff --git a/tsc/internal/checker/checker.go b/tsc/internal/checker/checker.go index 4c303df537c61..48d37a31884b3 100644 --- a/tsc/internal/checker/checker.go +++ b/tsc/internal/checker/checker.go @@ -1643,6 +1643,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.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) { 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/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 From b1e52aec51e727c8f9bddb47f09224658a20286e Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Sun, 18 Oct 2026 20:58:18 -0700 Subject: [PATCH 14/60] Make flow analysis of a reference independent of other references When one reference hit the flow analysis depth limit, flow analysis was disabled for every later reference in the same function or module body, so the type of a reference depended on whether another reference in the body had been analyzed before it. Each reference now gives up only when its own analysis hits the limit. Shared flow node results are cached for the duration of one flow analysis, including incomplete results computed under a loop back edge. Once that loop's back edge has been exited and the loop label has a complete type, they are stale. Reusing them made a reference's type depend on which reference was analyzed first: in exhaustiveSwitchCheckCircularity, querying the reference inside the loop before the switch expression produced `never` instead of "bbb". An incomplete shared result is now reused only while the loop that was innermost when it was computed is still being analyzed. --- tsc/internal/checker/checker.go | 9 +- tsc/internal/checker/flow.go | 18 +- ...ckCircularity(checkorder=typesfirst).types | 2 +- ...pthCheckOrder(checkorder=typesfirst).types | 2020 ++++----- ...ooDeepCheckOrder(checkorder=default).types | 2002 ++++----- ...eepCheckOrder(checkorder=typesfirst).types | 2000 ++++----- .../compiler/largeControlFlowGraph.types | 4000 ++++++++--------- ...dNeverAfterLoopWithAndCondition.errors.txt | 6 +- 8 files changed, 5027 insertions(+), 5030 deletions(-) diff --git a/tsc/internal/checker/checker.go b/tsc/internal/checker/checker.go index 48d37a31884b3..2d3515d0fdbe4 100644 --- a/tsc/internal/checker/checker.go +++ b/tsc/internal/checker/checker.go @@ -846,7 +846,6 @@ type Checker struct { flowLoopStack []FlowLoopInfo sharedFlows []SharedFlow antecedentTypes []*Type - flowAnalysisDisabled bool flowInvocationCount int flowTypeCache map[*ast.Node]*Type lastFlowNode *ast.FlowNode @@ -3868,13 +3867,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) } diff --git a/tsc/internal/checker/flow.go b/tsc/internal/checker/flow.go index 8d14ca5258079..50fdea5bbb724 100644 --- a/tsc/internal/checker/flow.go +++ b/tsc/internal/checker/flow.go @@ -79,9 +79,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 { @@ -117,11 +114,11 @@ func (c *Checker) getFlowTypeOfReferenceEx(reference *ast.Node, declaredType *Ty func (c *Checker) getTypeAtFlowNode(f *FlowState, flow *ast.FlowNode) FlowType { if f.depth == 2000 { // 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. if tr := c.tracer; tr != nil { tr.Instant(tracing.PhaseCheckTypes, "getTypeAtFlowNode_DepthLimit", map[string]any{"depth": f.depth}) } - c.flowAnalysisDisabled = true c.reportFlowControlError(f.reference) return FlowType{t: c.errorType} } @@ -134,9 +131,9 @@ func (c *Checker) getTypeAtFlowNode(f *FlowState, flow *ast.FlowNode) FlowType { // the same getFlowTypeOfReference invocation. A node is considered shared when it is the // antecedent of more than one node. for i := f.sharedFlowStart; i < len(c.sharedFlows); i++ { - if c.sharedFlows[i].flow == flow { + if s := &c.sharedFlows[i]; s.flow == flow { f.depth-- - return c.sharedFlows[i].flowType + return s.flowType } } sharedFlow = flow @@ -1364,12 +1361,19 @@ func (c *Checker) getTypeAtFlowLoopLabel(f *FlowState, flow *ast.FlowNode) FlowT } else { // All but the first antecedent are the looping control flow paths that lead // back to the loop junction. We track these on the flow loop stack. + sharedFlowStart := len(c.sharedFlows) c.flowLoopStack = append(c.flowLoopStack, FlowLoopInfo{key: key, types: antecedentTypes}) saveFlowTypeCache := c.flowTypeCache c.flowTypeCache = nil flowType = c.getTypeAtFlowNode(f, list.Flow) c.flowTypeCache = saveFlowTypeCache c.flowLoopStack = c.flowLoopStack[:len(c.flowLoopStack)-1] + // An incomplete type computed under the back edge reflects the loop's + // partial types, so it is not valid once the back edge is exited. + // Reusing it would make the result depend on which reference was + // analyzed first. + kept := slices.DeleteFunc(c.sharedFlows[sharedFlowStart:], func(s SharedFlow) bool { return s.flowType.incomplete }) + c.sharedFlows = c.sharedFlows[:sharedFlowStart+len(kept)] // If we see a value appear in the cache it is a sign that control flow analysis // was restarted and completed by checkExpressionCached. We can simply pick up // the resulting type and bail out. diff --git a/tsc/testdata/baselines/reference/compiler/exhaustiveSwitchCheckCircularity(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/exhaustiveSwitchCheckCircularity(checkorder=typesfirst).types index 651cd4a45a647..a7b44f6811ab9 100644 --- a/tsc/testdata/baselines/reference/compiler/exhaustiveSwitchCheckCircularity(checkorder=typesfirst).types +++ b/tsc/testdata/baselines/reference/compiler/exhaustiveSwitchCheckCircularity(checkorder=typesfirst).types @@ -36,7 +36,7 @@ function f() { else if (isNever(foo)) { // Error expected >isNever(foo) : boolean >isNever : (n: never) => boolean ->foo : never +>foo : "bbb" break; } diff --git a/tsc/testdata/baselines/reference/compiler/flowLoopDepthCheckOrder(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/flowLoopDepthCheckOrder(checkorder=typesfirst).types index 99b5a33596d2c..247a176187cc8 100644 --- a/tsc/testdata/baselines/reference/compiler/flowLoopDepthCheckOrder(checkorder=typesfirst).types +++ b/tsc/testdata/baselines/reference/compiler/flowLoopDepthCheckOrder(checkorder=typesfirst).types @@ -34,3034 +34,3034 @@ while (cond()) { >"a" : "a" if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean } if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean const deep = x; >deep : any diff --git a/tsc/testdata/baselines/reference/compiler/flowLoopTooDeepCheckOrder(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/flowLoopTooDeepCheckOrder(checkorder=default).types index 2a0727e493817..b73df554b7234 100644 --- a/tsc/testdata/baselines/reference/compiler/flowLoopTooDeepCheckOrder(checkorder=default).types +++ b/tsc/testdata/baselines/reference/compiler/flowLoopTooDeepCheckOrder(checkorder=default).types @@ -23,19 +23,19 @@ while (cond()) { >cond : () => boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (typeof w === "string") { w = 1; } else { w = "a"; } >typeof w === "string" : boolean @@ -50,2986 +50,2986 @@ while (cond()) { >"a" : "a" if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} >b : any @@ -3355,7 +3355,7 @@ if (isString(w)) { >w : any const narrowed = w; ->narrowed : any ->w : any +>narrowed : string +>w : string } diff --git a/tsc/testdata/baselines/reference/compiler/flowLoopTooDeepCheckOrder(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/flowLoopTooDeepCheckOrder(checkorder=typesfirst).types index 5bb07088ede1b..b73df554b7234 100644 --- a/tsc/testdata/baselines/reference/compiler/flowLoopTooDeepCheckOrder(checkorder=typesfirst).types +++ b/tsc/testdata/baselines/reference/compiler/flowLoopTooDeepCheckOrder(checkorder=typesfirst).types @@ -23,19 +23,19 @@ while (cond()) { >cond : () => boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (typeof w === "string") { w = 1; } else { w = "a"; } >typeof w === "string" : boolean @@ -50,2986 +50,2986 @@ while (cond()) { >"a" : "a" if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} ->b : any +>b : boolean if (b) {} >b : any @@ -3355,7 +3355,7 @@ if (isString(w)) { >w : any const narrowed = w; ->narrowed : any +>narrowed : string >w : string } 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/narrowedNeverAfterLoopWithAndCondition.errors.txt b/tsc/testdata/baselines/reference/compiler/narrowedNeverAfterLoopWithAndCondition.errors.txt index 0ba88e426e409..dfe01f2eea345 100644 --- a/tsc/testdata/baselines/reference/compiler/narrowedNeverAfterLoopWithAndCondition.errors.txt +++ b/tsc/testdata/baselines/reference/compiler/narrowedNeverAfterLoopWithAndCondition.errors.txt @@ -1,4 +1,4 @@ -narrowedNeverAfterLoopWithAndCondition.ts(9,9): error TS2322: Type 'false' is not assignable to type 'never'. +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'. @@ -12,8 +12,8 @@ narrowedNeverAfterLoopWithAndCondition.ts(17,19): error TS2339: Property 'last_r if (value_def) { while (x && y); value_def.last_ref = false; - ~~~~~~~~~~~~~~~~~~ -!!! error TS2322: Type 'false' is not assignable to type 'never'. + ~~~~~~~~ +!!! error TS2339: Property 'last_ref' does not exist on type 'never'. } } From 28a49a7f906f28d60cccdbdd9fc3d7241de97158 Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Mon, 19 Oct 2026 09:35:28 -0700 Subject: [PATCH 15/60] Track computed property name cycles on the resolution stack A computed property name stored a placeholder type while its expression was checked, and returned the placeholder when re-entered. That kept the cycle off the resolution stack, so the computations in between did not fail, and the placeholder `{}` escaped into messages when checking entered through the property name, while `any` did when it entered through the variable it references. In blockScopedBindingUsedBeforeDef, the error read "Type '{}' cannot be used as an index type" or "Type 'any' ..." depending on which of them was checked first. Resolve computed property names on the resolution stack, failing with the error type on re-entry like other circular resolutions. --- tsc/internal/checker/checker.go | 14 ++++++++++++-- .../blockScopedBindingUsedBeforeDef.errors.txt | 12 ++++++------ 2 files changed, 18 insertions(+), 8 deletions(-) diff --git a/tsc/internal/checker/checker.go b/tsc/internal/checker/checker.go index 2d3515d0fdbe4..bd6cbf6290bc9 100644 --- a/tsc/internal/checker/checker.go +++ b/tsc/internal/checker/checker.go @@ -66,6 +66,7 @@ const ( TypeSystemPropertyNameWriteType TypeSystemPropertyNameInitializerIsUndefined TypeSystemPropertyNameAliasTarget + TypeSystemPropertyNameComputedPropertyName ) type TypeResolution struct { @@ -19485,6 +19486,8 @@ func (c *Checker) typeResolutionHasProperty(r *TypeResolution) bool { return c.valueSymbolLinks.Get(r.target.(*ast.Symbol)).getWriteType() != nil case TypeSystemPropertyNameAliasTarget: return c.aliasSymbolLinks.Get(r.target.(*ast.Symbol)).aliasTarget != nil + case TypeSystemPropertyNameComputedPropertyName: + return c.typeNodeLinks.Get(r.target.(*ast.Node)).resolvedType != nil } panic("Unhandled case in typeResolutionHasProperty") } @@ -27805,12 +27808,19 @@ func isInvalidComputedPropertyName(node *ast.Node) bool { func (c *Checker) checkComputedPropertyName(node *ast.Node) *Type { links := c.typeNodeLinks.Get(node) if links.resolvedType == nil { - links.resolvedType = c.circularConstraintType if isInvalidComputedPropertyName(node) { links.resolvedType = c.errorType return links.resolvedType } - links.resolvedType = c.checkExpression(node.Expression()) + if !c.pushTypeResolution(node, TypeSystemPropertyNameComputedPropertyName) { + return c.errorType + } + t := c.checkExpression(node.Expression()) + c.popTypeResolution() + if links.resolvedType != nil { + return links.resolvedType + } + links.resolvedType = 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 || 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 From d1db4f92fa93e6e49d17561d021dc88cbe96f8ca Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Tue, 20 Oct 2026 15:26:08 -0700 Subject: [PATCH 16/60] Order and intern types by content instead of by type id CompareTypes orders the constituents of unions, and so printed types, union deduplication, and everything derived from them. Many types it cannot tell apart fell through to the type id, which follows creation order, so these results depended on which code had been checked before. Most such ties were copies: checking the same expression again (inference passes, overload resolution, contextual re-checks) created a new type with identical content every time. Types that are the same by content are now interned, so the same inputs yield the same type whenever and however often they are computed: object literal types, spread results and the property symbols they synthesize, widened, regular, and padded copies of object literals, object rest types, types implied by binding patterns, intersections with the same constituents, flags, and alias, and deferred indexed accesses, which are keyed by the flags they record rather than by transient ones. Interned object types are keyed by their members in table order, so spreads such as { ...a, ...b } and { ...b, ...a } stay distinct and each keeps its own property order. Types that remain distinct are ordered by how they were derived: - type parameters sharing a symbol (tuple elements, clones made for signature and mapped type instantiation, distributive and restrictive copies) by the kind of copy, then by their origin and the instantiation they were made for; - fresh and regular literal types, array literal types after the references they were cloned from, and object literal copies by the flags they were created with; - object literal, rest, and binding pattern types by their members, compared by declaration and name rather than by symbol id; - tuple targets by their label declarations. isDeeplyNestedType counts only occurrences of a recursion identity newer than the previous one, using type ids for "newer", so whether a comparison gave up as deeply nested depended on which code had been checked before. It now uses a type's generation, one more than that of the types it was built from, which captures the same ordering wherever it follows from how the types are built, and nothing else. The pseudo-type printer reused the declared type of an inferred property assignment when the expression's widened type matched, but that type is widened without the context of its object literal and can differ from the real one. It is now reused only when equivalent. Fixes 17873 Fixes 34099 Fixes 60453 --- tsc/internal/checker/checker.go | 316 ++++++++++++++++-- tsc/internal/checker/pseudotypenodebuilder.go | 8 + tsc/internal/checker/relater.go | 96 +++++- tsc/internal/checker/types.go | 2 + tsc/internal/checker/types_test.go | 11 +- tsc/internal/checker/utilities.go | 227 ++++++++++++- ...nObjectLiteral_Js(alwaysstrict=true).types | 4 +- ...OrderSpreadCycle(checkorder=default).types | 8 +- ...rderSpreadCycle(checkorder=isolated).types | 8 +- ...OrderSpreadCycle(checkorder=reverse).types | 8 +- ...erSpreadCycle(checkorder=typesfirst).types | 8 +- ...ameterUnionOrder(checkorder=default).types | 4 +- ...terUnionOrder(checkorder=typesfirst).types | 4 +- ...sUnionOrder(checkorder=default).errors.txt | 22 -- ...sFlagsUnionOrder(checkorder=default).types | 4 +- ...inferenceDeeplyNestedCheckOrder.errors.txt | 4 +- .../inferenceDeeplyNestedCheckOrder.types | 2 +- ...onOfTypeParameterAndPromiseLike.errors.txt | 17 - ...omUnionOfTypeParameterAndPromiseLike.types | 2 +- ...eThroughSortOfFlattenedIterable.errors.txt | 26 -- ...erenceThroughSortOfFlattenedIterable.types | 10 +- ...ithPrototypeNoErrorTruncationNoCrash.types | 8 +- ...paceMembersResolutionOrderExportStar.types | 6 +- ...icArrayAssignabilityAfterErrors.errors.txt | 12 +- .../compiler/nestedSpreadsAndWidening.types | 10 +- ...akyDeclarationEmitSharedCheckerOrder.types | 6 +- ...sticsNamespaceMembersResolutionOrder.types | 6 +- ...embersResolutionOrderReexportedTypes.types | 6 +- ...icitAnyUnionNormalizedObjectLiteral1.types | 4 +- .../objectInstantiationFromUnionSpread.types | 36 +- ...WidenedCopyOrder(checkorder=default).types | 2 +- ...ntiationOrder(checkorder=typesfirst).types | 14 +- .../compiler/recursiveConditionalTypes.types | 4 +- .../relationDeeplyNestedCheckOrder.errors.txt | 32 ++ ...eckOrder(checkorder=typesfirst).errors.txt | 9 +- .../compiler/spreadUnionPropOverride.types | 8 +- ...yCheckOrder(checkorder=default).errors.txt | 21 +- .../varianceCycleCapnwebRpcStub.errors.txt | 165 --------- .../varianceCycleCapnwebRpcStub.types | 32 +- .../reference/conformance/spreadUnion.types | 2 +- ...indingElementPropertyName05.baseline.jsonc | 2 +- ...e-with-multiple-files-and-complex-types.js | 3 +- 42 files changed, 791 insertions(+), 388 deletions(-) delete mode 100644 tsc/testdata/baselines/reference/compiler/indexedAccessAccessFlagsUnionOrder(checkorder=default).errors.txt delete mode 100644 tsc/testdata/baselines/reference/compiler/inferenceFromUnionOfTypeParameterAndPromiseLike.errors.txt delete mode 100644 tsc/testdata/baselines/reference/compiler/inferenceThroughSortOfFlattenedIterable.errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/relationDeeplyNestedCheckOrder.errors.txt delete mode 100644 tsc/testdata/baselines/reference/compiler/varianceCycleCapnwebRpcStub.errors.txt diff --git a/tsc/internal/checker/checker.go b/tsc/internal/checker/checker.go index bd6cbf6290bc9..b93f38a8ed21b 100644 --- a/tsc/internal/checker/checker.go +++ b/tsc/internal/checker/checker.go @@ -677,8 +677,16 @@ type Checker struct { 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 + objectLiteralTypes map[CacheHashKey]*Type + spreadTypes map[CacheHashKey]*Type + objectContentTypes map[CacheHashKey]*Type + spreadSymbols map[spreadSymbolKey]*ast.Symbol + symbolsWithType map[symbolWithTypeKey]*ast.Symbol + paddedProperties map[symbolWithTypeKey]*ast.Symbol + bindingPatternTypes map[CacheHashKey]*Type unionOfUnionTypes map[UnionOfUnionKey]*Type intersectionTypes map[CacheHashKey]*Type + intersectionContentTypes map[CacheHashKey]*Type propertiesTypes map[PropertiesTypesKey]*Type diagnostics ast.DiagnosticsCollection suggestionDiagnostics ast.DiagnosticsCollection @@ -1015,8 +1023,16 @@ func NewChecker(program Program, tracer *Tracer) (*Checker, *sync.Mutex) { c.resolveNameForSymbolSuggestion = c.createNameResolverForSuggestion().Resolve c.tupleTypes = make(map[CacheHashKey]*Type) c.unionTypes = make(map[CacheHashKey]*Type) + c.objectLiteralTypes = make(map[CacheHashKey]*Type) + c.spreadTypes = make(map[CacheHashKey]*Type) + c.objectContentTypes = make(map[CacheHashKey]*Type) + c.spreadSymbols = make(map[spreadSymbolKey]*ast.Symbol) + c.symbolsWithType = make(map[symbolWithTypeKey]*ast.Symbol) + c.paddedProperties = make(map[symbolWithTypeKey]*ast.Symbol) + c.bindingPatternTypes = make(map[CacheHashKey]*Type) c.unionOfUnionTypes = make(map[UnionOfUnionKey]*Type) c.intersectionTypes = make(map[CacheHashKey]*Type) + c.intersectionContentTypes = make(map[CacheHashKey]*Type) c.propertiesTypes = make(map[PropertiesTypesKey]*Type) c.patternForType = make(map[*Type]*ast.Node) c.contextFreeTypes = make(map[*ast.Node]*Type) @@ -13606,17 +13622,23 @@ 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 } + key := c.getObjectLiteralTypeKey(node, flags, propertiesTable, indexInfos) + if existing := c.objectLiteralTypes[key]; existing != nil { + return existing + } + result := c.newAnonymousType(node.Symbol(), propertiesTable, nil, nil, indexInfos) + result.objectFlags |= flags if inDestructuringPattern { c.patternForType[result] = node } + c.objectLiteralTypes[key] = result return result } for _, memberDecl := range node.Properties() { @@ -13850,6 +13872,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[key]; existing != nil { + return existing + } members := ast.NewSymbolTable() var skippedPrivateMembers collections.Set[string] var indexInfos []*IndexInfo @@ -13874,6 +13915,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[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()) @@ -13894,6 +13940,7 @@ func (c *Checker) getSpreadType(left *Type, right *Type, symbol *ast.Symbol, obj c.spreadLinks.Get(result).rightSpread = rightProp result.SetDeclarations(declarations) links.setNameType(c, c.valueSymbolLinks.Get(leftProp).getNameType()) + c.spreadSymbols[key] = result members.Set(leftProp.Name(), result) } } else { @@ -13903,8 +13950,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[contentKey]; existing != nil { + c.spreadTypes[key] = existing + return existing + } spread := c.newAnonymousType(symbol, members, nil, nil, spreadIndexInfos) - spread.objectFlags |= ObjectFlagsObjectLiteral | ObjectFlagsContainsObjectOrArrayLiteral | ObjectFlagsContainsSpread | objectFlags + spread.objectFlags |= flags + c.objectContentTypes[contentKey] = spread + c.spreadTypes[key] = spread return spread } @@ -14001,6 +14058,10 @@ 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[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) @@ -14012,9 +14073,59 @@ func (c *Checker) getSpreadSymbol(prop *ast.Symbol, readonly bool) *ast.Symbol { result.SetDeclarations(prop.Declarations()) links.setNameType(c, c.valueSymbolLinks.Get(prop).getNameType()) c.mappedSymbolLinks.Get(result).syntheticOrigin = prop + c.spreadSymbols[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 } @@ -17476,13 +17587,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[key] + if symbol == nil { + symbol = c.newSymbol(ast.SymbolFlagsProperty|ast.SymbolFlagsOptional, name) + c.valueSymbolLinks.Get(symbol).resolvedType = propType + c.paddedProperties[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 { @@ -18160,6 +18281,54 @@ func (b *keyBuilder) writeNode(node *ast.Node) { } } +// getObjectLiteralTypeKey identifies the content of an object literal type, so +// that checking the same object literal again with the same results yields the +// same type. +func (c *Checker) getObjectLiteralTypeKey(node *ast.Node, flags ObjectFlags, properties ast.SymbolTable, indexInfos []*IndexInfo) CacheHashKey { + var b keyBuilder + b.writeNode(node) + b.writeUint32(uint32(flags)) + names := slices.Sorted(properties.Keys()) + b.writeInt(len(names)) + for _, name := range names { + prop := properties.Get(name) + b.writeString(name) + b.writeByte(0) + b.writeUint32(uint32(prop.Flags())) + b.writeUint32(uint32(prop.CheckFlags())) + // Members created by this object literal have their types set at + // creation; other members (accessors) are the declared symbols. + links := c.valueSymbolLinks.TryGet(prop) + if links == nil || links.target == nil { + b.writeByte(2) + b.writeSymbol(prop) + continue + } + if nameType := links.getNameType(); nameType != nil { + b.writeByte(1) + b.writeType(nameType) + } else { + b.writeByte(0) + } + b.writeType(links.resolvedType) + } + 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) + } + b.writeInt(len(info.components)) + for _, n := range info.components { + b.writeNode(n) + } + } + return b.hash() +} + func getTypeListKey(types []*Type) CacheHashKey { var b keyBuilder b.writeTypes(types) @@ -18497,9 +18666,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 @@ -18611,12 +18783,35 @@ func (c *Checker) getTypeFromObjectBindingPattern(pattern *ast.Node, includePatt 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)) + names := slices.Sorted(members.Keys()) + for _, name := range names { + b.writeString(name) + b.writeByte(0) + b.writeUint32(uint32(members.Get(name).Flags())) + b.writeType(c.valueSymbolLinks.Get(members.Get(name)).resolvedType) + } + key := b.hash() + if existing := c.bindingPatternTypes[key]; existing != nil { + return existing + } result := c.newAnonymousType(nil, members, nil, nil, indexInfos) result.objectFlags |= objectFlags if includePatternInType { c.patternForType[result] = pattern result.objectFlags |= ObjectFlagsContainsObjectOrArrayLiteral } + c.bindingPatternTypes[key] = result return result } @@ -18660,9 +18855,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[key]; existing != nil { + return existing + } result = c.cloneTypeReference(result) c.patternForType[result] = pattern result.objectFlags |= ObjectFlagsContainsObjectOrArrayLiteral + c.bindingPatternTypes[key] = result } return result } @@ -19085,11 +19288,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 { @@ -19115,7 +19323,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 { @@ -22569,6 +22777,36 @@ 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[key]; existing != nil { + return existing + } + result := c.createSymbolWithType(source, t) + c.symbolsWithType[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[key]; existing != nil { + return existing + } + result := create() + c.objectContentTypes[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()) @@ -25491,6 +25729,7 @@ func (c *Checker) getRestrictiveTypeParameter(t *Type) *Type { } result := c.newTypeParameter(t.symbol) result.AsTypeParameter().constraint = c.noConstraintType + result.AsTypeParameter().origin = t c.cachedTypes[key] = result return result } @@ -25785,6 +26024,9 @@ func (c *Checker) createTupleTargetType(elementInfos []TupleElementInfo, readonl d.thisType = c.newTypeParameter(nil) d.thisType.AsTypeParameter().isThisType = true d.thisType.AsTypeParameter().constraint = 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 @@ -27211,19 +27453,36 @@ 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 } 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[key]; existing != nil { + return existing + } + result := c.newIntersectionType(objectFlags, typeSet) + result.alias = alias + c.intersectionContentTypes[key] = result + return result +} + func isUnionWithUndefined(t *Type) bool { return t.flags&TypeFlagsUnion != 0 && t.Types()[0].flags&TypeFlagsUndefined != 0 } @@ -29199,9 +29458,18 @@ func (c *Checker) getRegularTypeOfObjectLiteral(t *Type) *Type { } 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 + 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[key] = regular return regular } @@ -29212,7 +29480,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) } 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..969284a6fd796 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" @@ -776,18 +777,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 { + // 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,6 +798,89 @@ func (c *Checker) isDeeplyNestedType(t *Type, stack []*Type, maxDepth int) bool return false } +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) + } 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; 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 +} + func hasMatchingRecursionIdentity(t *Type, identity RecursionId) bool { target := getRecursionIdentityTarget(t) if target.flags&TypeFlagsIntersection != 0 { diff --git a/tsc/internal/checker/types.go b/tsc/internal/checker/types.go index 6eb2dd8a5b3c5..3a387f3cf33d5 100644 --- a/tsc/internal/checker/types.go +++ b/tsc/internal/checker/types.go @@ -790,6 +790,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 @@ -1505,6 +1506,7 @@ type TypeParameter struct { isDistributed bool resolvedDefaultType *Type distributedType *Type + 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 } diff --git a/tsc/internal/checker/types_test.go b/tsc/internal/checker/types_test.go index d19d10419bcd8..6e0f19446fe00 100644 --- a/tsc/internal/checker/types_test.go +++ b/tsc/internal/checker/types_test.go @@ -177,11 +177,12 @@ func BenchmarkTypeListKey(b *testing.B) { 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), + strictNullChecks: true, + unionTypes: make(map[CacheHashKey]*Type), + unionOfUnionTypes: make(map[UnionOfUnionKey]*Type), + intersectionTypes: make(map[CacheHashKey]*Type), + intersectionContentTypes: make(map[CacheHashKey]*Type), + subtypeReductionCache: make(map[CacheHashKey][]*Type), } c.compareSymbols = c.compareSymbolsWorker c.neverType = c.newIntrinsicType(TypeFlagsNever, "never") diff --git a/tsc/internal/checker/utilities.go b/tsc/internal/checker/utilities.go index c4cc97fa29a1b..bdc55ba66c932 100644 --- a/tsc/internal/checker/utilities.go +++ b/tsc/internal/checker/utilities.go @@ -372,6 +372,15 @@ func (c *Checker) compareSymbolsWorker(s1, s2 *ast.Symbol) int { if s2 == nil { return -1 } + if r := c.compareSymbolDeclarationsAndNames(s1, s2); 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 +390,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 { @@ -488,6 +492,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 +538,28 @@ func CompareTypes(t1, t2 *Type) int { if c := compareTypeMappers(m1, m2); c != 0 { return c } + if hasObjectLiteralMembers(t1) && hasObjectLiteralMembers(t2) { + if c := compareObjectMembers(t1, t2, true /*withTypes*/); c != 0 { + return c + } + // Fresh, regular, and widened copies of the same literal differ only in + // the flags set when they were created. + if c := int(t1.objectFlags&objectLiteralCreationFlags) - int(t2.objectFlags&objectLiteralCreationFlags); c != 0 { + return c + } + } else if t1.objectFlags&t2.objectFlags&ObjectFlagsObjectRestType != 0 { + // Rest types share the symbol of their declaration, so a rest from a union + // yields one type per constituent, distinguished by the members they keep. + // Instantiations of rest types, whose members may not be resolved yet, are + // ordered by the rest types they instantiate, which are created resolved. + if d1, d2 := t1.AsObjectType().target, t2.AsObjectType().target; d1 != nil && d2 != nil { + if c := CompareTypes(d1, d2); c != 0 { + return c + } + } else if c := compareObjectMembers(t1, t2, false /*withTypes*/); c != 0 { + return c + } + } } case t1.flags&TypeFlagsUnion != 0: // Unions are ordered by origin and then constituent type lists. @@ -580,6 +615,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 +632,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 +661,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[t1] + p2 := t2.checker.patternForType[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 +746,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 +771,154 @@ func compareElementLabels(n1, n2 *ast.Node) int { return strings.Compare(n1.Name().Text(), n2.Name().Text()) } +// Object literal types, and types derived from them, are given their members +// at creation rather than resolving them from their symbol. +const objectLiteralCreationFlags = ObjectFlagsObjectLiteral | ObjectFlagsFreshLiteral | ObjectFlagsJSLiteral | ObjectFlagsArrayLiteral | + ObjectFlagsContainsSpread | ObjectFlagsObjectLiteralPatternWithComputedProperties | ObjectFlagsNonInferrableType | + ObjectFlagsContainsWideningType | ObjectFlagsContainsObjectOrArrayLiteral + +func hasObjectLiteralMembers(t *Type) bool { + d := t.AsObjectType() + if d.target != nil || d.mapper != nil { + return false + } + if t.symbol == nil { + // Types implied by binding patterns have no symbol. + return t.objectFlags&ObjectFlagsObjectLiteral != 0 + } + return t.symbol.Flags()&ast.SymbolFlagsObjectLiteral != 0 +} + +// compareObjectMembers orders resolved object types by what their members +// declare, and with withTypes, by the types of members of object literal +// types, which are set when the members are created. Members are created per +// type, so they are compared by what they declare rather than by identity, +// pairwise since getNamedMembers sorts the properties. +func compareObjectMembers(t1, t2 *Type, withTypes bool) int { + c := t1.checker + p1 := t1.AsStructuredType().properties + p2 := t2.AsStructuredType().properties + if n := len(p1) - len(p2); n != 0 { + return n + } + for i, s1 := range p1 { + s2 := p2[i] + if r := c.compareSymbolDeclarationsAndNames(s1, s2); r != 0 { + return r + } + if r := int(s1.Flags()&ast.SymbolFlagsOptional) - int(s2.Flags()&ast.SymbolFlagsOptional); r != 0 { + return r + } + if withTypes { + if r := CompareTypes(c.peekTypeOfObjectLiteralMember(s1), c.peekTypeOfObjectLiteralMember(s2)); r != 0 { + return r + } + } + } + return 0 +} + +// The type of a member of an object literal type is set when the member is +// created. +func (c *Checker) peekTypeOfObjectLiteralMember(s *ast.Symbol) *Type { + if links := c.valueSymbolLinks.TryGet(s); links != nil { + return links.resolvedType + } + 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, p2.constraint) + } + 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/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/checkOrderSpreadCycle(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=default).types index 901461cf3d36b..216ad9304dfd7 100644 --- a/tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=default).types +++ b/tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=default).types @@ -57,12 +57,12 @@ const M = /** @type {any} */ (null); >(null) : any module.exports = { v: { ...M } }; ->module.exports = { v: { ...M } } : { v: { pa: { pb: {}; mb: 1; }; ma: 1; }; } +>module.exports = { v: { ...M } } : { v: {}; } >module.exports : { v: {}; } >module : { exports: { v: {}; }; } >exports : { v: {}; } ->{ v: { ...M } } : { v: { pa: { pb: {}; mb: 1; }; ma: 1; }; } ->v : { pa: { pb: {}; mb: 1; }; ma: 1; } ->{ ...M } : { pa: { pb: {}; mb: 1; }; ma: 1; } +>{ v: { ...M } } : { v: {}; } +>v : {} +>{ ...M } : {} >M : typeof import("./ma") diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=isolated).types b/tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=isolated).types index 901461cf3d36b..216ad9304dfd7 100644 --- a/tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=isolated).types +++ b/tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=isolated).types @@ -57,12 +57,12 @@ const M = /** @type {any} */ (null); >(null) : any module.exports = { v: { ...M } }; ->module.exports = { v: { ...M } } : { v: { pa: { pb: {}; mb: 1; }; ma: 1; }; } +>module.exports = { v: { ...M } } : { v: {}; } >module.exports : { v: {}; } >module : { exports: { v: {}; }; } >exports : { v: {}; } ->{ v: { ...M } } : { v: { pa: { pb: {}; mb: 1; }; ma: 1; }; } ->v : { pa: { pb: {}; mb: 1; }; ma: 1; } ->{ ...M } : { pa: { pb: {}; mb: 1; }; ma: 1; } +>{ v: { ...M } } : { v: {}; } +>v : {} +>{ ...M } : {} >M : typeof import("./ma") diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=reverse).types b/tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=reverse).types index 901461cf3d36b..216ad9304dfd7 100644 --- a/tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=reverse).types +++ b/tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=reverse).types @@ -57,12 +57,12 @@ const M = /** @type {any} */ (null); >(null) : any module.exports = { v: { ...M } }; ->module.exports = { v: { ...M } } : { v: { pa: { pb: {}; mb: 1; }; ma: 1; }; } +>module.exports = { v: { ...M } } : { v: {}; } >module.exports : { v: {}; } >module : { exports: { v: {}; }; } >exports : { v: {}; } ->{ v: { ...M } } : { v: { pa: { pb: {}; mb: 1; }; ma: 1; }; } ->v : { pa: { pb: {}; mb: 1; }; ma: 1; } ->{ ...M } : { pa: { pb: {}; mb: 1; }; ma: 1; } +>{ v: { ...M } } : { v: {}; } +>v : {} +>{ ...M } : {} >M : typeof import("./ma") diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=typesfirst).types index 901461cf3d36b..216ad9304dfd7 100644 --- a/tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=typesfirst).types +++ b/tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=typesfirst).types @@ -57,12 +57,12 @@ const M = /** @type {any} */ (null); >(null) : any module.exports = { v: { ...M } }; ->module.exports = { v: { ...M } } : { v: { pa: { pb: {}; mb: 1; }; ma: 1; }; } +>module.exports = { v: { ...M } } : { v: {}; } >module.exports : { v: {}; } >module : { exports: { v: {}; }; } >exports : { v: {}; } ->{ v: { ...M } } : { v: { pa: { pb: {}; mb: 1; }; ma: 1; }; } ->v : { pa: { pb: {}; mb: 1; }; ma: 1; } ->{ ...M } : { pa: { pb: {}; mb: 1; }; ma: 1; } +>{ v: { ...M } } : { v: {}; } +>v : {} +>{ ...M } : {} >M : typeof import("./ma") diff --git a/tsc/testdata/baselines/reference/compiler/clonedTypeParameterUnionOrder(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/clonedTypeParameterUnionOrder(checkorder=default).types index 487cdba50bc87..8b93c5f3f8987 100644 --- a/tsc/testdata/baselines/reference/compiler/clonedTypeParameterUnionOrder(checkorder=default).types +++ b/tsc/testdata/baselines/reference/compiler/clonedTypeParameterUnionOrder(checkorder=default).types @@ -34,8 +34,8 @@ 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) +>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 diff --git a/tsc/testdata/baselines/reference/compiler/clonedTypeParameterUnionOrder(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/clonedTypeParameterUnionOrder(checkorder=typesfirst).types index 487cdba50bc87..8b93c5f3f8987 100644 --- a/tsc/testdata/baselines/reference/compiler/clonedTypeParameterUnionOrder(checkorder=typesfirst).types +++ b/tsc/testdata/baselines/reference/compiler/clonedTypeParameterUnionOrder(checkorder=typesfirst).types @@ -34,8 +34,8 @@ 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) +>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 diff --git a/tsc/testdata/baselines/reference/compiler/indexedAccessAccessFlagsUnionOrder(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/indexedAccessAccessFlagsUnionOrder(checkorder=default).errors.txt deleted file mode 100644 index b1e49290327ec..0000000000000 --- a/tsc/testdata/baselines/reference/compiler/indexedAccessAccessFlagsUnionOrder(checkorder=default).errors.txt +++ /dev/null @@ -1,22 +0,0 @@ -indexedAccessAccessFlagsUnionOrder.ts(3,11): error TS2322: Type 'string | undefined' is not assignable to type 'string'. - Type 'undefined' is not assignable to type 'string'. -indexedAccessAccessFlagsUnionOrder.ts(5,11): error TS2322: Type 'string | undefined' is not assignable to type 'string'. - Type 'undefined' is not assignable to type 'string'. - - -==== indexedAccessAccessFlagsUnionOrder.ts (2 errors) ==== - function f, K extends keyof T>(obj: T, k: K, b: boolean) { - const x = b ? obj[k] : g(); - const s1: string = x; - ~~ -!!! error TS2322: Type 'string | undefined' is not assignable to type 'string'. -!!! error TS2322: Type 'undefined' is not assignable to type 'string'. - const y = b ? g() : obj[k]; - const s2: string = y; - ~~ -!!! error TS2322: Type 'string | undefined' is not assignable to type 'string'. -!!! error TS2322: Type 'undefined' is not assignable to type 'string'. - } - - declare function g(): T[K]; - \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/indexedAccessAccessFlagsUnionOrder(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/indexedAccessAccessFlagsUnionOrder(checkorder=default).types index 5f8f696fbf930..3842ea2cb6352 100644 --- a/tsc/testdata/baselines/reference/compiler/indexedAccessAccessFlagsUnionOrder(checkorder=default).types +++ b/tsc/testdata/baselines/reference/compiler/indexedAccessAccessFlagsUnionOrder(checkorder=default).types @@ -19,7 +19,7 @@ function f, K extends keyof T>(obj: T, k: K, b: const s1: string = x; >s1 : string ->x : string | undefined +>x : T[K] const y = b ? g() : obj[k]; >y : T[K] @@ -33,7 +33,7 @@ function f, K extends keyof T>(obj: T, k: K, b: const s2: string = y; >s2 : string ->y : string | undefined +>y : T[K] } declare function g(): T[K]; diff --git a/tsc/testdata/baselines/reference/compiler/inferenceDeeplyNestedCheckOrder.errors.txt b/tsc/testdata/baselines/reference/compiler/inferenceDeeplyNestedCheckOrder.errors.txt index 32e5d2c00be81..b98c3dd4a3075 100644 --- a/tsc/testdata/baselines/reference/compiler/inferenceDeeplyNestedCheckOrder.errors.txt +++ b/tsc/testdata/baselines/reference/compiler/inferenceDeeplyNestedCheckOrder.errors.txt @@ -1,4 +1,4 @@ -first.ts(3,7): error TS2322: Type 'unknown[]' is not assignable to type 'null'. +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'. @@ -7,7 +7,7 @@ second.ts(6,7): error TS2322: Type 'number[]' is not assignable to type 'null'. declare const lists1: string[][]; const flat1: null = flatten1(lists1); ~~~~~ -!!! error TS2322: Type 'unknown[]' is not assignable to type 'null'. +!!! error TS2322: Type 'string[]' is not assignable to type 'null'. declare const items1: string[]; for (const item of items1) {} diff --git a/tsc/testdata/baselines/reference/compiler/inferenceDeeplyNestedCheckOrder.types b/tsc/testdata/baselines/reference/compiler/inferenceDeeplyNestedCheckOrder.types index c1fc223370a61..a4b3f46e454aa 100644 --- a/tsc/testdata/baselines/reference/compiler/inferenceDeeplyNestedCheckOrder.types +++ b/tsc/testdata/baselines/reference/compiler/inferenceDeeplyNestedCheckOrder.types @@ -10,7 +10,7 @@ declare const lists1: string[][]; const flat1: null = flatten1(lists1); >flat1 : null ->flatten1(lists1) : unknown[] +>flatten1(lists1) : string[] >flatten1 : (iterable: Iterable>) => T[] >lists1 : string[][] diff --git a/tsc/testdata/baselines/reference/compiler/inferenceFromUnionOfTypeParameterAndPromiseLike.errors.txt b/tsc/testdata/baselines/reference/compiler/inferenceFromUnionOfTypeParameterAndPromiseLike.errors.txt deleted file mode 100644 index 1810c3d299596..0000000000000 --- a/tsc/testdata/baselines/reference/compiler/inferenceFromUnionOfTypeParameterAndPromiseLike.errors.txt +++ /dev/null @@ -1,17 +0,0 @@ -inferenceFromUnionOfTypeParameterAndPromiseLike.ts(6,7): error TS2322: Type 'Promise>>' is not assignable to type 'Promise>'. - Type 'Map>' is not assignable to type 'Map'. - Type 'Promise' is not assignable to type 'string'. - - -==== inferenceFromUnionOfTypeParameterAndPromiseLike.ts (1 errors) ==== - // Inferring from Promise to PromiseLike | V must infer V as string, - // whichever order the union's members are in. - - declare function props(x: PromiseLike | V>>): Promise>; - declare const input: Promise>>; - const out: Promise> = props(input); - ~~~ -!!! error TS2322: Type 'Promise>>' is not assignable to type 'Promise>'. -!!! error TS2322: Type 'Map>' is not assignable to type 'Map'. -!!! error TS2322: Type 'Promise' is not assignable to type 'string'. - \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/inferenceFromUnionOfTypeParameterAndPromiseLike.types b/tsc/testdata/baselines/reference/compiler/inferenceFromUnionOfTypeParameterAndPromiseLike.types index c3d2ece0232d6..9c53d108ea674 100644 --- a/tsc/testdata/baselines/reference/compiler/inferenceFromUnionOfTypeParameterAndPromiseLike.types +++ b/tsc/testdata/baselines/reference/compiler/inferenceFromUnionOfTypeParameterAndPromiseLike.types @@ -13,7 +13,7 @@ declare const input: Promise>>; const out: Promise> = props(input); >out : Promise> ->props(input) : Promise>> +>props(input) : Promise> >props : (x: PromiseLike | V>>) => Promise> >input : Promise>> diff --git a/tsc/testdata/baselines/reference/compiler/inferenceThroughSortOfFlattenedIterable.errors.txt b/tsc/testdata/baselines/reference/compiler/inferenceThroughSortOfFlattenedIterable.errors.txt deleted file mode 100644 index a34bbb1f6960b..0000000000000 --- a/tsc/testdata/baselines/reference/compiler/inferenceThroughSortOfFlattenedIterable.errors.txt +++ /dev/null @@ -1,26 +0,0 @@ -inferenceThroughSortOfFlattenedIterable.ts(10,2): error TS2322: Type 'unknown[]' is not assignable to type 'readonly string[]'. - Type 'unknown' is not assignable to type 'string'. - - -==== inferenceThroughSortOfFlattenedIterable.ts (1 errors) ==== - // Sorting the array made from a flattened iterable must keep its element type. - - function getAllValuesUnsorted(m: ReadonlyArray>): ReadonlyArray { - // OK - return Array.from(flatten(m.values())) - } - - function getAllValuesSorted(m: ReadonlyArray>): ReadonlyArray { - // Type 'unknown[]' is not assignable to type 'readonly string[]'. - return Array.from(flatten(m.values())).sort() - ~~~~~~ -!!! error TS2322: Type 'unknown[]' is not assignable to type 'readonly string[]'. -!!! error TS2322: Type 'unknown' is not assignable to type 'string'. - } - - function* flatten(a: Iterable>): Iterable { - for (const xs of a) - for (const x of xs) - yield x - } - \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/inferenceThroughSortOfFlattenedIterable.types b/tsc/testdata/baselines/reference/compiler/inferenceThroughSortOfFlattenedIterable.types index fa14743403d39..aaccfb8fcc5f4 100644 --- a/tsc/testdata/baselines/reference/compiler/inferenceThroughSortOfFlattenedIterable.types +++ b/tsc/testdata/baselines/reference/compiler/inferenceThroughSortOfFlattenedIterable.types @@ -27,19 +27,19 @@ function getAllValuesSorted(m: ReadonlyArray>): ReadonlyAr // Type 'unknown[]' is not assignable to type 'readonly string[]'. return Array.from(flatten(m.values())).sort() ->Array.from(flatten(m.values())).sort() : unknown[] ->Array.from(flatten(m.values())).sort : (compareFn?: ((a: unknown, b: unknown) => number) | undefined) => unknown[] ->Array.from(flatten(m.values())) : unknown[] +>Array.from(flatten(m.values())).sort() : string[] +>Array.from(flatten(m.values())).sort : (compareFn?: ((a: string, b: string) => number) | undefined) => string[] +>Array.from(flatten(m.values())) : string[] >Array.from : { (arrayLike: ArrayLike): T[]; (arrayLike: ArrayLike, mapfn: (v: T, k: number) => U, thisArg?: any): U[]; (iterable: Iterable | ArrayLike): T[]; (iterable: Iterable | ArrayLike, mapfn: (v: T, k: number) => U, thisArg?: any): U[]; } >Array : ArrayConstructor >from : { (arrayLike: ArrayLike): T[]; (arrayLike: ArrayLike, mapfn: (v: T, k: number) => U, thisArg?: any): U[]; (iterable: Iterable | ArrayLike): T[]; (iterable: Iterable | ArrayLike, mapfn: (v: T, k: number) => U, thisArg?: any): U[]; } ->flatten(m.values()) : Iterable +>flatten(m.values()) : Iterable >flatten : (a: Iterable>) => Iterable >m.values() : ArrayIterator >m.values : () => ArrayIterator >m : readonly (readonly string[])[] >values : () => ArrayIterator ->sort : (compareFn?: ((a: unknown, b: unknown) => number) | undefined) => unknown[] +>sort : (compareFn?: ((a: string, b: string) => number) | undefined) => string[] } function* flatten(a: Iterable>): Iterable { 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/namespaceMembersResolutionOrderExportStar.types b/tsc/testdata/baselines/reference/compiler/namespaceMembersResolutionOrderExportStar.types index 179ce8b0ee07e..0153880cec8d7 100644 --- a/tsc/testdata/baselines/reference/compiler/namespaceMembersResolutionOrderExportStar.types +++ b/tsc/testdata/baselines/reference/compiler/namespaceMembersResolutionOrderExportStar.types @@ -69,9 +69,9 @@ const M = /** @type {any} */ (null); 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; } +>{ v: { ...M } } : { v: {}; } +>v : {} +>{ ...M } : {} >M : typeof import("./mb") module.exports = o; diff --git a/tsc/testdata/baselines/reference/compiler/nestedGenericArrayAssignabilityAfterErrors.errors.txt b/tsc/testdata/baselines/reference/compiler/nestedGenericArrayAssignabilityAfterErrors.errors.txt index c5f982be59dda..92c6dfe7ad198 100644 --- a/tsc/testdata/baselines/reference/compiler/nestedGenericArrayAssignabilityAfterErrors.errors.txt +++ b/tsc/testdata/baselines/reference/compiler/nestedGenericArrayAssignabilityAfterErrors.errors.txt @@ -1,8 +1,12 @@ nestedGenericArrayAssignabilityAfterErrors.ts(14,27): error TS2322: Type 'boolean' is not assignable to type 'number'. nestedGenericArrayAssignabilityAfterErrors.ts(17,17): error TS2322: Type 'boolean' is not assignable to type 'number'. +nestedGenericArrayAssignabilityAfterErrors.ts(23,5): error TS2322: Type 'DataTypeThree' is not assignable to type 'DataTypeThree'. + Type 'number' is not assignable to type 'boolean'. +nestedGenericArrayAssignabilityAfterErrors.ts(28,5): error TS2322: Type 'DataTypeTwo' is not assignable to type 'DataTypeTwo'. + Type 'number' is not assignable to type 'boolean'. -==== nestedGenericArrayAssignabilityAfterErrors.ts (2 errors) ==== +==== nestedGenericArrayAssignabilityAfterErrors.ts (4 errors) ==== // Assigning DataTypeThree to DataTypeThree, and likewise for // DataTypeTwo, must be reported whether or not earlier assignments errored. @@ -30,9 +34,15 @@ nestedGenericArrayAssignabilityAfterErrors.ts(17,17): error TS2322: Type 'boolea one: [{ two: [{ three: [5] }] }] }; let t3a: DataTypeThree = testingThree; + ~~~ +!!! error TS2322: Type 'DataTypeThree' is not assignable to type 'DataTypeThree'. +!!! error TS2322: Type 'number' is not assignable to type 'boolean'. let testingTwo: DataTypeTwo = { one: [{ two: [5] }] }; let t2a: DataTypeTwo = testingTwo; + ~~~ +!!! error TS2322: Type 'DataTypeTwo' is not assignable to type 'DataTypeTwo'. +!!! error TS2322: Type 'number' is not assignable to type 'boolean'. \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/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/noFlakyDeclarationEmitSharedCheckerOrder.types b/tsc/testdata/baselines/reference/compiler/noFlakyDeclarationEmitSharedCheckerOrder.types index cde44436bf6e0..07b1f23ab8990 100644 --- a/tsc/testdata/baselines/reference/compiler/noFlakyDeclarationEmitSharedCheckerOrder.types +++ b/tsc/testdata/baselines/reference/compiler/noFlakyDeclarationEmitSharedCheckerOrder.types @@ -26,9 +26,9 @@ const M = /** @type {any} */ (null); 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; } +>{ v: { ...M } } : { v: {}; } +>v : {} +>{ ...M } : {} >M : typeof import("./mb") module.exports = o; diff --git a/tsc/testdata/baselines/reference/compiler/noFlakyDiagnosticsNamespaceMembersResolutionOrder.types b/tsc/testdata/baselines/reference/compiler/noFlakyDiagnosticsNamespaceMembersResolutionOrder.types index 7813095f076be..753e075741287 100644 --- a/tsc/testdata/baselines/reference/compiler/noFlakyDiagnosticsNamespaceMembersResolutionOrder.types +++ b/tsc/testdata/baselines/reference/compiler/noFlakyDiagnosticsNamespaceMembersResolutionOrder.types @@ -89,9 +89,9 @@ const M = /** @type {any} */ (null); 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; } +>{ v: { ...M } } : { v: {}; } +>v : {} +>{ ...M } : {} >M : typeof import("./ma") module.exports = o; diff --git a/tsc/testdata/baselines/reference/compiler/noFlakyDiagnosticsNamespaceMembersResolutionOrderReexportedTypes.types b/tsc/testdata/baselines/reference/compiler/noFlakyDiagnosticsNamespaceMembersResolutionOrderReexportedTypes.types index acecbd2516c82..53a815348e451 100644 --- a/tsc/testdata/baselines/reference/compiler/noFlakyDiagnosticsNamespaceMembersResolutionOrderReexportedTypes.types +++ b/tsc/testdata/baselines/reference/compiler/noFlakyDiagnosticsNamespaceMembersResolutionOrderReexportedTypes.types @@ -89,9 +89,9 @@ const M = /** @type {any} */ (null); 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; } +>{ v: { ...M } } : { v: {}; } +>v : {} +>{ ...M } : {} >M : typeof import("./ma") module.exports = 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).types b/tsc/testdata/baselines/reference/compiler/objectLiteralRegularAndWidenedCopyOrder(checkorder=default).types index 407435a6f1e42..c357eab575d5b 100644 --- a/tsc/testdata/baselines/reference/compiler/objectLiteralRegularAndWidenedCopyOrder(checkorder=default).types +++ b/tsc/testdata/baselines/reference/compiler/objectLiteralRegularAndWidenedCopyOrder(checkorder=default).types @@ -30,7 +30,7 @@ const y = x; // widened copy of the literal >x : { a: number; } const z = b ? (b ? arr[0] : y) : { c: 1 }; ->z : { a: number; c?: undefined; } | { a?: undefined; c: number; } +>z : { a: number; } | { c: number; } >b ? (b ? arr[0] : y) : { c: 1 } : { a: number; } | { c: number; } >b : boolean >(b ? arr[0] : y) : { a: number; } diff --git a/tsc/testdata/baselines/reference/compiler/objectRestUnionInstantiationOrder(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/objectRestUnionInstantiationOrder(checkorder=typesfirst).types index 858790155480b..b0974642e75b9 100644 --- a/tsc/testdata/baselines/reference/compiler/objectRestUnionInstantiationOrder(checkorder=typesfirst).types +++ b/tsc/testdata/baselines/reference/compiler/objectRestUnionInstantiationOrder(checkorder=typesfirst).types @@ -27,8 +27,8 @@ function f(v: { k: "a"; a: T } | { k: "b"; b: number }) { >undefined : undefined } const o = f({ k: "a", a: "s" }); ->o : { all: { b: number; } | { a: string; }; onlyB: { b: number; } | undefined; } ->f({ k: "a", a: "s" }) : { all: { b: number; } | { a: string; }; onlyB: { b: number; } | undefined; } +>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" @@ -37,14 +37,14 @@ const o = f({ k: "a", a: "s" }); >"s" : "s" const all = o.all; ->all : { b: number; } | { a: string; } ->o.all : { b: number; } | { a: string; } ->o : { all: { b: number; } | { a: string; }; onlyB: { b: number; } | undefined; } ->all : { b: number; } | { a: string; } +>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: { b: number; } | { a: string; }; 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/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/relationDeeplyNestedCheckOrder.errors.txt b/tsc/testdata/baselines/reference/compiler/relationDeeplyNestedCheckOrder.errors.txt new file mode 100644 index 0000000000000..b12e3d7fff298 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/relationDeeplyNestedCheckOrder.errors.txt @@ -0,0 +1,32 @@ +relationDeeplyNestedCheckOrder.ts(13,1): error TS2322: Type 'A<{ a: string; }>' is not assignable to type 'A<{ a: "lit"; }>'. + The types of 'm1.a.m0.m1' are incompatible between these types. + Type 'string' is not assignable to type '"lit"'. +relationDeeplyNestedCheckOrder.ts(14,1): error TS2322: Type 'B<{ a: string; }>' is not assignable to type 'B<{ a: "lit"; }>'. + The types of 'm0.m1.a.m0.m1' are incompatible between these types. + Type 'string' is not assignable to type '"lit"'. + + +==== relationDeeplyNestedCheckOrder.ts (2 errors) ==== + // 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; + ~~ +!!! error TS2322: Type 'A<{ a: string; }>' is not assignable to type 'A<{ a: "lit"; }>'. +!!! error TS2322: The types of 'm1.a.m0.m1' are incompatible between these types. +!!! error TS2322: Type 'string' is not assignable to type '"lit"'. + b2 = b1; + ~~ +!!! error TS2322: Type 'B<{ a: string; }>' is not assignable to type 'B<{ a: "lit"; }>'. +!!! error TS2322: The types of 'm0.m1.a.m0.m1' 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/relationTruncatedCacheCheckOrder(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/relationTruncatedCacheCheckOrder(checkorder=typesfirst).errors.txt index 343f53694e8da..8b543f32384ea 100644 --- a/tsc/testdata/baselines/reference/compiler/relationTruncatedCacheCheckOrder(checkorder=typesfirst).errors.txt +++ b/tsc/testdata/baselines/reference/compiler/relationTruncatedCacheCheckOrder(checkorder=typesfirst).errors.txt @@ -1,12 +1,9 @@ -relationTruncatedCacheCheckOrder.ts(13,1): error TS2322: Type 'S' is not assignable to type 'R'. - The types of 'next.next.leaf' are incompatible between these types. - Type 'number' is not assignable to type '[[string]]'. 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 (2 errors) ==== +==== 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 @@ -20,10 +17,6 @@ relationTruncatedCacheCheckOrder.ts(14,1): error TS2322: Type 'S<[string]>' is n declare let p: S<[string]>, q: R<[string]>; y = x; - ~ -!!! error TS2322: Type 'S' is not assignable to type 'R'. -!!! error TS2322: The types of 'next.next.leaf' are incompatible between these types. -!!! error TS2322: Type 'number' is not assignable to type '[[string]]'. q = p; ~ !!! error TS2322: Type 'S<[string]>' is not assignable to type 'R<[string]>'. 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/typeReferenceRecursionIdentityCheckOrder(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/typeReferenceRecursionIdentityCheckOrder(checkorder=default).errors.txt index 2f05537ca40a0..51fd83b016a0e 100644 --- a/tsc/testdata/baselines/reference/compiler/typeReferenceRecursionIdentityCheckOrder(checkorder=default).errors.txt +++ b/tsc/testdata/baselines/reference/compiler/typeReferenceRecursionIdentityCheckOrder(checkorder=default).errors.txt @@ -7,9 +7,18 @@ typeReferenceRecursionIdentityCheckOrder.ts(11,7): error TS2322: Type 'never[]' Type '(U | A)[]' is not assignable to type 'U[]'. Type 'U | A' is not assignable to type 'U'. 'U' could be instantiated with an arbitrary type which could be unrelated to 'U | A'. +typeReferenceRecursionIdentityCheckOrder.ts(12,7): error TS2322: Type 'never[]' is not assignable to type 'B<0>'. + The types returned by 'slice(...).every' are incompatible between these types. + Type '{ (predicate: (value: never, index: number, array: never[]) => value is S, thisArg?: any): this is S[]; (predicate: (value: never, index: number, array: never[]) => unknown, thisArg?: any): boolean; }' is not assignable to type '(predicate: (value: 0) => value is S) => this is A'. + Type predicate 'this is any[]' is not assignable to 'this is A'. + Type 'any[]' is not assignable to type 'A'. + The types returned by 'flatMap(...)' are incompatible between these types. + Type '(U | A)[]' is not assignable to type 'U[]'. + Type 'U | A' is not assignable to type 'U'. + 'U' could be instantiated with an arbitrary type which could be unrelated to 'U | A'. -==== typeReferenceRecursionIdentityCheckOrder.ts (1 errors) ==== +==== typeReferenceRecursionIdentityCheckOrder.ts (2 errors) ==== // Comparing never[] to B<0> nests comparisons of the members of A and B. // Whether they are cut short as deeply nested must not depend on whether the // annotation of b is resolved before checking a instantiates slice. @@ -32,4 +41,14 @@ typeReferenceRecursionIdentityCheckOrder.ts(11,7): error TS2322: Type 'never[]' !!! error TS2322: Type 'U | A' is not assignable to type 'U'. !!! error TS2322: 'U' could be instantiated with an arbitrary type which could be unrelated to 'U | A'. const b: B<0> = []; + ~ +!!! error TS2322: Type 'never[]' is not assignable to type 'B<0>'. +!!! error TS2322: The types returned by 'slice(...).every' are incompatible between these types. +!!! error TS2322: Type '{ (predicate: (value: never, index: number, array: never[]) => value is S, thisArg?: any): this is S[]; (predicate: (value: never, index: number, array: never[]) => unknown, thisArg?: any): boolean; }' is not assignable to type '(predicate: (value: 0) => value is S) => this is A'. +!!! error TS2322: Type predicate 'this is any[]' is not assignable to 'this is A'. +!!! error TS2322: Type 'any[]' is not assignable to type 'A'. +!!! error TS2322: The types returned by 'flatMap(...)' are incompatible between these types. +!!! error TS2322: Type '(U | A)[]' is not assignable to type 'U[]'. +!!! error TS2322: Type 'U | A' is not assignable to type 'U'. +!!! error TS2322: 'U' could be instantiated with an arbitrary type which could be unrelated to 'U | A'. \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/varianceCycleCapnwebRpcStub.errors.txt b/tsc/testdata/baselines/reference/compiler/varianceCycleCapnwebRpcStub.errors.txt deleted file mode 100644 index b2e530d9aca01..0000000000000 --- a/tsc/testdata/baselines/reference/compiler/varianceCycleCapnwebRpcStub.errors.txt +++ /dev/null @@ -1,165 +0,0 @@ -main.ts(5,3): error TS2589: Type instantiation is excessively deep and possibly infinite. -main.ts(6,18): error TS7006: Parameter 's' implicitly has an 'any' type. - - -==== capnweb.d.ts (0 errors) ==== - // Copyright (c) 2025 Cloudflare, Inc. - // Licensed under the MIT license found in the LICENSE.txt file or at: - // https://opensource.org/license/mit - // This file borrows heavily from `types/defines/rpc.d.ts` in workerd. - // Branded types for identifying `WorkerEntrypoint`/`DurableObject`/`Target`s. - // TypeScript uses *structural* typing meaning anything with the same shape as type `T` is a `T`. - // For the classes exported by `cloudflare:workers` we want *nominal* typing (i.e. we only want to - // accept `WorkerEntrypoint` from `cloudflare:workers`, not any other class with the same shape) - declare const __RPC_STUB_BRAND: '__RPC_STUB_BRAND'; - declare const __RPC_TARGET_BRAND: '__RPC_TARGET_BRAND'; - // Distinguishes mapper placeholders from regular values so param unwrapping can accept them. - declare const __RPC_MAP_VALUE_BRAND: unique symbol; - interface RpcTargetBranded { - [__RPC_TARGET_BRAND]: never; - } - // Types that can be used through `Stub`s - // `never[]` preserves compatibility with strongly-typed function signatures without introducing - // `any` into inference. - type Stubable = RpcTargetBranded | ((...args: never[]) => unknown); - // Note: also true for `any` (call sites that care check `IsAny` first). - type IsUnknown = unknown extends T ? true : false; // Types that can be passed over RPC - // The reason for using a generic type here is to build the serializable subset of RPC-compatible - // composite types. This allows types defined with the "interface" keyword to pass the - // serializable check as well. Otherwise, only types defined with the "type" keyword would pass. - type RpcCompatible = // Allow `unknown` as a leaf so records/interfaces with `unknown` fields remain compatible. - (IsUnknown extends true ? unknown : never) // RPC-compatible base values - | BaseType // RPC-compatible composites - | Map ? RpcCompatible : never, T extends Map ? RpcCompatible : never> | Set ? RpcCompatible : never> | Array ? RpcCompatible : never> | ReadonlyArray ? RpcCompatible : never> | { [K in keyof T as K extends string | number ? K : never]: RpcCompatible } | Promise ? RpcCompatible : never> // Special types - | Stub // Serialized as stubs, see `Stubify` - | Stubable; - // Base type for all RPC stubs, including common memory management methods. - // `T` is used as a marker type for unwrapping `Stub`s later. - interface StubBase extends Disposable { - [__RPC_STUB_BRAND]: T; - dup(): this; - onRpcBroken(callback: (error: any) => void): void; - } - type Stub> = T extends object ? Provider & StubBase : StubBase; - type TypedArray = Uint8Array | Uint8ClampedArray | Uint16Array | Uint32Array | Int8Array | Int16Array | Int32Array | BigUint64Array | BigInt64Array | Float32Array | Float64Array; // This represents all the types that can be sent as-is over an RPC boundary - type BaseType = void | undefined | null | boolean | number | bigint | string | TypedArray | ArrayBuffer | DataView | Date | Error | RegExp | Blob | ReadableStream // Chunk type can be any RPC-compatible type - | WritableStream // Chunk type can be any RPC-compatible type - | URL | Request | Response | Headers; // Recursively rewrite all `Stubable` types with `Stub`s, and resolve promises. - // Arm ordering matters here: - // - `Promise` must come before `StubBase`: `RpcPromise` matches both, and must resolve - // through the Promise arm rather than pass through as-is. - // - `StubBase` must come before `Stubable`: `Stub` of a callable `T` is itself callable, so - // it matches `Stubable`. Checking `StubBase` first keeps existing stubs as-is instead of - // double-wrapping them as `Stub>`. - // prettier-ignore - type Stubify = T extends Promise ? Stubify : T extends StubBase ? T : T extends Stubable ? Stub : T extends Map ? Map, Stubify> : T extends Set ? Set> : T extends [] ? [] : T extends [infer Head, ...infer Tail] ? [Stubify, ...Stubify] : T extends readonly [] ? readonly [] : T extends readonly [infer Head, ...infer Tail] ? readonly [Stubify, ...Stubify] : T extends Array ? Array> : T extends ReadonlyArray ? ReadonlyArray> : T extends BaseType ? T // When using "unknown" instead of "any", interfaces are not stubified. - : T extends { - [key: string | number]: any; - } ? { [K in keyof T as K extends string | number ? K : never]: Stubify } : T; - // Recursively rewrite all `Stub`s with the corresponding `T`s. - // Note we use `StubBase` instead of `Stub` here to avoid circular dependencies: - // `Stub` depends on `Provider`, which depends on `Unstubify`, which would depend on `Stub`. - // prettier-ignore - type UnstubifyInner = // Preserve local RpcTarget acceptance, but avoid needless `Stub | Value` unions when the stub - // is already assignable to the value type (important for callback contextual typing). - T extends StubBase ? (T extends V ? UnstubifyInner : (T | UnstubifyInner)) : T extends Promise ? UnstubifyInner : T extends Map ? Map, Unstubify> : T extends Set ? Set> : T extends [] ? [] : T extends [infer Head, ...infer Tail] ? [Unstubify, ...Unstubify] : T extends readonly [] ? readonly [] : T extends readonly [infer Head, ...infer Tail] ? readonly [Unstubify, ...Unstubify] : T extends Array ? Array> : T extends ReadonlyArray ? ReadonlyArray> : T extends BaseType ? T : T extends { - [key: string | number]: unknown; - } ? { [K in keyof T as K extends string | number ? K : never]: Unstubify } : T; // You can put promises anywhere in the params and they'll be resolved before delivery. - // (This also covers RpcPromise, because it's defined as being a Promise.) - // Map placeholders are also allowed so primitive map callback inputs can be forwarded directly - // into RPC params. - // - // Keep raw non-stub members so generic assignability still works when UnstubifyInner is deferred. - // Remove stub members from mixed unions so callback params don’t get both stub and unstubbed signatures. - // Marker carried by map() callback inputs. This lets primitive placeholders flow through params. - type Unstubify = NonStubMembers | UnstubifyInner | Promise> | MapValuePlaceholder>; - type UnstubifyAll = { [I in keyof A]: Unstubify }; - interface MapValuePlaceholder { - [__RPC_MAP_VALUE_BRAND]: T; - } - type NonStubMembers = Exclude>; // Utility type for adding `Disposable`s to `object` types only. - // Note `unknown & T` is equivalent to `T`. - type MaybeDisposable = T extends object ? Disposable : unknown; // The type behind the public `RpcPromise` (re-exported with its `RpcCompatible` constraint from - // index.ts). Defined here so that `Result`'s arms below resolve to the exact same alias - // instantiation: when both sides of an assignability check are the same alias applied to the - // same type arguments, the checker short-circuits on identity instead of recursing through the - // full structural comparison of these mutually-recursive types. - type RpcPromise$1 = T extends Stubable ? Promise> & Provider & StubBase : Promise & MaybeDisposable> & Provider & StubBase; - // The elision `Result` applies to a bare stub type: unwrap `Stub` back to `T` when the - // payload is `Stubable`. Such stubs await back to a stub either way, so eliding keeps a - // declared `Promise>` return interchangeable with a `Promise` return. - // Plain-interface stubs are NOT elided: `RpcPromise` only awaits to `Stub` when - // `U extends Stubable`, so eliding those would change the awaited type from a stub to a - // stubified record. The payload check is deliberately non-distributive (`[U] extends [...]`). - // `Stub` is not elided either: `[any] extends [Stubable]` is true, so without the `IsAny` - // guard an `any`-payload stub would lose its stub surface. - // Also used by the `RpcPromise` constructor signature (index.ts), which applies exactly this - // transformation so constructing from a promised stub matches the method-return type. - type ElideStub = T extends StubBase ? (IsAny extends true ? T : [U] extends [Stubable] ? U : T) : T; - // What the promise given to `new RpcPromise(...)` may resolve to: the payload itself, or — - // for stubable payloads — a stub of it. `NoInfer` keeps the stub arm out of inference, so an - // inferred `T` is always the promise's own resolution type; the arm only matters when `T` is - // explicitly annotated (`new RpcPromise(promiseOfStub)`). Stubs of non-stubable - // payloads are deliberately rejected: `ElideStub` wouldn't elide those, so accepting one would - // claim the promise awaits to a stubified record while the runtime resolves to a stub. - type PayloadOrStub = T | NoInfer>>; - // Type for method return or property on an RPC interface. - // - Stubable types are replaced by stubs. - // - RpcCompatible types are passed by value, with stubable types replaced by stubs - // and a top-level `Disposer`. - // Everything else can't be passed over RPC. - // Technically, we use custom thenables here, but they quack like `Promise`s. - // Intersecting with `(Maybe)Provider` allows pipelining. - // prettier-ignore - type Result = IsAny extends true ? RpcPromise$1 // `RpcPromise`: always safe to normalize — `Result` is idempotent — so a declared - // `RpcPromise` return produces the same type as a `Promise` return. - : R extends PromiseLike & StubBase ? Result // Bare stubs: elide per `ElideStub` above. Note there is no `RpcCompatible` re-check - // here: anything matching our `StubBase` was produced by machinery that already enforced - // the constraint, and re-evaluating `RpcCompatible` in this arm recurses through its - // `Stub` member back into `Result`, tripping TS2615 circularity errors in mapped - // types. - : R extends StubBase ? RpcPromise$1> : R extends RpcCompatible ? RpcPromise$1 : never; - type IsAny = 0 extends (1 & T) ? true : false; // Type for method or property on an RPC interface. - // For methods, unwrap `Stub`s in parameters, and rewrite returns to be `Result`s. - // Unwrapping `Stub`s allows calling with `Stubable` arguments. - // For properties, rewrite types to be `Result`s. - // In each case, unwrap `Promise`s. - type MethodOrProperty = V extends ((...args: infer P) => infer R) ? (...args: UnstubifyAll

) => Result> : Result>; // Type for the callable part of an `Provider` if `T` is callable. - // This is intersected with methods/properties. - type MaybeCallableProvider = T extends ((...args: any[]) => any) ? MethodOrProperty : unknown; - type TupleIndexKeys> = Extract; - type MapCallbackValue = // `Omit` removes call signatures, so re-intersect callable provider behavior. - T extends unknown ? Omit, keyof Promise> & MaybeCallableProvider & MapValuePlaceholder : never; - type InvalidNativePromiseInMapResult = T extends unknown ? InvalidNativePromiseInMapResultImpl : never; - type InvalidNativePromiseInMapResultImpl = [T] extends [Seen] ? never // RpcPromise is modeled as Promise & StubBase, so allow promise-like stub values. - : T extends StubBase ? never // Native thenables cannot be represented in map recordings, even when typed as PromiseLike. - : T extends PromiseLike ? T : T extends Map ? InvalidNativePromiseInMapResult | InvalidNativePromiseInMapResult : T extends Set ? InvalidNativePromiseInMapResult : T extends readonly [] ? never : T extends readonly [infer Head, ...infer Tail] ? InvalidNativePromiseInMapResult | InvalidNativePromiseInMapResult : T extends ReadonlyArray ? InvalidNativePromiseInMapResult : T extends { - [key: string | number]: unknown; - } ? InvalidNativePromiseInMapResult], Seen | T> : never; - type MapCallbackReturn = InvalidNativePromiseInMapResult extends never ? T : never; - type ArrayProvider = { [K in number]: MethodOrProperty } & { - map(callback: (elem: MapCallbackValue) => MapCallbackReturn): Result>; - }; - type TupleProvider> = { [K in TupleIndexKeys]: MethodOrProperty } & ArrayProvider; // Base type for all other types providing RPC-like interfaces. - // Rewrites all methods/properties to be `MethodOrProperty`s, while preserving callable types. - // `__RPC_TARGET_BRAND` deliberately flows through the key mapping (as a `never` property) so - // stubs of branded targets stay assignable to workers-types' `Stubable`. Such stubs match our - // `Stubable` too — harmless, since all machinery checks `StubBase` before `Stubable`. - type Provider = MaybeCallableProvider & (T extends ReadonlyArray ? number extends T["length"] ? ArrayProvider : TupleProvider : { [K in Exclude>]: MethodOrProperty } & { - map(callback: (value: MapCallbackValue>) => MapCallbackReturn): Result>; - }); - export type RpcStub> = Stub; - -==== main.ts (2 errors) ==== - import type { RpcStub } from "./capnweb"; - - declare const api: RpcStub<{ sub(): Promise> }>; - export async function f() { - await api.sub(); - ~~~~~~~~~~~~~~~ -!!! error TS2589: Type instantiation is excessively deep and possibly infinite. - api.sub().then(s => s); - ~ -!!! error TS7006: Parameter 's' implicitly has an 'any' type. - } - \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/varianceCycleCapnwebRpcStub.types b/tsc/testdata/baselines/reference/compiler/varianceCycleCapnwebRpcStub.types index c562e36ae1268..ee9a9c413fa4f 100644 --- a/tsc/testdata/baselines/reference/compiler/varianceCycleCapnwebRpcStub.types +++ b/tsc/testdata/baselines/reference/compiler/varianceCycleCapnwebRpcStub.types @@ -252,29 +252,29 @@ import type { RpcStub } from "./capnweb"; >RpcStub : RpcStub declare const api: RpcStub<{ sub(): Promise> }>; ->api : { sub: () => Promise<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}> & Disposable> & { map: any; } & {} & import("./capnweb").StubBase<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}>>; } & { map(callback: (value: Omit Promise<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}> & Disposable> & { map: any; } & {} & import("./capnweb").StubBase<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}>>) & {} & { map(callback: (value: Omit Promise<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}> & Disposable> & { map: any; } & {} & import("./capnweb").StubBase<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}>>) & {} & any & import("./capnweb").StubBase<() => Promise>>> & (() => Promise<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}> & Disposable> & { map: any; } & {} & import("./capnweb").StubBase<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}>>) & {} & any & import("./capnweb").StubBase<() => Promise>>, keyof Promise> & (() => Promise<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}> & Disposable> & { map: any; } & {} & import("./capnweb").StubBase<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}>>) & import("./capnweb").MapValuePlaceholder<() => Promise>>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & any & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & Disposable> & any & any & import("./capnweb").StubBase, keyof Promise> & import("./capnweb").MapValuePlaceholder) => import("./capnweb").MapCallbackReturn): any & any & import("./capnweb").StubBase; } & import("./capnweb").StubBase +>api : { sub: () => Promise<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & any & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase & Disposable> & any & any & import("./capnweb").StubBase; } & any & import("./capnweb").StubBase >sub : () => Promise> export async function f() { >f : () => Promise await api.sub(); ->await api.sub() : Promise<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}> & Disposable> & { map: any; } & {} & import("./capnweb").StubBase<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}>> ->api.sub() : Promise<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}> & Disposable> & { map: any; } & {} & import("./capnweb").StubBase<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}>> ->api.sub : () => Promise<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}> & Disposable> & { map: any; } & {} & import("./capnweb").StubBase<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}>> ->api : { sub: () => Promise<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}> & Disposable> & { map: any; } & {} & import("./capnweb").StubBase<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}>>; } & { map(callback: (value: Omit Promise<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}> & Disposable> & { map: any; } & {} & import("./capnweb").StubBase<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}>>) & {} & { map(callback: (value: Omit Promise<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}> & Disposable> & { map: any; } & {} & import("./capnweb").StubBase<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}>>) & {} & any & import("./capnweb").StubBase<() => Promise>>> & (() => Promise<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}> & Disposable> & { map: any; } & {} & import("./capnweb").StubBase<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}>>) & {} & any & import("./capnweb").StubBase<() => Promise>>, keyof Promise> & (() => Promise<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}> & Disposable> & { map: any; } & {} & import("./capnweb").StubBase<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}>>) & import("./capnweb").MapValuePlaceholder<() => Promise>>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & any & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & Disposable> & any & any & import("./capnweb").StubBase, keyof Promise> & import("./capnweb").MapValuePlaceholder) => import("./capnweb").MapCallbackReturn): any & any & import("./capnweb").StubBase; } & import("./capnweb").StubBase ->sub : () => Promise<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}> & Disposable> & { map: any; } & {} & import("./capnweb").StubBase<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}>> +>await api.sub() : {} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & any & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase & Disposable +>api.sub() : Promise<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & any & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase & Disposable> & any & any & import("./capnweb").StubBase +>api.sub : () => Promise<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & any & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase & Disposable> & any & any & import("./capnweb").StubBase +>api : { sub: () => Promise<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & any & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase & Disposable> & any & any & import("./capnweb").StubBase; } & any & import("./capnweb").StubBase +>sub : () => Promise<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & any & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase & Disposable> & any & any & import("./capnweb").StubBase api.sub().then(s => s); ->api.sub().then(s => s) : any ->api.sub().then : any ->api.sub() : Promise<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}> & Disposable> & { map: any; } & {} & import("./capnweb").StubBase<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}>> ->api.sub : () => Promise<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}> & Disposable> & { map: any; } & {} & import("./capnweb").StubBase<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}>> ->api : { sub: () => Promise<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}> & Disposable> & { map: any; } & {} & import("./capnweb").StubBase<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}>>; } & { map(callback: (value: Omit Promise<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}> & Disposable> & { map: any; } & {} & import("./capnweb").StubBase<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}>>) & {} & { map(callback: (value: Omit Promise<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}> & Disposable> & { map: any; } & {} & import("./capnweb").StubBase<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}>>) & {} & any & import("./capnweb").StubBase<() => Promise>>> & (() => Promise<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}> & Disposable> & { map: any; } & {} & import("./capnweb").StubBase<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}>>) & {} & any & import("./capnweb").StubBase<() => Promise>>, keyof Promise> & (() => Promise<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}> & Disposable> & { map: any; } & {} & import("./capnweb").StubBase<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}>>) & import("./capnweb").MapValuePlaceholder<() => Promise>>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & any & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & Disposable> & any & any & import("./capnweb").StubBase, keyof Promise> & import("./capnweb").MapValuePlaceholder) => import("./capnweb").MapCallbackReturn): any & any & import("./capnweb").StubBase; } & import("./capnweb").StubBase ->sub : () => Promise<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}> & Disposable> & { map: any; } & {} & import("./capnweb").StubBase<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): import("./capnweb").Result>; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase<{}>> ->then : any ->s => s : (s: any) => any ->s : any ->s : any +>api.sub().then(s => s) : Promise<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & any & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase & Disposable> +>api.sub().then : (callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & any & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase & Disposable, TResult2 = never>(onfulfilled?: any | any | undefined, onrejected?: any | any | undefined) => Promise +>api.sub() : Promise<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & any & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase & Disposable> & any & any & import("./capnweb").StubBase +>api.sub : () => Promise<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & any & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase & Disposable> & any & any & import("./capnweb").StubBase +>api : { sub: () => Promise<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & any & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase & Disposable> & any & any & import("./capnweb").StubBase; } & any & import("./capnweb").StubBase +>sub : () => Promise<{} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & any & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase & Disposable> & any & any & import("./capnweb").StubBase +>then : (callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & any & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase & Disposable, TResult2 = never>(onfulfilled?: any | any | undefined, onrejected?: any | any | undefined) => Promise +>s => s : (s: {} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & any & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase & Disposable) => any & any & Disposable +>s : {} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & any & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase & Disposable +>s : {} & { map(callback: (value: Omit & {} & any & import("./capnweb").StubBase<{}>, keyof Promise> & import("./capnweb").MapValuePlaceholder<{}>) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & { map(callback: (elem: import("./capnweb").MapCallbackValue) => import("./capnweb").MapCallbackReturn): Promise[] & Disposable> & { [x: number]: import("./capnweb").MethodOrProperty; } & any & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase; } & import("./capnweb").StubBase & Disposable } diff --git a/tsc/testdata/baselines/reference/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/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 37b9f7c034fcb..deba75ba4156b 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 @@ -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\""}] From 25955d063afd300b0b638b40720121a709eeadec Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Tue, 20 Oct 2026 15:28:49 -0700 Subject: [PATCH 17/60] Cache relation results only once their assumptions are resolved A relation that succeeds while an outer comparison is still in progress has only been shown to hold under the outer comparison's assumption. Caching it globally made later lookups depend on which comparison happened to run first. The same was true for results cut short by depth limits measured against outer resolutions. Each result now tracks the lowest resolution it depends on and whether it was truncated. Results are cached globally only when the comparison that introduced their assumptions completes, and truncated results only at their own head. Failures remain cached immediately, since assumptions only ever make a relation more likely to succeed. A comparison that only relates by assuming comparisons within it is reported as related once it completes, whether it is computed or read from the cache. Comparisons of types referencing constrained type parameters are considered related while the same comparison with unconstrained type parameters is in progress, since constraints only make more types related. A completed comparison found to succeed now counts the same way. That only went unnoticed because completed comparisons used to stay in progress until the outermost one completed; without it, relating structurally identical generic interfaces creates ten times the types. --- tsc/internal/checker/relater.go | 211 ++++++++++++++---- ...redCheckOrder(checkorder=typesfirst).types | 2 +- .../relationMaybeCheckOrder.errors.txt | 5 +- .../compiler/relationMaybeCheckOrder.types | 2 +- ...redCheckOrder(checkorder=typesfirst).types | 2 +- ...eCheckOrder(checkorder=default).errors.txt | 25 +++ 6 files changed, 194 insertions(+), 53 deletions(-) create mode 100644 tsc/testdata/baselines/reference/compiler/relationTruncatedCacheCheckOrder(checkorder=default).errors.txt diff --git a/tsc/internal/checker/relater.go b/tsc/internal/checker/relater.go index 969284a6fd796..e5b173a299b10 100644 --- a/tsc/internal/checker/relater.go +++ b/tsc/internal/checker/relater.go @@ -881,6 +881,21 @@ func (c *Checker) mapperGeneration(m *TypeMapper) int { 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 hasMatchingRecursionIdentity(t *Type, identity RecursionId) bool { target := getRecursionIdentityTarget(t) if target.flags&TypeFlagsIntersection != 0 { @@ -2668,22 +2683,48 @@ 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 + sourceStack []*Type + targetStack []*Type + // sourceDepths and targetDepths are the depths of the comparisons that + // pushed each entry of sourceStack and targetStack. + sourceDepths []int + targetDepths []int + // depth is the number of comparisons in progress. + depth int + // low is the lowest depth that the result of the innermost comparison in + // progress depends on, through assumptions or truncation. Results that + // depend on no comparison below their own are the same from scratch. + low int + // truncated is set if that result depends on a truncation that would not + // happen from scratch. + truncated bool expandingFlags ExpandingFlags - overflow bool - relationCount int - next *Relater + // expandingSourceDepth and expandingTargetDepth are the highest depths + // from which the expanding flags would still be set. + expandingSourceDepth int + expandingTargetDepth int + overflow bool + relationCount int + next *Relater +} + +type maybeKey struct { + key CacheHashKey + // low is the lowest depth that the comparison depends on, which is its + // own while it is in progress. + low int + result Ternary + truncated bool } func (c *Checker) getRelater() *Relater { @@ -2696,13 +2737,15 @@ func (c *Checker) getRelater() *Relater { } func (c *Checker) putRelater(r *Relater) { - r.maybeKeysSet.Clear() + clear(r.maybeKeysSet) *r = Relater{ c: c, maybeKeys: r.maybeKeys[:0], maybeKeysSet: r.maybeKeysSet, sourceStack: r.sourceStack[:0], targetStack: r.targetStack[:0], + sourceDepths: r.sourceDepths[:0], + targetDepths: r.targetDepths[:0], next: c.freeRelater, } c.freeRelater = r @@ -3227,38 +3270,67 @@ func (r *Relater) recursiveTypeRelatedTo(source *Type, target *Type, reportError return TernaryFalse } // If source and target are already being compared, consider them related with assumptions - if r.maybeKeysSet.Has(id) { - return TernaryMaybe + if i, ok := r.maybeKeysSet[id]; ok { + return r.assume(i) } // A constrained key indicates that we have type references that reference constrained // type parameters. For such keys we also check against the key we would have gotten if all type parameters // were unconstrained. if constrained { broadestEquivalentId, _ := getRelationKey(source, target, intersectionState, r.relation == r.c.identityRelation, true /*ignoreConstraints*/) - if r.maybeKeysSet.Has(broadestEquivalentId) { - return TernaryMaybe + 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(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 @@ -3268,6 +3340,7 @@ func (r *Relater) recursiveTypeRelatedTo(source *Type, target *Type, reportError if tr := r.c.tracer; tr != nil { tr.Instant(tracing.PhaseCheckTypes, "recursiveTypeRelatedTo_DepthLimit", map[string]any{"sourceId": source.id, "targetId": target.id, "depth": len(r.sourceStack), "targetDepth": len(r.targetStack)}) } + r.truncate(min(r.expandingSourceDepth, r.expandingTargetDepth)) result = TernaryMaybe } else { if tr := r.c.tracer; tr != nil { @@ -3279,39 +3352,83 @@ func (r *Relater) recursiveTypeRelatedTo(source *Type, target *Type, reportError r.c.reliabilityFlags |= saveReliabilityFlags if recursionFlags&RecursionFlagsSource != 0 { r.sourceStack = r.sourceStack[:len(r.sourceStack)-1] + r.sourceDepths = r.sourceDepths[:len(r.sourceDepths)-1] } if recursionFlags&RecursionFlagsTarget != 0 { r.targetStack = r.targetStack[:len(r.targetStack)-1] + r.targetDepths = r.targetDepths[:len(r.targetDepths)-1] } - r.expandingFlags = saveExpandingFlags - if result != TernaryFalse { - if result == TernaryTrue || (len(r.sourceStack) == 0 && len(r.targetStack) == 0) { - if result == TernaryTrue || result == TernaryMaybe { - // If result is definitely true, record all maybe keys as having succeeded. Also, record Ternary.Maybe - // results as having succeeded once we reach depth 0, but never record Ternary.Unknown results. - r.resetMaybeStack(maybeStart, propagatingVarianceFlags, true) - } else { - r.resetMaybeStack(maybeStart, propagatingVarianceFlags, false) - } - } - // Note: it's intentional that we don't reset in the else case; - // we leave them on the stack such that when we hit depth zero - // above, we can report all of them as successful. - } else { + r.expandingFlags, r.expandingSourceDepth, r.expandingTargetDepth = saveExpandingFlags, saveExpandingSourceDepth, saveExpandingTargetDepth + r.depth-- + low, truncated := r.low, r.truncated + r.low, r.truncated = saveLow, saveTruncated + switch { + case 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.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(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(key, RelationComparisonResultSucceeded|propagatingVarianceFlags) r.relationCount-- } } @@ -3681,7 +3798,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() @@ -3862,7 +3980,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 { diff --git a/tsc/testdata/baselines/reference/compiler/relationDepthSharedCheckOrder(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/relationDepthSharedCheckOrder(checkorder=typesfirst).types index 4d25be7bdfdba..2fbf00669bb64 100644 --- a/tsc/testdata/baselines/reference/compiler/relationDepthSharedCheckOrder(checkorder=typesfirst).types +++ b/tsc/testdata/baselines/reference/compiler/relationDepthSharedCheckOrder(checkorder=typesfirst).types @@ -728,7 +728,7 @@ interface J119 { leaf: number } >leaf : number type Mid = I60 extends J60 ? true : false; ->Mid : true +>Mid : false >true : true >false : false diff --git a/tsc/testdata/baselines/reference/compiler/relationMaybeCheckOrder.errors.txt b/tsc/testdata/baselines/reference/compiler/relationMaybeCheckOrder.errors.txt index 88dee4e5a8f7e..959e47bf00a94 100644 --- a/tsc/testdata/baselines/reference/compiler/relationMaybeCheckOrder.errors.txt +++ b/tsc/testdata/baselines/reference/compiler/relationMaybeCheckOrder.errors.txt @@ -1,8 +1,7 @@ relationMaybeCheckOrder.ts(8,32): error TS2322: Type 'B' is not assignable to type 'string | number | symbol'. -relationMaybeCheckOrder.ts(18,11): error TS2322: Type '2' is not assignable to type '1'. -==== relationMaybeCheckOrder.ts (2 errors) ==== +==== 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 @@ -23,8 +22,6 @@ relationMaybeCheckOrder.ts(18,11): error TS2322: Type '2' is not assignable to t function g(x: unknown): 2; function g(x: unknown) { return 1 as any; } const r: 1 = g(a); - ~ -!!! error TS2322: Type '2' is not assignable to type '1'. } const w: 1 = h(a); diff --git a/tsc/testdata/baselines/reference/compiler/relationMaybeCheckOrder.types b/tsc/testdata/baselines/reference/compiler/relationMaybeCheckOrder.types index ecbee15a795d4..79fb5d6072b67 100644 --- a/tsc/testdata/baselines/reference/compiler/relationMaybeCheckOrder.types +++ b/tsc/testdata/baselines/reference/compiler/relationMaybeCheckOrder.types @@ -47,7 +47,7 @@ function f() { const r: 1 = g(a); >r : 1 ->g(a) : 2 +>g(a) : 1 >g : { (x: keyof M): 1; (x: unknown): 2; } >a : A } diff --git a/tsc/testdata/baselines/reference/compiler/relationNestingSharedCheckOrder(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/relationNestingSharedCheckOrder(checkorder=typesfirst).types index fcc2fcc2b32aa..af0850b02eb7b 100644 --- a/tsc/testdata/baselines/reference/compiler/relationNestingSharedCheckOrder(checkorder=typesfirst).types +++ b/tsc/testdata/baselines/reference/compiler/relationNestingSharedCheckOrder(checkorder=typesfirst).types @@ -18,7 +18,7 @@ type R = { next: R<[T]>; leaf: T }; >leaf : T type Inner = S<[string]> extends R<[string]> ? true : false; ->Inner : true +>Inner : false >true : true >false : false diff --git a/tsc/testdata/baselines/reference/compiler/relationTruncatedCacheCheckOrder(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/relationTruncatedCacheCheckOrder(checkorder=default).errors.txt new file mode 100644 index 0000000000000..8b543f32384ea --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/relationTruncatedCacheCheckOrder(checkorder=default).errors.txt @@ -0,0 +1,25 @@ +relationTruncatedCacheCheckOrder.ts(14,1): error TS2322: Type 'S<[string]>' is not assignable to type 'R<[string]>'. + The types of 'next.leaf' are incompatible between these types. + Type 'number' is not assignable to type '[[string]]'. + + +==== relationTruncatedCacheCheckOrder.ts (1 errors) ==== + // Relating 'S<[string]>' to 'R<[string]>' from scratch reaches 'next.leaf' + // before giving up on deeply nested types, and fails there. Inside the + // relation of 'S' to 'R' it is one level deeper and is cut + // short instead. That truncated result must not be cached, so the error for + // 'q = p' must be reported whether or not 'y = x' was checked first. + + type S = { next: S<[T]>; leaf: T extends [[unknown]] ? number : T }; + type R = { next: R<[T]>; leaf: T }; + + declare let x: S, y: R; + declare let p: S<[string]>, q: R<[string]>; + + y = x; + q = p; + ~ +!!! error TS2322: Type 'S<[string]>' is not assignable to type 'R<[string]>'. +!!! error TS2322: The types of 'next.leaf' are incompatible between these types. +!!! error TS2322: Type 'number' is not assignable to type '[[string]]'. + \ No newline at end of file From 61bc2325d8c1fd8ec2ff8f2f4a5aa52d355ae9ec Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Thu, 22 Oct 2026 09:58:36 -0700 Subject: [PATCH 18/60] Look through instantiation when reusing a parameter name Instantiating a signature copies a parameter unless the parameter's type has already been resolved, so whether the parameter in a signature's printed scope is the declared one depends on the types checked before. Both name the same declaration, so treating only the declared one as the same reference made printing a reused annotation depend on check order. --- tsc/internal/checker/nodecopy.go | 6 ++++-- ...heckOrderParameterInTypeQuery(checkorder=isolated).types | 4 ++-- ...ckOrderParameterInTypeQuery(checkorder=typesfirst).types | 4 ++-- 3 files changed, 8 insertions(+), 6 deletions(-) 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/testdata/baselines/reference/compiler/checkOrderParameterInTypeQuery(checkorder=isolated).types b/tsc/testdata/baselines/reference/compiler/checkOrderParameterInTypeQuery(checkorder=isolated).types index 0c9c1f6dcfb8d..c7f091d02bcb0 100644 --- a/tsc/testdata/baselines/reference/compiler/checkOrderParameterInTypeQuery(checkorder=isolated).types +++ b/tsc/testdata/baselines/reference/compiler/checkOrderParameterInTypeQuery(checkorder=isolated).types @@ -30,10 +30,10 @@ export class C2 { } return new C().test1(this); >new C().test1(this) : number ->new C().test1 : (a: C2) => number +>new C().test1 : (a: C2) => typeof a.#a >new C() : C >C : typeof C ->test1 : (a: C2) => number +>test1 : (a: C2) => typeof a.#a >this : this } } diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderParameterInTypeQuery(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/checkOrderParameterInTypeQuery(checkorder=typesfirst).types index 0c9c1f6dcfb8d..c7f091d02bcb0 100644 --- a/tsc/testdata/baselines/reference/compiler/checkOrderParameterInTypeQuery(checkorder=typesfirst).types +++ b/tsc/testdata/baselines/reference/compiler/checkOrderParameterInTypeQuery(checkorder=typesfirst).types @@ -30,10 +30,10 @@ export class C2 { } return new C().test1(this); >new C().test1(this) : number ->new C().test1 : (a: C2) => number +>new C().test1 : (a: C2) => typeof a.#a >new C() : C >C : typeof C ->test1 : (a: C2) => number +>test1 : (a: C2) => typeof a.#a >this : this } } From 6f8d8dc41c84d6332a05f52c223a82433a27972f Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Thu, 22 Oct 2026 11:16:59 -0700 Subject: [PATCH 19/60] Check computed enum initializers when checking the member Computing the values of an enum's members type-checked each computed initializer to report one that is not a number. The initializer may refer to the enum itself, whose type then reads member values that are still being computed, so the enum's type depended on whether its values were first computed by checking it or by asking for its type. The values do not depend on the initializer's type, so the check now happens when the member is checked, as for any other error in an initializer. --- tsc/internal/checker/checker.go | 9 +++++---- ...eckOrderEnumComputedMember(checkorder=isolated).types | 2 +- 2 files changed, 6 insertions(+), 5 deletions(-) diff --git a/tsc/internal/checker/checker.go b/tsc/internal/checker/checker.go index b93f38a8ed21b..d79c09b6905ec 100644 --- a/tsc/internal/checker/checker.go +++ b/tsc/internal/checker/checker.go @@ -5274,8 +5274,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) + } } } @@ -25226,8 +25229,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 } diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderEnumComputedMember(checkorder=isolated).types b/tsc/testdata/baselines/reference/compiler/checkOrderEnumComputedMember(checkorder=isolated).types index 7ec12ac791f04..39ddeced5f433 100644 --- a/tsc/testdata/baselines/reference/compiler/checkOrderEnumComputedMember(checkorder=isolated).types +++ b/tsc/testdata/baselines/reference/compiler/checkOrderEnumComputedMember(checkorder=isolated).types @@ -23,7 +23,7 @@ enum E { } const member: Extract = E.C; ->member : never +>member : E.C >E.C : E.C >E : typeof E >C : E.C From 14bc3eeb20a087fff338d6c78fce1236e8718e97 Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Sat, 7 Nov 2026 09:00:52 -0800 Subject: [PATCH 20/60] Instantiate symbols whether or not their types are known Instantiating a symbol returned the symbol itself if its type was already resolved and could not contain type variables, and an instantiated symbol otherwise. Which one a member of an instantiated type is then depended on whether its declared type had been resolved first, which shows wherever symbols are displayed: hovering over the same property could show A.x or A<"a">.x. Always instantiating would also change types. Instantiating an instantiated symbol starts over from its target with the mappers combined, and that can evaluate differently than instantiating twice: for E := {}, E['V'][K] becomes unknown, but with K := never as well it becomes never, rejecting arguments that the shortcut accepted. So an instantiation of a symbol whose types have nothing left to instantiate keeps those types. --- tsc/internal/checker/checker.go | 47 ++++++++++++++----- tsc/internal/checker/types.go | 24 ++++++++-- tsc/internal/checker/types_test.go | 2 +- .../tests/jsxGenericQuickInfo_test.go | 4 +- ...antiatedParameterKeepsResolvedType.symbols | 29 ++++++++++++ ...stantiatedParameterKeepsResolvedType.types | 25 ++++++++++ ...e-with-multiple-files-and-complex-types.js | 4 +- ...einstantiatedParameterKeepsResolvedType.ts | 10 ++++ 8 files changed, 124 insertions(+), 21 deletions(-) create mode 100644 tsc/testdata/baselines/reference/compiler/reinstantiatedParameterKeepsResolvedType.symbols create mode 100644 tsc/testdata/baselines/reference/compiler/reinstantiatedParameterKeepsResolvedType.types create mode 100644 tsc/testdata/tests/cases/compiler/reinstantiatedParameterKeepsResolvedType.ts diff --git a/tsc/internal/checker/checker.go b/tsc/internal/checker/checker.go index d79c09b6905ec..522909cea3fe2 100644 --- a/tsc/internal/checker/checker.go +++ b/tsc/internal/checker/checker.go @@ -17276,7 +17276,13 @@ 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) + var t *Type + if from := c.instantiatedFromUnaffected(links); from != nil { + t = c.getTypeOfSymbol(from) + } else { + t = c.instantiateType(c.getTypeOfSymbol(links.target), links.mapper) + } + links.resolvedType = t } return links.resolvedType } @@ -17284,11 +17290,34 @@ func (c *Checker) getTypeOfInstantiatedSymbol(symbol *ast.Symbol) *Type { func (c *Checker) getWriteTypeOfInstantiatedSymbol(symbol *ast.Symbol) *Type { links := c.valueSymbolLinks.Get(symbol) if links.getWriteType() == nil { - links.setWriteType(c, c.instantiateType(c.getWriteTypeOfSymbol(links.target), links.mapper)) + var t *Type + if from := c.instantiatedFromUnaffected(links); from != nil { + t = c.getWriteTypeOfSymbol(from) + } else { + t = c.instantiateType(c.getWriteTypeOfSymbol(links.target), links.mapper) + } + links.setWriteType(c, t) } return links.getWriteType() } +// instantiatedFromUnaffected returns the instantiated symbol that the +// symbol of links instantiates, if its types have no type variables for +// the further instantiation to affect. The symbol then has the same types. +// Instantiating its target with the combined mappers instead can give a +// different type, as when an instantiation turns E['V'][K] into unknown +// for E := {}, but the combined one turns it into never for K := never. +func (c *Checker) instantiatedFromUnaffected(links *ValueSymbolLinks) *ast.Symbol { + from := links.getInstantiatedFrom() + if from == nil || c.couldContainTypeVariables(c.getTypeOfSymbol(from)) { + return nil + } + if from.Flags()&ast.SymbolFlagsSetAccessor != 0 && c.couldContainTypeVariables(c.getWriteTypeOfSymbol(from)) { + return nil + } + return from +} + func (c *Checker) getTypeOfVariableOrParameterOrProperty(symbol *ast.Symbol) *Type { links := c.valueSymbolLinks.Get(symbol) if links.resolvedType == nil { @@ -21818,21 +21847,12 @@ func (c *Checker) instantiateSymbol(symbol *ast.Symbol, m *TypeMapper) *ast.Symb if m.MapsThisOnly() && isThisless(symbol) { return symbol } - // If the type of the symbol is already resolved, and if that type could not possibly - // be affected by instantiation, simply return the symbol itself. - if links.resolvedType != nil && !c.couldContainTypeVariables(links.resolvedType) { - if symbol.Flags()&ast.SymbolFlagsSetAccessor == 0 { - return symbol - } - // If we're a setter, check writeType. - if links.getWriteType() != nil && !c.couldContainTypeVariables(links.getWriteType()) { - return symbol - } - } + var instantiatedFrom *ast.Symbol if symbol.CheckFlags()&ast.CheckFlagsInstantiated != 0 { // If symbol being instantiated is itself a instantiation, fetch the original target and combine the // type mappers. This ensures that original type identities are properly preserved and that aliases // always reference a non-aliases. + instantiatedFrom = symbol symbol = links.target m = c.combineTypeMappers(links.mapper, m) } @@ -21843,6 +21863,7 @@ func (c *Checker) instantiateSymbol(symbol *ast.Symbol, m *TypeMapper) *ast.Symb resultLinks.target = symbol resultLinks.mapper = m resultLinks.setNameType(c, links.getNameType()) + resultLinks.setInstantiatedFrom(c, instantiatedFrom) return result } diff --git a/tsc/internal/checker/types.go b/tsc/internal/checker/types.go index 3a387f3cf33d5..91d71a575ea6a 100644 --- a/tsc/internal/checker/types.go +++ b/tsc/internal/checker/types.go @@ -195,9 +195,10 @@ type ValueSymbolLinks struct { } type valueSymbolExtra struct { - writeType *Type - nameType *Type - containingType *Type // Mapped type for mapped type property, containing union or intersection type for synthetic property + writeType *Type + nameType *Type + containingType *Type // Mapped type for mapped type property, containing union or intersection type for synthetic property + instantiatedFrom *ast.Symbol // For an instantiation of an instantiated symbol, the symbol instantiated } func (links *ValueSymbolLinks) getWriteType() *Type { @@ -241,6 +242,23 @@ func (links *ValueSymbolLinks) setNameType(c *Checker, typ *Type) { links.extra.nameType = typ } +func (links *ValueSymbolLinks) getInstantiatedFrom() *ast.Symbol { + if links.extra == nil { + return nil + } + return links.extra.instantiatedFrom +} + +func (links *ValueSymbolLinks) setInstantiatedFrom(c *Checker, symbol *ast.Symbol) { + if links.extra == nil { + if symbol == nil { + return + } + links.extra = c.valueSymbolExtraArena.New() + } + links.extra.instantiatedFrom = symbol +} + func (links *ValueSymbolLinks) setContainingType(c *Checker, typ *Type) { if links.extra == nil { if typ == nil { diff --git a/tsc/internal/checker/types_test.go b/tsc/internal/checker/types_test.go index 6e0f19446fe00..63b9a61ce0424 100644 --- a/tsc/internal/checker/types_test.go +++ b/tsc/internal/checker/types_test.go @@ -486,7 +486,7 @@ func TestInferenceContextMappers(t *testing.T) { //nolint:paralleltest func TestCompactValueSymbolLinksLayout(t *testing.T) { t.Parallel() assert.Equal(t, unsafe.Sizeof(ValueSymbolLinks{}), 4*unsafe.Sizeof(uintptr(0))) - assert.Equal(t, unsafe.Sizeof(valueSymbolExtra{}), 3*unsafe.Sizeof(uintptr(0))) + assert.Equal(t, unsafe.Sizeof(valueSymbolExtra{}), 4*unsafe.Sizeof(uintptr(0))) c, types := newCompositeTestChecker() var links ValueSymbolLinks assert.Assert(t, links.getWriteType() == nil) diff --git a/tsc/internal/fourslash/tests/jsxGenericQuickInfo_test.go b/tsc/internal/fourslash/tests/jsxGenericQuickInfo_test.go index 22b845a168c7f..9e2b32d740495 100644 --- a/tsc/internal/fourslash/tests/jsxGenericQuickInfo_test.go +++ b/tsc/internal/fourslash/tests/jsxGenericQuickInfo_test.go @@ -39,8 +39,8 @@ var c = item.toFixed( defer done() f.VerifyQuickInfoAt(t, "0", "(property) PropsA.renderItem: (item: number) => string", "") f.VerifyQuickInfoAt(t, "1", "(parameter) item: number", "") - f.VerifyQuickInfoAt(t, "2", "(property) PropsA.name: \"A\"", "comments for A") + f.VerifyQuickInfoAt(t, "2", "(property) PropsA.name: \"A\"", "comments for A") f.VerifyQuickInfoAt(t, "3", "(property) PropsA.renderItem: (item: number) => string", "") f.VerifyQuickInfoAt(t, "4", "(parameter) item: number", "") - f.VerifyQuickInfoAt(t, "5", "(property) PropsA.name: \"A\"", "comments for A") + f.VerifyQuickInfoAt(t, "5", "(property) PropsA.name: \"A\"", "comments for A") } diff --git a/tsc/testdata/baselines/reference/compiler/reinstantiatedParameterKeepsResolvedType.symbols b/tsc/testdata/baselines/reference/compiler/reinstantiatedParameterKeepsResolvedType.symbols new file mode 100644 index 0000000000000..517ce9e1866b7 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/reinstantiatedParameterKeepsResolvedType.symbols @@ -0,0 +1,29 @@ +//// [tests/cases/compiler/reinstantiatedParameterKeepsResolvedType.ts] //// + +=== reinstantiatedParameterKeepsResolvedType.ts === +// Instantiating E := {} turns the type of v into unknown. Inferring +// K := never must not then turn it into {}['V'][never], which is never. +interface I { +>I : Symbol(I, Decl(reinstantiatedParameterKeepsResolvedType.ts, 0, 0)) +>E : Symbol(E, Decl(reinstantiatedParameterKeepsResolvedType.ts, 2, 12)) +>V : Symbol(V, Decl(reinstantiatedParameterKeepsResolvedType.ts, 2, 23)) + + f(k: K, v: E['V'][K]): void; +>f : Symbol(I.f, Decl(reinstantiatedParameterKeepsResolvedType.ts, 2, 39)) +>K : Symbol(K, Decl(reinstantiatedParameterKeepsResolvedType.ts, 3, 6)) +>E : Symbol(E, Decl(reinstantiatedParameterKeepsResolvedType.ts, 2, 12)) +>k : Symbol(k, Decl(reinstantiatedParameterKeepsResolvedType.ts, 3, 30)) +>K : Symbol(K, Decl(reinstantiatedParameterKeepsResolvedType.ts, 3, 6)) +>v : Symbol(v, Decl(reinstantiatedParameterKeepsResolvedType.ts, 3, 35)) +>E : Symbol(E, Decl(reinstantiatedParameterKeepsResolvedType.ts, 2, 12)) +>K : Symbol(K, Decl(reinstantiatedParameterKeepsResolvedType.ts, 3, 6)) +} +declare const i: I<{}>; +>i : Symbol(i, Decl(reinstantiatedParameterKeepsResolvedType.ts, 5, 13)) +>I : Symbol(I, Decl(reinstantiatedParameterKeepsResolvedType.ts, 0, 0)) + +i.f("x" as never, 1); +>i.f : Symbol(I.f, Decl(reinstantiatedParameterKeepsResolvedType.ts, 2, 39)) +>i : Symbol(i, Decl(reinstantiatedParameterKeepsResolvedType.ts, 5, 13)) +>f : Symbol(I.f, Decl(reinstantiatedParameterKeepsResolvedType.ts, 2, 39)) + diff --git a/tsc/testdata/baselines/reference/compiler/reinstantiatedParameterKeepsResolvedType.types b/tsc/testdata/baselines/reference/compiler/reinstantiatedParameterKeepsResolvedType.types new file mode 100644 index 0000000000000..824df47ea2a60 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/reinstantiatedParameterKeepsResolvedType.types @@ -0,0 +1,25 @@ +//// [tests/cases/compiler/reinstantiatedParameterKeepsResolvedType.ts] //// + +=== reinstantiatedParameterKeepsResolvedType.ts === +// Instantiating E := {} turns the type of v into unknown. Inferring +// K := never must not then turn it into {}['V'][never], which is never. +interface I { +>V : object | undefined + + f(k: K, v: E['V'][K]): void; +>f : (k: K, v: E['V'][K]) => void +>k : K +>v : E["V"][K] +} +declare const i: I<{}>; +>i : I<{}> + +i.f("x" as never, 1); +>i.f("x" as never, 1) : void +>i.f : (k: K, v: unknown) => void +>i : I<{}> +>f : (k: K, v: unknown) => void +>"x" as never : never +>"x" : "x" +>1 : 1 + diff --git a/tsc/testdata/baselines/reference/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 deba75ba4156b..e9c62457f637f 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 @@ -221,8 +221,8 @@ declare const console: { log(msg: any): void; }; {"id":111,"symbolName":"__object","recursionId":96,"firstDeclaration":{"path":"/home/src/workspaces/project/main.ts","start":{"line":2,"character":30},"end":{"line":2,"character":89}},"flags":["Object"],"display":"{ value: number; map: (fn: (x: number) => U) => { value: U; map: (fn: (x: number) => U) => Container; }; }"}, {"id":112,"symbolName":"U","recursionId":84,"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":3,"character":9},"end":{"line":3,"character":10}},"flags":["TypeParameter"]}, {"id":113,"symbolName":"__type","recursionId":85,"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":3,"character":16},"end":{"line":3,"character":27}},"flags":["Object"],"display":"(x: number) => any"}, -{"id":114,"symbolName":"__type","recursionId":85,"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":3,"character":16},"end":{"line":3,"character":27}},"flags":["Object"],"display":"(x: U) => any"}, -{"id":115,"symbolName":"__type","recursionId":85,"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":3,"character":16},"end":{"line":3,"character":27}},"flags":["Object"],"display":"(x: U) => U"}, +{"id":114,"symbolName":"__type","recursionId":85,"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":3,"character":16},"end":{"line":3,"character":27}},"flags":["Object"],"display":"(x: U) => U"}, +{"id":115,"symbolName":"__type","recursionId":85,"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":3,"character":16},"end":{"line":3,"character":27}},"flags":["Object"],"display":"(x: U) => any"}, {"id":116,"recursionId":97,"flags":["StringLiteral"],"display":"\"value\""}, {"id":117,"recursionId":98,"flags":["StringLiteral"],"display":"\"map\""}, {"id":118,"symbolName":"Container","recursionId":83,"instantiatedType":91,"typeArguments":[112],"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":1,"character":1},"end":{"line":4,"character":2}},"flags":["Object"]}, diff --git a/tsc/testdata/tests/cases/compiler/reinstantiatedParameterKeepsResolvedType.ts b/tsc/testdata/tests/cases/compiler/reinstantiatedParameterKeepsResolvedType.ts new file mode 100644 index 0000000000000..90d725f47d2e7 --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/reinstantiatedParameterKeepsResolvedType.ts @@ -0,0 +1,10 @@ +// @strict: true +// @noEmit: true + +// Instantiating E := {} turns the type of v into unknown. Inferring +// K := never must not then turn it into {}['V'][never], which is never. +interface I { + f(k: K, v: E['V'][K]): void; +} +declare const i: I<{}>; +i.f("x" as never, 1); From 3958a0355333d94f6333cc2f69620439e0970623 Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Sat, 7 Nov 2026 09:01:30 -0800 Subject: [PATCH 21/60] Keep declaration emit's visibility marks apart from cached visibility Declaration emit marks the declarations it depends on as visible, such as those an export assignment names. Whether a declaration is visible was cached together with those marks, so a declaration whose visibility was asked before emit marked its container, as hovering over a use of it does, stayed invisible, and emit left it out. Caching only the visibility the rules of a declaration give, and applying the marks when asked, gives the same answer whenever emit marks them. --- tsc/internal/checker/emitresolver.go | 12 +++- tsc/internal/checker/emitsupport.go | 64 +++++++++++-------- ...ilityQueryOrder(checkorder=editorfirst).js | 40 ++---------- 3 files changed, 54 insertions(+), 62 deletions(-) diff --git a/tsc/internal/checker/emitresolver.go b/tsc/internal/checker/emitresolver.go index e4fad5c3f5b1f..0e2938dbe8d1b 100644 --- a/tsc/internal/checker/emitresolver.go +++ b/tsc/internal/checker/emitresolver.go @@ -22,8 +22,16 @@ type JSXLinks struct { // Links for declarations +// DeclarationLinks hold whether a declaration is visible. Declaration emit +// makes the declarations it depends on visible as it goes, so that is kept +// apart from what the rules of the declaration say, which is all that is +// cached: a declaration found invisible before emit made it or its container +// visible is still found visible afterwards. type DeclarationLinks struct { - isVisible core.Tristate // if declaration is depended upon by exported declarations + madeVisible bool // Declaration emit depends on the declaration + ruleKnown bool // Whether ruleVisible and ruleInheritsFrom are known + ruleVisible bool // Whether the declaration is visible by its own rules + ruleInheritsFrom *ast.Node // A declaration it is as visible as, if any } type DeclarationFileLinks struct { @@ -186,7 +194,7 @@ func (r *EmitResolver) markLinkedAliases(node *ast.Node) { var nextSymbol *ast.Symbol for _, declaration := range exportSymbol.Declarations() { - r.checker.emitResolverLinks.declarationLinks.Get(declaration).isVisible = core.TSTrue + r.checker.emitResolverLinks.declarationLinks.Get(declaration).madeVisible = true if ast.IsInternalModuleImportEqualsDeclaration(declaration) { // Add the referenced top container visible diff --git a/tsc/internal/checker/emitsupport.go b/tsc/internal/checker/emitsupport.go index 3da782c9ab4c4..4044c67089955 100644 --- a/tsc/internal/checker/emitsupport.go +++ b/tsc/internal/checker/emitsupport.go @@ -5,7 +5,6 @@ import ( "slices" "github.com/microsoft/TypeScript/tsc/internal/ast" - "github.com/microsoft/TypeScript/tsc/internal/core" "github.com/microsoft/TypeScript/tsc/internal/printer" ) @@ -17,27 +16,40 @@ func (c *Checker) isDeclarationVisible(node *ast.Node) bool { return false } - links := c.emitResolverLinks.declarationLinks.Get(node) - if links.isVisible == core.TSUnknown { - if c.determineIfDeclarationIsVisible(node) { - links.isVisible = core.TSTrue - } else { - links.isVisible = core.TSFalse + for { + links := c.emitResolverLinks.declarationLinks.Get(node) + if links.madeVisible { + return true + } + if !links.ruleKnown { + links.ruleVisible, links.ruleInheritsFrom = c.determineIfDeclarationIsVisible(node) + links.ruleKnown = true + } + if links.ruleInheritsFrom == nil { + return links.ruleVisible + } + node = links.ruleInheritsFrom + if !ast.IsParseTreeNode(node) { + return false } } - return links.isVisible == core.TSTrue } -func (c *Checker) determineIfDeclarationIsVisible(node *ast.Node) bool { +// determineIfDeclarationIsVisible returns whether node is visible by the rules +// of its declaration alone, or, if those make it as visible as another +// declaration, that declaration. Which declarations are visible depends on +// what declaration emit makes visible (see DeclarationLinks), so whether +// another declaration is visible is not part of the result. +func (c *Checker) determineIfDeclarationIsVisible(node *ast.Node) (visible bool, inheritsFrom *ast.Node) { switch node.Kind { case ast.KindJSDocCallbackTag, // ast.KindJSDocEnumTag, // !!! TODO: JSDoc @enum support? ast.KindJSDocTypedefTag: // Top-level jsdoc type aliases are considered exported // First parent is comment node, second is hosting declaration or token; we only care about those tokens or declarations whose parent is a source file - return node.Parent != nil && node.Parent.Parent != nil && node.Parent.Parent.Parent != nil && ast.IsSourceFile(node.Parent.Parent.Parent) + return node.Parent != nil && node.Parent.Parent != nil && node.Parent.Parent.Parent != nil && ast.IsSourceFile(node.Parent.Parent.Parent), nil case ast.KindBindingElement: - return c.isDeclarationVisible(node.Parent.Parent) + return false, node.Parent.Parent case ast.KindVariableDeclaration, ast.KindModuleDeclaration, ast.KindClassDeclaration, @@ -51,23 +63,23 @@ func (c *Checker) determineIfDeclarationIsVisible(node *ast.Node) bool { if ast.IsBindingPattern(node.Name()) && len(node.Name().Elements()) == 0 { // If the binding pattern is empty, this variable declaration is not visible - return false + return false, nil } // falls through } // External module augmentation is always visible // A @typedef at top-level in an external module is always visible if ast.IsExternalModuleAugmentation(node) || ast.IsImplicitlyExportedJSDocDeclaration(node) { - return true + return true, nil } parent := ast.GetDeclarationContainer(node) // If the node is not exported or it is not ambient module element (except import declaration) if c.getCombinedModifierFlagsCached(node)&ast.ModifierFlagsExport == 0 && !(node.Kind != ast.KindImportEqualsDeclaration && parent.Kind != ast.KindSourceFile && parent.Flags&ast.NodeFlagsAmbient != 0) { - return ast.IsGlobalSourceFile(parent) + return ast.IsGlobalSourceFile(parent), nil } // Exported members/ambient module elements (exception import declaration) are visible if parent is visible - return c.isDeclarationVisible(parent) + return false, parent case ast.KindPropertyDeclaration, ast.KindPropertySignature, @@ -77,10 +89,10 @@ func (c *Checker) determineIfDeclarationIsVisible(node *ast.Node) bool { ast.KindMethodSignature: if c.GetEffectiveDeclarationFlags(node, ast.ModifierFlagsPrivate|ast.ModifierFlagsProtected) != 0 { // Private/protected properties/methods are not visible - return false + return false, nil } // Public properties/methods are visible if its parents are visible, so: - return c.isDeclarationVisible(node.Parent) + return false, node.Parent case ast.KindConstructor, ast.KindConstructSignature, @@ -98,38 +110,38 @@ func (c *Checker) determineIfDeclarationIsVisible(node *ast.Node) bool { ast.KindIntersectionType, ast.KindParenthesizedType, ast.KindNamedTupleMember: - return c.isDeclarationVisible(node.Parent) + return false, node.Parent // Default binding, import specifier and namespace import is visible // only on demand so by default it is not visible case ast.KindImportClause, ast.KindNamespaceImport, ast.KindImportSpecifier: - return false + return false, nil // Type parameters are always visible case ast.KindTypeParameter: - return true + return true, nil // Source file and namespace export are always visible case ast.KindSourceFile, ast.KindNamespaceExportDeclaration: - return true + return true, nil // Export assignments do not create name bindings outside the module case ast.KindExportAssignment: - return false + return false, nil // An `export {X}` (without a module specifier) is itself a visible re-export of // the named binding; it contributes to the symbol's external visibility. case ast.KindExportSpecifier: exportDecl := node.Parent.Parent if ast.IsExportDeclaration(exportDecl) && exportDecl.AsExportDeclaration().ModuleSpecifier == nil { - return c.isDeclarationVisible(exportDecl.Parent) + return false, exportDecl.Parent } - return false + return false, nil default: - return false + return false, nil } } @@ -205,7 +217,7 @@ func (c *Checker) hasVisibleDeclarations(symbol *ast.Symbol, shouldComputeAliasT var addVisibleAlias func(declaration *ast.Node, aliasingStatement *ast.Node) if shouldComputeAliasToMakeVisible { addVisibleAlias = func(declaration *ast.Node, aliasingStatement *ast.Node) { - c.emitResolverLinks.declarationLinks.Get(declaration).isVisible = core.TSTrue + c.emitResolverLinks.declarationLinks.Get(declaration).madeVisible = true if aliasesToMakeVisibleSet == nil { aliasesToMakeVisibleSet = make(map[ast.NodeId]*ast.Node) } diff --git a/tsc/testdata/baselines/reference/compiler/exportAssignmentNestedVisibilityQueryOrder(checkorder=editorfirst).js b/tsc/testdata/baselines/reference/compiler/exportAssignmentNestedVisibilityQueryOrder(checkorder=editorfirst).js index 405c0f22e5b40..7f22b20127d74 100644 --- a/tsc/testdata/baselines/reference/compiler/exportAssignmentNestedVisibilityQueryOrder(checkorder=editorfirst).js +++ b/tsc/testdata/baselines/reference/compiler/exportAssignmentNestedVisibilityQueryOrder(checkorder=editorfirst).js @@ -22,42 +22,14 @@ module.exports = m; //// [exportAssignmentNestedVisibilityQueryOrder.d.ts] declare namespace m { + interface Inner { + x: number; + } + interface Outer { + use: (inner: Inner) => Outer; + } } declare var m: { (): m.Outer; }; export = m; - - -//// [DtsFileErrors] - - -exportAssignmentNestedVisibilityQueryOrder.d.ts(4,11): error TS2694: Namespace 'm' has no exported member 'Outer'. - - -==== exportAssignmentNestedVisibilityQueryOrder.d.ts (1 errors) ==== - declare namespace m { - } - declare var m: { - (): m.Outer; - ~~~~~ -!!! error TS2694: Namespace 'm' has no exported member 'Outer'. - }; - export = m; - - -!!!! File exportAssignmentNestedVisibilityQueryOrder.d.ts differs from original emit in noCheck emit -//// [exportAssignmentNestedVisibilityQueryOrder.d.ts] ---- Expected The full check baseline -+++ Actual with noCheck set -@@ -1,4 +1,10 @@ - declare namespace m { -+ interface Inner { -+ x: number; -+ } -+ interface Outer { -+ use: (inner: Inner) => Outer; -+ } - } - declare var m: { - (): m.Outer; \ No newline at end of file From f5abfee2aedf0f198452266f37dc55781d5211bd Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Sat, 7 Nov 2026 08:59:19 -0800 Subject: [PATCH 22/60] Do not count names resolved to print a type as uses The node builder resolves names to decide whether it can reuse a type node written in the source, which marked them referenced. Printing a type, as hovering does, then hid unused declaration errors that checking alone reports. --- tsc/internal/checker/checker.go | 23 ++++++++++++------- tsc/internal/checker/nodebuilderimpl.go | 6 ++--- tsc/internal/checker/nodecopy.go | 4 ++-- ...ryOrder(checkorder=editorfirst).errors.txt | 12 ++++++++++ ...eryOrder(checkorder=hoverfirst).errors.txt | 12 ++++++++++ 5 files changed, 44 insertions(+), 13 deletions(-) create mode 100644 tsc/testdata/baselines/reference/compiler/unusedTypeParameterQueryOrder(checkorder=editorfirst).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/unusedTypeParameterQueryOrder(checkorder=hoverfirst).errors.txt diff --git a/tsc/internal/checker/checker.go b/tsc/internal/checker/checker.go index 522909cea3fe2..c28793a0b5b4b 100644 --- a/tsc/internal/checker/checker.go +++ b/tsc/internal/checker/checker.go @@ -16505,6 +16505,13 @@ func (c *Checker) getTargetOfAliasDeclaration(node *ast.Node, dontRecursivelyRes * Resolves a qualified name and any involved aliases. */ func (c *Checker) resolveEntityName(name *ast.Node, meaning ast.SymbolFlags, ignoreErrors bool, dontResolveAlias bool, location *ast.Node) *ast.Symbol { + return c.resolveEntityNameEx(name, meaning, ignoreErrors, dontResolveAlias, location, true /*use*/) +} + +// resolveEntityNameEx is resolveEntityName, where a name that is not a use, +// such as one resolved to print a type, does not mark what it resolves to as +// referenced. +func (c *Checker) resolveEntityNameEx(name *ast.Node, meaning ast.SymbolFlags, ignoreErrors bool, dontResolveAlias bool, location *ast.Node, use bool) *ast.Symbol { if ast.NodeIsMissing(name) { return nil } @@ -16524,26 +16531,26 @@ func (c *Checker) resolveEntityName(name *ast.Node, meaning ast.SymbolFlags, ign resolveLocation = name } if meaning == ast.SymbolFlagsNamespace { - symbol = c.getMergedSymbol(c.resolveName(resolveLocation, name.Text(), meaning, nil, true /*isUse*/, false /*excludeGlobals*/)) + symbol = c.getMergedSymbol(c.resolveName(resolveLocation, name.Text(), meaning, nil, use /*isUse*/, false /*excludeGlobals*/)) if symbol == nil { - alias := c.getMergedSymbol(c.resolveName(resolveLocation, name.Text(), ast.SymbolFlagsAlias, nil, true /*isUse*/, false /*excludeGlobals*/)) + alias := c.getMergedSymbol(c.resolveName(resolveLocation, name.Text(), ast.SymbolFlagsAlias, nil, use /*isUse*/, false /*excludeGlobals*/)) if alias != nil && alias.Name() == ast.InternalSymbolNameExportEquals { // resolve typedefs exported from commonjs, stored on the module symbol symbol = alias.Parent() } } if symbol == nil && message != nil { - c.resolveName(resolveLocation, name.Text(), meaning, message, true /*isUse*/, false /*excludeGlobals*/) + c.resolveName(resolveLocation, name.Text(), meaning, message, use /*isUse*/, false /*excludeGlobals*/) } } else { - symbol = c.getMergedSymbol(c.resolveName(resolveLocation, name.Text(), meaning, message, true /*isUse*/, false /*excludeGlobals*/)) + symbol = c.getMergedSymbol(c.resolveName(resolveLocation, name.Text(), meaning, message, use /*isUse*/, false /*excludeGlobals*/)) } case ast.KindQualifiedName: qualified := name.AsQualifiedName() - symbol = c.resolveQualifiedName(name, qualified.Left, qualified.Right, meaning, ignoreErrors, location) + symbol = c.resolveQualifiedName(name, qualified.Left, qualified.Right, meaning, ignoreErrors, location, use) case ast.KindPropertyAccessExpression: access := name.AsPropertyAccessExpression() - symbol = c.resolveQualifiedName(name, access.Expression, access.Name(), meaning, ignoreErrors, location) + symbol = c.resolveQualifiedName(name, access.Expression, access.Name(), meaning, ignoreErrors, location, use) default: panic("Unknown entity name kind") } @@ -16560,8 +16567,8 @@ func (c *Checker) resolveEntityName(name *ast.Node, meaning ast.SymbolFlags, ign return symbol } -func (c *Checker) resolveQualifiedName(name *ast.Node, left *ast.Node, right *ast.Node, meaning ast.SymbolFlags, ignoreErrors bool, location *ast.Node) *ast.Symbol { - namespace := c.resolveEntityName(left, ast.SymbolFlagsNamespace, ignoreErrors, false /*dontResolveAlias*/, location) +func (c *Checker) resolveQualifiedName(name *ast.Node, left *ast.Node, right *ast.Node, meaning ast.SymbolFlags, ignoreErrors bool, location *ast.Node, use bool) *ast.Symbol { + namespace := c.resolveEntityNameEx(left, ast.SymbolFlagsNamespace, ignoreErrors, false /*dontResolveAlias*/, location, use) if namespace == nil || ast.NodeIsMissing(right) { return nil } diff --git a/tsc/internal/checker/nodebuilderimpl.go b/tsc/internal/checker/nodebuilderimpl.go index 2d2d01e83affa..dcbdb8c0cd9fb 100644 --- a/tsc/internal/checker/nodebuilderimpl.go +++ b/tsc/internal/checker/nodebuilderimpl.go @@ -476,7 +476,7 @@ func (b *NodeBuilderImpl) serializeTypeName(node *ast.Node, isTypeOf bool, typeA if isTypeOf { meaning = ast.SymbolFlagsValue } - symbol := b.ch.resolveEntityName(node, meaning, true, false, node) + symbol := b.ch.resolveEntityNameEx(node, meaning, true, false, node, false /*use*/) if symbol == nil { return nil } @@ -2483,12 +2483,12 @@ func (b *NodeBuilderImpl) shouldUsePlaceholderForProperty(propertySymbol *ast.Sy func (b *NodeBuilderImpl) trackComputedName(accessExpression *ast.Node, enclosingDeclaration *ast.Node) { // get symbol of the first identifier of the entityName firstIdentifier := ast.GetFirstIdentifier(accessExpression) - name := b.ch.resolveName(enclosingDeclaration, firstIdentifier.Text(), ast.SymbolFlagsValue|ast.SymbolFlagsExportValue, nil /*nameNotFoundMessage*/, true /*isUse*/, false) + name := b.ch.resolveName(enclosingDeclaration, firstIdentifier.Text(), ast.SymbolFlagsValue|ast.SymbolFlagsExportValue, nil /*nameNotFoundMessage*/, false /*isUse*/, false) if name != nil { b.ctx.tracker.TrackSymbol(name, enclosingDeclaration, ast.SymbolFlagsValue) } else { // Name does not resolve at target location, track symbol at dest location (should be inaccessible) - fallback := b.ch.resolveName(firstIdentifier, firstIdentifier.Text(), ast.SymbolFlagsValue|ast.SymbolFlagsExportValue, nil /*nameNotFoundMessage*/, true /*isUse*/, false) + fallback := b.ch.resolveName(firstIdentifier, firstIdentifier.Text(), ast.SymbolFlagsValue|ast.SymbolFlagsExportValue, nil /*nameNotFoundMessage*/, false /*isUse*/, false) if fallback != nil { b.ctx.tracker.TrackSymbol(fallback, enclosingDeclaration, ast.SymbolFlagsValue) } diff --git a/tsc/internal/checker/nodecopy.go b/tsc/internal/checker/nodecopy.go index e3885a24be95d..c54113110b058 100644 --- a/tsc/internal/checker/nodecopy.go +++ b/tsc/internal/checker/nodecopy.go @@ -340,7 +340,7 @@ func getExistingNodeTreeVisitor(b *NodeBuilderImpl, bound *recoveryBoundary) *as } return introducesError, attachSymbolToLeftmostIdentifier(leftmost, node, sym), nil } - sym = b.ch.resolveEntityName(leftmost, meaning, true, true, nil) + sym = b.ch.resolveEntityNameEx(leftmost, meaning, true, true, nil, false /*use*/) if b.ctx.enclosingDeclaration != nil && !(sym != nil && sym.Flags()&ast.SymbolFlagsTypeParameter != 0) { sym = b.ch.getExportSymbolOfValueSymbolIfExported(sym) // Some declarations may be transplanted to a new location. @@ -348,7 +348,7 @@ func getExistingNodeTreeVisitor(b *NodeBuilderImpl, bound *recoveryBoundary) *as // We also check for the unknownSymbol because when we create a fake scope some parameters may actually not be usable // either because they are the expanded rest parameter, // or because they are the newly added parameters from the tuple, which might have different meanings in the original context - symAtLocation := b.ch.resolveEntityName(leftmost, meaning, true, true, b.ctx.enclosingDeclaration) + symAtLocation := b.ch.resolveEntityNameEx(leftmost, meaning, true, true, b.ctx.enclosingDeclaration, false /*use*/) if // Check for unusable parameters symbols symAtLocation == b.ch.unknownSymbol || diff --git a/tsc/testdata/baselines/reference/compiler/unusedTypeParameterQueryOrder(checkorder=editorfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/unusedTypeParameterQueryOrder(checkorder=editorfirst).errors.txt new file mode 100644 index 0000000000000..55aecda78cdca --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/unusedTypeParameterQueryOrder(checkorder=editorfirst).errors.txt @@ -0,0 +1,12 @@ +unusedTypeParameterQueryOrder.ts(3,17): error TS6196: 'T' is declared but never used. + + +==== unusedTypeParameterQueryOrder.ts (1 errors) ==== + class A { + f() { + return () => {}; + ~ +!!! error TS6196: 'T' is declared but never used. + } + } + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/unusedTypeParameterQueryOrder(checkorder=hoverfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/unusedTypeParameterQueryOrder(checkorder=hoverfirst).errors.txt new file mode 100644 index 0000000000000..55aecda78cdca --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/unusedTypeParameterQueryOrder(checkorder=hoverfirst).errors.txt @@ -0,0 +1,12 @@ +unusedTypeParameterQueryOrder.ts(3,17): error TS6196: 'T' is declared but never used. + + +==== unusedTypeParameterQueryOrder.ts (1 errors) ==== + class A { + f() { + return () => {}; + ~ +!!! error TS6196: 'T' is declared but never used. + } + } + \ No newline at end of file From d43fc4386e559c4851cd506d0045a91b38cb07d0 Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Sat, 7 Nov 2026 09:34:28 -0800 Subject: [PATCH 23/60] Do not let names in JSDoc keep imports Resolving the name of a JSDoc link, as hovering over a documented declaration does, checks it as an expression, which marked the imports it names as referenced. Emit then kept imports that checking alone elides. --- tsc/internal/checker/checker.go | 5 ++ ...isionQueryOrder(checkorder=editorfirst).js | 81 ------------------- 2 files changed, 5 insertions(+), 81 deletions(-) diff --git a/tsc/internal/checker/checker.go b/tsc/internal/checker/checker.go index c28793a0b5b4b..d90e7a1d7c382 100644 --- a/tsc/internal/checker/checker.go +++ b/tsc/internal/checker/checker.go @@ -29525,6 +29525,11 @@ func (c *Checker) markLinkedReferences(location *ast.Node, hint ReferenceHint, p // except for properties (which can be decorated). return } + if location.Flags&ast.NodeFlagsJSDoc != 0 { + // Neither are names in JSDoc, which only an editor resolves as + // expressions, such as the name of a link. + return + } switch hint { case ReferenceHintIdentifier: c.markIdentifierAliasReferenced(location) diff --git a/tsc/testdata/baselines/reference/compiler/jsdocLinkImportElisionQueryOrder(checkorder=editorfirst).js b/tsc/testdata/baselines/reference/compiler/jsdocLinkImportElisionQueryOrder(checkorder=editorfirst).js index 0da32e96e9494..bead869eaeb90 100644 --- a/tsc/testdata/baselines/reference/compiler/jsdocLinkImportElisionQueryOrder(checkorder=editorfirst).js +++ b/tsc/testdata/baselines/reference/compiler/jsdocLinkImportElisionQueryOrder(checkorder=editorfirst).js @@ -17,90 +17,9 @@ export function foo() {} Object.defineProperty(exports, "__esModule", { value: true }); //// [b.js] "use strict"; -var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { - if (k2 === undefined) k2 = k; - var desc = Object.getOwnPropertyDescriptor(m, k); - if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { - desc = { enumerable: true, get: function() { return m[k]; } }; - } - Object.defineProperty(o, k2, desc); -}) : (function(o, m, k, k2) { - if (k2 === undefined) k2 = k; - o[k2] = m[k]; -})); -var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { - Object.defineProperty(o, "default", { enumerable: true, value: v }); -}) : function(o, v) { - o["default"] = v; -}); -var __importStar = (this && this.__importStar) || (function () { - var ownKeys = function(o) { - ownKeys = Object.getOwnPropertyNames || function (o) { - var ar = []; - for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; - return ar; - }; - return ownKeys(o); - }; - return function (mod) { - if (mod && mod.__esModule) return mod; - var result = {}; - if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); - __setModuleDefault(result, mod); - return result; - }; -})(); Object.defineProperty(exports, "__esModule", { value: true }); exports.foo = foo; -const a = __importStar(require("./a")); /** * See {@link a.A}. */ function foo() { } - - -!!!! File /b.js differs from original emit in noCheck emit -//// [b.js] ---- Expected The full check baseline -+++ Actual with noCheck set -@@ -1,40 +1,6 @@ - "use strict"; --var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { -- if (k2 === undefined) k2 = k; -- var desc = Object.getOwnPropertyDescriptor(m, k); -- if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { -- desc = { enumerable: true, get: function() { return m[k]; } }; -- } -- Object.defineProperty(o, k2, desc); --}) : (function(o, m, k, k2) { -- if (k2 === undefined) k2 = k; -- o[k2] = m[k]; --})); --var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { -- Object.defineProperty(o, "default", { enumerable: true, value: v }); --}) : function(o, v) { -- o["default"] = v; --}); --var __importStar = (this && this.__importStar) || (function () { -- var ownKeys = function(o) { -- ownKeys = Object.getOwnPropertyNames || function (o) { -- var ar = []; -- for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; -- return ar; -- }; -- return ownKeys(o); -- }; -- return function (mod) { -- if (mod && mod.__esModule) return mod; -- var result = {}; -- if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); -- __setModuleDefault(result, mod); -- return result; -- }; --})(); - Object.defineProperty(exports, "__esModule", { value: true }); - exports.foo = foo; --const a = __importStar(require("./a")); - /** - * See {@link a.A}. - */ \ No newline at end of file From 2677361cf2746957a6b57a0db81b7423389bd395 Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Sat, 7 Nov 2026 10:29:47 -0800 Subject: [PATCH 24/60] Resolve the type of an accessor before the return type of its getter The type of a get accessor without a type annotation is the type its getter returns, but it is inferred apart from the return type of the getter's signature. Checking resolves the type of the accessor first, so a cycle through the accessor is detected and reported there. Asked for the return type of the getter first, as inlay hints do, the cycle through the accessor was detected only within the return type, whose result then hid the error. Resolving the type of the accessor first, as checking does, gives the same result either way. --- tsc/internal/checker/checker.go | 10 ++++++++++ ...eryOrder(checkorder=editorfirst).errors.txt | 18 ++++++++++++++++++ ...ypeQueryOrder(checkorder=editorfirst).types | 2 +- ...ueryOrder(checkorder=hoverfirst).errors.txt | 12 ------------ 4 files changed, 29 insertions(+), 13 deletions(-) create mode 100644 tsc/testdata/baselines/reference/compiler/getterReturnTypeQueryOrder(checkorder=editorfirst).errors.txt delete mode 100644 tsc/testdata/baselines/reference/compiler/unusedTypeParameterQueryOrder(checkorder=hoverfirst).errors.txt diff --git a/tsc/internal/checker/checker.go b/tsc/internal/checker/checker.go index d90e7a1d7c382..3d36c1a9b348e 100644 --- a/tsc/internal/checker/checker.go +++ b/tsc/internal/checker/checker.go @@ -21104,6 +21104,16 @@ func (c *Checker) getReturnTypeOfSignature(sig *Signature) *Type { if sig.resolvedReturnType != nil { return sig.resolvedReturnType } + if d := sig.declaration; d != nil && sig.target == nil && ast.IsGetAccessorDeclaration(d) && d.Type() == nil { + // The type of the accessor infers the same return type separately, and + // is what checking the getter resolves first. Resolved from within + // this return type instead, a cycle through the accessor would be + // detected at the accessor rather than here. + c.getTypeOfSymbol(c.getSymbolOfDeclaration(d)) + if sig.resolvedReturnType != nil { + return sig.resolvedReturnType + } + } if !c.pushTypeResolution(sig, TypeSystemPropertyNameResolvedReturnType) { return c.errorType } diff --git a/tsc/testdata/baselines/reference/compiler/getterReturnTypeQueryOrder(checkorder=editorfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/getterReturnTypeQueryOrder(checkorder=editorfirst).errors.txt new file mode 100644 index 0000000000000..4f28621217936 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/getterReturnTypeQueryOrder(checkorder=editorfirst).errors.txt @@ -0,0 +1,18 @@ +getterReturnTypeQueryOrder.ts(4,9): error TS7023: 'options' implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions. + + +==== getterReturnTypeQueryOrder.ts (1 errors) ==== + declare const props: Options; + + class Container { + get options() { + ~~~~~~~ +!!! error TS7023: 'options' implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions. + return { container: this, ...props } as Options; + } + } + + interface Options { + container?: Container; + } + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/getterReturnTypeQueryOrder(checkorder=editorfirst).types b/tsc/testdata/baselines/reference/compiler/getterReturnTypeQueryOrder(checkorder=editorfirst).types index 903243eef9cb7..df84cc21241ea 100644 --- a/tsc/testdata/baselines/reference/compiler/getterReturnTypeQueryOrder(checkorder=editorfirst).types +++ b/tsc/testdata/baselines/reference/compiler/getterReturnTypeQueryOrder(checkorder=editorfirst).types @@ -8,7 +8,7 @@ class Container { >Container : Container get options() { ->options : Options +>options : any return { container: this, ...props } as Options; >{ container: this, ...props } as Options : Options diff --git a/tsc/testdata/baselines/reference/compiler/unusedTypeParameterQueryOrder(checkorder=hoverfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/unusedTypeParameterQueryOrder(checkorder=hoverfirst).errors.txt deleted file mode 100644 index 55aecda78cdca..0000000000000 --- a/tsc/testdata/baselines/reference/compiler/unusedTypeParameterQueryOrder(checkorder=hoverfirst).errors.txt +++ /dev/null @@ -1,12 +0,0 @@ -unusedTypeParameterQueryOrder.ts(3,17): error TS6196: 'T' is declared but never used. - - -==== unusedTypeParameterQueryOrder.ts (1 errors) ==== - class A { - f() { - return () => {}; - ~ -!!! error TS6196: 'T' is declared but never used. - } - } - \ No newline at end of file From bf325bb811aa8842b1856b52fef1c89eaf8b6a26 Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Sun, 8 Nov 2026 00:36:19 -0800 Subject: [PATCH 25/60] Decide restrictive type parameters from their declarations Whether a conditional type is definitely true is checked with type parameters replaced by restrictive forms without constraints. A type parameter needed none if it had no constraint declaration and its constraint had not been computed yet, so an infer type parameter with a constraint implied by where it appears needed one only once something had asked for its constraint. Deciding from the declaration instead gives the same answer however the constraint was reached. --- tsc/internal/checker/checker.go | 15 ++++++++++++++- 1 file changed, 14 insertions(+), 1 deletion(-) diff --git a/tsc/internal/checker/checker.go b/tsc/internal/checker/checker.go index 3d36c1a9b348e..70d9b1ab0603e 100644 --- a/tsc/internal/checker/checker.go +++ b/tsc/internal/checker/checker.go @@ -25759,7 +25759,7 @@ func (c *Checker) getRestrictiveInstantiation(t *Type) *Type { } func (c *Checker) getRestrictiveTypeParameter(t *Type) *Type { - if t.AsTypeParameter().constraint == nil && c.getConstraintDeclaration(t) == nil || t.AsTypeParameter().constraint == c.noConstraintType { + if c.isRestrictivelyUnconstrained(t) { return t } key := CachedTypeKey{kind: CachedTypeKindRestrictiveTypeParameter, typeId: t.id} @@ -25773,6 +25773,19 @@ func (c *Checker) getRestrictiveTypeParameter(t *Type) *Type { return result } +// isRestrictivelyUnconstrained reports whether t needs no restrictive form. +// For a declared type parameter, that is decided from its declaration rather +// than from whether its constraint is computed yet, which an implied +// constraint of an infer type parameter would make depend on what was asked +// first. +func (c *Checker) isRestrictivelyUnconstrained(t *Type) bool { + if t.symbol != nil && core.Some(t.symbol.Declarations(), ast.IsTypeParameterDeclaration) { + return isUnconstrainedTypeParameter(t) + } + constraint := t.AsTypeParameter().constraint + return constraint == nil || constraint == c.noConstraintType +} + func (c *Checker) restrictiveMapperWorker(t *Type) *Type { if t.flags&TypeFlagsTypeParameter != 0 { return c.getRestrictiveTypeParameter(t) From 1a8d8c4d49083717400f92ca4aa5f69c30335951 Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Sun, 8 Nov 2026 09:07:18 -0800 Subject: [PATCH 26/60] Find the contextual type of a node from the innermost check of it A node checked again inside a check of itself, as when the call resolving its type re-enters through a callback, has a contextual type pushed for each check. The lookup took the outermost one, so the inner check of an argument saw the parameter type the outer resolution had instantiated with its inferences, rather than its own, and whether `const` type parameters made the argument readonly depended on whether its call had been resolved before. The original checker searches from the innermost, as this does now. --- tsc/internal/checker/checker.go | 2 +- ...unkReverseMapped(checkorder=default).types | 20 +++++++++---------- ...ReverseMapped(checkorder=typesfirst).types | 20 +++++++++---------- 3 files changed, 21 insertions(+), 21 deletions(-) diff --git a/tsc/internal/checker/checker.go b/tsc/internal/checker/checker.go index 70d9b1ab0603e..019ac5f1fc3b4 100644 --- a/tsc/internal/checker/checker.go +++ b/tsc/internal/checker/checker.go @@ -32261,7 +32261,7 @@ func (c *Checker) popContextualType() { } func (c *Checker) findContextualNode(node *ast.Node, includeCaches bool) int { - for i, info := range c.contextualInfos { + for i, info := range slices.Backward(c.contextualInfos) { if node == info.node && (includeCaches || !info.isCache) { return i } diff --git a/tsc/testdata/baselines/reference/compiler/circularScopeThunkReverseMapped(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/circularScopeThunkReverseMapped(checkorder=default).types index 41f30b7dbe3f2..6edac2ffefa43 100644 --- a/tsc/testdata/baselines/reference/compiler/circularScopeThunkReverseMapped(checkorder=default).types +++ b/tsc/testdata/baselines/reference/compiler/circularScopeThunkReverseMapped(checkorder=default).types @@ -27,8 +27,8 @@ declare function type(x: T): Type; >x : T export const $ = scope({ ->$ : Scope<{ a: Type; b: unknown; }> ->scope({ a: type("string").pipe(function (s) { return s.length; }), b: () => $.type("a").pipe(function (n) { return n === 0; }),}) : Scope<{ a: Type; b: unknown; }> +>$ : Scope<{ readonly a: Type; readonly b: () => Type; }> +>scope({ a: type("string").pipe(function (s) { return s.length; }), b: () => $.type("a").pipe(function (n) { return n === 0; }),}) : Scope<{ readonly a: Type; readonly b: () => Type; }> >scope : (def: Validate) => Scope >{ a: type("string").pipe(function (s) { return s.length; }), b: () => $.type("a").pipe(function (n) { return n === 0; }),} : { a: Type; b: () => Type; } @@ -52,9 +52,9 @@ export const $ = scope({ >$.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: unknown; }[k_1]> ->$ : Scope<{ a: Type; b: unknown; }> ->type : (k: k_1) => Resolve<{ a: Type; b: unknown; }[k_1]> +>$.type : (k: k_1) => Resolve<{ readonly a: Type; readonly b: () => Type; }[k_1]> +>$ : Scope<{ readonly a: Type; readonly b: () => Type; }> +>type : (k: k_1) => Resolve<{ readonly a: Type; readonly b: () => Type; }[k_1]> >"a" : "a" >pipe : (f: (x: number) => U) => Type >function (n) { return n === 0; } : (n: number) => n is 0 @@ -67,8 +67,8 @@ export const $ = scope({ // Entered from the function in the first property when queried in reverse export const $2 = scope({ ->$2 : Scope<{ a: Type; b: unknown; }> ->scope({ a: type("string").pipe(function (s) { return s.length; }), b: () => $2.type("a").pipe((n: number) => n === 0),}) : Scope<{ a: Type; b: unknown; }> +>$2 : Scope<{ readonly a: Type; readonly b: () => Type; }> +>scope({ a: type("string").pipe(function (s) { return s.length; }), b: () => $2.type("a").pipe((n: number) => n === 0),}) : Scope<{ readonly a: Type; readonly b: () => Type; }> >scope : (def: Validate) => Scope >{ a: type("string").pipe(function (s) { return s.length; }), b: () => $2.type("a").pipe((n: number) => n === 0),} : { a: Type; b: () => Type; } @@ -92,9 +92,9 @@ export const $2 = scope({ >$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: unknown; }[k_1]> ->$2 : Scope<{ a: Type; b: unknown; }> ->type : (k: k_1) => Resolve<{ a: Type; b: unknown; }[k_1]> +>$2.type : (k: k_1) => Resolve<{ readonly a: Type; readonly b: () => Type; }[k_1]> +>$2 : Scope<{ readonly a: Type; readonly b: () => Type; }> +>type : (k: k_1) => Resolve<{ readonly a: Type; readonly b: () => Type; }[k_1]> >"a" : "a" >pipe : (f: (x: number) => U) => Type >(n: number) => n === 0 : (n: number) => n is 0 diff --git a/tsc/testdata/baselines/reference/compiler/circularScopeThunkReverseMapped(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/circularScopeThunkReverseMapped(checkorder=typesfirst).types index 41f30b7dbe3f2..6edac2ffefa43 100644 --- a/tsc/testdata/baselines/reference/compiler/circularScopeThunkReverseMapped(checkorder=typesfirst).types +++ b/tsc/testdata/baselines/reference/compiler/circularScopeThunkReverseMapped(checkorder=typesfirst).types @@ -27,8 +27,8 @@ declare function type(x: T): Type; >x : T export const $ = scope({ ->$ : Scope<{ a: Type; b: unknown; }> ->scope({ a: type("string").pipe(function (s) { return s.length; }), b: () => $.type("a").pipe(function (n) { return n === 0; }),}) : Scope<{ a: Type; b: unknown; }> +>$ : Scope<{ readonly a: Type; readonly b: () => Type; }> +>scope({ a: type("string").pipe(function (s) { return s.length; }), b: () => $.type("a").pipe(function (n) { return n === 0; }),}) : Scope<{ readonly a: Type; readonly b: () => Type; }> >scope : (def: Validate) => Scope >{ a: type("string").pipe(function (s) { return s.length; }), b: () => $.type("a").pipe(function (n) { return n === 0; }),} : { a: Type; b: () => Type; } @@ -52,9 +52,9 @@ export const $ = scope({ >$.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: unknown; }[k_1]> ->$ : Scope<{ a: Type; b: unknown; }> ->type : (k: k_1) => Resolve<{ a: Type; b: unknown; }[k_1]> +>$.type : (k: k_1) => Resolve<{ readonly a: Type; readonly b: () => Type; }[k_1]> +>$ : Scope<{ readonly a: Type; readonly b: () => Type; }> +>type : (k: k_1) => Resolve<{ readonly a: Type; readonly b: () => Type; }[k_1]> >"a" : "a" >pipe : (f: (x: number) => U) => Type >function (n) { return n === 0; } : (n: number) => n is 0 @@ -67,8 +67,8 @@ export const $ = scope({ // Entered from the function in the first property when queried in reverse export const $2 = scope({ ->$2 : Scope<{ a: Type; b: unknown; }> ->scope({ a: type("string").pipe(function (s) { return s.length; }), b: () => $2.type("a").pipe((n: number) => n === 0),}) : Scope<{ a: Type; b: unknown; }> +>$2 : Scope<{ readonly a: Type; readonly b: () => Type; }> +>scope({ a: type("string").pipe(function (s) { return s.length; }), b: () => $2.type("a").pipe((n: number) => n === 0),}) : Scope<{ readonly a: Type; readonly b: () => Type; }> >scope : (def: Validate) => Scope >{ a: type("string").pipe(function (s) { return s.length; }), b: () => $2.type("a").pipe((n: number) => n === 0),} : { a: Type; b: () => Type; } @@ -92,9 +92,9 @@ export const $2 = scope({ >$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: unknown; }[k_1]> ->$2 : Scope<{ a: Type; b: unknown; }> ->type : (k: k_1) => Resolve<{ a: Type; b: unknown; }[k_1]> +>$2.type : (k: k_1) => Resolve<{ readonly a: Type; readonly b: () => Type; }[k_1]> +>$2 : Scope<{ readonly a: Type; readonly b: () => Type; }> +>type : (k: k_1) => Resolve<{ readonly a: Type; readonly b: () => Type; }[k_1]> >"a" : "a" >pipe : (f: (x: number) => U) => Type >(n: number) => n === 0 : (n: number) => n is 0 From a7c4e00fc8231f3fcf623300d1b4b242f80af12f Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Sun, 8 Nov 2026 11:08:01 -0800 Subject: [PATCH 27/60] Reuse cached comparisons the same way wherever they are reused A comparison that used variances it could not measure reliably marks its cached result, and reusing the result marks the variance measurement in progress, just as the comparison would. The fast path through cached results in isTypeRelatedTo did not, so a variance measured after the comparison had been cached came out different from one measured before, and whether two references of a generic type were related depended on which declaration came first (64891). The declaration order test now agrees across its two orders. Fixes 64891 --- tsc/internal/checker/relater.go | 1 + ...enericInterfaceDeclarationOrder.errors.txt | 22 ------------- .../varianceDeclarationOrder.errors.txt | 31 ------------------- 3 files changed, 1 insertion(+), 53 deletions(-) delete mode 100644 tsc/testdata/baselines/reference/compiler/recursiveGenericInterfaceDeclarationOrder.errors.txt delete mode 100644 tsc/testdata/baselines/reference/compiler/varianceDeclarationOrder.errors.txt diff --git a/tsc/internal/checker/relater.go b/tsc/internal/checker/relater.go index e5b173a299b10..6d5d11dd06faf 100644 --- a/tsc/internal/checker/relater.go +++ b/tsc/internal/checker/relater.go @@ -195,6 +195,7 @@ func (c *Checker) isTypeRelatedTo(source *Type, target *Type, relation *Relation id, _ := getRelationKey(source, target, IntersectionStateNone, relation == c.identityRelation, false) related := relation.get(id) if related != RelationComparisonResultNone { + c.reliabilityFlags |= related & (RelationComparisonResultReportsUnmeasurable | RelationComparisonResultReportsUnreliable) return related&RelationComparisonResultSucceeded != 0 } } diff --git a/tsc/testdata/baselines/reference/compiler/recursiveGenericInterfaceDeclarationOrder.errors.txt b/tsc/testdata/baselines/reference/compiler/recursiveGenericInterfaceDeclarationOrder.errors.txt deleted file mode 100644 index 61a80e2b83284..0000000000000 --- a/tsc/testdata/baselines/reference/compiler/recursiveGenericInterfaceDeclarationOrder.errors.txt +++ /dev/null @@ -1,22 +0,0 @@ -recursiveGenericInterfaceDeclarationOrder.ts(13,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; }'. - - -==== recursiveGenericInterfaceDeclarationOrder.ts (1 errors) ==== - // The assignment is valid, as method parameters are compared bivariantly, and - // must be accepted whichever of the interfaces is declared first. - - type M = { kind: "m" }; - type Filtered = { [K in keyof T as T[K] extends M ? K : never]: T[K] }; - interface Config { measure: keyof T } - interface Ref { dataset: DS, N> } - interface DS { - a(config: Config>): void; - b: Ref; - } - declare const x: DS<{ total: M }, string>; - export const y: DS, string> = x; - ~ -!!! 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; }'. - \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/varianceDeclarationOrder.errors.txt b/tsc/testdata/baselines/reference/compiler/varianceDeclarationOrder.errors.txt deleted file mode 100644 index 76e1b58ab4906..0000000000000 --- a/tsc/testdata/baselines/reference/compiler/varianceDeclarationOrder.errors.txt +++ /dev/null @@ -1,31 +0,0 @@ -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 From 066c717d2d145ab6dabdcb1e7fc00009d822a4d5 Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Sun, 8 Nov 2026 22:34:36 -0800 Subject: [PATCH 28/60] Keep the narrowing of a type variable in a conditional's true branch In the true branch of a conditional type, a reference to the check type is narrowed to the extends type by a substitution type. Instantiating it dropped the narrowing whenever the restrictive instantiation of the base type was assignable to the constraint, on the grounds that the conditional type would then resolve to its true branch. A conditional type whose check type is a type variable is deferred instead, so for a type variable that test decides nothing, and it can pass without the base satisfying the constraint: a deferred conditional type whose restrictive instantiation has no distributive constraint can have the base constraint never. Whether that conditional type had a distributive constraint depended on which restrictive instantiations were computed before, so the narrowing of a type such as Children> in type Children = S["states"] extends Record ? S["states"] : Record; was lost or kept depending on order, and losing it rejects Children<...> as a Record although both branches are one. (seen in xstate) --- tsc/internal/checker/checker.go | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/tsc/internal/checker/checker.go b/tsc/internal/checker/checker.go index 019ac5f1fc3b4..51d89967d51ed 100644 --- a/tsc/internal/checker/checker.go +++ b/tsc/internal/checker/checker.go @@ -23483,16 +23483,15 @@ func (c *Checker) instantiateTypeWorker(t *Type, m *TypeMapper, alias *TypeAlias newConstraint := c.instantiateType(t.AsSubstitutionType().constraint, m) // A substitution type originates in the true branch of a conditional type and can be resolved // to just the base type in the same cases as the conditional type resolves to its true branch - // (because the base type is then known to satisfy the constraint). - if newBaseType.flags&TypeFlagsTypeVariable != 0 && c.isGenericType(newConstraint) { + // (because the base type is then known to satisfy the constraint). A conditional type whose + // check type is a type variable is deferred instead, so a substitution for a type variable is + // kept. + if newBaseType.flags&TypeFlagsTypeVariable != 0 { return c.getSubstitutionType(newBaseType, newConstraint) } if newConstraint.flags&TypeFlagsAnyOrUnknown != 0 || c.isTypeAssignableTo(c.getRestrictiveInstantiation(newBaseType), c.getRestrictiveInstantiation(newConstraint)) { return newBaseType } - if newBaseType.flags&TypeFlagsTypeVariable != 0 { - return c.getSubstitutionType(newBaseType, newConstraint) - } return c.getIntersectionType([]*Type{newConstraint, newBaseType}) } return t From 1099d069b01f1f5875c4eb31f1e4adf7a1d76d10 Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Tue, 10 Nov 2026 22:24:31 -0800 Subject: [PATCH 29/60] Analyze each flow loop independently of the reference reaching it A loop's control flow type is cached for every reference with the same key, but its analysis counted depth from the reference that reached the loop first. A reference already near the depth limit made the loop give up and cached an error type for all references, including those inside the loop, while any other order cached a correct type. Querying a deep reference first could thus turn a whole loop's narrowing into any and report TS2563 that checking in program order does not. The analysis of a loop now measures depth from the loop and neither reuses nor leaves behind nodes the reference visited, so its result and whether it gives up do not depend on the reference. A loop that gives up is remembered, so every reference reaching it reports the failure as it would by analyzing the loop itself. As depth no longer accumulates across loops, a much larger limit on the whole walk only guards the call stack, and is reached only by runaway walks. --- tsc/internal/checker/checker.go | 10 +- tsc/internal/checker/flow.go | 53 +- ...eckOrder(checkorder=typesfirst).errors.txt | 1031 ----------------- ...pthCheckOrder(checkorder=typesfirst).types | 6 +- 4 files changed, 58 insertions(+), 1042 deletions(-) delete mode 100644 tsc/testdata/baselines/reference/compiler/flowLoopDepthCheckOrder(checkorder=typesfirst).errors.txt diff --git a/tsc/internal/checker/checker.go b/tsc/internal/checker/checker.go index 51d89967d51ed..2fa38c6844f2e 100644 --- a/tsc/internal/checker/checker.go +++ b/tsc/internal/checker/checker.go @@ -259,6 +259,12 @@ type FlowLoopKey struct { refKey CacheHashKey } +type flowLoopCacheEntry struct { + t *Type + // The analysis of the loop gave up because it was too deep. + tooDeep bool +} + type FlowLoopInfo struct { key FlowLoopKey types []*Type @@ -851,7 +857,7 @@ type Checker struct { lastGetCombinedModifierFlagsResult ast.ModifierFlags freeinferenceState *InferenceState freeFlowState *FlowState - flowLoopCache map[FlowLoopKey]*Type + flowLoopCache map[FlowLoopKey]flowLoopCacheEntry flowLoopStack []FlowLoopInfo sharedFlows []SharedFlow antecedentTypes []*Type @@ -1114,7 +1120,7 @@ func NewChecker(program Program, tracer *Tracer) (*Checker, *sync.Mutex) { 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.flowLoopCache = make(map[FlowLoopKey]flowLoopCacheEntry) c.flowNodeReachable = make(map[*ast.FlowNode]bool) c.flowNodePostSuper = make(map[*ast.FlowNode]bool) c.subtypeRelation = &Relation{} diff --git a/tsc/internal/checker/flow.go b/tsc/internal/checker/flow.go index 50fdea5bbb724..7dd6c4d3d9c4e 100644 --- a/tsc/internal/checker/flow.go +++ b/tsc/internal/checker/flow.go @@ -44,6 +44,8 @@ type FlowState struct { flowContainer *ast.Node refKey CacheHashKey depth int + depthBase int // depth of the loop analyses depth is measured from + limitHits int sharedFlowStart int reduceLabels []*ast.FlowReduceLabelData next *FlowState @@ -111,14 +113,25 @@ func (c *Checker) getFlowTypeOfReferenceEx(reference *ast.Node, declaredType *Ty return resultType } +// A walk gives up after maxFlowDepth nested steps. Each loop is analyzed +// once per reference key and its result is cached, so the analysis of a +// loop measures depth from the loop rather than from the reference that +// reached it first. maxFlowTotalDepth only guards the call stack against +// loop analyses nested so deeply that the walk is certain to be runaway. +const ( + maxFlowDepth = 2000 + maxFlowTotalDepth = 20 * maxFlowDepth +) + func (c *Checker) getTypeAtFlowNode(f *FlowState, flow *ast.FlowNode) FlowType { - if f.depth == 2000 { + if f.depth == maxFlowDepth || f.depthBase+f.depth == maxFlowTotalDepth { // We have made 2000 recursive invocations. To avoid overflowing the call stack we report an error // and 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. if tr := c.tracer; tr != nil { tr.Instant(tracing.PhaseCheckTypes, "getTypeAtFlowNode_DepthLimit", map[string]any{"depth": f.depth}) } + f.limitHits++ c.reportFlowControlError(f.reference) return FlowType{t: c.errorType} } @@ -1330,9 +1343,37 @@ func (c *Checker) getTypeAtFlowLoopLabel(f *FlowState, flow *ast.FlowNode) FlowT key := FlowLoopKey{flowNode: flow, refKey: f.refKey} // 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 cached := c.flowLoopCache[key]; cached.t != nil { + if cached.tooDeep { + // Analyzing the loop again would give up again. + c.reportFlowControlError(f.reference) + } + return FlowType{t: cached.t} + } + // The result is cached for every reference with this key, so the analysis + // neither uses the depth left to this reference nor the nodes this + // reference already visited, and the nodes it visits are not reused + // after it. + depth, depthBase, sharedFlowStart, hits := f.depth, f.depthBase, f.sharedFlowStart, f.limitHits + f.depthBase += f.depth + f.depth = 0 + f.sharedFlowStart = len(c.sharedFlows) + result := c.getTypeAtFlowLoopLabelUncached(f, flow, key) + c.sharedFlows = c.sharedFlows[:f.sharedFlowStart] + f.depth, f.depthBase, f.sharedFlowStart = depth, depthBase, sharedFlowStart + if cached := c.flowLoopCache[key]; cached.t != nil { + if f.limitHits != hits { + cached.tooDeep = true + c.flowLoopCache[key] = cached + } else if cached.tooDeep { + // Another reference completed the analysis meanwhile. + c.reportFlowControlError(f.reference) + } } + return result +} + +func (c *Checker) getTypeAtFlowLoopLabelUncached(f *FlowState, flow *ast.FlowNode, key FlowLoopKey) FlowType { // If this flow loop junction and reference are already being processed, return // the union of the types computed for each branch so far, marked as incomplete. // It is possible to see an empty array in cases where loops are nested and the @@ -1377,8 +1418,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 cached := c.flowLoopCache[key]; cached.t != nil { + return FlowType{t: cached.t} } } antecedentTypes = core.AppendIfUnique(antecedentTypes, flowType.t) @@ -1401,7 +1442,7 @@ func (c *Checker) getTypeAtFlowLoopLabel(f *FlowState, flow *ast.FlowNode) FlowT if firstAntecedentType.incomplete { return c.newFlowType(result, true /*incomplete*/) } - c.flowLoopCache[key] = result + c.flowLoopCache[key] = flowLoopCacheEntry{t: result} return FlowType{t: result} } diff --git a/tsc/testdata/baselines/reference/compiler/flowLoopDepthCheckOrder(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/flowLoopDepthCheckOrder(checkorder=typesfirst).errors.txt deleted file mode 100644 index 2e4675292eeb0..0000000000000 --- a/tsc/testdata/baselines/reference/compiler/flowLoopDepthCheckOrder(checkorder=typesfirst).errors.txt +++ /dev/null @@ -1,1031 +0,0 @@ -flowLoopDepthCheckOrder.ts(7,1): error TS2563: The containing function or module body is too large for control flow analysis. - - -==== flowLoopDepthCheckOrder.ts (1 errors) ==== - // A loop is analyzed once for all references to the same name and the - // result is cached, so its analysis must not depend on the reference that - // reached it first. 'deep' reaches the loop with little depth left. - // Analyzing the loop from there must not make 'x' inside it give up when - // 'deep' is queried first. - - declare function cond(): boolean; - ~~~~~~~ -!!! error TS2563: The containing function or module body is too large for control flow analysis. - declare let b: boolean; - - let x: string | number = 0; - while (cond()) { - if (typeof x === "string") { x = 1; } else { x = "a"; } - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - } - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - if (b) {} - const deep = x; - \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/flowLoopDepthCheckOrder(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/flowLoopDepthCheckOrder(checkorder=typesfirst).types index 247a176187cc8..efbb9a68a52ad 100644 --- a/tsc/testdata/baselines/reference/compiler/flowLoopDepthCheckOrder(checkorder=typesfirst).types +++ b/tsc/testdata/baselines/reference/compiler/flowLoopDepthCheckOrder(checkorder=typesfirst).types @@ -24,7 +24,7 @@ while (cond()) { if (typeof x === "string") { x = 1; } else { x = "a"; } >typeof x === "string" : boolean >typeof x : "bigint" | "boolean" | "function" | "number" | "object" | "string" | "symbol" | "undefined" ->x : any +>x : string | number >"string" : "string" >x = 1 : 1 >x : string | number @@ -3064,6 +3064,6 @@ if (b) {} >b : boolean const deep = x; ->deep : any ->x : any +>deep : string | number +>x : string | number From 7949d2852f9b15fdb3d284ecaa6d115240321f9d Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Tue, 10 Nov 2026 22:27:20 -0800 Subject: [PATCH 30/60] Make base constraints independent of the walk that reaches them A walk for a base constraint gives up on types nested 10 levels deep that are already on its stack, so a base constraint computed inside a walk depended on the types the walk came through, and caching it let every later walk reuse that. Real projects reach this: in webpack and xstate, cached constraints of zod and xstate types disagreed with the ones the walks reusing them would have computed. More types on the stack only make a walk give up sooner, so a base constraint whose own walk did not give up is the same however deep it is entered, and stays cached. One whose walk gave up inside another is not cached. Each cached constraint keeps how deep its own walk went, and a walk reuses it only where that depth stays clear of the limit; it computes the constraint again otherwise, as its own kind of resolution so that re-entering it is still a cycle. That made distributiveConditionalBaseConstraint report a false error. The code there passed only because a deep walk had cached "no constraint" for a conditional type whose constraints lead back to it, which a walk from the type itself finds circular, and a conditional type with a circular base constraint had no constraint at all. Its constraint is computed from its branches one level at a time, so it is well defined regardless, and is now available; the cycle members themselves stay circular, as infiniteConstraints needs. A distributive conditional type still does not distribute over such a check type, though: doing so leads back into the circularity and leaves it without a usable constraint, where the constraint of its branches was well defined. arktype spreads Parameters of such a type. --- tsc/internal/checker/checker.go | 123 +++++++++++++++--- tsc/internal/checker/types.go | 10 +- ...hCheckOrder(checkorder=default).errors.txt | 5 +- ...epthCheckOrder(checkorder=default).symbols | 2 + ...tDepthCheckOrder(checkorder=default).types | 4 +- ...eckOrder(checkorder=typesfirst).errors.txt | 16 +++ ...hCheckOrder(checkorder=typesfirst).symbols | 2 - ...pthCheckOrder(checkorder=typesfirst).types | 4 +- 8 files changed, 131 insertions(+), 35 deletions(-) create mode 100644 tsc/testdata/baselines/reference/compiler/baseConstraintDepthCheckOrder(checkorder=typesfirst).errors.txt diff --git a/tsc/internal/checker/checker.go b/tsc/internal/checker/checker.go index 2fa38c6844f2e..b153a4f169e1a 100644 --- a/tsc/internal/checker/checker.go +++ b/tsc/internal/checker/checker.go @@ -67,6 +67,7 @@ const ( TypeSystemPropertyNameInitializerIsUndefined TypeSystemPropertyNameAliasTarget TypeSystemPropertyNameComputedPropertyName + TypeSystemPropertyNameBaseConstraintInWalk ) type TypeResolution struct { @@ -616,6 +617,7 @@ type Checker struct { memberLayoutCount uint32 instantiationStack []*Type conditionalConstraintDepth uint32 + baseConstraintWalk baseConstraintWalk inlineLevel int serializationLevel int currentNode *ast.Node @@ -18056,10 +18058,11 @@ func (c *Checker) getConstraintFromIndexedAccess(t *Type) *Type { } func (c *Checker) getConstraintOfConditionalType(t *Type) *Type { - if c.hasNonCircularBaseConstraint(t) { - return c.getConstraintFromConditionalType(t) - } - return nil + // The constraint of a conditional type is computed from its branches one + // level at a time, so it is well defined even where following constraints + // from it leads back to it, which makes its base constraint circular. + // Callers following constraints further stop where they nest too deeply. + return c.getConstraintFromConditionalType(t) } func (c *Checker) getConstraintFromConditionalType(t *Type) *Type { @@ -18108,7 +18111,14 @@ func (c *Checker) getConstraintOfDistributiveConditionalType(t *Type) *Type { if d.root.isDistributive && c.cachedTypes[CachedTypeKey{kind: CachedTypeKindRestrictiveInstantiation, typeId: t.id}] != t { constraint := c.getSimplifiedType(d.checkType, false /*writing*/) if constraint == d.checkType { - constraint = c.getConstraintOfType(constraint) + // A conditional check type whose base constraint is circular + // has a constraint, but distributing over it leads back into + // the circularity, leaving this type without a usable one. + if constraint.flags&TypeFlagsConditional != 0 && !c.hasNonCircularBaseConstraint(constraint) { + constraint = nil + } else { + constraint = c.getConstraintOfType(constraint) + } } if constraint != nil && constraint != d.checkType { instantiated := c.getConditionalTypeInstantiation(t, prependTypeMapping(d.root.checkType, constraint, d.mapper), true /*forConstraint*/, nil) @@ -19741,6 +19751,8 @@ func (c *Checker) typeResolutionHasProperty(r *TypeResolution) bool { return c.aliasSymbolLinks.Get(r.target.(*ast.Symbol)).aliasTarget != nil case TypeSystemPropertyNameComputedPropertyName: return c.typeNodeLinks.Get(r.target.(*ast.Node)).resolvedType != nil + case TypeSystemPropertyNameBaseConstraintInWalk: + return false } panic("Unhandled case in typeResolutionHasProperty") } @@ -23764,7 +23776,7 @@ func (c *Checker) instantiateMappedType(t *Type, m *TypeMapper, alias *TypeAlias return s } if d.declaration.NameType == nil { - if c.isArrayType(s) || s.flags&TypeFlagsAny != 0 && c.findResolutionCycleStartIndex(typeVariable, TypeSystemPropertyNameResolvedBaseConstraint) < 0 && c.hasArrayOrTypeTypeConstraint(typeVariable) { + if c.isArrayType(s) || s.flags&TypeFlagsAny != 0 && !c.isBaseConstraintInProgress(typeVariable) && c.hasArrayOrTypeTypeConstraint(typeVariable) { return c.instantiateMappedArrayType(s, t, prependTypeMapping(typeVariable, s, m)) } if isTupleType(s) { @@ -28773,28 +28785,72 @@ func (c *Checker) getBaseConstraintOfType(t *Type) *Type { return nil } +// Base constraint walks +// +// A walk for a base constraint gives up on types nested 10 levels deep that +// are already on its stack, or nested 50 levels deep, so a base constraint +// computed inside a walk may depend on the types the walk came through. As +// more types on the stack only make a walk give up sooner, a base constraint +// whose own walk did not give up is the same wherever it is computed, and is +// kept; one whose walk gave up is kept only if the walk was started for it. +// A kept base constraint is reused inside a walk only where its own walk, +// whose depth is kept with it, stays within the first 10 levels, where +// nothing gives up. Elsewhere it is computed again inside that walk, as a +// distinct resolution so that re-entering it is still a cycle. + +const ( + baseConstraintFreeDepth = 10 + baseConstraintMaxDepth = 50 +) + +type baseConstraintWalk struct { + depth int32 // Deepest level the walk has reached + gaveUp bool +} + func (c *Checker) getResolvedBaseConstraint(t *Type, stack []RecursionId) *Type { constrained := t.AsConstrainedType() if constrained == nil { return t } if constrained.resolvedBaseConstraint != nil { + if len(stack) != 0 { + depth := int32(len(stack)) + int32(t.baseConstraintHeight) + if depth >= baseConstraintFreeDepth { + constraint, _, _ := c.resolveBaseConstraint(t, stack, TypeSystemPropertyNameBaseConstraintInWalk) + return constraint + } + c.baseConstraintWalk.depth = max(c.baseConstraintWalk.depth, depth) + } return constrained.resolvedBaseConstraint } - if !c.pushTypeResolution(t, TypeSystemPropertyNameResolvedBaseConstraint) { - return c.circularConstraintType + saveWalk := c.baseConstraintWalk + if len(stack) == 0 { + c.baseConstraintWalk = baseConstraintWalk{} } - var constraint *Type - // We always explore at least 10 levels of nested constraints. Thereafter, we continue to explore - // up to 50 levels of nested constraints provided there are no "deeply nested" types on the stack - // (i.e. no types for which five instantiations have been recorded on the stack). If we reach 50 - // levels of nesting, we are presumably exploring a repeating pattern with a long cycle that hasn't - // yet triggered the deeply nested limiter. We have no test cases that actually get to 50 levels of - // nesting, so it is effectively just a safety stop. - identity := getRecursionIdentity(t) - if len(stack) < 10 || len(stack) < 50 && !slices.Contains(stack, identity) { - constraint = c.computeBaseConstraint(c.getSimplifiedType(t /*writing*/, false), append(stack, identity)) + constraint, height, gaveUp := c.resolveBaseConstraint(t, stack, TypeSystemPropertyNameResolvedBaseConstraint) + if len(stack) == 0 { + c.baseConstraintWalk = saveWalk + } + if gaveUp && len(stack) != 0 { + // Depends on the walk it was computed in. + return constraint + } + if constrained.resolvedBaseConstraint == nil { + t.baseConstraintHeight = uint8(min(height, math.MaxUint8)) + constrained.resolvedBaseConstraint = constraint } + return constraint +} + +// resolveBaseConstraint computes the base constraint of t inside the walk +// with stack as the resolution of propertyName, and returns it with the depth +// its own walk reached and whether its own walk gave up. +func (c *Checker) resolveBaseConstraint(t *Type, stack []RecursionId, propertyName TypeSystemPropertyName) (*Type, int32, bool) { + if !c.pushTypeResolution(t, propertyName) { + return c.circularConstraintType, 0, false + } + constraint, height, gaveUp := c.walkBaseConstraint(t, stack) if !c.popTypeResolution() { if t.flags&TypeFlagsTypeParameter != 0 { errorNode := c.getConstraintDeclaration(t) @@ -28810,10 +28866,35 @@ func (c *Checker) getResolvedBaseConstraint(t *Type, stack []RecursionId) *Type if constraint == nil { constraint = c.noConstraintType } - if constrained.resolvedBaseConstraint == nil { - constrained.resolvedBaseConstraint = constraint + return constraint, height, gaveUp +} + +func (c *Checker) isBaseConstraintInProgress(t *Type) bool { + return c.findResolutionCycleStartIndex(t, TypeSystemPropertyNameResolvedBaseConstraint) >= 0 || c.findResolutionCycleStartIndex(t, TypeSystemPropertyNameBaseConstraintInWalk) >= 0 +} + +// walkBaseConstraint computes the base constraint of t inside the walk with +// stack, and returns it with the depth its own walk reached and whether its +// own walk gave up. +func (c *Checker) walkBaseConstraint(t *Type, stack []RecursionId) (*Type, int32, bool) { + saveWalk := c.baseConstraintWalk + c.baseConstraintWalk = baseConstraintWalk{depth: int32(len(stack))} + var constraint *Type + // We always explore at least 10 levels of nested constraints. Thereafter, we continue to explore + // up to 50 levels of nested constraints provided there are no "deeply nested" types on the stack + // (i.e. no types for which five instantiations have been recorded on the stack). If we reach 50 + // levels of nesting, we are presumably exploring a repeating pattern with a long cycle that hasn't + // yet triggered the deeply nested limiter. We have no test cases that actually get to 50 levels of + // nesting, so it is effectively just a safety stop. + identity := getRecursionIdentity(t) + if len(stack) < baseConstraintFreeDepth || len(stack) < baseConstraintMaxDepth && !slices.Contains(stack, identity) { + constraint = c.computeBaseConstraint(c.getSimplifiedType(t /*writing*/, false), append(stack, identity)) + } else { + c.baseConstraintWalk.gaveUp = true } - return constraint + walk := c.baseConstraintWalk + c.baseConstraintWalk = baseConstraintWalk{depth: max(saveWalk.depth, walk.depth), gaveUp: saveWalk.gaveUp || walk.gaveUp} + return constraint, walk.depth - int32(len(stack)), walk.gaveUp } func (c *Checker) computeBaseConstraint(t *Type, stack []RecursionId) *Type { diff --git a/tsc/internal/checker/types.go b/tsc/internal/checker/types.go index 91d71a575ea6a..dfcd7ddbead01 100644 --- a/tsc/internal/checker/types.go +++ b/tsc/internal/checker/types.go @@ -808,10 +808,12 @@ 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 + // Depth of the walk for the cached base constraint; see "Base constraint walks" + baseConstraintHeight uint8 + generation uint16 // see Checker.typeGeneration; zero until computed + symbol *ast.Symbol + alias *TypeAlias + checker *Checker } // Enforce the layout required by the pointer conversions, on every architecture. diff --git a/tsc/testdata/baselines/reference/compiler/baseConstraintDepthCheckOrder(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/baseConstraintDepthCheckOrder(checkorder=default).errors.txt index a247afb883ac5..a56b4e4614407 100644 --- a/tsc/testdata/baselines/reference/compiler/baseConstraintDepthCheckOrder(checkorder=default).errors.txt +++ b/tsc/testdata/baselines/reference/compiler/baseConstraintDepthCheckOrder(checkorder=default).errors.txt @@ -1,8 +1,7 @@ baseConstraintDepthCheckOrder.ts(7,7): error TS2339: Property 'length' does not exist on type 'T0'. -baseConstraintDepthCheckOrder.ts(8,7): error TS2339: Property 'length' does not exist on type 'T20'. -==== baseConstraintDepthCheckOrder.ts (2 errors) ==== +==== baseConstraintDepthCheckOrder.ts (1 errors) ==== // The base constraint of 'T0' is 60 type parameters deep and gives up after // 50, while that of 'T20' is found 40 deep. Neither may depend on which was // computed first: computing 'T0' first must not leave 'T20' without its @@ -13,7 +12,5 @@ baseConstraintDepthCheckOrder.ts(8,7): error TS2339: Property 'length' does not ~~~~~~ !!! error TS2339: Property 'length' does not exist on type 'T0'. y.length; - ~~~~~~ -!!! error TS2339: Property 'length' does not exist on type 'T20'. } \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/baseConstraintDepthCheckOrder(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/baseConstraintDepthCheckOrder(checkorder=default).symbols index 5cbd14622b89f..bea0526aba4e1 100644 --- a/tsc/testdata/baselines/reference/compiler/baseConstraintDepthCheckOrder(checkorder=default).symbols +++ b/tsc/testdata/baselines/reference/compiler/baseConstraintDepthCheckOrder(checkorder=default).symbols @@ -136,6 +136,8 @@ function fx : Symbol(x, Decl(baseConstraintDepthCheckOrder.ts, 5, 1015)) y.length; +>y.length : Symbol(String.length, Decl(lib.es5.d.ts, --, --)) >y : Symbol(y, Decl(baseConstraintDepthCheckOrder.ts, 5, 1021)) +>length : Symbol(String.length, Decl(lib.es5.d.ts, --, --)) } diff --git a/tsc/testdata/baselines/reference/compiler/baseConstraintDepthCheckOrder(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/baseConstraintDepthCheckOrder(checkorder=default).types index fbc7735f18c4c..e36c86990b2ec 100644 --- a/tsc/testdata/baselines/reference/compiler/baseConstraintDepthCheckOrder(checkorder=default).types +++ b/tsc/testdata/baselines/reference/compiler/baseConstraintDepthCheckOrder(checkorder=default).types @@ -17,8 +17,8 @@ function flength : any y.length; ->y.length : any +>y.length : number >y : T20 ->length : any +>length : number } diff --git a/tsc/testdata/baselines/reference/compiler/baseConstraintDepthCheckOrder(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/baseConstraintDepthCheckOrder(checkorder=typesfirst).errors.txt new file mode 100644 index 0000000000000..a56b4e4614407 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/baseConstraintDepthCheckOrder(checkorder=typesfirst).errors.txt @@ -0,0 +1,16 @@ +baseConstraintDepthCheckOrder.ts(7,7): error TS2339: Property 'length' does not exist on type 'T0'. + + +==== baseConstraintDepthCheckOrder.ts (1 errors) ==== + // The base constraint of 'T0' is 60 type parameters deep and gives up after + // 50, while that of 'T20' is found 40 deep. Neither may depend on which was + // computed first: computing 'T0' first must not leave 'T20' without its + // constraint, and computing 'T20' first must not let 'T0' reuse it. + + function f(x: T0, y: T20) { + x.length; + ~~~~~~ +!!! error TS2339: Property 'length' does not exist on type 'T0'. + y.length; + } + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/baseConstraintDepthCheckOrder(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/baseConstraintDepthCheckOrder(checkorder=typesfirst).symbols index 9b381179dc902..bea0526aba4e1 100644 --- a/tsc/testdata/baselines/reference/compiler/baseConstraintDepthCheckOrder(checkorder=typesfirst).symbols +++ b/tsc/testdata/baselines/reference/compiler/baseConstraintDepthCheckOrder(checkorder=typesfirst).symbols @@ -133,9 +133,7 @@ function fT20 : Symbol(T20, Decl(baseConstraintDepthCheckOrder.ts, 5, 331)) x.length; ->x.length : Symbol(String.length, Decl(lib.es5.d.ts, --, --)) >x : Symbol(x, Decl(baseConstraintDepthCheckOrder.ts, 5, 1015)) ->length : Symbol(String.length, Decl(lib.es5.d.ts, --, --)) y.length; >y.length : Symbol(String.length, Decl(lib.es5.d.ts, --, --)) diff --git a/tsc/testdata/baselines/reference/compiler/baseConstraintDepthCheckOrder(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/baseConstraintDepthCheckOrder(checkorder=typesfirst).types index 0fb24141449cc..e36c86990b2ec 100644 --- a/tsc/testdata/baselines/reference/compiler/baseConstraintDepthCheckOrder(checkorder=typesfirst).types +++ b/tsc/testdata/baselines/reference/compiler/baseConstraintDepthCheckOrder(checkorder=typesfirst).types @@ -12,9 +12,9 @@ function fy : T20 x.length; ->x.length : number +>x.length : any >x : T0 ->length : number +>length : any y.length; >y.length : number From c12252a8ee2677e317667e876a2b7ee6b01496c7 Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Wed, 11 Nov 2026 22:57:40 -0800 Subject: [PATCH 31/60] Assign contextual parameter types before reading a parameter A parameter of a context-sensitive function read before its contextual parameter types were assigned got its raw contextual type, without the widening by its initializer that the assignment applies. In const f: (g: () => number, x: 1) => void = (g = () => x, x = 0) => {}; the reference to x in the initializer of g was 1 when it was queried first, but number when the function was checked first. Obtaining the signature of the function already requests the assignment, so reading one of its parameters now does too. The assignment checks the initializers of the parameters in order, so checking the initializer of g still read x before x was assigned, and the arrow function was () => 1 when the function was checked first, but () => number when the arrow function was queried first. The type a parameter is assigned depends only on its own contextual type and initializer, so a parameter read while the parameters before it are assigned is now assigned first, and the arrow function is () => number, the type of the x it returns, in every order. Fixes 64278 --- tsc/internal/checker/checker.go | 102 ++++++++++++++---- ...erenceCheckOrder(checkorder=default).types | 2 +- ...nceCheckOrder(checkorder=typesfirst).types | 4 +- 3 files changed, 86 insertions(+), 22 deletions(-) diff --git a/tsc/internal/checker/checker.go b/tsc/internal/checker/checker.go index b153a4f169e1a..eaec6fc47dafe 100644 --- a/tsc/internal/checker/checker.go +++ b/tsc/internal/checker/checker.go @@ -861,6 +861,8 @@ type Checker struct { freeFlowState *FlowState flowLoopCache map[FlowLoopKey]flowLoopCacheEntry flowLoopStack []FlowLoopInfo + contextualParameterAssignments []contextualParameterAssignment + parametersAssigning []*ast.Symbol sharedFlows []SharedFlow antecedentTypes []*Type flowInvocationCount int @@ -10763,23 +10765,11 @@ func (c *Checker) assignContextualParameterTypes(sig *Signature, context *Signat } } length := len(sig.parameters) - core.IfElse(signatureHasRestParameter(sig), 1, 0) + c.contextualParameterAssignments = append(c.contextualParameterAssignments, contextualParameterAssignment{sig, context}) for i := range length { - parameter := sig.parameters[i] - declaration := parameter.ValueDeclaration() - if declaration.Type() == nil { - t := c.tryGetTypeAtPosition(context, i) - if t != nil && declaration.Initializer() != nil { - initializerType := c.checkDeclarationInitializer(declaration, CheckModeNormal, nil) - if !c.isTypeAssignableTo(initializerType, t) { - initializerType = c.widenTypeInferredFromInitializer(declaration, initializerType) - if c.isTypeAssignableTo(t, initializerType) { - t = initializerType - } - } - } - c.assignParameterType(parameter, t) - } + c.assignContextualParameterType(sig, context, i) } + c.contextualParameterAssignments = c.contextualParameterAssignments[:len(c.contextualParameterAssignments)-1] if signatureHasRestParameter(sig) { // parameter might be a transient symbol generated by use of `arguments` in the function body. parameter := core.LastOrNil(sig.parameters) @@ -10791,6 +10781,60 @@ func (c *Checker) assignContextualParameterTypes(sig *Signature, context *Signat } } +// A contextualParameterAssignment is the assignment of the contextual +// parameter types of a signature in progress. +type contextualParameterAssignment struct { + signature *Signature + context *Signature +} + +// assignContextualParameterType assigns the parameter at index i of sig its +// type from the contextual signature, unless it is annotated or already +// being assigned. The type depends only on the parameter's own declaration, +// so a parameter read while the parameters before it are assigned is +// assigned first; see getTypeOfVariableOrParameterOrProperty. +func (c *Checker) assignContextualParameterType(sig *Signature, context *Signature, i int) { + parameter := sig.parameters[i] + declaration := parameter.ValueDeclaration() + if declaration.Type() != nil || slices.Contains(c.parametersAssigning, parameter) { + return + } + c.parametersAssigning = append(c.parametersAssigning, parameter) + t := c.tryGetTypeAtPosition(context, i) + if t != nil && declaration.Initializer() != nil { + initializerType := c.checkDeclarationInitializer(declaration, CheckModeNormal, nil) + if !c.isTypeAssignableTo(initializerType, t) { + initializerType = c.widenTypeInferredFromInitializer(declaration, initializerType) + if c.isTypeAssignableTo(t, initializerType) { + t = initializerType + } + } + } + c.assignParameterType(parameter, t) + c.parametersAssigning = c.parametersAssigning[:len(c.parametersAssigning)-1] +} + +// assignContextualParameterTypeInProgress assigns the parameter of fn +// declaring symbol, or one of its binding elements, its contextual type, +// while the contextual parameter types of fn are being assigned. +func (c *Checker) assignContextualParameterTypeInProgress(fn *ast.Node, symbol *ast.Symbol) { + decl := symbol.ValueDeclaration() + if ast.IsBindingElement(decl) { + decl = ast.WalkUpBindingElementsAndPatterns(decl) + } + for _, a := range slices.Backward(c.contextualParameterAssignments) { + if a.signature.declaration == fn { + length := len(a.signature.parameters) - core.IfElse(signatureHasRestParameter(a.signature), 1, 0) + for i, parameter := range a.signature.parameters[:length] { + if parameter.ValueDeclaration() == decl { + c.assignContextualParameterType(a.signature, a.context, i) + } + } + return + } + } +} + func (c *Checker) assignNonContextualParameterTypes(signature *Signature) { if signature.ThisParameter() != nil { c.assignParameterType(signature.ThisParameter(), nil) @@ -17336,6 +17380,19 @@ func (c *Checker) instantiatedFromUnaffected(links *ValueSymbolLinks) *ast.Symbo func (c *Checker) getTypeOfVariableOrParameterOrProperty(symbol *ast.Symbol) *Type { links := c.valueSymbolLinks.Get(symbol) if links.resolvedType == nil { + if fn := c.getContextSensitiveFunctionOfParameter(symbol); fn != nil { + // The type of a parameter of a context-sensitive function is the + // one its contextual parameter types assign it, as for the + // signature of the function (see getTypeOfFuncClassEnumModule). + if c.nodeLinks.Get(fn).flags&NodeCheckFlagsContextChecked == 0 { + c.assignContextualParameterTypesOfFunction(fn, CheckModeNormal) + } else { + c.assignContextualParameterTypeInProgress(fn, symbol) + } + if assigned := links.resolvedType; assigned != nil { + return assigned + } + } t := c.getTypeOfVariableOrParameterOrPropertyWorker(symbol) if t == nil { panic("Unexpected nil type") @@ -17357,17 +17414,24 @@ func (c *Checker) getTypeOfVariableOrParameterOrProperty(symbol *ast.Symbol) *Ty } func (c *Checker) isParameterOfContextSensitiveSignature(symbol *ast.Symbol) bool { + return c.getContextSensitiveFunctionOfParameter(symbol) != nil +} + +// getContextSensitiveFunctionOfParameter returns the context-sensitive +// function or object literal method declaring the parameter symbol, or one +// of its binding elements, or nil. +func (c *Checker) getContextSensitiveFunctionOfParameter(symbol *ast.Symbol) *ast.Node { decl := symbol.ValueDeclaration() if decl == nil { - return false + return nil } if ast.IsBindingElement(decl) { decl = ast.WalkUpBindingElementsAndPatterns(decl) } - if ast.IsParameterDeclaration(decl) { - return c.isContextSensitiveFunctionOrObjectLiteralMethod(decl.Parent) + if ast.IsParameterDeclaration(decl) && c.isContextSensitiveFunctionOrObjectLiteralMethod(decl.Parent) { + return decl.Parent } - return false + return nil } func (c *Checker) getTypeOfVariableOrParameterOrPropertyWorker(symbol *ast.Symbol) *Type { diff --git a/tsc/testdata/baselines/reference/compiler/contextualParameterDefaultReferenceCheckOrder(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/contextualParameterDefaultReferenceCheckOrder(checkorder=default).types index b977f7c29faff..86f6c20f91df3 100644 --- a/tsc/testdata/baselines/reference/compiler/contextualParameterDefaultReferenceCheckOrder(checkorder=default).types +++ b/tsc/testdata/baselines/reference/compiler/contextualParameterDefaultReferenceCheckOrder(checkorder=default).types @@ -11,7 +11,7 @@ const f: (g: () => number, x: 1) => void = (g = () => x, x = 0) => {}; >x : 1 >(g = () => x, x = 0) => {} : (g?: () => number, x?: number) => void >g : () => number ->() => x : () => 1 +>() => x : () => number >x : number >x : number >0 : 0 diff --git a/tsc/testdata/baselines/reference/compiler/contextualParameterDefaultReferenceCheckOrder(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/contextualParameterDefaultReferenceCheckOrder(checkorder=typesfirst).types index ef328c8e6e1bc..86f6c20f91df3 100644 --- a/tsc/testdata/baselines/reference/compiler/contextualParameterDefaultReferenceCheckOrder(checkorder=typesfirst).types +++ b/tsc/testdata/baselines/reference/compiler/contextualParameterDefaultReferenceCheckOrder(checkorder=typesfirst).types @@ -11,8 +11,8 @@ const f: (g: () => number, x: 1) => void = (g = () => x, x = 0) => {}; >x : 1 >(g = () => x, x = 0) => {} : (g?: () => number, x?: number) => void >g : () => number ->() => x : () => 1 ->x : 1 +>() => x : () => number +>x : number >x : number >0 : 0 From 825bfa1436164405d79b2901853780836b0d21a0 Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Thu, 12 Nov 2026 00:21:09 -0800 Subject: [PATCH 32/60] Check imported names despite invalid import attribute values An import attribute with a value other than a string literal is a grammar error that does not affect the module the import refers to, yet it made checking the import skip its imported names. Resolving one of them for a query still resolved the module, so in import x from "x" with { a: 0 }; the missing module was reported only when the type of x was queried before the import was checked. The names are now checked as they are for an import type with such attributes. For 32063 --- tsc/internal/checker/checker.go | 7 ++++--- ...AttributeValueCheckOrder(checkorder=default).errors.txt | 5 ++++- 2 files changed, 8 insertions(+), 4 deletions(-) diff --git a/tsc/internal/checker/checker.go b/tsc/internal/checker/checker.go index eaec6fc47dafe..39f342240e812 100644 --- a/tsc/internal/checker/checker.go +++ b/tsc/internal/checker/checker.go @@ -5566,9 +5566,10 @@ func (c *Checker) checkExternalImportOrExportDeclaration(node *ast.Node) bool { if !ast.IsImportEqualsDeclaration(node) { attributes := ast.GetImportAttributes(node) if attributes != nil { - if c.checkGrammarImportAttributeValues(attributes.AsImportAttributes()) { - return false - } + // As for an import type, invalid attribute values leave the + // imported names to be checked, as resolving them for any query + // would check them. + c.checkGrammarImportAttributeValues(attributes.AsImportAttributes()) } } return true diff --git a/tsc/testdata/baselines/reference/compiler/importAttributeValueCheckOrder(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/importAttributeValueCheckOrder(checkorder=default).errors.txt index d95e6caed1e54..ebb125845b45c 100644 --- a/tsc/testdata/baselines/reference/compiler/importAttributeValueCheckOrder(checkorder=default).errors.txt +++ b/tsc/testdata/baselines/reference/compiler/importAttributeValueCheckOrder(checkorder=default).errors.txt @@ -1,15 +1,18 @@ +importAttributeValueCheckOrder.ts(5,15): error TS2307: Cannot find module 'x' or its corresponding type declarations. importAttributeValueCheckOrder.ts(5,19): error TS2322: Type '{ a: 0; }' is not assignable to type 'ImportAttributes'. Property 'a' is incompatible with index signature. Type 'number' is not assignable to type 'string'. importAttributeValueCheckOrder.ts(5,29): error TS2858: Import attribute values must be string literal expressions. -==== importAttributeValueCheckOrder.ts (2 errors) ==== +==== importAttributeValueCheckOrder.ts (3 errors) ==== // The attribute value is invalid, which does not affect the module. Its // missing module must be reported whether or not the type of x is queried // before the import is checked. import x from "x" with { a: 0 }; + ~~~ +!!! error TS2307: Cannot find module 'x' or its corresponding type declarations. ~~~~~~~~~~~~~ !!! error TS2322: Type '{ a: 0; }' is not assignable to type 'ImportAttributes'. !!! error TS2322: Property 'a' is incompatible with index signature. From 48df7f4a82c8d488f66718a48c05da58e4b4fd5c Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Thu, 12 Nov 2026 00:23:47 -0800 Subject: [PATCH 33/60] Infer the constraint of an infer type parameter without instantiating The constraint of U in a type reference such as S is inferred from the constraint of the corresponding type parameter of S. Finding that type parameter resolved the type of the reference, instantiating S with U, which can itself need the constraint of U. In type Copy = { [K in keyof T]: T[K] }; type S = Copy<{ x: 0 } & T>; type I = {} extends S ? U : never; U had no constraint, and did not satisfy object, when the type arguments of S were checked first, but had the constraint object when I was queried first. The type parameters of the declaration the reference refers to are now used directly. Fixes 38460 --- tsc/internal/checker/checker.go | 28 ++++++++++++++++++- ...nCheckOrder(checkorder=default).errors.txt | 16 ----------- 2 files changed, 27 insertions(+), 17 deletions(-) delete mode 100644 tsc/testdata/baselines/reference/compiler/inferTypeParameterConstraintFromMappedIntersectionCheckOrder(checkorder=default).errors.txt diff --git a/tsc/internal/checker/checker.go b/tsc/internal/checker/checker.go index 39f342240e812..f092b24a0a537 100644 --- a/tsc/internal/checker/checker.go +++ b/tsc/internal/checker/checker.go @@ -18005,7 +18005,7 @@ func (c *Checker) getInferredTypeParameterConstraint(t *Type, omitTypeReferences } switch { case ast.IsTypeReferenceNode(parent) && !omitTypeReferences: - typeParameters := c.getTypeParametersForTypeReferenceOrImport(parent) + typeParameters := c.getDeclaredTypeParametersOfTypeReference(parent) if typeParameters != nil { index := slices.Index(parent.TypeArguments(), child) if index >= 0 && index < len(typeParameters) { @@ -18072,6 +18072,32 @@ func (c *Checker) getTypeParametersForTypeReferenceOrImport(node *ast.Node) []*T return nil } +// getDeclaredTypeParametersOfTypeReference returns the type parameters of the +// type a type reference refers to, if it has an acceptable number of type +// arguments. Unlike getTypeParametersForTypeReferenceOrImport, it does not +// instantiate the type, which can need the constraints of the infer type +// parameters among its type arguments, inferred from these type parameters. +func (c *Checker) getDeclaredTypeParametersOfTypeReference(node *ast.Node) []*Type { + symbol := c.getSymbolFromTypeReference(node) + if symbol == c.unknownSymbol { + return nil + } + declared := c.getDeclaredTypeOfSymbol(symbol) + if c.isErrorType(declared) { + return nil + } + var typeParameters []*Type + if symbol.Flags()&ast.SymbolFlagsTypeAlias != 0 { + typeParameters = c.typeAliasLinks.Get(symbol).typeParameters + } else if declared.objectFlags&ObjectFlagsClassOrInterface != 0 { + typeParameters = declared.AsInterfaceType().LocalTypeParameters() + } + if n := len(node.TypeArguments()); n < c.getMinTypeArgumentCount(typeParameters) || n > len(typeParameters) { + return nil + } + return typeParameters +} + func (c *Checker) getTypeParametersForTypeAndSymbol(t *Type, symbol *ast.Symbol) []*Type { if !c.isErrorType(t) { if symbol.Flags()&ast.SymbolFlagsTypeAlias != 0 { diff --git a/tsc/testdata/baselines/reference/compiler/inferTypeParameterConstraintFromMappedIntersectionCheckOrder(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/inferTypeParameterConstraintFromMappedIntersectionCheckOrder(checkorder=default).errors.txt deleted file mode 100644 index 451dbe9e554a3..0000000000000 --- a/tsc/testdata/baselines/reference/compiler/inferTypeParameterConstraintFromMappedIntersectionCheckOrder(checkorder=default).errors.txt +++ /dev/null @@ -1,16 +0,0 @@ -inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts(8,23): error TS2344: Type 'U' does not satisfy the constraint 'object'. - - -==== inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts (1 errors) ==== - // The constraint of U is inferred from the constraint of the type parameter - // of S. Instantiating S with U needs the constraint of U, so whether U - // satisfies object must not depend on whether I is queried before its type - // arguments are checked. - - type Copy = { [K in keyof T]: T[K] }; - type S = Copy<{ x: 0 } & T>; - type I = {} extends S ? U : never; - ~~~~~~~ -!!! error TS2344: Type 'U' does not satisfy the constraint 'object'. -!!! related TS2208 inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts:8:29: This type parameter might need an `extends object` constraint. - \ No newline at end of file From 63c166adf16a731eca9f9af3d7be654aa6738c2f Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Fri, 13 Nov 2026 01:12:25 -0800 Subject: [PATCH 34/60] Instantiate an instantiation expression with the type arguments given An instantiation expression whose type arguments did not satisfy their constraints kept the generic signature, unlike a type reference, whose type is that of the type arguments given, with the constraints checked separately. Checking the constraints while computing the type made both depend on order: in declare function b(): U; interface A { value: T; child: typeof b>; } checking A against the constraint A needs the variances of A, which need the type of child. Checking A first measured the variances with child incomplete, which missed the constraint error, while querying child first reported it and kept the generic signature, giving child a different type. The signature is now instantiated with the type arguments given, as for a type reference, and the constraints are checked once the types they need are resolved, so child has the same type and error in every order. Type argument completions in a decorator read the signatures of its expression, which now has the type arguments being typed applied, so they read those of the expression the type arguments apply to. Fixes 61982 For 52892 --- tsc/internal/checker/checker.go | 14 ++++++++----- tsc/internal/checker/services.go | 7 ++++++- ...eCheckOrder(checkorder=default).errors.txt | 8 ++++++- ...cleCheckOrder(checkorder=typesfirst).types | 2 +- ...nstraintInStaticClassExpression.errors.txt | 21 +++++++++++++++++++ 5 files changed, 44 insertions(+), 8 deletions(-) create mode 100644 tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintInStaticClassExpression.errors.txt diff --git a/tsc/internal/checker/checker.go b/tsc/internal/checker/checker.go index f092b24a0a537..2364c7e7920ea 100644 --- a/tsc/internal/checker/checker.go +++ b/tsc/internal/checker/checker.go @@ -11117,11 +11117,15 @@ func (c *Checker) getInstantiationExpressionType(exprType *Type, node *ast.Node) return len(sig.TypeParameters()) != 0 && c.hasCorrectTypeArgumentArity(sig, typeArguments.Nodes) }) return core.SameMap(applicableSignatures, func(sig *Signature) *Signature { - typeArgumentTypes := c.checkTypeArguments(sig, typeArguments.Nodes, true /*reportErrors*/, nil) - if typeArgumentTypes != nil { - return c.getSignatureInstantiation(sig, typeArgumentTypes, ast.IsInJSFile(sig.declaration), nil) - } - return sig + // As for a type reference, the type arguments are those given + // whether or not they satisfy their constraints, which are + // checked once the types they need are resolved: checking them + // can need the variances of a type whose members include this + // expression. + c.addDeferredDiagnostic(func() { + c.checkTypeArguments(sig, typeArguments.Nodes, true /*reportErrors*/, nil) + }) + return c.getSignatureInstantiation(sig, core.Map(typeArguments.Nodes, c.getTypeFromTypeNode), ast.IsInJSFile(sig.declaration), nil) }) } var getInstantiatedType func(*Type) *Type diff --git a/tsc/internal/checker/services.go b/tsc/internal/checker/services.go index ecc28ea2b2b44..6838a3b242aa1 100644 --- a/tsc/internal/checker/services.go +++ b/tsc/internal/checker/services.go @@ -650,7 +650,12 @@ func (c *Checker) GetTypeArgumentConstraint(node *ast.Node) *Type { func (c *Checker) getUninstantiatedSignatures(node *ast.Node) []*Signature { switch node.Kind { case ast.KindCallExpression, ast.KindDecorator: - return c.getSignaturesOfType(c.getTypeOfExpression(node.Expression()), SignatureKindCall) + expression := node.Expression() + if ast.IsDecorator(node) && ast.IsExpressionWithTypeArguments(expression) { + // The type arguments of a decorator are part of its expression. + expression = expression.Expression() + } + return c.getSignaturesOfType(c.getTypeOfExpression(expression), SignatureKindCall) case ast.KindNewExpression: return c.getSignaturesOfType(c.getTypeOfExpression(node.Expression()), SignatureKindConstruct) case ast.KindJsxSelfClosingElement, ast.KindJsxOpeningElement: diff --git a/tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintCycleCheckOrder(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintCycleCheckOrder(checkorder=default).errors.txt index a674eea18c3f4..34b433cab41d3 100644 --- a/tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintCycleCheckOrder(checkorder=default).errors.txt +++ b/tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintCycleCheckOrder(checkorder=default).errors.txt @@ -1,8 +1,10 @@ +instantiationExpressionConstraintCycleCheckOrder.ts(10,25): error TS2344: Type 'A' does not satisfy the constraint 'A'. + Type 'T' is not assignable to type 'number'. instantiationExpressionConstraintCycleCheckOrder.ts(17,41): error TS2344: Type 'A' does not satisfy the constraint 'A'. Type 'T' is not assignable to type 'number'. -==== instantiationExpressionConstraintCycleCheckOrder.ts (1 errors) ==== +==== instantiationExpressionConstraintCycleCheckOrder.ts (2 errors) ==== // Checking the type arguments of the instantiation expressions against their // constraints needs the variances of A, which need the type of child. The // constraint errors and the types of child must not depend on whether child @@ -13,6 +15,10 @@ instantiationExpressionConstraintCycleCheckOrder.ts(17,41): error TS2344: Type ' interface A { value: T; child: typeof b>; + ~~~~ +!!! error TS2344: Type 'A' does not satisfy the constraint 'A'. +!!! error TS2344: Type 'T' is not assignable to type 'number'. +!!! related TS2208 instantiationExpressionConstraintCycleCheckOrder.ts:8:17: This type parameter might need an `extends number` constraint. } } diff --git a/tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintCycleCheckOrder(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintCycleCheckOrder(checkorder=typesfirst).types index 4b7e7e4ea94e9..21ae95de09035 100644 --- a/tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintCycleCheckOrder(checkorder=typesfirst).types +++ b/tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintCycleCheckOrder(checkorder=typesfirst).types @@ -17,7 +17,7 @@ namespace InterfaceCycle { >value : T child: typeof b>; ->child : () => A +>child : typeof b> >b : >() => U } } diff --git a/tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintInStaticClassExpression.errors.txt b/tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintInStaticClassExpression.errors.txt new file mode 100644 index 0000000000000..069ae1cb033da --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintInStaticClassExpression.errors.txt @@ -0,0 +1,21 @@ +instantiationExpressionConstraintInStaticClassExpression.ts(6,35): error TS2344: Type 'A' does not satisfy the constraint 'A'. + Type 'T' is not assignable to type 'number'. + + +==== instantiationExpressionConstraintInStaticClassExpression.ts (1 errors) ==== + // A does not satisfy the constraint A of B, as T is not assignable to + // number, which must be reported. + + class A { + value!: T; + child!: InstanceType>>; // this should error + ~~~~ +!!! error TS2344: Type 'A' does not satisfy the constraint 'A'. +!!! error TS2344: Type 'T' is not assignable to type 'number'. +!!! related TS2208 instantiationExpressionConstraintInStaticClassExpression.ts:4:9: This type parameter might need an `extends number` constraint. + + static B = class B { + parent!: T; + }; + } + \ No newline at end of file From 4b31fcf526ebe7d1e918c3b44d7dea438c69857c Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Fri, 13 Nov 2026 01:14:46 -0800 Subject: [PATCH 35/60] Decide whether a type reference can recurse from its type arguments Comparing types assumes a comparison holds once it is nested in three others of types with the same recursion identity. A type reference created while resolving a type node was tracked by itself rather than by its symbol, as it cannot be the source of generative recursion without being instantiated. Type references are interned, so this depended on how a reference was first created. In interface A { slice(): B; every(predicate: (value: T) => value is S): this is A; flatMap(callback: (value: T) => U | readonly U[] | A): U[]; } interface B extends A {} const a: A<0> = []; const b: B<0> = []; B<0> was tracked by itself when the annotation of b was resolved before checking a instantiated slice, and by its symbol otherwise, so the comparison for b was cut short at different depths, changing the error it reported. Cutting a comparison short can also change whether the types are related. A type reference whose type arguments were not themselves instantiated is now tracked by itself however it was created. For 54921 --- packages/typescript/enums/objectFlags.d.ts | 1 - packages/typescript/enums/objectFlags.js | 1 - tsc/internal/api/enum_values_generated.go | 1 - tsc/internal/checker/checker.go | 26 +-- tsc/internal/checker/relater.go | 30 +-- tsc/internal/checker/tracer.go | 2 +- tsc/internal/checker/types.go | 1 - .../complexRecursiveCollections.errors.txt | 4 +- ...yCheckOrder(checkorder=default).errors.txt | 4 +- ...gnature-sibling-types-in-a-stable-order.js | 144 ++++++------ ...gnature-sibling-types-in-a-stable-order.js | 142 ++++++------ ...teTrace-creates-types-in-a-stable-order.js | 216 +++++++++--------- .../generateTrace-generates-types-file.js | 58 ++--- ...e-with-multiple-files-and-complex-types.js | 110 ++++----- 14 files changed, 366 insertions(+), 374 deletions(-) diff --git a/packages/typescript/enums/objectFlags.d.ts b/packages/typescript/enums/objectFlags.d.ts index 45303ee1ce1a4..78ce1bb59fff1 100644 --- a/packages/typescript/enums/objectFlags.d.ts +++ b/packages/typescript/enums/objectFlags.d.ts @@ -36,7 +36,6 @@ export declare enum ObjectFlags { IsClassInstanceClone = 1 << 26, IdenticalBaseTypeCalculated = 1 << 27, IdenticalBaseTypeExists = 1 << 28, - FromTypeNode = 1 << 29, IsGenericTypeComputed = 1 << 22, IsGenericObjectType = 1 << 23, IsGenericIndexType = 1 << 24, diff --git a/packages/typescript/enums/objectFlags.js b/packages/typescript/enums/objectFlags.js index 380ea72af1c7d..7adbed11771cc 100644 --- a/packages/typescript/enums/objectFlags.js +++ b/packages/typescript/enums/objectFlags.js @@ -36,7 +36,6 @@ export var ObjectFlags; ObjectFlags[ObjectFlags["IsClassInstanceClone"] = 67108864] = "IsClassInstanceClone"; ObjectFlags[ObjectFlags["IdenticalBaseTypeCalculated"] = 134217728] = "IdenticalBaseTypeCalculated"; ObjectFlags[ObjectFlags["IdenticalBaseTypeExists"] = 268435456] = "IdenticalBaseTypeExists"; - ObjectFlags[ObjectFlags["FromTypeNode"] = 536870912] = "FromTypeNode"; ObjectFlags[ObjectFlags["IsGenericTypeComputed"] = 4194304] = "IsGenericTypeComputed"; ObjectFlags[ObjectFlags["IsGenericObjectType"] = 8388608] = "IsGenericObjectType"; ObjectFlags[ObjectFlags["IsGenericIndexType"] = 16777216] = "IsGenericIndexType"; diff --git a/tsc/internal/api/enum_values_generated.go b/tsc/internal/api/enum_values_generated.go index 1697a479539a5..f1db3543e9184 100644 --- a/tsc/internal/api/enum_values_generated.go +++ b/tsc/internal/api/enum_values_generated.go @@ -244,7 +244,6 @@ func main() { "IsClassInstanceClone": toInt32(checker.ObjectFlagsIsClassInstanceClone), "IdenticalBaseTypeCalculated": toInt32(checker.ObjectFlagsIdenticalBaseTypeCalculated), "IdenticalBaseTypeExists": toInt32(checker.ObjectFlagsIdenticalBaseTypeExists), - "FromTypeNode": toInt32(checker.ObjectFlagsFromTypeNode), "IsGenericTypeComputed": toInt32(checker.ObjectFlagsIsGenericTypeComputed), "IsGenericObjectType": toInt32(checker.ObjectFlagsIsGenericObjectType), "IsGenericIndexType": toInt32(checker.ObjectFlagsIsGenericIndexType), diff --git a/tsc/internal/checker/checker.go b/tsc/internal/checker/checker.go index 2364c7e7920ea..61ef8b4af0590 100644 --- a/tsc/internal/checker/checker.go +++ b/tsc/internal/checker/checker.go @@ -24560,7 +24560,7 @@ func (c *Checker) getTypeFromClassOrInterfaceReference(node *ast.Node, symbol *a // of the class or interface. localTypeArguments := c.fillMissingTypeArguments(c.getTypeArgumentsFromNode(node), typeParameters, minTypeArgumentCount, isJs) typeArguments := append(d.OuterTypeParameters(), localTypeArguments...) - return c.createTypeReferenceEx(t, typeArguments, ObjectFlagsFromTypeNode) + return c.createTypeReference(t, typeArguments) } if c.checkNoTypeArguments(node, symbol) { return t @@ -24655,11 +24655,11 @@ func (c *Checker) createNormalizedTypeReference(target *Type, typeArguments []*T return c.createTypeReference(target, typeArguments) } -func (c *Checker) createNormalizedTupleTypeEx(target *Type, elementTypes []*Type, objectFlags ObjectFlags) *Type { +func (c *Checker) createNormalizedTupleType(target *Type, elementTypes []*Type) *Type { d := target.AsTupleType() if d.combinedFlags&ElementFlagsNonRequired == 0 { // No need to normalize when we only have regular required elements - return c.createTypeReferenceEx(target, elementTypes, objectFlags) + return c.createTypeReference(target, elementTypes) } if d.combinedFlags&ElementFlagsVariadic != 0 { for i, e := range elementTypes { @@ -24673,7 +24673,7 @@ func (c *Checker) createNormalizedTupleTypeEx(target *Type, elementTypes []*Type }) if c.checkCrossProductUnion(checkTypes) { return c.mapType(e, func(t *Type) *Type { - return c.createNormalizedTupleTypeEx(target, core.ReplaceElement(elementTypes, i, t), objectFlags) + return c.createNormalizedTupleType(target, core.ReplaceElement(elementTypes, i, t)) }) } } @@ -24698,15 +24698,11 @@ func (c *Checker) createNormalizedTupleTypeEx(target *Type, elementTypes []*Type case tupleTarget == c.emptyGenericType: return c.emptyObjectType case len(n.types) != 0: - return c.createTypeReferenceEx(tupleTarget, n.types, objectFlags) + return c.createTypeReference(tupleTarget, n.types) } return tupleTarget } -func (c *Checker) createNormalizedTupleType(target *Type, elementTypes []*Type) *Type { - return c.createNormalizedTupleTypeEx(target, elementTypes, ObjectFlagsNone) -} - type TupleNormalizer struct { c *Checker types []*Type @@ -25494,9 +25490,9 @@ 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 = c.createNormalizedTupleType(target, elementTypes) } else { - links.resolvedType = c.createTypeReferenceEx(target, elementTypes, ObjectFlagsFromTypeNode) + links.resolvedType = c.createTypeReference(target, elementTypes) } } } @@ -26488,16 +26484,12 @@ func (c *Checker) tryCreateTypeReference(target *Type, typeArguments []*Type) *T } func (c *Checker) createTypeReference(target *Type, typeArguments []*Type) *Type { - return c.createTypeReferenceEx(target, typeArguments, ObjectFlagsNone) -} - -func (c *Checker) createTypeReferenceEx(target *Type, typeArguments []*Type, objectFlags ObjectFlags) *Type { id := getTypeListKey(typeArguments) intf := target.AsInterfaceType() if t, ok := intf.instantiations[id]; ok { return t } - t := c.newObjectType(ObjectFlagsReference|objectFlags|c.getPropagatingFlagsOfTypes(typeArguments, TypeFlagsNone), target.symbol) + t := c.newObjectType(ObjectFlagsReference|c.getPropagatingFlagsOfTypes(typeArguments, TypeFlagsNone), target.symbol) d := t.AsTypeReference() d.target = target d.resolvedTypeArguments = typeArguments @@ -28981,7 +28973,7 @@ func (c *Checker) walkBaseConstraint(t *Type, stack []RecursionId) (*Type, int32 // 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) < baseConstraintFreeDepth || len(stack) < baseConstraintMaxDepth && !slices.Contains(stack, identity) { constraint = c.computeBaseConstraint(c.getSimplifiedType(t /*writing*/, false), append(stack, identity)) } else { diff --git a/tsc/internal/checker/relater.go b/tsc/internal/checker/relater.go index 6d5d11dd06faf..6b038a9c464fd 100644 --- a/tsc/internal/checker/relater.go +++ b/tsc/internal/checker/relater.go @@ -776,11 +776,11 @@ func (c *Checker) isDeeplyNestedType(t *Type, stack []*Type, maxDepth int) bool } } } else { - identity := getRecursionIdentityFromTarget(target) + identity := c.getRecursionIdentityFromTarget(target) count := 0 lastGeneration := 0 for _, t := range stack { - if hasMatchingRecursionIdentity(t, identity) { + 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. @@ -897,21 +897,21 @@ func (c *Checker) deeplyNestedStart(t *Type, stack []*Type, maxDepth int) int { return 0 } -func hasMatchingRecursionIdentity(t *Type, identity RecursionId) bool { +func (c *Checker) hasMatchingRecursionIdentity(t *Type, identity RecursionId) bool { target := getRecursionIdentityTarget(t) if target.flags&TypeFlagsIntersection != 0 { for _, t := range target.Types() { - if hasMatchingRecursionIdentity(t, identity) { + if c.hasMatchingRecursionIdentity(t, identity) { return true } } return false } - return getRecursionIdentityFromTarget(target) == identity + return c.getRecursionIdentityFromTarget(target) == identity } -func getRecursionIdentity(t *Type) RecursionId { - return getRecursionIdentityFromTarget(getRecursionIdentityTarget(t)) +func (c *Checker) getRecursionIdentity(t *Type) RecursionId { + return c.getRecursionIdentityFromTarget(getRecursionIdentityTarget(t)) } // Get the recursion identity target type from a type. Recursively (a) obtain the target object type of an @@ -940,7 +940,7 @@ func getRecursionIdentityTarget(t *Type) *Type { // instantiations of that type have the same recursion identity. The default recursion identity is the object // identity of the type, meaning that every type is unique. Generally, types with constituents that could circularly // reference the type have a recursion identity that differs from the object identity. -func getRecursionIdentityFromTarget(t *Type) RecursionId { +func (c *Checker) getRecursionIdentityFromTarget(t *Type) RecursionId { // Object and array literals are known not to contain recursive references and don't need a recursion identity. if t.flags&TypeFlagsObject != 0 && !isObjectOrArrayLiteralType(t) { if t.objectFlags&ObjectFlagsReference != 0 && t.AsTypeReference().node != nil { @@ -949,14 +949,18 @@ func getRecursionIdentityFromTarget(t *Type) RecursionId { // unique AST node. return asRecursionId(t.AsTypeReference().node) } - if t.symbol != nil && !(t.objectFlags&ObjectFlagsAnonymous != 0 && t.symbol.Flags()&ast.SymbolFlagsClass != 0) && t.objectFlags&ObjectFlagsFromTypeNode == 0 { + // A type reference whose type arguments were not themselves + // instantiated, such as one written out in a type node, cannot be the + // source of generative recursion, so it is tracked by itself. Type + // references are interned, so this depends on the type arguments + // rather than on how the reference was first created. + generative := t.objectFlags&ObjectFlagsReference == 0 || c.typeGeneration(t) > 1 + if t.symbol != nil && !(t.objectFlags&ObjectFlagsAnonymous != 0 && t.symbol.Flags()&ast.SymbolFlagsClass != 0) && generative { // We track object types that have a symbol by that symbol (representing the origin of the type), but - // exclude the static sides of classes (since they share their symbols with the instance sides) and type - // references that originate in resolution of AST type nodes (since such type nodes cannot be the source - // of generative recursion without first being instantiated). + // exclude the static sides of classes (since they share their symbols with the instance sides). return asRecursionId(t.symbol) } - if isTupleType(t) && t.objectFlags&ObjectFlagsFromTypeNode == 0 { + if isTupleType(t) && generative { return asRecursionId(t.Target()) } } diff --git a/tsc/internal/checker/tracer.go b/tsc/internal/checker/tracer.go index 0fea57f8d4d70..d514ef9fbd4da 100644 --- a/tsc/internal/checker/tracer.go +++ b/tsc/internal/checker/tracer.go @@ -323,7 +323,7 @@ func (a *tracedTypeAdapter) Pattern() *ast.Node { } 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 dfcd7ddbead01..6d1d9f26c6005 100644 --- a/tsc/internal/checker/types.go +++ b/tsc/internal/checker/types.go @@ -734,7 +734,6 @@ const ( // 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 // 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 diff --git a/tsc/testdata/baselines/reference/compiler/complexRecursiveCollections.errors.txt b/tsc/testdata/baselines/reference/compiler/complexRecursiveCollections.errors.txt index 2a4fb0967ee33..8b242f6fc3238 100644 --- a/tsc/testdata/baselines/reference/compiler/complexRecursiveCollections.errors.txt +++ b/tsc/testdata/baselines/reference/compiler/complexRecursiveCollections.errors.txt @@ -6,7 +6,7 @@ immutable.ts(289,22): error TS2320: Interface 'Indexed' cannot simultaneously immutable.ts(305,22): error TS2320: Interface 'Set' cannot simultaneously extend types 'Seq' and 'Set'. Named property 'size' of types 'Seq' and 'Set' are not identical. immutable.ts(323,20): error TS2430: Interface 'Seq' incorrectly extends interface 'Collection'. - The types returned by 'map(...).size' are incompatible between these types. + The types returned by 'map(...).filter(...).size' are incompatible between these types. Type 'number | undefined' is not assignable to type 'number'. Type 'undefined' is not assignable to type 'number'. immutable.ts(341,22): error TS2430: Interface 'Keyed' incorrectly extends interface 'Collection'. @@ -382,7 +382,7 @@ immutable.ts(391,22): error TS2430: Interface 'Set' incorrectly extends inter export interface Seq extends Collection { ~~~ !!! error TS2430: Interface 'Seq' incorrectly extends interface 'Collection'. -!!! error TS2430: The types returned by 'map(...).size' are incompatible between these types. +!!! error TS2430: The types returned by 'map(...).filter(...).size' are incompatible between these types. !!! error TS2430: Type 'number | undefined' is not assignable to type 'number'. !!! error TS2430: Type 'undefined' is not assignable to type 'number'. readonly size: number | undefined; diff --git a/tsc/testdata/baselines/reference/compiler/typeReferenceRecursionIdentityCheckOrder(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/typeReferenceRecursionIdentityCheckOrder(checkorder=default).errors.txt index 51fd83b016a0e..6e024512e0b5b 100644 --- a/tsc/testdata/baselines/reference/compiler/typeReferenceRecursionIdentityCheckOrder(checkorder=default).errors.txt +++ b/tsc/testdata/baselines/reference/compiler/typeReferenceRecursionIdentityCheckOrder(checkorder=default).errors.txt @@ -12,7 +12,7 @@ typeReferenceRecursionIdentityCheckOrder.ts(12,7): error TS2322: Type 'never[]' Type '{ (predicate: (value: never, index: number, array: never[]) => value is S, thisArg?: any): this is S[]; (predicate: (value: never, index: number, array: never[]) => unknown, thisArg?: any): boolean; }' is not assignable to type '(predicate: (value: 0) => value is S) => this is A'. Type predicate 'this is any[]' is not assignable to 'this is A'. Type 'any[]' is not assignable to type 'A'. - The types returned by 'flatMap(...)' are incompatible between these types. + The types returned by 'slice(...).flatMap(...)' are incompatible between these types. Type '(U | A)[]' is not assignable to type 'U[]'. Type 'U | A' is not assignable to type 'U'. 'U' could be instantiated with an arbitrary type which could be unrelated to 'U | A'. @@ -47,7 +47,7 @@ typeReferenceRecursionIdentityCheckOrder.ts(12,7): error TS2322: Type 'never[]' !!! error TS2322: Type '{ (predicate: (value: never, index: number, array: never[]) => value is S, thisArg?: any): this is S[]; (predicate: (value: never, index: number, array: never[]) => unknown, thisArg?: any): boolean; }' is not assignable to type '(predicate: (value: 0) => value is S) => this is A'. !!! error TS2322: Type predicate 'this is any[]' is not assignable to 'this is A'. !!! error TS2322: Type 'any[]' is not assignable to type 'A'. -!!! error TS2322: The types returned by 'flatMap(...)' are incompatible between these types. +!!! error TS2322: The types returned by 'slice(...).flatMap(...)' are incompatible between these types. !!! error TS2322: Type '(U | A)[]' is not assignable to type 'U[]'. !!! error TS2322: Type 'U | A' is not assignable to type 'U'. !!! error TS2322: 'U' could be instantiated with an arbitrary type which could be unrelated to 'U | A'. diff --git a/tsc/testdata/baselines/reference/tsc/generateTrace/generateTrace-creates-index-signature-sibling-types-in-a-stable-order.js b/tsc/testdata/baselines/reference/tsc/generateTrace/generateTrace-creates-index-signature-sibling-types-in-a-stable-order.js index c2fc8d7b618c1..c636506b065dd 100644 --- a/tsc/testdata/baselines/reference/tsc/generateTrace/generateTrace-creates-index-signature-sibling-types-in-a-stable-order.js +++ b/tsc/testdata/baselines/reference/tsc/generateTrace/generateTrace-creates-index-signature-sibling-types-in-a-stable-order.js @@ -230,77 +230,77 @@ export declare const w: { {"id":64,"symbolName":"globalThis","recursionId":63,"flags":["Object"],"display":"typeof globalThis"}, {"id":65,"symbolName":"Array","recursionId":64,"instantiatedType":65,"typeArguments":[66],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["Object"]}, {"id":66,"symbolName":"T","recursionId":65,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":17},"end":{"line":11,"character":18}},"flags":["TypeParameter"]}, -{"id":67,"symbolName":"Array","recursionId":64,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["TypeParameter"]}, -{"id":68,"symbolName":"Object","recursionId":66,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":8,"character":1},"end":{"line":8,"character":20}},"flags":["Object"]}, -{"id":69,"symbolName":"Function","recursionId":67,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":3,"character":1},"end":{"line":3,"character":22}},"flags":["Object"]}, -{"id":70,"symbolName":"CallableFunction","recursionId":68,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":4,"character":1},"end":{"line":4,"character":30}},"flags":["Object"]}, -{"id":71,"symbolName":"NewableFunction","recursionId":69,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":5,"character":1},"end":{"line":5,"character":29}},"flags":["Object"]}, -{"id":72,"symbolName":"String","recursionId":70,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":10,"character":1},"end":{"line":10,"character":34}},"flags":["Object"]}, -{"id":73,"symbolName":"Number","recursionId":71,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":7,"character":1},"end":{"line":7,"character":41}},"flags":["Object"]}, -{"id":74,"symbolName":"Boolean","recursionId":72,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":2,"character":1},"end":{"line":2,"character":21}},"flags":["Object"]}, -{"id":75,"symbolName":"RegExp","recursionId":73,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":9,"character":1},"end":{"line":9,"character":20}},"flags":["Object"]}, -{"id":76,"symbolName":"Array","recursionId":64,"instantiatedType":65,"typeArguments":[1],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["Object"]}, -{"id":77,"symbolName":"Array","recursionId":64,"instantiatedType":65,"typeArguments":[2],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["Object"]}, -{"id":78,"symbolName":"ReadonlyArray","recursionId":74,"instantiatedType":78,"typeArguments":[79],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":1},"end":{"line":12,"character":30}},"flags":["Object"]}, -{"id":79,"symbolName":"T","recursionId":75,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":25},"end":{"line":12,"character":26}},"flags":["TypeParameter"]}, -{"id":80,"symbolName":"ReadonlyArray","recursionId":74,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":1},"end":{"line":12,"character":30}},"flags":["TypeParameter"]}, -{"id":81,"symbolName":"ReadonlyArray","recursionId":74,"instantiatedType":78,"typeArguments":[1],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":1},"end":{"line":12,"character":30}},"flags":["Object"]}, -{"id":82,"symbolName":"X","recursionId":76,"firstDeclaration":{"path":"/home/src/workspaces/project/main.ts","start":{"line":1,"character":25},"end":{"line":1,"character":26}},"flags":["TypeParameter"]}, -{"id":83,"symbolName":"K","recursionId":77,"firstDeclaration":{"path":"/home/src/workspaces/project/main.ts","start":{"line":1,"character":34},"end":{"line":1,"character":46}},"flags":["TypeParameter"]}, -{"id":84,"recursionId":78,"keyofType":82,"flags":["Index"]}, -{"id":85,"symbolName":"__type","recursionId":79,"firstDeclaration":{"path":"/home/src/workspaces/project/main.ts","start":{"line":1,"character":31},"end":{"line":1,"character":55}},"flags":["Object"]}, -{"id":86,"recursionId":76,"indexedAccessObjectType":82,"indexedAccessIndexType":83,"flags":["IndexedAccess"]}, -{"id":87,"symbolName":"Symbol","recursionId":80,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":18,"character":13},"end":{"line":18,"character":38}},"flags":["Object"]}, -{"id":88,"symbolName":"SymbolConstructor","recursionId":81,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":13,"character":1},"end":{"line":17,"character":2}},"flags":["Object"]}, -{"id":89,"symbolName":"toStringTag","recursionId":82,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":16,"character":5},"end":{"line":16,"character":34}},"flags":["UniqueESSymbol"]}, -{"id":90,"symbolName":"expand","recursionId":83,"firstDeclaration":{"path":"/home/src/workspaces/project/main.ts","start":{"line":1,"character":1},"end":{"line":1,"character":56}},"flags":["Object"],"display":"() => { [K in keyof X]: X[K]; }"}, -{"id":91,"symbolName":"C","recursionId":84,"instantiatedType":91,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":2,"character":1},"end":{"line":14,"character":2}},"flags":["Object"]}, -{"id":92,"symbolName":"C","recursionId":84,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":2,"character":1},"end":{"line":14,"character":2}},"flags":["TypeParameter"]}, -{"id":93,"symbolName":"__type","recursionId":84,"firstDeclaration":{"path":"/home/src/workspaces/project/main.ts","start":{"line":1,"character":31},"end":{"line":1,"character":55}},"flags":["Object"]}, -{"id":94,"symbolName":"K","recursionId":77,"firstDeclaration":{"path":"/home/src/workspaces/project/main.ts","start":{"line":1,"character":34},"end":{"line":1,"character":46}},"flags":["TypeParameter"]}, -{"id":95,"recursionId":85,"keyofType":91,"flags":["Index"]}, -{"id":96,"symbolName":"__type","recursionId":86,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":3,"character":11},"end":{"line":3,"character":19}},"flags":["Object"],"display":"{ a: 1; }"}, -{"id":97,"symbolName":"__type","recursionId":87,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":4,"character":9},"end":{"line":4,"character":18}},"flags":["Object"],"display":"{ p1: 1; }"}, -{"id":98,"symbolName":"__type","recursionId":88,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":5,"character":9},"end":{"line":5,"character":18}},"flags":["Object"],"display":"{ p2: 2; }"}, -{"id":99,"symbolName":"__type","recursionId":89,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":6,"character":9},"end":{"line":6,"character":18}},"flags":["Object"],"display":"{ p3: 3; }"}, -{"id":100,"symbolName":"__type","recursionId":90,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":7,"character":9},"end":{"line":7,"character":18}},"flags":["Object"],"display":"{ p4: 4; }"}, -{"id":101,"symbolName":"__type","recursionId":91,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":8,"character":9},"end":{"line":8,"character":18}},"flags":["Object"],"display":"{ p5: 5; }"}, -{"id":102,"symbolName":"__type","recursionId":92,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":9,"character":9},"end":{"line":9,"character":18}},"flags":["Object"],"display":"{ p6: 6; }"}, -{"id":103,"symbolName":"__type","recursionId":93,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":10,"character":9},"end":{"line":10,"character":18}},"flags":["Object"],"display":"{ p7: 7; }"}, -{"id":104,"symbolName":"__type","recursionId":94,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":11,"character":9},"end":{"line":11,"character":18}},"flags":["Object"],"display":"{ p8: 8; }"}, -{"id":105,"symbolName":"__type","recursionId":95,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":12,"character":9},"end":{"line":12,"character":18}},"flags":["Object"],"display":"{ p9: 9; }"}, -{"id":106,"symbolName":"__type","recursionId":96,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":13,"character":10},"end":{"line":13,"character":21}},"flags":["Object"],"display":"{ p10: 10; }"}, -{"id":107,"recursionId":97,"flags":["NumberLiteral"],"display":"10"}, -{"id":108,"recursionId":98,"flags":["NumberLiteral"],"display":"10"}, -{"id":109,"recursionId":99,"flags":["NumberLiteral"],"display":"9"}, -{"id":110,"recursionId":100,"flags":["NumberLiteral"],"display":"9"}, -{"id":111,"recursionId":101,"flags":["NumberLiteral"],"display":"8"}, -{"id":112,"recursionId":102,"flags":["NumberLiteral"],"display":"8"}, -{"id":113,"recursionId":103,"flags":["NumberLiteral"],"display":"7"}, -{"id":114,"recursionId":104,"flags":["NumberLiteral"],"display":"7"}, -{"id":115,"recursionId":105,"flags":["NumberLiteral"],"display":"6"}, -{"id":116,"recursionId":106,"flags":["NumberLiteral"],"display":"6"}, -{"id":117,"recursionId":107,"flags":["NumberLiteral"],"display":"5"}, -{"id":118,"recursionId":108,"flags":["NumberLiteral"],"display":"5"}, -{"id":119,"recursionId":109,"flags":["NumberLiteral"],"display":"4"}, -{"id":120,"recursionId":110,"flags":["NumberLiteral"],"display":"4"}, -{"id":121,"recursionId":111,"flags":["NumberLiteral"],"display":"3"}, -{"id":122,"recursionId":112,"flags":["NumberLiteral"],"display":"3"}, -{"id":123,"recursionId":113,"flags":["NumberLiteral"],"display":"2"}, -{"id":124,"recursionId":114,"flags":["NumberLiteral"],"display":"2"}, -{"id":125,"recursionId":115,"flags":["NumberLiteral"],"display":"1"}, -{"id":126,"recursionId":116,"flags":["NumberLiteral"],"display":"1"}, -{"id":127,"recursionId":117,"unionTypes":[96,97,98,99,100,101,102,103,104,105,106],"flags":["Union"],"display":"{ a: 1; } | { p1: 1; } | { p2: 2; } | { p3: 3; } | { p4: 4; } | { p5: 5; } | { p6: 6; } | { p7: 7; } | { p8: 8; } | { p9: 9; } | { p10: 10; }"}, -{"id":128,"recursionId":118,"flags":["StringLiteral"],"display":"\"m1\""}, -{"id":129,"recursionId":119,"flags":["StringLiteral"],"display":"\"m2\""}, -{"id":130,"recursionId":120,"flags":["StringLiteral"],"display":"\"m3\""}, -{"id":131,"recursionId":121,"flags":["StringLiteral"],"display":"\"m4\""}, -{"id":132,"recursionId":122,"flags":["StringLiteral"],"display":"\"m5\""}, -{"id":133,"recursionId":123,"flags":["StringLiteral"],"display":"\"m6\""}, -{"id":134,"recursionId":124,"flags":["StringLiteral"],"display":"\"m7\""}, -{"id":135,"recursionId":125,"flags":["StringLiteral"],"display":"\"m8\""}, -{"id":136,"recursionId":126,"flags":["StringLiteral"],"display":"\"m9\""}, -{"id":137,"recursionId":127,"flags":["StringLiteral"],"display":"\"m10\""}, -{"id":138,"recursionId":128,"unionTypes":[14,15],"flags":["Union"],"display":"keyof C"}] +{"id":67,"symbolName":"Array","recursionId":66,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["TypeParameter"]}, +{"id":68,"symbolName":"Object","recursionId":67,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":8,"character":1},"end":{"line":8,"character":20}},"flags":["Object"]}, +{"id":69,"symbolName":"Function","recursionId":68,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":3,"character":1},"end":{"line":3,"character":22}},"flags":["Object"]}, +{"id":70,"symbolName":"CallableFunction","recursionId":69,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":4,"character":1},"end":{"line":4,"character":30}},"flags":["Object"]}, +{"id":71,"symbolName":"NewableFunction","recursionId":70,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":5,"character":1},"end":{"line":5,"character":29}},"flags":["Object"]}, +{"id":72,"symbolName":"String","recursionId":71,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":10,"character":1},"end":{"line":10,"character":34}},"flags":["Object"]}, +{"id":73,"symbolName":"Number","recursionId":72,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":7,"character":1},"end":{"line":7,"character":41}},"flags":["Object"]}, +{"id":74,"symbolName":"Boolean","recursionId":73,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":2,"character":1},"end":{"line":2,"character":21}},"flags":["Object"]}, +{"id":75,"symbolName":"RegExp","recursionId":74,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":9,"character":1},"end":{"line":9,"character":20}},"flags":["Object"]}, +{"id":76,"symbolName":"Array","recursionId":75,"instantiatedType":65,"typeArguments":[1],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["Object"]}, +{"id":77,"symbolName":"Array","recursionId":76,"instantiatedType":65,"typeArguments":[2],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["Object"]}, +{"id":78,"symbolName":"ReadonlyArray","recursionId":77,"instantiatedType":78,"typeArguments":[79],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":1},"end":{"line":12,"character":30}},"flags":["Object"]}, +{"id":79,"symbolName":"T","recursionId":78,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":25},"end":{"line":12,"character":26}},"flags":["TypeParameter"]}, +{"id":80,"symbolName":"ReadonlyArray","recursionId":79,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":1},"end":{"line":12,"character":30}},"flags":["TypeParameter"]}, +{"id":81,"symbolName":"ReadonlyArray","recursionId":80,"instantiatedType":78,"typeArguments":[1],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":1},"end":{"line":12,"character":30}},"flags":["Object"]}, +{"id":82,"symbolName":"X","recursionId":81,"firstDeclaration":{"path":"/home/src/workspaces/project/main.ts","start":{"line":1,"character":25},"end":{"line":1,"character":26}},"flags":["TypeParameter"]}, +{"id":83,"symbolName":"K","recursionId":82,"firstDeclaration":{"path":"/home/src/workspaces/project/main.ts","start":{"line":1,"character":34},"end":{"line":1,"character":46}},"flags":["TypeParameter"]}, +{"id":84,"recursionId":83,"keyofType":82,"flags":["Index"]}, +{"id":85,"symbolName":"__type","recursionId":84,"firstDeclaration":{"path":"/home/src/workspaces/project/main.ts","start":{"line":1,"character":31},"end":{"line":1,"character":55}},"flags":["Object"]}, +{"id":86,"recursionId":81,"indexedAccessObjectType":82,"indexedAccessIndexType":83,"flags":["IndexedAccess"]}, +{"id":87,"symbolName":"Symbol","recursionId":85,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":18,"character":13},"end":{"line":18,"character":38}},"flags":["Object"]}, +{"id":88,"symbolName":"SymbolConstructor","recursionId":86,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":13,"character":1},"end":{"line":17,"character":2}},"flags":["Object"]}, +{"id":89,"symbolName":"toStringTag","recursionId":87,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":16,"character":5},"end":{"line":16,"character":34}},"flags":["UniqueESSymbol"]}, +{"id":90,"symbolName":"expand","recursionId":88,"firstDeclaration":{"path":"/home/src/workspaces/project/main.ts","start":{"line":1,"character":1},"end":{"line":1,"character":56}},"flags":["Object"],"display":"() => { [K in keyof X]: X[K]; }"}, +{"id":91,"symbolName":"C","recursionId":89,"instantiatedType":91,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":2,"character":1},"end":{"line":14,"character":2}},"flags":["Object"]}, +{"id":92,"symbolName":"C","recursionId":90,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":2,"character":1},"end":{"line":14,"character":2}},"flags":["TypeParameter"]}, +{"id":93,"symbolName":"__type","recursionId":89,"firstDeclaration":{"path":"/home/src/workspaces/project/main.ts","start":{"line":1,"character":31},"end":{"line":1,"character":55}},"flags":["Object"]}, +{"id":94,"symbolName":"K","recursionId":82,"firstDeclaration":{"path":"/home/src/workspaces/project/main.ts","start":{"line":1,"character":34},"end":{"line":1,"character":46}},"flags":["TypeParameter"]}, +{"id":95,"recursionId":91,"keyofType":91,"flags":["Index"]}, +{"id":96,"symbolName":"__type","recursionId":92,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":3,"character":11},"end":{"line":3,"character":19}},"flags":["Object"],"display":"{ a: 1; }"}, +{"id":97,"symbolName":"__type","recursionId":93,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":4,"character":9},"end":{"line":4,"character":18}},"flags":["Object"],"display":"{ p1: 1; }"}, +{"id":98,"symbolName":"__type","recursionId":94,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":5,"character":9},"end":{"line":5,"character":18}},"flags":["Object"],"display":"{ p2: 2; }"}, +{"id":99,"symbolName":"__type","recursionId":95,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":6,"character":9},"end":{"line":6,"character":18}},"flags":["Object"],"display":"{ p3: 3; }"}, +{"id":100,"symbolName":"__type","recursionId":96,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":7,"character":9},"end":{"line":7,"character":18}},"flags":["Object"],"display":"{ p4: 4; }"}, +{"id":101,"symbolName":"__type","recursionId":97,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":8,"character":9},"end":{"line":8,"character":18}},"flags":["Object"],"display":"{ p5: 5; }"}, +{"id":102,"symbolName":"__type","recursionId":98,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":9,"character":9},"end":{"line":9,"character":18}},"flags":["Object"],"display":"{ p6: 6; }"}, +{"id":103,"symbolName":"__type","recursionId":99,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":10,"character":9},"end":{"line":10,"character":18}},"flags":["Object"],"display":"{ p7: 7; }"}, +{"id":104,"symbolName":"__type","recursionId":100,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":11,"character":9},"end":{"line":11,"character":18}},"flags":["Object"],"display":"{ p8: 8; }"}, +{"id":105,"symbolName":"__type","recursionId":101,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":12,"character":9},"end":{"line":12,"character":18}},"flags":["Object"],"display":"{ p9: 9; }"}, +{"id":106,"symbolName":"__type","recursionId":102,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":13,"character":10},"end":{"line":13,"character":21}},"flags":["Object"],"display":"{ p10: 10; }"}, +{"id":107,"recursionId":103,"flags":["NumberLiteral"],"display":"10"}, +{"id":108,"recursionId":104,"flags":["NumberLiteral"],"display":"10"}, +{"id":109,"recursionId":105,"flags":["NumberLiteral"],"display":"9"}, +{"id":110,"recursionId":106,"flags":["NumberLiteral"],"display":"9"}, +{"id":111,"recursionId":107,"flags":["NumberLiteral"],"display":"8"}, +{"id":112,"recursionId":108,"flags":["NumberLiteral"],"display":"8"}, +{"id":113,"recursionId":109,"flags":["NumberLiteral"],"display":"7"}, +{"id":114,"recursionId":110,"flags":["NumberLiteral"],"display":"7"}, +{"id":115,"recursionId":111,"flags":["NumberLiteral"],"display":"6"}, +{"id":116,"recursionId":112,"flags":["NumberLiteral"],"display":"6"}, +{"id":117,"recursionId":113,"flags":["NumberLiteral"],"display":"5"}, +{"id":118,"recursionId":114,"flags":["NumberLiteral"],"display":"5"}, +{"id":119,"recursionId":115,"flags":["NumberLiteral"],"display":"4"}, +{"id":120,"recursionId":116,"flags":["NumberLiteral"],"display":"4"}, +{"id":121,"recursionId":117,"flags":["NumberLiteral"],"display":"3"}, +{"id":122,"recursionId":118,"flags":["NumberLiteral"],"display":"3"}, +{"id":123,"recursionId":119,"flags":["NumberLiteral"],"display":"2"}, +{"id":124,"recursionId":120,"flags":["NumberLiteral"],"display":"2"}, +{"id":125,"recursionId":121,"flags":["NumberLiteral"],"display":"1"}, +{"id":126,"recursionId":122,"flags":["NumberLiteral"],"display":"1"}, +{"id":127,"recursionId":123,"unionTypes":[96,97,98,99,100,101,102,103,104,105,106],"flags":["Union"],"display":"{ a: 1; } | { p1: 1; } | { p2: 2; } | { p3: 3; } | { p4: 4; } | { p5: 5; } | { p6: 6; } | { p7: 7; } | { p8: 8; } | { p9: 9; } | { p10: 10; }"}, +{"id":128,"recursionId":124,"flags":["StringLiteral"],"display":"\"m1\""}, +{"id":129,"recursionId":125,"flags":["StringLiteral"],"display":"\"m2\""}, +{"id":130,"recursionId":126,"flags":["StringLiteral"],"display":"\"m3\""}, +{"id":131,"recursionId":127,"flags":["StringLiteral"],"display":"\"m4\""}, +{"id":132,"recursionId":128,"flags":["StringLiteral"],"display":"\"m5\""}, +{"id":133,"recursionId":129,"flags":["StringLiteral"],"display":"\"m6\""}, +{"id":134,"recursionId":130,"flags":["StringLiteral"],"display":"\"m7\""}, +{"id":135,"recursionId":131,"flags":["StringLiteral"],"display":"\"m8\""}, +{"id":136,"recursionId":132,"flags":["StringLiteral"],"display":"\"m9\""}, +{"id":137,"recursionId":133,"flags":["StringLiteral"],"display":"\"m10\""}, +{"id":138,"recursionId":134,"unionTypes":[14,15],"flags":["Union"],"display":"keyof C"}] diff --git a/tsc/testdata/baselines/reference/tsc/generateTrace/generateTrace-creates-static-index-signature-sibling-types-in-a-stable-order.js b/tsc/testdata/baselines/reference/tsc/generateTrace/generateTrace-creates-static-index-signature-sibling-types-in-a-stable-order.js index 91ed1755c8ff3..bed3ae67e51e0 100644 --- a/tsc/testdata/baselines/reference/tsc/generateTrace/generateTrace-creates-static-index-signature-sibling-types-in-a-stable-order.js +++ b/tsc/testdata/baselines/reference/tsc/generateTrace/generateTrace-creates-static-index-signature-sibling-types-in-a-stable-order.js @@ -209,76 +209,76 @@ export declare const w: { {"id":64,"symbolName":"globalThis","recursionId":63,"flags":["Object"],"display":"typeof globalThis"}, {"id":65,"symbolName":"Array","recursionId":64,"instantiatedType":65,"typeArguments":[66],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["Object"]}, {"id":66,"symbolName":"T","recursionId":65,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":17},"end":{"line":11,"character":18}},"flags":["TypeParameter"]}, -{"id":67,"symbolName":"Array","recursionId":64,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["TypeParameter"]}, -{"id":68,"symbolName":"Object","recursionId":66,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":8,"character":1},"end":{"line":8,"character":20}},"flags":["Object"]}, -{"id":69,"symbolName":"Function","recursionId":67,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":3,"character":1},"end":{"line":3,"character":22}},"flags":["Object"]}, -{"id":70,"symbolName":"CallableFunction","recursionId":68,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":4,"character":1},"end":{"line":4,"character":30}},"flags":["Object"]}, -{"id":71,"symbolName":"NewableFunction","recursionId":69,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":5,"character":1},"end":{"line":5,"character":29}},"flags":["Object"]}, -{"id":72,"symbolName":"String","recursionId":70,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":10,"character":1},"end":{"line":10,"character":34}},"flags":["Object"]}, -{"id":73,"symbolName":"Number","recursionId":71,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":7,"character":1},"end":{"line":7,"character":41}},"flags":["Object"]}, -{"id":74,"symbolName":"Boolean","recursionId":72,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":2,"character":1},"end":{"line":2,"character":21}},"flags":["Object"]}, -{"id":75,"symbolName":"RegExp","recursionId":73,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":9,"character":1},"end":{"line":9,"character":20}},"flags":["Object"]}, -{"id":76,"symbolName":"Array","recursionId":64,"instantiatedType":65,"typeArguments":[1],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["Object"]}, -{"id":77,"symbolName":"Array","recursionId":64,"instantiatedType":65,"typeArguments":[2],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["Object"]}, -{"id":78,"symbolName":"ReadonlyArray","recursionId":74,"instantiatedType":78,"typeArguments":[79],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":1},"end":{"line":12,"character":30}},"flags":["Object"]}, -{"id":79,"symbolName":"T","recursionId":75,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":25},"end":{"line":12,"character":26}},"flags":["TypeParameter"]}, -{"id":80,"symbolName":"ReadonlyArray","recursionId":74,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":1},"end":{"line":12,"character":30}},"flags":["TypeParameter"]}, -{"id":81,"symbolName":"ReadonlyArray","recursionId":74,"instantiatedType":78,"typeArguments":[1],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":1},"end":{"line":12,"character":30}},"flags":["Object"]}, -{"id":82,"symbolName":"X","recursionId":76,"firstDeclaration":{"path":"/home/src/workspaces/project/main.ts","start":{"line":1,"character":25},"end":{"line":1,"character":26}},"flags":["TypeParameter"]}, -{"id":83,"symbolName":"K","recursionId":77,"firstDeclaration":{"path":"/home/src/workspaces/project/main.ts","start":{"line":1,"character":34},"end":{"line":1,"character":46}},"flags":["TypeParameter"]}, -{"id":84,"recursionId":78,"keyofType":82,"flags":["Index"]}, -{"id":85,"symbolName":"__type","recursionId":79,"firstDeclaration":{"path":"/home/src/workspaces/project/main.ts","start":{"line":1,"character":31},"end":{"line":1,"character":55}},"flags":["Object"]}, -{"id":86,"recursionId":76,"indexedAccessObjectType":82,"indexedAccessIndexType":83,"flags":["IndexedAccess"]}, -{"id":87,"symbolName":"Symbol","recursionId":80,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":18,"character":13},"end":{"line":18,"character":38}},"flags":["Object"]}, -{"id":88,"symbolName":"SymbolConstructor","recursionId":81,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":13,"character":1},"end":{"line":17,"character":2}},"flags":["Object"]}, -{"id":89,"symbolName":"toStringTag","recursionId":82,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":16,"character":5},"end":{"line":16,"character":34}},"flags":["UniqueESSymbol"]}, -{"id":90,"symbolName":"expand","recursionId":83,"firstDeclaration":{"path":"/home/src/workspaces/project/main.ts","start":{"line":1,"character":1},"end":{"line":1,"character":56}},"flags":["Object"],"display":"() => { [K in keyof X]: X[K]; }"}, -{"id":91,"symbolName":"C","recursionId":84,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":2,"character":1},"end":{"line":14,"character":2}},"flags":["Object"],"display":"typeof C"}, -{"id":92,"symbolName":"C","recursionId":85,"instantiatedType":92,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":2,"character":1},"end":{"line":14,"character":2}},"flags":["Object"]}, -{"id":93,"symbolName":"C","recursionId":85,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":2,"character":1},"end":{"line":14,"character":2}},"flags":["TypeParameter"]}, -{"id":94,"symbolName":"__type","recursionId":84,"firstDeclaration":{"path":"/home/src/workspaces/project/main.ts","start":{"line":1,"character":31},"end":{"line":1,"character":55}},"flags":["Object"]}, -{"id":95,"symbolName":"K","recursionId":77,"firstDeclaration":{"path":"/home/src/workspaces/project/main.ts","start":{"line":1,"character":34},"end":{"line":1,"character":46}},"flags":["TypeParameter"]}, -{"id":96,"symbolName":"__type","recursionId":86,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":3,"character":18},"end":{"line":3,"character":26}},"flags":["Object"],"display":"{ a: 1; }"}, -{"id":97,"symbolName":"__type","recursionId":87,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":4,"character":16},"end":{"line":4,"character":25}},"flags":["Object"],"display":"{ p1: 1; }"}, -{"id":98,"symbolName":"__type","recursionId":88,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":5,"character":16},"end":{"line":5,"character":25}},"flags":["Object"],"display":"{ p2: 2; }"}, -{"id":99,"symbolName":"__type","recursionId":89,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":6,"character":16},"end":{"line":6,"character":25}},"flags":["Object"],"display":"{ p3: 3; }"}, -{"id":100,"symbolName":"__type","recursionId":90,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":7,"character":16},"end":{"line":7,"character":25}},"flags":["Object"],"display":"{ p4: 4; }"}, -{"id":101,"symbolName":"__type","recursionId":91,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":8,"character":16},"end":{"line":8,"character":25}},"flags":["Object"],"display":"{ p5: 5; }"}, -{"id":102,"symbolName":"__type","recursionId":92,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":9,"character":16},"end":{"line":9,"character":25}},"flags":["Object"],"display":"{ p6: 6; }"}, -{"id":103,"symbolName":"__type","recursionId":93,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":10,"character":16},"end":{"line":10,"character":25}},"flags":["Object"],"display":"{ p7: 7; }"}, -{"id":104,"symbolName":"__type","recursionId":94,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":11,"character":16},"end":{"line":11,"character":25}},"flags":["Object"],"display":"{ p8: 8; }"}, -{"id":105,"symbolName":"__type","recursionId":95,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":12,"character":16},"end":{"line":12,"character":25}},"flags":["Object"],"display":"{ p9: 9; }"}, -{"id":106,"symbolName":"__type","recursionId":96,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":13,"character":17},"end":{"line":13,"character":28}},"flags":["Object"],"display":"{ p10: 10; }"}, -{"id":107,"recursionId":97,"flags":["NumberLiteral"],"display":"10"}, -{"id":108,"recursionId":98,"flags":["NumberLiteral"],"display":"10"}, -{"id":109,"recursionId":99,"flags":["NumberLiteral"],"display":"9"}, -{"id":110,"recursionId":100,"flags":["NumberLiteral"],"display":"9"}, -{"id":111,"recursionId":101,"flags":["NumberLiteral"],"display":"8"}, -{"id":112,"recursionId":102,"flags":["NumberLiteral"],"display":"8"}, -{"id":113,"recursionId":103,"flags":["NumberLiteral"],"display":"7"}, -{"id":114,"recursionId":104,"flags":["NumberLiteral"],"display":"7"}, -{"id":115,"recursionId":105,"flags":["NumberLiteral"],"display":"6"}, -{"id":116,"recursionId":106,"flags":["NumberLiteral"],"display":"6"}, -{"id":117,"recursionId":107,"flags":["NumberLiteral"],"display":"5"}, -{"id":118,"recursionId":108,"flags":["NumberLiteral"],"display":"5"}, -{"id":119,"recursionId":109,"flags":["NumberLiteral"],"display":"4"}, -{"id":120,"recursionId":110,"flags":["NumberLiteral"],"display":"4"}, -{"id":121,"recursionId":111,"flags":["NumberLiteral"],"display":"3"}, -{"id":122,"recursionId":112,"flags":["NumberLiteral"],"display":"3"}, -{"id":123,"recursionId":113,"flags":["NumberLiteral"],"display":"2"}, -{"id":124,"recursionId":114,"flags":["NumberLiteral"],"display":"2"}, -{"id":125,"recursionId":115,"flags":["NumberLiteral"],"display":"1"}, -{"id":126,"recursionId":116,"flags":["NumberLiteral"],"display":"1"}, -{"id":127,"recursionId":117,"flags":["StringLiteral"],"display":"\"m1\""}, -{"id":128,"recursionId":118,"flags":["StringLiteral"],"display":"\"m2\""}, -{"id":129,"recursionId":119,"flags":["StringLiteral"],"display":"\"m3\""}, -{"id":130,"recursionId":120,"flags":["StringLiteral"],"display":"\"m4\""}, -{"id":131,"recursionId":121,"flags":["StringLiteral"],"display":"\"m5\""}, -{"id":132,"recursionId":122,"flags":["StringLiteral"],"display":"\"m6\""}, -{"id":133,"recursionId":123,"flags":["StringLiteral"],"display":"\"m7\""}, -{"id":134,"recursionId":124,"flags":["StringLiteral"],"display":"\"m8\""}, -{"id":135,"recursionId":125,"flags":["StringLiteral"],"display":"\"m9\""}, -{"id":136,"recursionId":126,"flags":["StringLiteral"],"display":"\"m10\""}, -{"id":137,"recursionId":127,"flags":["StringLiteral"],"display":"\"prototype\""}] +{"id":67,"symbolName":"Array","recursionId":66,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["TypeParameter"]}, +{"id":68,"symbolName":"Object","recursionId":67,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":8,"character":1},"end":{"line":8,"character":20}},"flags":["Object"]}, +{"id":69,"symbolName":"Function","recursionId":68,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":3,"character":1},"end":{"line":3,"character":22}},"flags":["Object"]}, +{"id":70,"symbolName":"CallableFunction","recursionId":69,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":4,"character":1},"end":{"line":4,"character":30}},"flags":["Object"]}, +{"id":71,"symbolName":"NewableFunction","recursionId":70,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":5,"character":1},"end":{"line":5,"character":29}},"flags":["Object"]}, +{"id":72,"symbolName":"String","recursionId":71,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":10,"character":1},"end":{"line":10,"character":34}},"flags":["Object"]}, +{"id":73,"symbolName":"Number","recursionId":72,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":7,"character":1},"end":{"line":7,"character":41}},"flags":["Object"]}, +{"id":74,"symbolName":"Boolean","recursionId":73,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":2,"character":1},"end":{"line":2,"character":21}},"flags":["Object"]}, +{"id":75,"symbolName":"RegExp","recursionId":74,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":9,"character":1},"end":{"line":9,"character":20}},"flags":["Object"]}, +{"id":76,"symbolName":"Array","recursionId":75,"instantiatedType":65,"typeArguments":[1],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["Object"]}, +{"id":77,"symbolName":"Array","recursionId":76,"instantiatedType":65,"typeArguments":[2],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["Object"]}, +{"id":78,"symbolName":"ReadonlyArray","recursionId":77,"instantiatedType":78,"typeArguments":[79],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":1},"end":{"line":12,"character":30}},"flags":["Object"]}, +{"id":79,"symbolName":"T","recursionId":78,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":25},"end":{"line":12,"character":26}},"flags":["TypeParameter"]}, +{"id":80,"symbolName":"ReadonlyArray","recursionId":79,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":1},"end":{"line":12,"character":30}},"flags":["TypeParameter"]}, +{"id":81,"symbolName":"ReadonlyArray","recursionId":80,"instantiatedType":78,"typeArguments":[1],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":1},"end":{"line":12,"character":30}},"flags":["Object"]}, +{"id":82,"symbolName":"X","recursionId":81,"firstDeclaration":{"path":"/home/src/workspaces/project/main.ts","start":{"line":1,"character":25},"end":{"line":1,"character":26}},"flags":["TypeParameter"]}, +{"id":83,"symbolName":"K","recursionId":82,"firstDeclaration":{"path":"/home/src/workspaces/project/main.ts","start":{"line":1,"character":34},"end":{"line":1,"character":46}},"flags":["TypeParameter"]}, +{"id":84,"recursionId":83,"keyofType":82,"flags":["Index"]}, +{"id":85,"symbolName":"__type","recursionId":84,"firstDeclaration":{"path":"/home/src/workspaces/project/main.ts","start":{"line":1,"character":31},"end":{"line":1,"character":55}},"flags":["Object"]}, +{"id":86,"recursionId":81,"indexedAccessObjectType":82,"indexedAccessIndexType":83,"flags":["IndexedAccess"]}, +{"id":87,"symbolName":"Symbol","recursionId":85,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":18,"character":13},"end":{"line":18,"character":38}},"flags":["Object"]}, +{"id":88,"symbolName":"SymbolConstructor","recursionId":86,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":13,"character":1},"end":{"line":17,"character":2}},"flags":["Object"]}, +{"id":89,"symbolName":"toStringTag","recursionId":87,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":16,"character":5},"end":{"line":16,"character":34}},"flags":["UniqueESSymbol"]}, +{"id":90,"symbolName":"expand","recursionId":88,"firstDeclaration":{"path":"/home/src/workspaces/project/main.ts","start":{"line":1,"character":1},"end":{"line":1,"character":56}},"flags":["Object"],"display":"() => { [K in keyof X]: X[K]; }"}, +{"id":91,"symbolName":"C","recursionId":89,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":2,"character":1},"end":{"line":14,"character":2}},"flags":["Object"],"display":"typeof C"}, +{"id":92,"symbolName":"C","recursionId":90,"instantiatedType":92,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":2,"character":1},"end":{"line":14,"character":2}},"flags":["Object"]}, +{"id":93,"symbolName":"C","recursionId":91,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":2,"character":1},"end":{"line":14,"character":2}},"flags":["TypeParameter"]}, +{"id":94,"symbolName":"__type","recursionId":89,"firstDeclaration":{"path":"/home/src/workspaces/project/main.ts","start":{"line":1,"character":31},"end":{"line":1,"character":55}},"flags":["Object"]}, +{"id":95,"symbolName":"K","recursionId":82,"firstDeclaration":{"path":"/home/src/workspaces/project/main.ts","start":{"line":1,"character":34},"end":{"line":1,"character":46}},"flags":["TypeParameter"]}, +{"id":96,"symbolName":"__type","recursionId":92,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":3,"character":18},"end":{"line":3,"character":26}},"flags":["Object"],"display":"{ a: 1; }"}, +{"id":97,"symbolName":"__type","recursionId":93,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":4,"character":16},"end":{"line":4,"character":25}},"flags":["Object"],"display":"{ p1: 1; }"}, +{"id":98,"symbolName":"__type","recursionId":94,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":5,"character":16},"end":{"line":5,"character":25}},"flags":["Object"],"display":"{ p2: 2; }"}, +{"id":99,"symbolName":"__type","recursionId":95,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":6,"character":16},"end":{"line":6,"character":25}},"flags":["Object"],"display":"{ p3: 3; }"}, +{"id":100,"symbolName":"__type","recursionId":96,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":7,"character":16},"end":{"line":7,"character":25}},"flags":["Object"],"display":"{ p4: 4; }"}, +{"id":101,"symbolName":"__type","recursionId":97,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":8,"character":16},"end":{"line":8,"character":25}},"flags":["Object"],"display":"{ p5: 5; }"}, +{"id":102,"symbolName":"__type","recursionId":98,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":9,"character":16},"end":{"line":9,"character":25}},"flags":["Object"],"display":"{ p6: 6; }"}, +{"id":103,"symbolName":"__type","recursionId":99,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":10,"character":16},"end":{"line":10,"character":25}},"flags":["Object"],"display":"{ p7: 7; }"}, +{"id":104,"symbolName":"__type","recursionId":100,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":11,"character":16},"end":{"line":11,"character":25}},"flags":["Object"],"display":"{ p8: 8; }"}, +{"id":105,"symbolName":"__type","recursionId":101,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":12,"character":16},"end":{"line":12,"character":25}},"flags":["Object"],"display":"{ p9: 9; }"}, +{"id":106,"symbolName":"__type","recursionId":102,"firstDeclaration":{"path":"/home/src/workspaces/project/ambient.d.ts","start":{"line":13,"character":17},"end":{"line":13,"character":28}},"flags":["Object"],"display":"{ p10: 10; }"}, +{"id":107,"recursionId":103,"flags":["NumberLiteral"],"display":"10"}, +{"id":108,"recursionId":104,"flags":["NumberLiteral"],"display":"10"}, +{"id":109,"recursionId":105,"flags":["NumberLiteral"],"display":"9"}, +{"id":110,"recursionId":106,"flags":["NumberLiteral"],"display":"9"}, +{"id":111,"recursionId":107,"flags":["NumberLiteral"],"display":"8"}, +{"id":112,"recursionId":108,"flags":["NumberLiteral"],"display":"8"}, +{"id":113,"recursionId":109,"flags":["NumberLiteral"],"display":"7"}, +{"id":114,"recursionId":110,"flags":["NumberLiteral"],"display":"7"}, +{"id":115,"recursionId":111,"flags":["NumberLiteral"],"display":"6"}, +{"id":116,"recursionId":112,"flags":["NumberLiteral"],"display":"6"}, +{"id":117,"recursionId":113,"flags":["NumberLiteral"],"display":"5"}, +{"id":118,"recursionId":114,"flags":["NumberLiteral"],"display":"5"}, +{"id":119,"recursionId":115,"flags":["NumberLiteral"],"display":"4"}, +{"id":120,"recursionId":116,"flags":["NumberLiteral"],"display":"4"}, +{"id":121,"recursionId":117,"flags":["NumberLiteral"],"display":"3"}, +{"id":122,"recursionId":118,"flags":["NumberLiteral"],"display":"3"}, +{"id":123,"recursionId":119,"flags":["NumberLiteral"],"display":"2"}, +{"id":124,"recursionId":120,"flags":["NumberLiteral"],"display":"2"}, +{"id":125,"recursionId":121,"flags":["NumberLiteral"],"display":"1"}, +{"id":126,"recursionId":122,"flags":["NumberLiteral"],"display":"1"}, +{"id":127,"recursionId":123,"flags":["StringLiteral"],"display":"\"m1\""}, +{"id":128,"recursionId":124,"flags":["StringLiteral"],"display":"\"m2\""}, +{"id":129,"recursionId":125,"flags":["StringLiteral"],"display":"\"m3\""}, +{"id":130,"recursionId":126,"flags":["StringLiteral"],"display":"\"m4\""}, +{"id":131,"recursionId":127,"flags":["StringLiteral"],"display":"\"m5\""}, +{"id":132,"recursionId":128,"flags":["StringLiteral"],"display":"\"m6\""}, +{"id":133,"recursionId":129,"flags":["StringLiteral"],"display":"\"m7\""}, +{"id":134,"recursionId":130,"flags":["StringLiteral"],"display":"\"m8\""}, +{"id":135,"recursionId":131,"flags":["StringLiteral"],"display":"\"m9\""}, +{"id":136,"recursionId":132,"flags":["StringLiteral"],"display":"\"m10\""}, +{"id":137,"recursionId":133,"flags":["StringLiteral"],"display":"\"prototype\""}] diff --git a/tsc/testdata/baselines/reference/tsc/generateTrace/generateTrace-creates-types-in-a-stable-order.js b/tsc/testdata/baselines/reference/tsc/generateTrace/generateTrace-creates-types-in-a-stable-order.js index 98f600aca3a1c..620aa56b804f8 100644 --- a/tsc/testdata/baselines/reference/tsc/generateTrace/generateTrace-creates-types-in-a-stable-order.js +++ b/tsc/testdata/baselines/reference/tsc/generateTrace/generateTrace-creates-types-in-a-stable-order.js @@ -445,113 +445,113 @@ export declare const widget: import("./gadget").Gadget; {"id":64,"symbolName":"globalThis","recursionId":63,"flags":["Object"],"display":"typeof globalThis"}, {"id":65,"symbolName":"Array","recursionId":64,"instantiatedType":65,"typeArguments":[66],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["Object"]}, {"id":66,"symbolName":"T","recursionId":65,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":17},"end":{"line":11,"character":18}},"flags":["TypeParameter"]}, -{"id":67,"symbolName":"Array","recursionId":64,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["TypeParameter"]}, -{"id":68,"symbolName":"Object","recursionId":66,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":8,"character":1},"end":{"line":8,"character":20}},"flags":["Object"]}, -{"id":69,"symbolName":"Function","recursionId":67,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":3,"character":1},"end":{"line":3,"character":22}},"flags":["Object"]}, -{"id":70,"symbolName":"CallableFunction","recursionId":68,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":4,"character":1},"end":{"line":4,"character":30}},"flags":["Object"]}, -{"id":71,"symbolName":"NewableFunction","recursionId":69,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":5,"character":1},"end":{"line":5,"character":29}},"flags":["Object"]}, -{"id":72,"symbolName":"String","recursionId":70,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":10,"character":1},"end":{"line":10,"character":34}},"flags":["Object"]}, -{"id":73,"symbolName":"Number","recursionId":71,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":7,"character":1},"end":{"line":7,"character":41}},"flags":["Object"]}, -{"id":74,"symbolName":"Boolean","recursionId":72,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":2,"character":1},"end":{"line":2,"character":21}},"flags":["Object"]}, -{"id":75,"symbolName":"RegExp","recursionId":73,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":9,"character":1},"end":{"line":9,"character":20}},"flags":["Object"]}, -{"id":76,"symbolName":"Array","recursionId":64,"instantiatedType":65,"typeArguments":[1],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["Object"]}, -{"id":77,"symbolName":"Array","recursionId":64,"instantiatedType":65,"typeArguments":[2],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["Object"]}, -{"id":78,"symbolName":"ReadonlyArray","recursionId":74,"instantiatedType":78,"typeArguments":[79],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":1},"end":{"line":12,"character":30}},"flags":["Object"]}, -{"id":79,"symbolName":"T","recursionId":75,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":25},"end":{"line":12,"character":26}},"flags":["TypeParameter"]}, -{"id":80,"symbolName":"ReadonlyArray","recursionId":74,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":1},"end":{"line":12,"character":30}},"flags":["TypeParameter"]}, -{"id":81,"symbolName":"ReadonlyArray","recursionId":74,"instantiatedType":78,"typeArguments":[1],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":1},"end":{"line":12,"character":30}},"flags":["Object"]}, -{"id":82,"symbolName":"\"/home/src/workspaces/project/parts/index\"","recursionId":76,"firstDeclaration":{"path":"/home/src/workspaces/project/parts/index.d.ts","start":{"line":1,"character":1},"end":{"line":14,"character":1}},"flags":["Object"],"display":"typeof import(\"/home/src/workspaces/project/parts/index\")"}, -{"id":83,"symbolName":"\"/home/src/workspaces/project/parts/alpha\"","recursionId":77,"firstDeclaration":{"path":"/home/src/workspaces/project/parts/alpha.d.ts","start":{"line":1,"character":1},"end":{"line":2,"character":1}},"flags":["Object"],"display":"typeof import(\"/home/src/workspaces/project/parts/alpha\")"}, -{"id":84,"symbolName":"\"/home/src/workspaces/project/parts/beta\"","recursionId":78,"firstDeclaration":{"path":"/home/src/workspaces/project/parts/beta.d.ts","start":{"line":1,"character":1},"end":{"line":2,"character":1}},"flags":["Object"],"display":"typeof import(\"/home/src/workspaces/project/parts/beta\")"}, -{"id":85,"symbolName":"\"/home/src/workspaces/project/parts/gamma\"","recursionId":79,"firstDeclaration":{"path":"/home/src/workspaces/project/parts/gamma.d.ts","start":{"line":1,"character":1},"end":{"line":2,"character":1}},"flags":["Object"],"display":"typeof import(\"/home/src/workspaces/project/parts/gamma\")"}, -{"id":86,"symbolName":"\"/home/src/workspaces/project/parts/delta\"","recursionId":80,"firstDeclaration":{"path":"/home/src/workspaces/project/parts/delta.d.ts","start":{"line":1,"character":1},"end":{"line":2,"character":1}},"flags":["Object"],"display":"typeof import(\"/home/src/workspaces/project/parts/delta\")"}, -{"id":87,"symbolName":"\"/home/src/workspaces/project/parts/epsilon\"","recursionId":81,"firstDeclaration":{"path":"/home/src/workspaces/project/parts/epsilon.d.ts","start":{"line":1,"character":1},"end":{"line":2,"character":1}},"flags":["Object"],"display":"typeof import(\"/home/src/workspaces/project/parts/epsilon\")"}, -{"id":88,"symbolName":"\"/home/src/workspaces/project/parts/zeta\"","recursionId":82,"firstDeclaration":{"path":"/home/src/workspaces/project/parts/zeta.d.ts","start":{"line":1,"character":1},"end":{"line":2,"character":1}},"flags":["Object"],"display":"typeof import(\"/home/src/workspaces/project/parts/zeta\")"}, -{"id":89,"symbolName":"\"/home/src/workspaces/project/parts/eta\"","recursionId":83,"firstDeclaration":{"path":"/home/src/workspaces/project/parts/eta.d.ts","start":{"line":1,"character":1},"end":{"line":2,"character":1}},"flags":["Object"],"display":"typeof import(\"/home/src/workspaces/project/parts/eta\")"}, -{"id":90,"symbolName":"\"/home/src/workspaces/project/parts/theta\"","recursionId":84,"firstDeclaration":{"path":"/home/src/workspaces/project/parts/theta.d.ts","start":{"line":1,"character":1},"end":{"line":2,"character":1}},"flags":["Object"],"display":"typeof import(\"/home/src/workspaces/project/parts/theta\")"}, -{"id":91,"symbolName":"\"/home/src/workspaces/project/parts/iota\"","recursionId":85,"firstDeclaration":{"path":"/home/src/workspaces/project/parts/iota.d.ts","start":{"line":1,"character":1},"end":{"line":2,"character":1}},"flags":["Object"],"display":"typeof import(\"/home/src/workspaces/project/parts/iota\")"}, -{"id":92,"symbolName":"\"/home/src/workspaces/project/parts/kappa\"","recursionId":86,"firstDeclaration":{"path":"/home/src/workspaces/project/parts/kappa.d.ts","start":{"line":1,"character":1},"end":{"line":2,"character":1}},"flags":["Object"],"display":"typeof import(\"/home/src/workspaces/project/parts/kappa\")"}, -{"id":93,"symbolName":"\"/home/src/workspaces/project/parts/lambda\"","recursionId":87,"firstDeclaration":{"path":"/home/src/workspaces/project/parts/lambda.d.ts","start":{"line":1,"character":1},"end":{"line":2,"character":1}},"flags":["Object"],"display":"typeof import(\"/home/src/workspaces/project/parts/lambda\")"}, -{"id":94,"symbolName":"\"/home/src/workspaces/project/parts/mu\"","recursionId":88,"firstDeclaration":{"path":"/home/src/workspaces/project/parts/mu.d.ts","start":{"line":1,"character":1},"end":{"line":2,"character":1}},"flags":["Object"],"display":"typeof import(\"/home/src/workspaces/project/parts/mu\")"}, -{"id":95,"recursionId":89,"flags":["NumberLiteral"],"display":"1"}, -{"id":96,"recursionId":90,"flags":["NumberLiteral"],"display":"1"}, -{"id":97,"recursionId":91,"flags":["NumberLiteral"],"display":"2"}, -{"id":98,"recursionId":92,"flags":["NumberLiteral"],"display":"2"}, -{"id":99,"recursionId":93,"flags":["NumberLiteral"],"display":"3"}, -{"id":100,"recursionId":94,"flags":["NumberLiteral"],"display":"3"}, -{"id":101,"recursionId":95,"flags":["NumberLiteral"],"display":"4"}, -{"id":102,"recursionId":96,"flags":["NumberLiteral"],"display":"4"}, -{"id":103,"recursionId":97,"flags":["NumberLiteral"],"display":"5"}, -{"id":104,"recursionId":98,"flags":["NumberLiteral"],"display":"5"}, -{"id":105,"recursionId":99,"flags":["NumberLiteral"],"display":"6"}, -{"id":106,"recursionId":100,"flags":["NumberLiteral"],"display":"6"}, -{"id":107,"recursionId":101,"flags":["NumberLiteral"],"display":"7"}, -{"id":108,"recursionId":102,"flags":["NumberLiteral"],"display":"7"}, -{"id":109,"recursionId":103,"flags":["NumberLiteral"],"display":"8"}, -{"id":110,"recursionId":104,"flags":["NumberLiteral"],"display":"8"}, -{"id":111,"recursionId":105,"flags":["NumberLiteral"],"display":"9"}, -{"id":112,"recursionId":106,"flags":["NumberLiteral"],"display":"9"}, -{"id":113,"recursionId":107,"flags":["NumberLiteral"],"display":"10"}, -{"id":114,"recursionId":108,"flags":["NumberLiteral"],"display":"10"}, -{"id":115,"recursionId":109,"flags":["NumberLiteral"],"display":"11"}, -{"id":116,"recursionId":110,"flags":["NumberLiteral"],"display":"11"}, -{"id":117,"recursionId":111,"flags":["NumberLiteral"],"display":"12"}, -{"id":118,"recursionId":112,"flags":["NumberLiteral"],"display":"12"}, -{"id":119,"symbolName":"__type","recursionId":113,"firstDeclaration":{"path":"/home/src/workspaces/project/main.ts","start":{"line":5,"character":29},"end":{"line":5,"character":106}},"flags":["Object"],"display":"{ a: 1; b: 2; c: 3; d: 4; e: 5; f: 6; g: 7; h: 8; i: 9; j: 10; k: 11; l: 12; }"}, -{"id":120,"symbolName":"T","recursionId":114,"firstDeclaration":{"path":"/home/src/workspaces/project/fields.d.ts","start":{"line":1,"character":20},"end":{"line":1,"character":21}},"flags":["TypeParameter"]}, -{"id":121,"symbolName":"T","recursionId":114,"firstDeclaration":{"path":"/home/src/workspaces/project/fields.d.ts","start":{"line":1,"character":20},"end":{"line":1,"character":21}},"flags":["TypeParameter"]}, -{"id":122,"symbolName":"__type","recursionId":115,"firstDeclaration":{"path":"/home/src/workspaces/project/fields.d.ts","start":{"line":1,"character":35},"end":{"line":1,"character":181}},"flags":["Object"],"display":"{ a: A; b: B; c: C; d: D; e: E; f: F; g: G; h: H; i: I; j: J; k: K; l: L; }"}, -{"id":123,"symbolName":"A","recursionId":116,"firstDeclaration":{"path":"/home/src/workspaces/project/fields.d.ts","start":{"line":1,"character":46},"end":{"line":1,"character":47}},"flags":["TypeParameter"]}, -{"id":124,"symbolName":"B","recursionId":117,"firstDeclaration":{"path":"/home/src/workspaces/project/fields.d.ts","start":{"line":1,"character":58},"end":{"line":1,"character":59}},"flags":["TypeParameter"]}, -{"id":125,"symbolName":"C","recursionId":118,"firstDeclaration":{"path":"/home/src/workspaces/project/fields.d.ts","start":{"line":1,"character":70},"end":{"line":1,"character":71}},"flags":["TypeParameter"]}, -{"id":126,"symbolName":"D","recursionId":119,"firstDeclaration":{"path":"/home/src/workspaces/project/fields.d.ts","start":{"line":1,"character":82},"end":{"line":1,"character":83}},"flags":["TypeParameter"]}, -{"id":127,"symbolName":"E","recursionId":120,"firstDeclaration":{"path":"/home/src/workspaces/project/fields.d.ts","start":{"line":1,"character":94},"end":{"line":1,"character":95}},"flags":["TypeParameter"]}, -{"id":128,"symbolName":"F","recursionId":121,"firstDeclaration":{"path":"/home/src/workspaces/project/fields.d.ts","start":{"line":1,"character":106},"end":{"line":1,"character":107}},"flags":["TypeParameter"]}, -{"id":129,"symbolName":"G","recursionId":122,"firstDeclaration":{"path":"/home/src/workspaces/project/fields.d.ts","start":{"line":1,"character":118},"end":{"line":1,"character":119}},"flags":["TypeParameter"]}, -{"id":130,"symbolName":"H","recursionId":123,"firstDeclaration":{"path":"/home/src/workspaces/project/fields.d.ts","start":{"line":1,"character":130},"end":{"line":1,"character":131}},"flags":["TypeParameter"]}, -{"id":131,"symbolName":"I","recursionId":124,"firstDeclaration":{"path":"/home/src/workspaces/project/fields.d.ts","start":{"line":1,"character":142},"end":{"line":1,"character":143}},"flags":["TypeParameter"]}, -{"id":132,"symbolName":"J","recursionId":125,"firstDeclaration":{"path":"/home/src/workspaces/project/fields.d.ts","start":{"line":1,"character":154},"end":{"line":1,"character":155}},"flags":["TypeParameter"]}, -{"id":133,"symbolName":"K","recursionId":126,"firstDeclaration":{"path":"/home/src/workspaces/project/fields.d.ts","start":{"line":1,"character":166},"end":{"line":1,"character":167}},"flags":["TypeParameter"]}, -{"id":134,"symbolName":"L","recursionId":127,"firstDeclaration":{"path":"/home/src/workspaces/project/fields.d.ts","start":{"line":1,"character":178},"end":{"line":1,"character":179}},"flags":["TypeParameter"]}, -{"id":135,"symbolName":"__type","recursionId":115,"firstDeclaration":{"path":"/home/src/workspaces/project/fields.d.ts","start":{"line":1,"character":35},"end":{"line":1,"character":181}},"flags":["Object"],"display":"{ a: unknown; b: unknown; c: unknown; d: unknown; e: unknown; f: unknown; g: unknown; h: unknown; i: unknown; j: unknown; k: unknown; l: unknown; }"}, -{"id":136,"symbolName":"Fields","recursionId":128,"aliasTypeArguments":[120],"conditionalCheckType":121,"conditionalExtendsType":122,"conditionalTrueType":-1,"conditionalFalseType":-1,"firstDeclaration":{"path":"/home/src/workspaces/project/fields.d.ts","start":{"line":1,"character":1},"end":{"line":1,"character":229}},"flags":["Conditional"]}, -{"id":137,"symbolName":"__type","recursionId":115,"firstDeclaration":{"path":"/home/src/workspaces/project/fields.d.ts","start":{"line":1,"character":35},"end":{"line":1,"character":181}},"flags":["Object"],"display":"{ a: 1; b: 2; c: 3; d: 4; e: 5; f: 6; g: 7; h: 8; i: 9; j: 10; k: 11; l: 12; }"}, -{"id":138,"recursionId":129,"flags":["TypeParameter"]}, -{"id":139,"recursionId":130,"flags":["TypeParameter"]}, -{"id":140,"recursionId":131,"flags":["TypeParameter"]}, -{"id":141,"recursionId":132,"flags":["TypeParameter"]}, -{"id":142,"recursionId":133,"flags":["TypeParameter"]}, -{"id":143,"recursionId":134,"flags":["TypeParameter"]}, -{"id":144,"recursionId":135,"flags":["TypeParameter"]}, -{"id":145,"recursionId":136,"flags":["TypeParameter"]}, -{"id":146,"recursionId":137,"flags":["TypeParameter"]}, -{"id":147,"recursionId":138,"flags":["TypeParameter"]}, -{"id":148,"recursionId":139,"flags":["TypeParameter"]}, -{"id":149,"recursionId":140,"flags":["TypeParameter"]}, -{"id":150,"recursionId":141,"isTuple":true,"instantiatedType":150,"typeArguments":[138,139,140,141,142,143,144,145,146,147,148,149],"flags":["Object"]}, -{"id":151,"recursionId":142,"flags":["TypeParameter"]}, -{"id":152,"recursionId":143,"instantiatedType":150,"typeArguments":[123,124,125,126,127,128,129,130,131,132,133,134],"flags":["Object"]}, -{"id":153,"recursionId":141,"instantiatedType":150,"typeArguments":[95,97,99,101,103,105,107,109,111,113,115,117],"flags":["Object"]}, -{"id":154,"recursionId":144,"instantiatedType":150,"typeArguments":[95,97,99,101,103,105,107,109,111,113,115,117],"flags":["Object"]}, -{"id":155,"recursionId":145,"unionTypes":[138,139,140,141,142,143,144,145,146,147,148,149],"flags":["Union"],"display":"? | ? | ? | ? | ? | ? | ? | ? | ? | ? | ? | ?"}, -{"id":156,"symbolName":"Array","recursionId":64,"instantiatedType":65,"typeArguments":[155],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["Object"]}, -{"id":157,"recursionId":146,"unionTypes":[95,97,99,101,103,105,107,109,111,113,115,117],"flags":["Union"],"display":"1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12"}, -{"id":158,"symbolName":"Array","recursionId":64,"instantiatedType":65,"typeArguments":[157],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["Object"]}, -{"id":159,"symbolName":"Array","recursionId":64,"instantiatedType":65,"typeArguments":[157,153],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["Object"]}, -{"id":160,"symbolName":"Array","recursionId":64,"instantiatedType":65,"typeArguments":[157,154],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["Object"]}, -{"id":161,"symbolName":"makeWidget","recursionId":147,"firstDeclaration":{"path":"/home/src/workspaces/project/widget.d.ts","start":{"line":2,"character":1},"end":{"line":2,"character":46}},"flags":["Object"],"display":"() => Gadget"}, -{"id":162,"symbolName":"Gadget","recursionId":148,"firstDeclaration":{"path":"/home/src/workspaces/project/gadget.d.ts","start":{"line":1,"character":1},"end":{"line":3,"character":2}},"flags":["Object"]}, -{"id":163,"symbolName":"__type","recursionId":149,"firstDeclaration":{"path":"/home/src/workspaces/project/locales/ar.d.ts","start":{"line":1,"character":25},"end":{"line":1,"character":47}},"flags":["Object"],"display":"() => { locale: \"ar\"; }"}, -{"id":164,"symbolName":"__type","recursionId":150,"firstDeclaration":{"path":"/home/src/workspaces/project/locales/de.d.ts","start":{"line":1,"character":25},"end":{"line":1,"character":47}},"flags":["Object"],"display":"() => { locale: \"de\"; }"}, -{"id":165,"symbolName":"__type","recursionId":151,"firstDeclaration":{"path":"/home/src/workspaces/project/locales/en.d.ts","start":{"line":1,"character":25},"end":{"line":1,"character":47}},"flags":["Object"],"display":"() => { locale: \"en\"; }"}, -{"id":166,"symbolName":"__type","recursionId":152,"firstDeclaration":{"path":"/home/src/workspaces/project/locales/es.d.ts","start":{"line":1,"character":25},"end":{"line":1,"character":47}},"flags":["Object"],"display":"() => { locale: \"es\"; }"}, -{"id":167,"symbolName":"__type","recursionId":153,"firstDeclaration":{"path":"/home/src/workspaces/project/locales/fr.d.ts","start":{"line":1,"character":25},"end":{"line":1,"character":47}},"flags":["Object"],"display":"() => { locale: \"fr\"; }"}, -{"id":168,"symbolName":"__type","recursionId":154,"firstDeclaration":{"path":"/home/src/workspaces/project/locales/he.d.ts","start":{"line":1,"character":25},"end":{"line":1,"character":47}},"flags":["Object"],"display":"() => { locale: \"he\"; }"}, -{"id":169,"symbolName":"__type","recursionId":155,"firstDeclaration":{"path":"/home/src/workspaces/project/locales/it.d.ts","start":{"line":1,"character":25},"end":{"line":1,"character":47}},"flags":["Object"],"display":"() => { locale: \"it\"; }"}, -{"id":170,"symbolName":"__type","recursionId":156,"firstDeclaration":{"path":"/home/src/workspaces/project/locales/ja.d.ts","start":{"line":1,"character":25},"end":{"line":1,"character":47}},"flags":["Object"],"display":"() => { locale: \"ja\"; }"}, -{"id":171,"symbolName":"__type","recursionId":157,"firstDeclaration":{"path":"/home/src/workspaces/project/locales/ko.d.ts","start":{"line":1,"character":25},"end":{"line":1,"character":47}},"flags":["Object"],"display":"() => { locale: \"ko\"; }"}, -{"id":172,"symbolName":"__type","recursionId":158,"firstDeclaration":{"path":"/home/src/workspaces/project/locales/nl.d.ts","start":{"line":1,"character":25},"end":{"line":1,"character":47}},"flags":["Object"],"display":"() => { locale: \"nl\"; }"}, -{"id":173,"symbolName":"__type","recursionId":159,"firstDeclaration":{"path":"/home/src/workspaces/project/locales/pl.d.ts","start":{"line":1,"character":25},"end":{"line":1,"character":47}},"flags":["Object"],"display":"() => { locale: \"pl\"; }"}, -{"id":174,"symbolName":"__type","recursionId":160,"firstDeclaration":{"path":"/home/src/workspaces/project/locales/pt.d.ts","start":{"line":1,"character":25},"end":{"line":1,"character":47}},"flags":["Object"],"display":"() => { locale: \"pt\"; }"}] +{"id":67,"symbolName":"Array","recursionId":66,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["TypeParameter"]}, +{"id":68,"symbolName":"Object","recursionId":67,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":8,"character":1},"end":{"line":8,"character":20}},"flags":["Object"]}, +{"id":69,"symbolName":"Function","recursionId":68,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":3,"character":1},"end":{"line":3,"character":22}},"flags":["Object"]}, +{"id":70,"symbolName":"CallableFunction","recursionId":69,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":4,"character":1},"end":{"line":4,"character":30}},"flags":["Object"]}, +{"id":71,"symbolName":"NewableFunction","recursionId":70,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":5,"character":1},"end":{"line":5,"character":29}},"flags":["Object"]}, +{"id":72,"symbolName":"String","recursionId":71,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":10,"character":1},"end":{"line":10,"character":34}},"flags":["Object"]}, +{"id":73,"symbolName":"Number","recursionId":72,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":7,"character":1},"end":{"line":7,"character":41}},"flags":["Object"]}, +{"id":74,"symbolName":"Boolean","recursionId":73,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":2,"character":1},"end":{"line":2,"character":21}},"flags":["Object"]}, +{"id":75,"symbolName":"RegExp","recursionId":74,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":9,"character":1},"end":{"line":9,"character":20}},"flags":["Object"]}, +{"id":76,"symbolName":"Array","recursionId":75,"instantiatedType":65,"typeArguments":[1],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["Object"]}, +{"id":77,"symbolName":"Array","recursionId":76,"instantiatedType":65,"typeArguments":[2],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["Object"]}, +{"id":78,"symbolName":"ReadonlyArray","recursionId":77,"instantiatedType":78,"typeArguments":[79],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":1},"end":{"line":12,"character":30}},"flags":["Object"]}, +{"id":79,"symbolName":"T","recursionId":78,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":25},"end":{"line":12,"character":26}},"flags":["TypeParameter"]}, +{"id":80,"symbolName":"ReadonlyArray","recursionId":79,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":1},"end":{"line":12,"character":30}},"flags":["TypeParameter"]}, +{"id":81,"symbolName":"ReadonlyArray","recursionId":80,"instantiatedType":78,"typeArguments":[1],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":1},"end":{"line":12,"character":30}},"flags":["Object"]}, +{"id":82,"symbolName":"\"/home/src/workspaces/project/parts/index\"","recursionId":81,"firstDeclaration":{"path":"/home/src/workspaces/project/parts/index.d.ts","start":{"line":1,"character":1},"end":{"line":14,"character":1}},"flags":["Object"],"display":"typeof import(\"/home/src/workspaces/project/parts/index\")"}, +{"id":83,"symbolName":"\"/home/src/workspaces/project/parts/alpha\"","recursionId":82,"firstDeclaration":{"path":"/home/src/workspaces/project/parts/alpha.d.ts","start":{"line":1,"character":1},"end":{"line":2,"character":1}},"flags":["Object"],"display":"typeof import(\"/home/src/workspaces/project/parts/alpha\")"}, +{"id":84,"symbolName":"\"/home/src/workspaces/project/parts/beta\"","recursionId":83,"firstDeclaration":{"path":"/home/src/workspaces/project/parts/beta.d.ts","start":{"line":1,"character":1},"end":{"line":2,"character":1}},"flags":["Object"],"display":"typeof import(\"/home/src/workspaces/project/parts/beta\")"}, +{"id":85,"symbolName":"\"/home/src/workspaces/project/parts/gamma\"","recursionId":84,"firstDeclaration":{"path":"/home/src/workspaces/project/parts/gamma.d.ts","start":{"line":1,"character":1},"end":{"line":2,"character":1}},"flags":["Object"],"display":"typeof import(\"/home/src/workspaces/project/parts/gamma\")"}, +{"id":86,"symbolName":"\"/home/src/workspaces/project/parts/delta\"","recursionId":85,"firstDeclaration":{"path":"/home/src/workspaces/project/parts/delta.d.ts","start":{"line":1,"character":1},"end":{"line":2,"character":1}},"flags":["Object"],"display":"typeof import(\"/home/src/workspaces/project/parts/delta\")"}, +{"id":87,"symbolName":"\"/home/src/workspaces/project/parts/epsilon\"","recursionId":86,"firstDeclaration":{"path":"/home/src/workspaces/project/parts/epsilon.d.ts","start":{"line":1,"character":1},"end":{"line":2,"character":1}},"flags":["Object"],"display":"typeof import(\"/home/src/workspaces/project/parts/epsilon\")"}, +{"id":88,"symbolName":"\"/home/src/workspaces/project/parts/zeta\"","recursionId":87,"firstDeclaration":{"path":"/home/src/workspaces/project/parts/zeta.d.ts","start":{"line":1,"character":1},"end":{"line":2,"character":1}},"flags":["Object"],"display":"typeof import(\"/home/src/workspaces/project/parts/zeta\")"}, +{"id":89,"symbolName":"\"/home/src/workspaces/project/parts/eta\"","recursionId":88,"firstDeclaration":{"path":"/home/src/workspaces/project/parts/eta.d.ts","start":{"line":1,"character":1},"end":{"line":2,"character":1}},"flags":["Object"],"display":"typeof import(\"/home/src/workspaces/project/parts/eta\")"}, +{"id":90,"symbolName":"\"/home/src/workspaces/project/parts/theta\"","recursionId":89,"firstDeclaration":{"path":"/home/src/workspaces/project/parts/theta.d.ts","start":{"line":1,"character":1},"end":{"line":2,"character":1}},"flags":["Object"],"display":"typeof import(\"/home/src/workspaces/project/parts/theta\")"}, +{"id":91,"symbolName":"\"/home/src/workspaces/project/parts/iota\"","recursionId":90,"firstDeclaration":{"path":"/home/src/workspaces/project/parts/iota.d.ts","start":{"line":1,"character":1},"end":{"line":2,"character":1}},"flags":["Object"],"display":"typeof import(\"/home/src/workspaces/project/parts/iota\")"}, +{"id":92,"symbolName":"\"/home/src/workspaces/project/parts/kappa\"","recursionId":91,"firstDeclaration":{"path":"/home/src/workspaces/project/parts/kappa.d.ts","start":{"line":1,"character":1},"end":{"line":2,"character":1}},"flags":["Object"],"display":"typeof import(\"/home/src/workspaces/project/parts/kappa\")"}, +{"id":93,"symbolName":"\"/home/src/workspaces/project/parts/lambda\"","recursionId":92,"firstDeclaration":{"path":"/home/src/workspaces/project/parts/lambda.d.ts","start":{"line":1,"character":1},"end":{"line":2,"character":1}},"flags":["Object"],"display":"typeof import(\"/home/src/workspaces/project/parts/lambda\")"}, +{"id":94,"symbolName":"\"/home/src/workspaces/project/parts/mu\"","recursionId":93,"firstDeclaration":{"path":"/home/src/workspaces/project/parts/mu.d.ts","start":{"line":1,"character":1},"end":{"line":2,"character":1}},"flags":["Object"],"display":"typeof import(\"/home/src/workspaces/project/parts/mu\")"}, +{"id":95,"recursionId":94,"flags":["NumberLiteral"],"display":"1"}, +{"id":96,"recursionId":95,"flags":["NumberLiteral"],"display":"1"}, +{"id":97,"recursionId":96,"flags":["NumberLiteral"],"display":"2"}, +{"id":98,"recursionId":97,"flags":["NumberLiteral"],"display":"2"}, +{"id":99,"recursionId":98,"flags":["NumberLiteral"],"display":"3"}, +{"id":100,"recursionId":99,"flags":["NumberLiteral"],"display":"3"}, +{"id":101,"recursionId":100,"flags":["NumberLiteral"],"display":"4"}, +{"id":102,"recursionId":101,"flags":["NumberLiteral"],"display":"4"}, +{"id":103,"recursionId":102,"flags":["NumberLiteral"],"display":"5"}, +{"id":104,"recursionId":103,"flags":["NumberLiteral"],"display":"5"}, +{"id":105,"recursionId":104,"flags":["NumberLiteral"],"display":"6"}, +{"id":106,"recursionId":105,"flags":["NumberLiteral"],"display":"6"}, +{"id":107,"recursionId":106,"flags":["NumberLiteral"],"display":"7"}, +{"id":108,"recursionId":107,"flags":["NumberLiteral"],"display":"7"}, +{"id":109,"recursionId":108,"flags":["NumberLiteral"],"display":"8"}, +{"id":110,"recursionId":109,"flags":["NumberLiteral"],"display":"8"}, +{"id":111,"recursionId":110,"flags":["NumberLiteral"],"display":"9"}, +{"id":112,"recursionId":111,"flags":["NumberLiteral"],"display":"9"}, +{"id":113,"recursionId":112,"flags":["NumberLiteral"],"display":"10"}, +{"id":114,"recursionId":113,"flags":["NumberLiteral"],"display":"10"}, +{"id":115,"recursionId":114,"flags":["NumberLiteral"],"display":"11"}, +{"id":116,"recursionId":115,"flags":["NumberLiteral"],"display":"11"}, +{"id":117,"recursionId":116,"flags":["NumberLiteral"],"display":"12"}, +{"id":118,"recursionId":117,"flags":["NumberLiteral"],"display":"12"}, +{"id":119,"symbolName":"__type","recursionId":118,"firstDeclaration":{"path":"/home/src/workspaces/project/main.ts","start":{"line":5,"character":29},"end":{"line":5,"character":106}},"flags":["Object"],"display":"{ a: 1; b: 2; c: 3; d: 4; e: 5; f: 6; g: 7; h: 8; i: 9; j: 10; k: 11; l: 12; }"}, +{"id":120,"symbolName":"T","recursionId":119,"firstDeclaration":{"path":"/home/src/workspaces/project/fields.d.ts","start":{"line":1,"character":20},"end":{"line":1,"character":21}},"flags":["TypeParameter"]}, +{"id":121,"symbolName":"T","recursionId":119,"firstDeclaration":{"path":"/home/src/workspaces/project/fields.d.ts","start":{"line":1,"character":20},"end":{"line":1,"character":21}},"flags":["TypeParameter"]}, +{"id":122,"symbolName":"__type","recursionId":120,"firstDeclaration":{"path":"/home/src/workspaces/project/fields.d.ts","start":{"line":1,"character":35},"end":{"line":1,"character":181}},"flags":["Object"],"display":"{ a: A; b: B; c: C; d: D; e: E; f: F; g: G; h: H; i: I; j: J; k: K; l: L; }"}, +{"id":123,"symbolName":"A","recursionId":121,"firstDeclaration":{"path":"/home/src/workspaces/project/fields.d.ts","start":{"line":1,"character":46},"end":{"line":1,"character":47}},"flags":["TypeParameter"]}, +{"id":124,"symbolName":"B","recursionId":122,"firstDeclaration":{"path":"/home/src/workspaces/project/fields.d.ts","start":{"line":1,"character":58},"end":{"line":1,"character":59}},"flags":["TypeParameter"]}, +{"id":125,"symbolName":"C","recursionId":123,"firstDeclaration":{"path":"/home/src/workspaces/project/fields.d.ts","start":{"line":1,"character":70},"end":{"line":1,"character":71}},"flags":["TypeParameter"]}, +{"id":126,"symbolName":"D","recursionId":124,"firstDeclaration":{"path":"/home/src/workspaces/project/fields.d.ts","start":{"line":1,"character":82},"end":{"line":1,"character":83}},"flags":["TypeParameter"]}, +{"id":127,"symbolName":"E","recursionId":125,"firstDeclaration":{"path":"/home/src/workspaces/project/fields.d.ts","start":{"line":1,"character":94},"end":{"line":1,"character":95}},"flags":["TypeParameter"]}, +{"id":128,"symbolName":"F","recursionId":126,"firstDeclaration":{"path":"/home/src/workspaces/project/fields.d.ts","start":{"line":1,"character":106},"end":{"line":1,"character":107}},"flags":["TypeParameter"]}, +{"id":129,"symbolName":"G","recursionId":127,"firstDeclaration":{"path":"/home/src/workspaces/project/fields.d.ts","start":{"line":1,"character":118},"end":{"line":1,"character":119}},"flags":["TypeParameter"]}, +{"id":130,"symbolName":"H","recursionId":128,"firstDeclaration":{"path":"/home/src/workspaces/project/fields.d.ts","start":{"line":1,"character":130},"end":{"line":1,"character":131}},"flags":["TypeParameter"]}, +{"id":131,"symbolName":"I","recursionId":129,"firstDeclaration":{"path":"/home/src/workspaces/project/fields.d.ts","start":{"line":1,"character":142},"end":{"line":1,"character":143}},"flags":["TypeParameter"]}, +{"id":132,"symbolName":"J","recursionId":130,"firstDeclaration":{"path":"/home/src/workspaces/project/fields.d.ts","start":{"line":1,"character":154},"end":{"line":1,"character":155}},"flags":["TypeParameter"]}, +{"id":133,"symbolName":"K","recursionId":131,"firstDeclaration":{"path":"/home/src/workspaces/project/fields.d.ts","start":{"line":1,"character":166},"end":{"line":1,"character":167}},"flags":["TypeParameter"]}, +{"id":134,"symbolName":"L","recursionId":132,"firstDeclaration":{"path":"/home/src/workspaces/project/fields.d.ts","start":{"line":1,"character":178},"end":{"line":1,"character":179}},"flags":["TypeParameter"]}, +{"id":135,"symbolName":"__type","recursionId":120,"firstDeclaration":{"path":"/home/src/workspaces/project/fields.d.ts","start":{"line":1,"character":35},"end":{"line":1,"character":181}},"flags":["Object"],"display":"{ a: unknown; b: unknown; c: unknown; d: unknown; e: unknown; f: unknown; g: unknown; h: unknown; i: unknown; j: unknown; k: unknown; l: unknown; }"}, +{"id":136,"symbolName":"Fields","recursionId":133,"aliasTypeArguments":[120],"conditionalCheckType":121,"conditionalExtendsType":122,"conditionalTrueType":-1,"conditionalFalseType":-1,"firstDeclaration":{"path":"/home/src/workspaces/project/fields.d.ts","start":{"line":1,"character":1},"end":{"line":1,"character":229}},"flags":["Conditional"]}, +{"id":137,"symbolName":"__type","recursionId":120,"firstDeclaration":{"path":"/home/src/workspaces/project/fields.d.ts","start":{"line":1,"character":35},"end":{"line":1,"character":181}},"flags":["Object"],"display":"{ a: 1; b: 2; c: 3; d: 4; e: 5; f: 6; g: 7; h: 8; i: 9; j: 10; k: 11; l: 12; }"}, +{"id":138,"recursionId":134,"flags":["TypeParameter"]}, +{"id":139,"recursionId":135,"flags":["TypeParameter"]}, +{"id":140,"recursionId":136,"flags":["TypeParameter"]}, +{"id":141,"recursionId":137,"flags":["TypeParameter"]}, +{"id":142,"recursionId":138,"flags":["TypeParameter"]}, +{"id":143,"recursionId":139,"flags":["TypeParameter"]}, +{"id":144,"recursionId":140,"flags":["TypeParameter"]}, +{"id":145,"recursionId":141,"flags":["TypeParameter"]}, +{"id":146,"recursionId":142,"flags":["TypeParameter"]}, +{"id":147,"recursionId":143,"flags":["TypeParameter"]}, +{"id":148,"recursionId":144,"flags":["TypeParameter"]}, +{"id":149,"recursionId":145,"flags":["TypeParameter"]}, +{"id":150,"recursionId":146,"isTuple":true,"instantiatedType":150,"typeArguments":[138,139,140,141,142,143,144,145,146,147,148,149],"flags":["Object"]}, +{"id":151,"recursionId":147,"flags":["TypeParameter"]}, +{"id":152,"recursionId":148,"instantiatedType":150,"typeArguments":[123,124,125,126,127,128,129,130,131,132,133,134],"flags":["Object"]}, +{"id":153,"recursionId":149,"instantiatedType":150,"typeArguments":[95,97,99,101,103,105,107,109,111,113,115,117],"flags":["Object"]}, +{"id":154,"recursionId":150,"instantiatedType":150,"typeArguments":[95,97,99,101,103,105,107,109,111,113,115,117],"flags":["Object"]}, +{"id":155,"recursionId":151,"unionTypes":[138,139,140,141,142,143,144,145,146,147,148,149],"flags":["Union"],"display":"? | ? | ? | ? | ? | ? | ? | ? | ? | ? | ? | ?"}, +{"id":156,"symbolName":"Array","recursionId":66,"instantiatedType":65,"typeArguments":[155],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["Object"]}, +{"id":157,"recursionId":152,"unionTypes":[95,97,99,101,103,105,107,109,111,113,115,117],"flags":["Union"],"display":"1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12"}, +{"id":158,"symbolName":"Array","recursionId":66,"instantiatedType":65,"typeArguments":[157],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["Object"]}, +{"id":159,"symbolName":"Array","recursionId":66,"instantiatedType":65,"typeArguments":[157,153],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["Object"]}, +{"id":160,"symbolName":"Array","recursionId":66,"instantiatedType":65,"typeArguments":[157,154],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["Object"]}, +{"id":161,"symbolName":"makeWidget","recursionId":153,"firstDeclaration":{"path":"/home/src/workspaces/project/widget.d.ts","start":{"line":2,"character":1},"end":{"line":2,"character":46}},"flags":["Object"],"display":"() => Gadget"}, +{"id":162,"symbolName":"Gadget","recursionId":154,"firstDeclaration":{"path":"/home/src/workspaces/project/gadget.d.ts","start":{"line":1,"character":1},"end":{"line":3,"character":2}},"flags":["Object"]}, +{"id":163,"symbolName":"__type","recursionId":155,"firstDeclaration":{"path":"/home/src/workspaces/project/locales/ar.d.ts","start":{"line":1,"character":25},"end":{"line":1,"character":47}},"flags":["Object"],"display":"() => { locale: \"ar\"; }"}, +{"id":164,"symbolName":"__type","recursionId":156,"firstDeclaration":{"path":"/home/src/workspaces/project/locales/de.d.ts","start":{"line":1,"character":25},"end":{"line":1,"character":47}},"flags":["Object"],"display":"() => { locale: \"de\"; }"}, +{"id":165,"symbolName":"__type","recursionId":157,"firstDeclaration":{"path":"/home/src/workspaces/project/locales/en.d.ts","start":{"line":1,"character":25},"end":{"line":1,"character":47}},"flags":["Object"],"display":"() => { locale: \"en\"; }"}, +{"id":166,"symbolName":"__type","recursionId":158,"firstDeclaration":{"path":"/home/src/workspaces/project/locales/es.d.ts","start":{"line":1,"character":25},"end":{"line":1,"character":47}},"flags":["Object"],"display":"() => { locale: \"es\"; }"}, +{"id":167,"symbolName":"__type","recursionId":159,"firstDeclaration":{"path":"/home/src/workspaces/project/locales/fr.d.ts","start":{"line":1,"character":25},"end":{"line":1,"character":47}},"flags":["Object"],"display":"() => { locale: \"fr\"; }"}, +{"id":168,"symbolName":"__type","recursionId":160,"firstDeclaration":{"path":"/home/src/workspaces/project/locales/he.d.ts","start":{"line":1,"character":25},"end":{"line":1,"character":47}},"flags":["Object"],"display":"() => { locale: \"he\"; }"}, +{"id":169,"symbolName":"__type","recursionId":161,"firstDeclaration":{"path":"/home/src/workspaces/project/locales/it.d.ts","start":{"line":1,"character":25},"end":{"line":1,"character":47}},"flags":["Object"],"display":"() => { locale: \"it\"; }"}, +{"id":170,"symbolName":"__type","recursionId":162,"firstDeclaration":{"path":"/home/src/workspaces/project/locales/ja.d.ts","start":{"line":1,"character":25},"end":{"line":1,"character":47}},"flags":["Object"],"display":"() => { locale: \"ja\"; }"}, +{"id":171,"symbolName":"__type","recursionId":163,"firstDeclaration":{"path":"/home/src/workspaces/project/locales/ko.d.ts","start":{"line":1,"character":25},"end":{"line":1,"character":47}},"flags":["Object"],"display":"() => { locale: \"ko\"; }"}, +{"id":172,"symbolName":"__type","recursionId":164,"firstDeclaration":{"path":"/home/src/workspaces/project/locales/nl.d.ts","start":{"line":1,"character":25},"end":{"line":1,"character":47}},"flags":["Object"],"display":"() => { locale: \"nl\"; }"}, +{"id":173,"symbolName":"__type","recursionId":165,"firstDeclaration":{"path":"/home/src/workspaces/project/locales/pl.d.ts","start":{"line":1,"character":25},"end":{"line":1,"character":47}},"flags":["Object"],"display":"() => { locale: \"pl\"; }"}, +{"id":174,"symbolName":"__type","recursionId":166,"firstDeclaration":{"path":"/home/src/workspaces/project/locales/pt.d.ts","start":{"line":1,"character":25},"end":{"line":1,"character":47}},"flags":["Object"],"display":"() => { locale: \"pt\"; }"}] diff --git a/tsc/testdata/baselines/reference/tsc/generateTrace/generateTrace-generates-types-file.js b/tsc/testdata/baselines/reference/tsc/generateTrace/generateTrace-generates-types-file.js index e4f896a874835..470095da1544d 100644 --- a/tsc/testdata/baselines/reference/tsc/generateTrace/generateTrace-generates-types-file.js +++ b/tsc/testdata/baselines/reference/tsc/generateTrace/generateTrace-generates-types-file.js @@ -147,34 +147,34 @@ declare const console: { log(msg: any): void; }; {"id":64,"symbolName":"globalThis","recursionId":63,"flags":["Object"],"display":"typeof globalThis"}, {"id":65,"symbolName":"Array","recursionId":64,"instantiatedType":65,"typeArguments":[66],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["Object"]}, {"id":66,"symbolName":"T","recursionId":65,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":17},"end":{"line":11,"character":18}},"flags":["TypeParameter"]}, -{"id":67,"symbolName":"Array","recursionId":64,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["TypeParameter"]}, -{"id":68,"symbolName":"Object","recursionId":66,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":8,"character":1},"end":{"line":8,"character":20}},"flags":["Object"]}, -{"id":69,"symbolName":"Function","recursionId":67,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":3,"character":1},"end":{"line":3,"character":22}},"flags":["Object"]}, -{"id":70,"symbolName":"CallableFunction","recursionId":68,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":4,"character":1},"end":{"line":4,"character":30}},"flags":["Object"]}, -{"id":71,"symbolName":"NewableFunction","recursionId":69,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":5,"character":1},"end":{"line":5,"character":29}},"flags":["Object"]}, -{"id":72,"symbolName":"String","recursionId":70,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":10,"character":1},"end":{"line":10,"character":34}},"flags":["Object"]}, -{"id":73,"symbolName":"Number","recursionId":71,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":7,"character":1},"end":{"line":7,"character":41}},"flags":["Object"]}, -{"id":74,"symbolName":"Boolean","recursionId":72,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":2,"character":1},"end":{"line":2,"character":21}},"flags":["Object"]}, -{"id":75,"symbolName":"RegExp","recursionId":73,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":9,"character":1},"end":{"line":9,"character":20}},"flags":["Object"]}, -{"id":76,"symbolName":"Array","recursionId":64,"instantiatedType":65,"typeArguments":[1],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["Object"]}, -{"id":77,"symbolName":"Array","recursionId":64,"instantiatedType":65,"typeArguments":[2],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["Object"]}, -{"id":78,"symbolName":"ReadonlyArray","recursionId":74,"instantiatedType":78,"typeArguments":[79],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":1},"end":{"line":12,"character":30}},"flags":["Object"]}, -{"id":79,"symbolName":"T","recursionId":75,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":25},"end":{"line":12,"character":26}},"flags":["TypeParameter"]}, -{"id":80,"symbolName":"ReadonlyArray","recursionId":74,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":1},"end":{"line":12,"character":30}},"flags":["TypeParameter"]}, -{"id":81,"symbolName":"ReadonlyArray","recursionId":74,"instantiatedType":78,"typeArguments":[1],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":1},"end":{"line":12,"character":30}},"flags":["Object"]}, -{"id":82,"symbolName":"Array","recursionId":64,"instantiatedType":65,"typeArguments":[66,67],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["Object"]}, -{"id":83,"recursionId":76,"flags":["StringLiteral"],"display":"\"length\""}, -{"id":84,"symbolName":"ReadonlyArray","recursionId":74,"instantiatedType":78,"typeArguments":[79,80],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":1},"end":{"line":12,"character":30}},"flags":["Object"]}, -{"id":85,"symbolName":"SymbolConstructor","recursionId":77,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":13,"character":1},"end":{"line":17,"character":2}},"flags":["Object"]}, -{"id":86,"recursionId":78,"unionTypes":[10,14,15],"flags":["Union"],"display":"string | number | undefined"}, -{"id":87,"symbolName":"toStringTag","recursionId":79,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":16,"character":5},"end":{"line":16,"character":34}},"flags":["UniqueESSymbol"]}, -{"id":88,"symbolName":"Symbol","recursionId":80,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":18,"character":13},"end":{"line":18,"character":38}},"flags":["Object"]}, -{"id":89,"symbolName":"__type","recursionId":81,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":22,"character":24},"end":{"line":22,"character":48}},"flags":["Object"],"display":"{ log(msg: any): void; }"}, -{"id":90,"symbolName":"Person","recursionId":82,"firstDeclaration":{"path":"/home/src/workspaces/project/a.ts","start":{"line":1,"character":1},"end":{"line":4,"character":2}},"flags":["Object"]}, -{"id":91,"recursionId":83,"flags":["StringLiteral"],"display":"\"Alice\""}, -{"id":92,"recursionId":84,"flags":["StringLiteral"],"display":"\"Alice\""}, -{"id":93,"recursionId":85,"flags":["NumberLiteral"],"display":"30"}, -{"id":94,"recursionId":86,"flags":["NumberLiteral"],"display":"30"}, -{"id":95,"symbolName":"__object","recursionId":87,"firstDeclaration":{"path":"/home/src/workspaces/project/a.ts","start":{"line":5,"character":19},"end":{"line":5,"character":45}},"flags":["Object"],"display":"{ name: string; age: number; }"}] +{"id":67,"symbolName":"Array","recursionId":66,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["TypeParameter"]}, +{"id":68,"symbolName":"Object","recursionId":67,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":8,"character":1},"end":{"line":8,"character":20}},"flags":["Object"]}, +{"id":69,"symbolName":"Function","recursionId":68,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":3,"character":1},"end":{"line":3,"character":22}},"flags":["Object"]}, +{"id":70,"symbolName":"CallableFunction","recursionId":69,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":4,"character":1},"end":{"line":4,"character":30}},"flags":["Object"]}, +{"id":71,"symbolName":"NewableFunction","recursionId":70,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":5,"character":1},"end":{"line":5,"character":29}},"flags":["Object"]}, +{"id":72,"symbolName":"String","recursionId":71,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":10,"character":1},"end":{"line":10,"character":34}},"flags":["Object"]}, +{"id":73,"symbolName":"Number","recursionId":72,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":7,"character":1},"end":{"line":7,"character":41}},"flags":["Object"]}, +{"id":74,"symbolName":"Boolean","recursionId":73,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":2,"character":1},"end":{"line":2,"character":21}},"flags":["Object"]}, +{"id":75,"symbolName":"RegExp","recursionId":74,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":9,"character":1},"end":{"line":9,"character":20}},"flags":["Object"]}, +{"id":76,"symbolName":"Array","recursionId":75,"instantiatedType":65,"typeArguments":[1],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["Object"]}, +{"id":77,"symbolName":"Array","recursionId":76,"instantiatedType":65,"typeArguments":[2],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["Object"]}, +{"id":78,"symbolName":"ReadonlyArray","recursionId":77,"instantiatedType":78,"typeArguments":[79],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":1},"end":{"line":12,"character":30}},"flags":["Object"]}, +{"id":79,"symbolName":"T","recursionId":78,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":25},"end":{"line":12,"character":26}},"flags":["TypeParameter"]}, +{"id":80,"symbolName":"ReadonlyArray","recursionId":79,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":1},"end":{"line":12,"character":30}},"flags":["TypeParameter"]}, +{"id":81,"symbolName":"ReadonlyArray","recursionId":80,"instantiatedType":78,"typeArguments":[1],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":1},"end":{"line":12,"character":30}},"flags":["Object"]}, +{"id":82,"symbolName":"Array","recursionId":81,"instantiatedType":65,"typeArguments":[66,67],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["Object"]}, +{"id":83,"recursionId":82,"flags":["StringLiteral"],"display":"\"length\""}, +{"id":84,"symbolName":"ReadonlyArray","recursionId":83,"instantiatedType":78,"typeArguments":[79,80],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":1},"end":{"line":12,"character":30}},"flags":["Object"]}, +{"id":85,"symbolName":"SymbolConstructor","recursionId":84,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":13,"character":1},"end":{"line":17,"character":2}},"flags":["Object"]}, +{"id":86,"recursionId":85,"unionTypes":[10,14,15],"flags":["Union"],"display":"string | number | undefined"}, +{"id":87,"symbolName":"toStringTag","recursionId":86,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":16,"character":5},"end":{"line":16,"character":34}},"flags":["UniqueESSymbol"]}, +{"id":88,"symbolName":"Symbol","recursionId":87,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":18,"character":13},"end":{"line":18,"character":38}},"flags":["Object"]}, +{"id":89,"symbolName":"__type","recursionId":88,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":22,"character":24},"end":{"line":22,"character":48}},"flags":["Object"],"display":"{ log(msg: any): void; }"}, +{"id":90,"symbolName":"Person","recursionId":89,"firstDeclaration":{"path":"/home/src/workspaces/project/a.ts","start":{"line":1,"character":1},"end":{"line":4,"character":2}},"flags":["Object"]}, +{"id":91,"recursionId":90,"flags":["StringLiteral"],"display":"\"Alice\""}, +{"id":92,"recursionId":91,"flags":["StringLiteral"],"display":"\"Alice\""}, +{"id":93,"recursionId":92,"flags":["NumberLiteral"],"display":"30"}, +{"id":94,"recursionId":93,"flags":["NumberLiteral"],"display":"30"}, +{"id":95,"symbolName":"__object","recursionId":94,"firstDeclaration":{"path":"/home/src/workspaces/project/a.ts","start":{"line":5,"character":19},"end":{"line":5,"character":45}},"flags":["Object"],"display":"{ name: string; age: number; }"}] diff --git a/tsc/testdata/baselines/reference/tsc/generateTrace/generateTrace-with-multiple-files-and-complex-types.js b/tsc/testdata/baselines/reference/tsc/generateTrace/generateTrace-with-multiple-files-and-complex-types.js index e9c62457f637f..bb92b7489685e 100644 --- a/tsc/testdata/baselines/reference/tsc/generateTrace/generateTrace-with-multiple-files-and-complex-types.js +++ b/tsc/testdata/baselines/reference/tsc/generateTrace/generateTrace-with-multiple-files-and-complex-types.js @@ -174,60 +174,60 @@ declare const console: { log(msg: any): void; }; {"id":64,"symbolName":"globalThis","recursionId":63,"flags":["Object"],"display":"typeof globalThis"}, {"id":65,"symbolName":"Array","recursionId":64,"instantiatedType":65,"typeArguments":[66],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["Object"]}, {"id":66,"symbolName":"T","recursionId":65,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":17},"end":{"line":11,"character":18}},"flags":["TypeParameter"]}, -{"id":67,"symbolName":"Array","recursionId":64,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["TypeParameter"]}, -{"id":68,"symbolName":"Object","recursionId":66,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":8,"character":1},"end":{"line":8,"character":20}},"flags":["Object"]}, -{"id":69,"symbolName":"Function","recursionId":67,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":3,"character":1},"end":{"line":3,"character":22}},"flags":["Object"]}, -{"id":70,"symbolName":"CallableFunction","recursionId":68,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":4,"character":1},"end":{"line":4,"character":30}},"flags":["Object"]}, -{"id":71,"symbolName":"NewableFunction","recursionId":69,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":5,"character":1},"end":{"line":5,"character":29}},"flags":["Object"]}, -{"id":72,"symbolName":"String","recursionId":70,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":10,"character":1},"end":{"line":10,"character":34}},"flags":["Object"]}, -{"id":73,"symbolName":"Number","recursionId":71,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":7,"character":1},"end":{"line":7,"character":41}},"flags":["Object"]}, -{"id":74,"symbolName":"Boolean","recursionId":72,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":2,"character":1},"end":{"line":2,"character":21}},"flags":["Object"]}, -{"id":75,"symbolName":"RegExp","recursionId":73,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":9,"character":1},"end":{"line":9,"character":20}},"flags":["Object"]}, -{"id":76,"symbolName":"Array","recursionId":64,"instantiatedType":65,"typeArguments":[1],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["Object"]}, -{"id":77,"symbolName":"Array","recursionId":64,"instantiatedType":65,"typeArguments":[2],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["Object"]}, -{"id":78,"symbolName":"ReadonlyArray","recursionId":74,"instantiatedType":78,"typeArguments":[79],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":1},"end":{"line":12,"character":30}},"flags":["Object"]}, -{"id":79,"symbolName":"T","recursionId":75,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":25},"end":{"line":12,"character":26}},"flags":["TypeParameter"]}, -{"id":80,"symbolName":"ReadonlyArray","recursionId":74,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":1},"end":{"line":12,"character":30}},"flags":["TypeParameter"]}, -{"id":81,"symbolName":"ReadonlyArray","recursionId":74,"instantiatedType":78,"typeArguments":[1],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":1},"end":{"line":12,"character":30}},"flags":["Object"]}, -{"id":82,"symbolName":"Array","recursionId":64,"instantiatedType":65,"typeArguments":[66,67],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["Object"]}, -{"id":83,"recursionId":76,"flags":["StringLiteral"],"display":"\"length\""}, -{"id":84,"symbolName":"ReadonlyArray","recursionId":74,"instantiatedType":78,"typeArguments":[79,80],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":1},"end":{"line":12,"character":30}},"flags":["Object"]}, -{"id":85,"symbolName":"SymbolConstructor","recursionId":77,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":13,"character":1},"end":{"line":17,"character":2}},"flags":["Object"]}, -{"id":86,"recursionId":78,"unionTypes":[10,14,15],"flags":["Union"],"display":"string | number | undefined"}, -{"id":87,"symbolName":"toStringTag","recursionId":79,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":16,"character":5},"end":{"line":16,"character":34}},"flags":["UniqueESSymbol"]}, -{"id":88,"symbolName":"Symbol","recursionId":80,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":18,"character":13},"end":{"line":18,"character":38}},"flags":["Object"]}, -{"id":89,"symbolName":"__type","recursionId":81,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":22,"character":24},"end":{"line":22,"character":48}},"flags":["Object"],"display":"{ log(msg: any): void; }"}, -{"id":90,"symbolName":"T","recursionId":82,"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":1,"character":28},"end":{"line":1,"character":29}},"flags":["TypeParameter"]}, -{"id":91,"symbolName":"Container","recursionId":83,"instantiatedType":91,"typeArguments":[90],"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":1,"character":1},"end":{"line":4,"character":2}},"flags":["Object"]}, -{"id":92,"symbolName":"Container","recursionId":83,"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":1,"character":1},"end":{"line":4,"character":2}},"flags":["TypeParameter"]}, -{"id":93,"symbolName":"Container","recursionId":83,"instantiatedType":91,"typeArguments":[90,92],"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":1,"character":1},"end":{"line":4,"character":2}},"flags":["Object"]}, -{"id":94,"symbolName":"U","recursionId":84,"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":3,"character":9},"end":{"line":3,"character":10}},"flags":["TypeParameter"]}, -{"id":95,"symbolName":"__type","recursionId":85,"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":3,"character":16},"end":{"line":3,"character":27}},"flags":["Object"],"display":"(x: T) => U"}, -{"id":96,"symbolName":"Container","recursionId":86,"instantiatedType":91,"typeArguments":[94],"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":1,"character":1},"end":{"line":4,"character":2}},"flags":["Object"]}, -{"id":97,"symbolName":"T","recursionId":87,"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":5,"character":22},"end":{"line":5,"character":23}},"flags":["TypeParameter"]}, -{"id":98,"symbolName":"Nullable","recursionId":88,"unionTypes":[10,13,97],"aliasTypeArguments":[97],"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":5,"character":1},"end":{"line":5,"character":48}},"flags":["Union"],"display":"Nullable"}, -{"id":99,"symbolName":"Container","recursionId":89,"instantiatedType":91,"typeArguments":[15],"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":1,"character":1},"end":{"line":4,"character":2}},"flags":["Object"]}, -{"id":100,"recursionId":90,"flags":["NumberLiteral"],"display":"42"}, -{"id":101,"recursionId":91,"flags":["NumberLiteral"],"display":"42"}, -{"id":102,"symbolName":"map","recursionId":92,"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":3,"character":5},"end":{"line":3,"character":43}},"flags":["Object"],"display":"(fn: (x: T) => U) => Container"}, -{"id":103,"symbolName":"map","recursionId":92,"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":3,"character":5},"end":{"line":3,"character":43}},"flags":["Object"],"display":"(fn: (x: number) => U) => Container"}, -{"id":104,"symbolName":"U","recursionId":84,"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":3,"character":9},"end":{"line":3,"character":10}},"flags":["TypeParameter"]}, -{"id":105,"symbolName":"__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":"__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"}, -{"id":114,"symbolName":"__type","recursionId":85,"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":3,"character":16},"end":{"line":3,"character":27}},"flags":["Object"],"display":"(x: U) => U"}, -{"id":115,"symbolName":"__type","recursionId":85,"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":3,"character":16},"end":{"line":3,"character":27}},"flags":["Object"],"display":"(x: U) => any"}, -{"id":116,"recursionId":97,"flags":["StringLiteral"],"display":"\"value\""}, -{"id":117,"recursionId":98,"flags":["StringLiteral"],"display":"\"map\""}, -{"id":118,"symbolName":"Container","recursionId":83,"instantiatedType":91,"typeArguments":[112],"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":1,"character":1},"end":{"line":4,"character":2}},"flags":["Object"]}, -{"id":119,"symbolName":"Nullable","recursionId":99,"unionTypes":[10,13,14],"aliasTypeArguments":[14],"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":5,"character":1},"end":{"line":5,"character":48}},"flags":["Union"],"display":"Nullable"}, -{"id":120,"recursionId":100,"flags":["StringLiteral"],"display":"\"hello\""}, -{"id":121,"recursionId":101,"flags":["StringLiteral"],"display":"\"hello\""}] +{"id":67,"symbolName":"Array","recursionId":66,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["TypeParameter"]}, +{"id":68,"symbolName":"Object","recursionId":67,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":8,"character":1},"end":{"line":8,"character":20}},"flags":["Object"]}, +{"id":69,"symbolName":"Function","recursionId":68,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":3,"character":1},"end":{"line":3,"character":22}},"flags":["Object"]}, +{"id":70,"symbolName":"CallableFunction","recursionId":69,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":4,"character":1},"end":{"line":4,"character":30}},"flags":["Object"]}, +{"id":71,"symbolName":"NewableFunction","recursionId":70,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":5,"character":1},"end":{"line":5,"character":29}},"flags":["Object"]}, +{"id":72,"symbolName":"String","recursionId":71,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":10,"character":1},"end":{"line":10,"character":34}},"flags":["Object"]}, +{"id":73,"symbolName":"Number","recursionId":72,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":7,"character":1},"end":{"line":7,"character":41}},"flags":["Object"]}, +{"id":74,"symbolName":"Boolean","recursionId":73,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":2,"character":1},"end":{"line":2,"character":21}},"flags":["Object"]}, +{"id":75,"symbolName":"RegExp","recursionId":74,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":9,"character":1},"end":{"line":9,"character":20}},"flags":["Object"]}, +{"id":76,"symbolName":"Array","recursionId":75,"instantiatedType":65,"typeArguments":[1],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["Object"]}, +{"id":77,"symbolName":"Array","recursionId":76,"instantiatedType":65,"typeArguments":[2],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["Object"]}, +{"id":78,"symbolName":"ReadonlyArray","recursionId":77,"instantiatedType":78,"typeArguments":[79],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":1},"end":{"line":12,"character":30}},"flags":["Object"]}, +{"id":79,"symbolName":"T","recursionId":78,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":25},"end":{"line":12,"character":26}},"flags":["TypeParameter"]}, +{"id":80,"symbolName":"ReadonlyArray","recursionId":79,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":1},"end":{"line":12,"character":30}},"flags":["TypeParameter"]}, +{"id":81,"symbolName":"ReadonlyArray","recursionId":80,"instantiatedType":78,"typeArguments":[1],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":1},"end":{"line":12,"character":30}},"flags":["Object"]}, +{"id":82,"symbolName":"Array","recursionId":81,"instantiatedType":65,"typeArguments":[66,67],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":11,"character":1},"end":{"line":11,"character":55}},"flags":["Object"]}, +{"id":83,"recursionId":82,"flags":["StringLiteral"],"display":"\"length\""}, +{"id":84,"symbolName":"ReadonlyArray","recursionId":83,"instantiatedType":78,"typeArguments":[79,80],"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":12,"character":1},"end":{"line":12,"character":30}},"flags":["Object"]}, +{"id":85,"symbolName":"SymbolConstructor","recursionId":84,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":13,"character":1},"end":{"line":17,"character":2}},"flags":["Object"]}, +{"id":86,"recursionId":85,"unionTypes":[10,14,15],"flags":["Union"],"display":"string | number | undefined"}, +{"id":87,"symbolName":"toStringTag","recursionId":86,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":16,"character":5},"end":{"line":16,"character":34}},"flags":["UniqueESSymbol"]}, +{"id":88,"symbolName":"Symbol","recursionId":87,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":18,"character":13},"end":{"line":18,"character":38}},"flags":["Object"]}, +{"id":89,"symbolName":"__type","recursionId":88,"firstDeclaration":{"path":"/home/src/tslibs/ts/lib/lib.es2026.full.d.ts","start":{"line":22,"character":24},"end":{"line":22,"character":48}},"flags":["Object"],"display":"{ log(msg: any): void; }"}, +{"id":90,"symbolName":"T","recursionId":89,"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":1,"character":28},"end":{"line":1,"character":29}},"flags":["TypeParameter"]}, +{"id":91,"symbolName":"Container","recursionId":90,"instantiatedType":91,"typeArguments":[90],"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":1,"character":1},"end":{"line":4,"character":2}},"flags":["Object"]}, +{"id":92,"symbolName":"Container","recursionId":91,"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":1,"character":1},"end":{"line":4,"character":2}},"flags":["TypeParameter"]}, +{"id":93,"symbolName":"Container","recursionId":92,"instantiatedType":91,"typeArguments":[90,92],"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":1,"character":1},"end":{"line":4,"character":2}},"flags":["Object"]}, +{"id":94,"symbolName":"U","recursionId":93,"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":3,"character":9},"end":{"line":3,"character":10}},"flags":["TypeParameter"]}, +{"id":95,"symbolName":"__type","recursionId":94,"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":3,"character":16},"end":{"line":3,"character":27}},"flags":["Object"],"display":"(x: T) => U"}, +{"id":96,"symbolName":"Container","recursionId":95,"instantiatedType":91,"typeArguments":[94],"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":1,"character":1},"end":{"line":4,"character":2}},"flags":["Object"]}, +{"id":97,"symbolName":"T","recursionId":96,"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":5,"character":22},"end":{"line":5,"character":23}},"flags":["TypeParameter"]}, +{"id":98,"symbolName":"Nullable","recursionId":97,"unionTypes":[10,13,97],"aliasTypeArguments":[97],"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":5,"character":1},"end":{"line":5,"character":48}},"flags":["Union"],"display":"Nullable"}, +{"id":99,"symbolName":"Container","recursionId":98,"instantiatedType":91,"typeArguments":[15],"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":1,"character":1},"end":{"line":4,"character":2}},"flags":["Object"]}, +{"id":100,"recursionId":99,"flags":["NumberLiteral"],"display":"42"}, +{"id":101,"recursionId":100,"flags":["NumberLiteral"],"display":"42"}, +{"id":102,"symbolName":"map","recursionId":101,"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":3,"character":5},"end":{"line":3,"character":43}},"flags":["Object"],"display":"(fn: (x: T) => U) => Container"}, +{"id":103,"symbolName":"map","recursionId":101,"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":3,"character":5},"end":{"line":3,"character":43}},"flags":["Object"],"display":"(fn: (x: number) => U) => Container"}, +{"id":104,"symbolName":"U","recursionId":93,"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":3,"character":9},"end":{"line":3,"character":10}},"flags":["TypeParameter"]}, +{"id":105,"symbolName":"__type","recursionId":94,"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":3,"character":16},"end":{"line":3,"character":27}},"flags":["Object"],"display":"(x: number) => U"}, +{"id":106,"symbolName":"Container","recursionId":102,"instantiatedType":91,"typeArguments":[104],"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":1,"character":1},"end":{"line":4,"character":2}},"flags":["Object"]}, +{"id":107,"symbolName":"map","recursionId":101,"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":3,"character":5},"end":{"line":3,"character":43}},"flags":["Object"],"display":"(fn: (x: U) => U) => Container"}, +{"id":108,"symbolName":"__object","recursionId":103,"firstDeclaration":{"path":"/home/src/workspaces/project/main.ts","start":{"line":2,"character":57},"end":{"line":2,"character":86}},"flags":["Object"],"display":"{ value: U; map: (fn: (x: number) => U) => Container; }"}, +{"id":109,"symbolName":"__object","recursionId":104,"firstDeclaration":{"path":"/home/src/workspaces/project/main.ts","start":{"line":2,"character":57},"end":{"line":2,"character":86}},"flags":["Object"],"display":"{ value: U; map: (fn: (x: number) => U) => Container; }"}, +{"id":110,"symbolName":"__function","recursionId":105,"firstDeclaration":{"path":"/home/src/workspaces/project/main.ts","start":{"line":2,"character":48},"end":{"line":2,"character":87}},"flags":["Object"],"display":"(fn: (x: number) => U) => { value: U; map: (fn: (x: number) => U) => Container; }"}, +{"id":111,"symbolName":"__object","recursionId":106,"firstDeclaration":{"path":"/home/src/workspaces/project/main.ts","start":{"line":2,"character":30},"end":{"line":2,"character":89}},"flags":["Object"],"display":"{ value: number; map: (fn: (x: number) => U) => { value: U; map: (fn: (x: number) => U) => Container; }; }"}, +{"id":112,"symbolName":"U","recursionId":93,"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":3,"character":9},"end":{"line":3,"character":10}},"flags":["TypeParameter"]}, +{"id":113,"symbolName":"__type","recursionId":94,"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":3,"character":16},"end":{"line":3,"character":27}},"flags":["Object"],"display":"(x: number) => any"}, +{"id":114,"symbolName":"__type","recursionId":94,"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":3,"character":16},"end":{"line":3,"character":27}},"flags":["Object"],"display":"(x: U) => U"}, +{"id":115,"symbolName":"__type","recursionId":94,"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":3,"character":16},"end":{"line":3,"character":27}},"flags":["Object"],"display":"(x: U) => any"}, +{"id":116,"recursionId":107,"flags":["StringLiteral"],"display":"\"value\""}, +{"id":117,"recursionId":108,"flags":["StringLiteral"],"display":"\"map\""}, +{"id":118,"symbolName":"Container","recursionId":109,"instantiatedType":91,"typeArguments":[112],"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":1,"character":1},"end":{"line":4,"character":2}},"flags":["Object"]}, +{"id":119,"symbolName":"Nullable","recursionId":110,"unionTypes":[10,13,14],"aliasTypeArguments":[14],"firstDeclaration":{"path":"/home/src/workspaces/project/types.ts","start":{"line":5,"character":1},"end":{"line":5,"character":48}},"flags":["Union"],"display":"Nullable"}, +{"id":120,"recursionId":111,"flags":["StringLiteral"],"display":"\"hello\""}, +{"id":121,"recursionId":112,"flags":["StringLiteral"],"display":"\"hello\""}] From 248bfdf8cd2a36e3ab7ba1dbd7b5ed300aee13da Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Sun, 8 Nov 2026 18:49:15 -0800 Subject: [PATCH 36/60] Make checker results independent of check and query order The checker caches nearly everything it computes, and many results depend on the results that happened to be cached when they were computed: which file was checked first, which types an editor asked for before requesting diagnostics, whether a file was emitted before it was checked. The check order tests and fuzzer show hundreds of such differences on main. As long as they exist, checkers cannot share results, a cached result cannot be dropped and recomputed later, and concurrent checking needs separate checkers with fixed file assignments to stay deterministic. The goal is a checker that behaves like a pure function with a cache: the answer to any query is the answer of computing it from scratch. The cached state of a checker moves to a memo store, leaving the Checker with only the state of the computation in progress. Every cached result is a memo: a cell, a keyed map, or a check-once set. Reading one records it as a dependency of the computation in progress. Whether a memo holds a result depends on the results computed before, so only the computation of a result reads its memo: its getter, which reuses the result, and the computation itself. A computation reading the result a computation re-entering it cached early says so with inProgress, which asserts that it is in progress. Everything else asks the getter. A result filled in as a side output of another computation, such as the symbol a name resolves to when its expression is checked, is read through an accessor that runs that computation first, and a part an entity's creator supplies, such as the type arguments of a reference that is not deferred, through one saying so. Creators set such parts with setIdentity or intern, which are kept when a computation is discarded. Tests find any memo read outside these, and any creator setting part of an entity it creates in a way that can be discarded. Computing a result can produce more than the result: diagnostics, reference marks for unused checks, deferred nodes, required emit helpers. When a query computed a result first, those effects were either reported for code checking never visits or lost when checking reused the result. A query now records them on the result instead, along with the results it reused, and checking replays them, exactly once, when it reuses the result, as if it had computed it. Effects produced outside any memoized computation belong only to the query and are dropped. Checking applies effects inside the computation producing them, and a query only after it, so an effect only applies the results computed where it was recorded: computing more when applied, such as printing a type for a message, could find other computations in progress. A test finds effects that compute when applied. Circularities are where most of the order dependence lives. A computation that re-enters one in progress sees a provisional state, so the results cached until the outermost computation of the cycle finishes depend on where the cycle was entered. Those results are now discarded when it finishes, and recomputed when next requested. The computations in progress when the cycle was detected keep their fallbacks, as each reaches the cycle when computed from scratch too. Results that define identity, such as declared types and instantiations, are kept, so no second, distinct result can exist. Main detects many re-entries silently, through markers and probes rather than the resolution stack; those now go through the resolution stack too, so their cycles are seen. Where a cycle's result depends on which member was entered, the cycle is resolved from a canonical entry, the member declared first, as when checking in program order: cycles through the types of symbols, mutually dependent member tables and module tables, and type parameter defaults. Variances of circular types are measured with TypeScript's rule from the canonical type of each strongly connected component, so that they no longer depend on which type was measured first. Instantiation depth is measured from the start of each memoized computation, and a reused result adds none, so whether a result reaches the depth limit does not depend on the results cached. The count limit, which only stops runaway instantiations, still counts per statement or expression, and starts again for each outermost computation; its error is reported once, where it is reached. Smaller fixes needed for the same reason are part of this change: errors for accessor pairs are reported by each accessor without a flag, type alias type parameters are read through the declared type, name lookups that cannot match a late-bound member do not resolve late-bound members, symbols derived from the same declaration are ordered without ids, awaited types that refer back to themselves fail as a cycle, relation complexity overflows are reported in every comparison that needs them, statements not allowed in an ambient context are reported at the first of their block rather than the first checked, emit resolves the names and exported aliases it refers to unless the check of their file has resolved them, union and intersection properties are not shared between augmented and plain lookups, a conditional type is a restrictive instantiation if it is created as one, the API computes the parts of mapped types it returns, a call deferred while inferring from an enclosing call leaves no mark of its resolution behind, the type parameter whose variance annotation is checked is restored after the check, the binding elements renamed in function types are kept with their own file, and deferred diagnostics added while deferred diagnostics are produced are produced too. Fixes 30982 Fixes 63949 Fixes 65440 For 64278 --- packages/typescript/enums/objectFlags.d.ts | 1 - packages/typescript/enums/objectFlags.js | 1 - tsc/internal/api/enum_values_generated.go | 1 - tsc/internal/api/session.go | 40 +- tsc/internal/ast/symbol.go | 5 + tsc/internal/ast/utilities.go | 10 + tsc/internal/checker/checker.go | 4932 +++++++++++------ tsc/internal/checker/checker_test.go | 518 ++ tsc/internal/checker/emitresolver.go | 19 +- tsc/internal/checker/exports.go | 16 + tsc/internal/checker/flow.go | 241 +- tsc/internal/checker/grammarchecks.go | 42 +- tsc/internal/checker/inference.go | 53 +- tsc/internal/checker/jsx.go | 164 +- tsc/internal/checker/links.go | 14 +- tsc/internal/checker/memo.go | 2160 ++++++++ tsc/internal/checker/memopeek_test.go | 383 ++ tsc/internal/checker/nodebuilder_hover.go | 2 +- tsc/internal/checker/nodebuilderimpl.go | 38 +- tsc/internal/checker/printer.go | 6 +- tsc/internal/checker/relater.go | 797 ++- tsc/internal/checker/resolutions.go | 380 ++ tsc/internal/checker/services.go | 18 +- tsc/internal/checker/symbolaccessibility.go | 111 +- tsc/internal/checker/tracer.go | 11 +- tsc/internal/checker/types.go | 265 +- tsc/internal/checker/types_test.go | 163 +- tsc/internal/checker/utilities.go | 19 +- tsc/internal/execute/tsctests/tsc_test.go | 6 +- tsc/internal/testrunner/compiler_runner.go | 13 - ...entifier(checkorder=typesfirst).errors.txt | 5 +- ...rsiveTypeInferredThroughClosure.errors.txt | 86 - ...waitedCycle(checkorder=default).errors.txt | 5 +- ...waitedCycle(checkorder=reverse).errors.txt | 5 +- ...tedCycle(checkorder=typesfirst).errors.txt | 5 +- ...rConstraint(checkorder=default).errors.txt | 1 - ...rConstraint(checkorder=reverse).errors.txt | 1 - ...nstraint(checkorder=typesfirst).errors.txt | 1 - ...larDefaults(checkorder=default).errors.txt | 10 +- ...CircularDefaults(checkorder=default).types | 4 +- ...arDefaults(checkorder=isolated).errors.txt | 15 + ...ircularDefaults(checkorder=isolated).types | 4 +- ...Defaults(checkorder=typesfirst).errors.txt | 10 +- ...cularDefaults(checkorder=typesfirst).types | 4 +- ...BeforeCheck(checkorder=default).errors.txt | 6 +- ...eforeCheck(checkorder=isolated).errors.txt | 4 +- ...eckOrderSpreadCycle(checkorder=default).js | 15 +- ...OrderSpreadCycle(checkorder=default).types | 50 +- ...ckOrderSpreadCycle(checkorder=isolated).js | 16 +- ...rderSpreadCycle(checkorder=isolated).types | 50 +- ...eckOrderSpreadCycle(checkorder=reverse).js | 15 +- ...OrderSpreadCycle(checkorder=reverse).types | 50 +- ...OrderSpreadCycle(checkorder=typesfirst).js | 15 +- ...erSpreadCycle(checkorder=typesfirst).types | 50 +- ...ationErrors(checkorder=default).errors.txt | 13 +- ...ationErrors(checkorder=reverse).errors.txt | 13 +- ...onErrors(checkorder=typesfirst).errors.txt | 18 +- ...orAnnotations(checkorder=typesfirst).types | 8 +- ...larIndexedPropertyInstantiation.errors.txt | 5 +- ...TypeNoCrash(checkorder=default).errors.txt | 5 +- ...eNoCrash(checkorder=typesfirst).errors.txt | 5 +- ...ReturnTypeSubtypeReductionOrder.errors.txt | 12 +- ...cularReturnTypeSubtypeReductionOrder.types | 28 +- ...hCallbackArgument(strict=false).errors.txt | 38 + ...hroughCallbackArgument(strict=false).types | 24 +- ...ghCallbackArgument(strict=true).errors.txt | 30 +- ...ThroughCallbackArgument(strict=true).types | 24 +- ...verseMapped(checkorder=default).errors.txt | 40 + ...kReverseMapped(checkorder=default).symbols | 8 - ...unkReverseMapped(checkorder=default).types | 54 +- ...seMapped(checkorder=typesfirst).errors.txt | 40 + ...verseMapped(checkorder=typesfirst).symbols | 8 - ...ReverseMapped(checkorder=typesfirst).types | 54 +- ...lassVarianceResolveCircularity2.errors.txt | 24 - .../classVarianceResolveCircularity2.types | 2 +- .../contextualCheckInDiscardedCycle.symbols | 150 + .../contextualCheckInDiscardedCycle.types | 117 + ...textualCheckReentryAfterParameters.symbols | 181 + ...ontextualCheckReentryAfterParameters.types | 190 + .../contextualReturnTypeInSpreadArgument.js | 36 + ...ntextualReturnTypeInSpreadArgument.symbols | 59 + ...contextualReturnTypeInSpreadArgument.types | 63 + ...eCheckOrder(checkorder=default).errors.txt | 21 + ...nalModuleContainerIndexDeclarationOrder.js | 2 + ...ModuleContainerIndexDeclarationOrder.types | 4 +- ...volvingArrayReadInLoopCondition.errors.txt | 23 - ...leSpread(checkorder=typesfirst).errors.txt | 10 +- ...ooDeepCheckOrder(checkorder=default).types | 4 +- ...eepCheckOrder(checkorder=typesfirst).types | 4 +- ...ctRecursiveMappedTypeConstraint.errors.txt | 2 - ...IndexedAccessOfDerivedInterface.errors.txt | 28 - ...eckOrder(checkorder=typesfirst).errors.txt | 7 +- ...eckOrder(checkorder=typesfirst).errors.txt | 16 +- ...tCheckOrder(checkorder=default).errors.txt | 5 +- ...kLimitCheckOrder(checkorder=default).types | 2 +- ...eckOrder(checkorder=typesfirst).errors.txt | 10 +- ...mitCheckOrder(checkorder=typesfirst).types | 2 +- ...eckOrder(checkorder=typesfirst).errors.txt | 5 +- ...cleCheckOrder(checkorder=typesfirst).types | 2 +- ...andoIndexedAssignmentDiagnostic.errors.txt | 19 + .../jsExpandoIndexedAssignmentDiagnostic.js | 20 + ...ExpandoIndexedAssignmentDiagnostic.symbols | 33 + ...jsExpandoIndexedAssignmentDiagnostic.types | 42 + ...aComment(checkorder=typesfirst).errors.txt | 6 +- ...dsRecord(checkorder=typesfirst).errors.txt | 12 - ...ExtendsRecord(checkorder=typesfirst).types | 2 +- ...enericExtendingClassDoubleLayer.errors.txt | 5 +- .../lateBoundMutualMemberTables.errors.txt | 26 + .../compiler/lateBoundMutualMemberTables.js | 33 + .../lateBoundMutualMemberTables.symbols | 71 + .../lateBoundMutualMemberTables.types | 69 + ...tantiations(checkorder=default).errors.txt | 5 +- ...tiations(checkorder=typesfirst).errors.txt | 10 +- ...embersResolutionOrderExportStar.errors.txt | 6 +- ...mespaceMembersResolutionOrderExportStar.js | 28 +- ...ceMembersResolutionOrderExportStar.symbols | 4 +- ...paceMembersResolutionOrderExportStar.types | 120 +- ...ationEmitExportEqualsQualifiedNameOrder.js | 2 + ...onEmitExportEqualsQualifiedNameOrder.types | 4 +- ...onEmitExternalModuleContainerIndexOrder.js | 2 + ...mitExternalModuleContainerIndexOrder.types | 4 +- ...mitLateBoundIndexSignatureSiblingsOrder.js | 2 + ...LateBoundIndexSignatureSiblingsOrder.types | 4 +- ...oFlakyDeclarationEmitRenamedExportOrder.js | 2 + ...akyDeclarationEmitRenamedExportOrder.types | 4 +- ...akyDeclarationEmitSharedCheckerOrder.types | 6 +- ...akyDeclarationEmitUmdGlobalAliasesOrder.js | 2 + ...DeclarationEmitUmdGlobalAliasesOrder.types | 4 +- ...larationEmitVariableMatchesInScopeOrder.js | 2 + ...ationEmitVariableMatchesInScopeOrder.types | 4 +- ...nosticsExportStarCollisionOrder.errors.txt | 4 +- ...yDiagnosticsExportStarCollisionOrder.types | 2 +- ...rtStarDeclarationCollisionOrder.errors.txt | 4 +- ...sExportStarDeclarationCollisionOrder.types | 2 +- ...NamespaceMembersResolutionOrder.errors.txt | 6 +- ...gnosticsNamespaceMembersResolutionOrder.js | 28 +- ...icsNamespaceMembersResolutionOrder.symbols | 4 +- ...sticsNamespaceMembersResolutionOrder.types | 120 +- ...sResolutionOrderReexportedTypes.errors.txt | 6 +- ...ceMembersResolutionOrderReexportedTypes.js | 28 +- ...bersResolutionOrderReexportedTypes.symbols | 4 +- ...embersResolutionOrderReexportedTypes.types | 132 +- ...agnosticsNonExportedMemberOrder.errors.txt | 4 +- ...akyDiagnosticsNonExportedMemberOrder.types | 2 +- ...qualsWithOtherExportsCheckOrder.errors.txt | 5 +- ...rtEqualsWithOtherExportsCheckOrder.symbols | 2 + ...portEqualsWithOtherExportsCheckOrder.types | 4 +- ...ExportEqualsWithOtherExportsImportOrder.js | 2 + ...ortEqualsWithOtherExportsImportOrder.types | 4 +- ...rCheckOrder(checkorder=default).errors.txt | 5 +- ...lexityError(checkorder=default).errors.txt | 19 +- ...ityError(checkorder=typesfirst).errors.txt | 19 +- ...dCheckOrder(checkorder=default).errors.txt | 32 - ...eckOrder(checkorder=typesfirst).errors.txt | 5 +- .../relationDeeplyNestedCheckOrder.errors.txt | 32 - ...ssiveLength(checkorder=default).errors.txt | 35 +- ...veLength(checkorder=typesfirst).errors.txt | 31 +- ...aultInCallInsideGenericCallback.errors.txt | 28 - ...nstraint(checkorder=typesfirst).errors.txt | 1 - ...ameterWithInvalidConstraintType.errors.txt | 1 - ...aration1(checkorder=typesfirst).errors.txt | 5 +- .../varianceCircularConsistency.errors.txt | 28 +- ...ByInference(checkorder=default).errors.txt | 56 + ...sInvariance(checkorder=default).errors.txt | 141 + ...variance(checkorder=typesfirst).errors.txt | 141 + ...rianceCycleDiscardedDiagnostics.errors.txt | 6 +- .../varianceCycleDiscardedDiagnostics.symbols | 2 - .../varianceCycleDiscardedDiagnostics.types | 6 +- ...aration1(checkorder=typesfirst).errors.txt | 5 +- ...nDeclaration1(checkorder=typesfirst).types | 2 +- ...ortTag13(checkorder=typesfirst).errors.txt | 5 +- ...hadowing(checkorder=typesfirst).errors.txt | 2 +- .../recursiveMappedTypes.errors.txt | 14 +- .../templateLiteralTypes1.errors.txt | 13 +- ...stics-produced-during-semantic-checking.js | 70 +- ...ive-mapped-type-after-comment-only-edit.js | 118 +- ...nly-mapped-type-after-comment-only-edit.js | 118 +- .../contextualCheckInDiscardedCycle.ts | 39 + .../contextualCheckReentryAfterParameters.ts | 41 + .../contextualReturnTypeInSpreadArgument.ts | 18 + .../jsExpandoIndexedAssignmentDiagnostic.ts | 13 + .../compiler/lateBoundMutualMemberTables.ts | 20 + 182 files changed, 10773 insertions(+), 3466 deletions(-) create mode 100644 tsc/internal/checker/memo.go create mode 100644 tsc/internal/checker/memopeek_test.go create mode 100644 tsc/internal/checker/resolutions.go delete mode 100644 tsc/testdata/baselines/reference/compiler/boundedRecursiveTypeInferredThroughClosure.errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/checkOrderCircularDefaults(checkorder=isolated).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallbackArgument(strict=false).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/circularScopeThunkReverseMapped(checkorder=default).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/circularScopeThunkReverseMapped(checkorder=typesfirst).errors.txt delete mode 100644 tsc/testdata/baselines/reference/compiler/classVarianceResolveCircularity2.errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/contextualCheckInDiscardedCycle.symbols create mode 100644 tsc/testdata/baselines/reference/compiler/contextualCheckInDiscardedCycle.types create mode 100644 tsc/testdata/baselines/reference/compiler/contextualCheckReentryAfterParameters.symbols create mode 100644 tsc/testdata/baselines/reference/compiler/contextualCheckReentryAfterParameters.types create mode 100644 tsc/testdata/baselines/reference/compiler/contextualReturnTypeInSpreadArgument.js create mode 100644 tsc/testdata/baselines/reference/compiler/contextualReturnTypeInSpreadArgument.symbols create mode 100644 tsc/testdata/baselines/reference/compiler/contextualReturnTypeInSpreadArgument.types create mode 100644 tsc/testdata/baselines/reference/compiler/cycleYieldThroughVarianceCheckOrder(checkorder=default).errors.txt delete mode 100644 tsc/testdata/baselines/reference/compiler/evolvingArrayReadInLoopCondition.errors.txt delete mode 100644 tsc/testdata/baselines/reference/compiler/indexSignatureWithIndexedAccessOfDerivedInterface.errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/jsExpandoIndexedAssignmentDiagnostic.errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/jsExpandoIndexedAssignmentDiagnostic.js create mode 100644 tsc/testdata/baselines/reference/compiler/jsExpandoIndexedAssignmentDiagnostic.symbols create mode 100644 tsc/testdata/baselines/reference/compiler/jsExpandoIndexedAssignmentDiagnostic.types delete mode 100644 tsc/testdata/baselines/reference/compiler/jsxIntrinsicElementsExtendsRecord(checkorder=typesfirst).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/lateBoundMutualMemberTables.errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/lateBoundMutualMemberTables.js create mode 100644 tsc/testdata/baselines/reference/compiler/lateBoundMutualMemberTables.symbols create mode 100644 tsc/testdata/baselines/reference/compiler/lateBoundMutualMemberTables.types delete mode 100644 tsc/testdata/baselines/reference/compiler/relationComplexitySharedCheckOrder(checkorder=default).errors.txt delete mode 100644 tsc/testdata/baselines/reference/compiler/relationDeeplyNestedCheckOrder.errors.txt delete mode 100644 tsc/testdata/baselines/reference/compiler/typeParameterDefaultInCallInsideGenericCallback.errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/varianceCircularityEnteredByInference(checkorder=default).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/varianceCircularityHidesInvariance(checkorder=default).errors.txt create mode 100644 tsc/testdata/baselines/reference/compiler/varianceCircularityHidesInvariance(checkorder=typesfirst).errors.txt create mode 100644 tsc/testdata/tests/cases/compiler/contextualCheckInDiscardedCycle.ts create mode 100644 tsc/testdata/tests/cases/compiler/contextualCheckReentryAfterParameters.ts create mode 100644 tsc/testdata/tests/cases/compiler/contextualReturnTypeInSpreadArgument.ts create mode 100644 tsc/testdata/tests/cases/compiler/jsExpandoIndexedAssignmentDiagnostic.ts create mode 100644 tsc/testdata/tests/cases/compiler/lateBoundMutualMemberTables.ts diff --git a/packages/typescript/enums/objectFlags.d.ts b/packages/typescript/enums/objectFlags.d.ts index 78ce1bb59fff1..ac8ff7d3d315b 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, IsGenericTypeComputed = 1 << 22, IsGenericObjectType = 1 << 23, diff --git a/packages/typescript/enums/objectFlags.js b/packages/typescript/enums/objectFlags.js index 7adbed11771cc..050bb675d623c 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["IsGenericTypeComputed"] = 4194304] = "IsGenericTypeComputed"; ObjectFlags[ObjectFlags["IsGenericObjectType"] = 8388608] = "IsGenericObjectType"; diff --git a/tsc/internal/api/enum_values_generated.go b/tsc/internal/api/enum_values_generated.go index f1db3543e9184..709893c44f9ac 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), "IsGenericTypeComputed": toInt32(checker.ObjectFlagsIsGenericTypeComputed), "IsGenericObjectType": toInt32(checker.ObjectFlagsIsGenericObjectType), diff --git a/tsc/internal/api/session.go b/tsc/internal/api/session.go index 4438ab668486f..ffef73437f19f 100644 --- a/tsc/internal/api/session.go +++ b/tsc/internal/api/session.go @@ -340,12 +340,10 @@ func (sd *snapshotData) newTypeResponse(projectID project.Handle, t *checker.Typ resp.AliasSymbol = newSymbolReference(t.Alias().Symbol()) } if t.ObjectFlags()&checker.ObjectFlagsMapped != 0 { - mapped := t.AsMappedType() - mapped.ResolveComponents(c, t) - resp.TypeParameter = sd.registerType(projectID, mapped.TypeParameter()) - resp.ConstraintType = sd.registerType(projectID, mapped.ConstraintType()) - resp.NameType = sd.registerType(projectID, mapped.NameType()) - resp.TemplateType = sd.registerType(projectID, mapped.TemplateType()) + resp.TypeParameter = sd.registerType(projectID, c.GetTypeParameterOfMappedType(t)) + resp.ConstraintType = sd.registerType(projectID, c.GetConstraintTypeOfMappedType(t)) + resp.NameType = sd.registerType(projectID, c.GetNameTypeOfMappedType(t)) + resp.TemplateType = sd.registerType(projectID, c.GetTemplateTypeOfMappedType(t)) } if checker.IsTupleTypeTarget(t) { elementInfos := t.AsTupleType().ElementInfos() @@ -3271,20 +3269,20 @@ func (s *Session) handleGetConstraintOfType(ctx context.Context, params *GetType } func (s *Session) handleGetTypeParameterOfMappedType(ctx context.Context, params *GetTypePropertyParams) (*TypeResponse, error) { - return s.resolveTypePropertyOfType(ctx, params, func(t *checker.Type) *checker.Type { return t.AsMappedType().TypeParameter() }) + return s.resolveTypePropertyOfTypeWithChecker(ctx, params, (*checker.Checker).GetTypeParameterOfMappedType) } func (s *Session) handleGetConstraintTypeOfMappedType(ctx context.Context, params *GetTypePropertyParams) (*TypeResponse, error) { - return s.resolveTypePropertyOfType(ctx, params, func(t *checker.Type) *checker.Type { return t.AsMappedType().ConstraintType() }) + return s.resolveTypePropertyOfTypeWithChecker(ctx, params, (*checker.Checker).GetConstraintTypeOfMappedType) } // @gen-proto-nullable func (s *Session) handleGetNameTypeOfMappedType(ctx context.Context, params *GetTypePropertyParams) (*TypeResponse, error) { - return s.resolveTypePropertyOfType(ctx, params, func(t *checker.Type) *checker.Type { return t.AsMappedType().NameType() }) + return s.resolveTypePropertyOfTypeWithChecker(ctx, params, (*checker.Checker).GetNameTypeOfMappedType) } func (s *Session) handleGetTemplateTypeOfMappedType(ctx context.Context, params *GetTypePropertyParams) (*TypeResponse, error) { - return s.resolveTypePropertyOfType(ctx, params, func(t *checker.Type) *checker.Type { return t.AsMappedType().TemplateType() }) + return s.resolveTypePropertyOfTypeWithChecker(ctx, params, (*checker.Checker).GetTemplateTypeOfMappedType) } // @gen-proto-nullable @@ -3465,6 +3463,28 @@ func (s *Session) resolveTypePropertyOfType(ctx context.Context, params *GetType return setup.sd.newTypeResponse(setup.projectID, result, setup.checker), nil } +// resolveTypePropertyOfTypeWithChecker is resolveTypePropertyOfType for a +// property the checker computes. +func (s *Session) resolveTypePropertyOfTypeWithChecker(ctx context.Context, params *GetTypePropertyParams, getter func(*checker.Checker, *checker.Type) *checker.Type) (*TypeResponse, error) { + setup, err := s.setupChecker(ctx, params.Snapshot, params.Project) + if err != nil { + return nil, err + } + defer setup.done() + + t, err := setup.sd.resolveTypeHandle(params.Project, params.Type) + if err != nil { + return nil, err + } + + result := getter(setup.checker, t) + if result == nil { + return nil, nil + } + + return setup.sd.newTypeResponse(setup.projectID, result, setup.checker), nil +} + // resolveTypeArrayPropertyOfType resolves a type property of an array of types and returns an array of type responses. func (s *Session) resolveTypeArrayPropertyOfType(ctx context.Context, params *GetTypePropertyParams, getter func(*checker.Type) []*checker.Type) ([]*TypeResponse, error) { setup, err := s.setupChecker(ctx, params.Snapshot, params.Project) diff --git a/tsc/internal/ast/symbol.go b/tsc/internal/ast/symbol.go index 7c8e60e921d55..28862ff494d3d 100644 --- a/tsc/internal/ast/symbol.go +++ b/tsc/internal/ast/symbol.go @@ -223,6 +223,11 @@ func (m *SymbolMap) SymbolAt(i int) *Symbol { return symbol } +// At returns the name and symbol of the i-th entry, in insertion order. +func (m *SymbolMap) At(i int) (string, *Symbol) { + return m.KeyAt(i), m.SymbolAt(i) +} + func (m *SymbolMap) Find(key string) int { if m == nil { return -1 diff --git a/tsc/internal/ast/utilities.go b/tsc/internal/ast/utilities.go index f178903372dc2..d029159e971d3 100644 --- a/tsc/internal/ast/utilities.go +++ b/tsc/internal/ast/utilities.go @@ -33,6 +33,16 @@ func GetNodeId(node *Node) NodeId { return NodeId(id) } +// PeekNodeId returns the id of node, or 0 if it has none yet. +func PeekNodeId(node *Node) NodeId { + return NodeId(node.id.Load()) +} + +// PeekSymbolId returns the id of symbol, or 0 if it has none yet. +func PeekSymbolId(symbol *Symbol) SymbolId { + return SymbolId(symbol.id.Load()) +} + func GetSymbolId(symbol *Symbol) SymbolId { id := symbol.id.Load() if id == 0 { diff --git a/tsc/internal/checker/checker.go b/tsc/internal/checker/checker.go index 61ef8b4af0590..3c6943a6ff679 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" @@ -67,13 +68,34 @@ const ( TypeSystemPropertyNameInitializerIsUndefined TypeSystemPropertyNameAliasTarget TypeSystemPropertyNameComputedPropertyName + TypeSystemPropertyNameContextChecked + TypeSystemPropertyNameVariances + TypeSystemPropertyNameStructuredMembers + TypeSystemPropertyNameSimplifiedForReading + TypeSystemPropertyNameSimplifiedForWriting + TypeSystemPropertyNameDefaultType + TypeSystemPropertyNameAwaitedType + TypeSystemPropertyNameExplicitType + TypeSystemPropertyNameBindingElementParent + TypeSystemPropertyNameCallResolution + TypeSystemPropertyNameAssertionOperand + TypeSystemPropertyNamePatternInitializer TypeSystemPropertyNameBaseConstraintInWalk ) type TypeResolution struct { - target TypeSystemEntity + target TypeSystemEntity + // canonical is the member of a cycle headed by this resolution that is + // resolved first; see observeCircularHead. + canonical TypeSystemEntity + // participant records that the resolution is in cycleParticipants. + participant bool + memo *memoHeader propertyName TypeSystemPropertyName result bool + // restartHidden records that a cycle entered below this resolution of a + // module table passes through it; see resolveModuleTableMembers. + restartHidden bool } // ContextualInfo @@ -245,14 +267,6 @@ type PropertiesTypesKey struct { includeOrigin bool } -// NonExistentPropertyKey - -type NonExistentPropertyKey struct { - propNode *ast.Node - containingType *Type - isUncheckedJS bool -} - // FlowLoopKey type FlowLoopKey struct { @@ -557,8 +571,21 @@ type WideningContext struct { } type VarianceStackEntry struct { - symbol *ast.Symbol - typeParameters []*Type + symbol *ast.Symbol + resolution int // Index in Checker.resolutions of the resolution of the measurement + // The lowest index in the variance stack of a measurement in progress + // that this one or one it reached needed, and the smallest type in the + // circularity so far, as in Tarjan's algorithm for strongly connected + // components. + low int + min *ast.Symbol + minTypeParameters []*Type + discardPoint // When the measurement began + // The measurement is being repeated because the measurement from the + // canonical entry of its circularity did not reach it, so it is not + // superseded again. + remeasuring bool + provisionalStart int // Length of Checker.varianceProvisional when the measurement began } type ResolvingObjectType struct { @@ -601,103 +628,36 @@ 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 - baseConstraintWalk baseConstraintWalk - inlineLevel int - serializationLevel int - currentNode *ast.Node - varianceTypeParameter *Type - languageVersion core.ScriptTarget - moduleKind core.ModuleKind - moduleResolutionKind core.ModuleResolutionKind + *memoStore + compareSymbols func(*ast.Symbol, *ast.Symbol) int + compareSymbolChains func([]*ast.Symbol, []*ast.Symbol) int + awaitedTypeErrors uint32 // Errors computing awaited types have reported or would report; see getAwaitedTypeNoAliasEx + resolutionSerials uint32 + resolutions []resolution + instantiationStack []*Type + conditionalConstraintDepth depthLimit + baseConstraintWalk baseConstraintWalk + inlineLevel depthLimit + serializationLevel depthLimit + currentNode *ast.Node + currentNodeResolution int // 1-based index in resolutions of the resolution of currentNode, or 0; see enterCurrentNode + querySave savedCurrentNode // Saved by the query in progress made outside of checking; see startEffects + queryRoot int // 1-based index in resolutions of the computation of that query, or 0 + varianceTypeParameter *Type + // The parent last looked up in parentLateBindableKinds and its kinds, as + // members of one parent are often looked up together. + lastLateBindableParent *ast.Symbol + lastLateBindableKinds uint8 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] - resolvingAssertionOperands collections.Set[*ast.Node] - 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 - objectLiteralTypes map[CacheHashKey]*Type - spreadTypes map[CacheHashKey]*Type - objectContentTypes map[CacheHashKey]*Type - spreadSymbols map[spreadSymbolKey]*ast.Symbol - symbolsWithType map[symbolWithTypeKey]*ast.Symbol - paddedProperties map[symbolWithTypeKey]*ast.Symbol - bindingPatternTypes map[CacheHashKey]*Type - unionOfUnionTypes map[UnionOfUnionKey]*Type - intersectionTypes map[CacheHashKey]*Type - intersectionContentTypes 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 @@ -724,134 +684,39 @@ type Checker struct { layoutBaseIndices []int32 freeTypeSets *temporaryTypeSet freePropertyCounts *temporaryPropertyCounts - mergedSymbols symbolLinkStore[*ast.Symbol] - mergedExportsChecked collections.Set[*ast.Symbol] factory ast.NodeFactory - nodeLinks core.LinkStore[*ast.Node, NodeLinks] - signatureLinks nodeLinkStore[SignatureLinks] - symbolNodeLinks nodeLinkStore[SymbolNodeLinks] - typeNodeLinks nodeLinkStore[TypeNodeLinks] - enumMemberLinks core.LinkStore[*ast.Node, EnumMemberLinks] - arrayLiteralLinks core.LinkStore[*ast.Node, ArrayLiteralLinks] - switchStatementLinks core.LinkStore[*ast.Node, SwitchStatementLinks] - jsxElementLinks core.LinkStore[*ast.Node, JsxElementLinks] - computedNameLinks core.LinkStore[*ast.Node, ComputedNameNodeLinks] - symbolReferenceLinks core.LinkStore[*ast.Symbol, SymbolReferenceLinks] - valueSymbolLinks symbolLinkStore[ValueSymbolLinks] - mappedSymbolLinks core.LinkStore[*ast.Symbol, MappedSymbolLinks] - deferredSymbolLinks core.LinkStore[*ast.Symbol, DeferredSymbolLinks] - aliasSymbolLinks core.LinkStore[*ast.Symbol, AliasSymbolLinks] - moduleSymbolLinks core.LinkStore[*ast.Symbol, ModuleSymbolLinks] - lateBoundLinks core.LinkStore[*ast.Symbol, LateBoundLinks] - exportTypeLinks core.LinkStore[*ast.Symbol, ExportTypeLinks] - membersAndExportsLinks core.LinkStore[*ast.Symbol, MembersAndExportsLinks] - typeAliasLinks core.LinkStore[*ast.Symbol, TypeAliasLinks] - declaredTypeLinks core.LinkStore[*ast.Symbol, DeclaredTypeLinks] - spreadLinks core.LinkStore[*ast.Symbol, SpreadLinks] - varianceLinks core.LinkStore[*ast.Symbol, VarianceLinks] - ReverseMappedSymbolLinks core.LinkStore[*ast.Symbol, ReverseMappedSymbolLinks] - markedAssignmentSymbolLinks core.LinkStore[*ast.Symbol, MarkedAssignmentSymbolLinks] - symbolContainerLinks core.LinkStore[*ast.Symbol, ContainingSymbolLinks] - externalModuleContainers *externalModuleContainerIndex - sourceFileLinks core.LinkStore[*ast.SourceFile, SourceFileLinks] regExpScanner *scanner.Scanner - patternForType map[*Type]*ast.Node - contextFreeTypes map[*ast.Node]*Type - anyType *Type - autoType *Type - wildcardType *Type - blockedStringType *Type - errorType *Type - unresolvedType *Type - nonInferrableAnyType *Type - intrinsicMarkerType *Type - unknownType *Type - undefinedType *Type - undefinedWideningType *Type - missingType *Type - undefinedOrMissingType *Type - optionalType *Type - nullType *Type - nullWideningType *Type - stringType *Type - numberType *Type - bigintType *Type - regularFalseType *Type - falseType *Type - regularTrueType *Type - trueType *Type - booleanType *Type - esSymbolType *Type - voidType *Type - neverType *Type - silentNeverType *Type - implicitNeverType *Type - unreachableNeverType *Type - nonPrimitiveType *Type - stringOrNumberType *Type - stringNumberSymbolType *Type - numberOrBigIntType *Type - templateConstraintType *Type - numericStringType *Type - uniqueLiteralType *Type uniqueLiteralMapper *TypeMapper reliabilityFlags RelationComparisonResult reportUnreliableMapper *TypeMapper reportUnmeasurableMapper *TypeMapper restrictiveMapper *TypeMapper permissiveMapper *TypeMapper - emptyObjectType *Type - emptyJsxObjectType *Type - emptyFreshJsxObjectType *Type - emptyTypeLiteralType *Type - unknownEmptyObjectType *Type - unknownUnionType *Type - emptyGenericType *Type - anyFunctionType *Type - noConstraintType *Type - circularConstraintType *Type - resolvingDefaultType *Type - markerSuperType *Type - markerSubType *Type - markerOtherType *Type - markerSuperTypeForCheck *Type - markerSubTypeForCheck *Type - noTypePredicate *TypePredicate - anySignature *Signature - unknownSignature *Signature - resolvingSignature *Signature - silentNeverSignature *Signature - cachedArgumentsReferenced map[*ast.Node]bool - enumNumberIndexInfo *IndexInfo - anyBaseTypeIndexInfo *IndexInfo - patternAmbientModules []*ast.PatternAmbientModule - patternAmbientModuleAugmentations ast.SymbolTable - patternAmbientModuleAugmentationTargets ast.SymbolTable - moduleImportAttributesTypes map[*ast.Symbol]*Type - globalObjectType *Type - globalFunctionType *Type - globalCallableFunctionType *Type - globalNewableFunctionType *Type - globalArrayType *Type - globalReadonlyArrayType *Type - globalStringType *Type - globalNumberType *Type - globalBooleanType *Type - globalRegExpType *Type - globalThisType *Type - anyArrayType *Type - autoArrayType *Type - anyReadonlyArrayType *Type - deferredGlobalImportMetaExpressionType *Type contextualBindingPatterns []*ast.Node - emptyStringType *Type - zeroType *Type - zeroBigIntType *Type - typeofType *Type - typeResolutions []TypeResolution - resolutionStart int + resolving resolvingTable // Index in resolutions of the outermost computation of each key in progress + typeResolutionTop int // 1-based index in resolutions of the innermost resolution, or 0 + resolutionStart int // Index in resolutions below which resolutions are not searched for cycles + visibleStart int // Index in resolutions below which nothing in progress is visible; see yieldCycle + cycleYields []cycleYield // Canonical recomputations in progress; see yieldCycle + circularityStart int // 1-based index in resolutions of the outermost cycle in progress, or 0; see memo.go + currentNodeErrors []*currentNodeError // Errors reported at the current node while collecting; see startCurrentNodeErrors + currentNodeErrorCollectors int // Number of computations collecting currentNodeErrors + currentNodeErrorsCyclic bool // Whether a cycle was observed while collecting currentNodeErrors; see endCurrentNodeErrors + discardLog []discardEntry // Restores what was cached while anything may be discarded; see "Discard log" in memo.go + discardLogFloor int // Length of the discard log kept for measurements hidden by a canonical variance remeasurement; see trimDiscardLog + circularityMark int // Length of discard log when the cycle in progress was detected + innerCycles []innerCycle // Cycles detected inside the one in progress; see extendCircularity + flowDepthFailures map[FlowLoopKey]int // Largest depth budget known to be too small for a flow walk from a node; see getTypeAtFlowNode + cycleParticipants []*memoHeader // Computations that observed a cycle in progress + effectsMarkDepth int // 1 + resolution index of the innermost effects mark that may be discarded, or 0 varianceStack []VarianceStackEntry - callResolutionStack []*ast.Node + varianceCycleRoot int // 1 + index in varianceStack of the outermost measurement re-entered in progress, or 0; see getRecursiveVariances + varianceSuperseded bool // The measurement at the bottom of varianceStack is certain to be discarded; see getRecursiveVariances + varianceProvisional []*ast.Symbol // Types measured in a circularity with a measurement in progress; see isGuessedVariance + flushBuf []*memoState + resumeBuf []int + deferredAttach []*memoState // See attachState + recordingFromCheck bool // A query begun in a check is in progress; see recordFromCheck apparentArgumentCount *int lastGetCombinedNodeFlagsNode *ast.Node lastGetCombinedNodeFlagsResult ast.NodeFlags @@ -859,33 +724,25 @@ type Checker struct { lastGetCombinedModifierFlagsResult ast.ModifierFlags freeinferenceState *InferenceState freeFlowState *FlowState - flowLoopCache map[FlowLoopKey]flowLoopCacheEntry flowLoopStack []FlowLoopInfo contextualParameterAssignments []contextualParameterAssignment parametersAssigning []*ast.Symbol + signaturesResolving []*SignatureLinks // Calls whose resolution is in progress + visibleSignatures int // Index in signaturesResolving below which nothing is visible; see yieldCycle sharedFlows []SharedFlow antecedentTypes []*Type 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 @@ -946,38 +803,275 @@ 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 + globalIDs map[globalKey]globalID + globalTypes []memo[resolvedGlobal[*Type]] // Indexed by globalID + globalSymbols []memo[resolvedGlobal[*ast.Symbol]] // Indexed by globalID + stringLiteralTypes internMap[string, *Type] + numberLiteralTypes internMap[jsnum.Number, *Type] + nanType *Type + bigintLiteralTypes internMap[jsnum.PseudoBigInt, *Type] + enumLiteralTypes internMap[EnumLiteralKey, *Type] + enumNaNLiteralTypes internMap[*ast.Symbol, *Type] + indexedAccessTypes internMap[CacheHashKey, *Type] + templateLiteralTypes internMap[CacheHashKey, *Type] + stringMappingTypes internMap[StringMappingKey, *Type] + uniqueESSymbolTypes internMap[*ast.Symbol, *Type] + thisExpandos internMap[*ast.Symbol, thisExpando] + subtypeReductionCache memoMap[CacheHashKey, []*Type] + cachedTypes memoMap[CachedTypeKey, *Type] + cachedSignatures memoMap[CachedSignatureKey, *Signature] + undefinedProperties memoMap[*ast.Symbol, *ast.Symbol] + narrowedTypes memoMap[NarrowedTypeKey, *Type] + assignmentReducedTypes memoMap[AssignmentReducedKey, *Type] + discriminatedContextualTypes memoMap[DiscriminatedContextualTypeKey, *Type] + instantiationExpressionTypes internMap[InstantiationExpressionKey, *instantiationExpressionEntry] + substitutionTypes internMap[SubstitutionTypeKey, *Type] + reverseMappedCache memoMap[ReverseMappedTypeKey, *Type] + reverseHomomorphicMappedCache memoMap[ReverseMappedTypeKey, *Type] + iterationTypesCache memoMap[IterationTypesKey, IterationTypes] + memberLayoutCache memoMap[CacheHashKey, *MemberLayout] + constructorOrFunctionChecked memoSet[*ast.Symbol] + typeParametersChecked memoSet[*ast.Symbol] + indexSignaturesChecked memoSet[*ast.Symbol] + interfaceChecked memoSet[*ast.Symbol] + enumChecked memoSet[*ast.Symbol] + moduleExportsChecked memoSet[*ast.Symbol] + assignmentsMarked memoSet[*ast.Node] // Functions and source files whose assignments have been marked + undefinedSymbol *ast.Symbol + argumentsSymbol *ast.Symbol + requireSymbol *ast.Symbol + unknownSymbol *ast.Symbol + unresolvedSymbols internMap[string, *ast.Symbol] + errorTypes internMap[CacheHashKey, *Type] + globalThisSymbol *ast.Symbol + symbolTableAliasCache internMap[symbolTableID, []*ast.Symbol] + classExpressionNameTables internMap[ast.NodeId, ast.SymbolTable] + tupleTypes internMap[CacheHashKey, *Type] + unionTypes internMap[CacheHashKey, *Type] + unionOfUnionTypes memoMap[UnionOfUnionKey, *Type] + intersectionTypes memoMap[CacheHashKey, *Type] + objectLiteralTypes internMap[*ast.Node, []objectLiteralType] + spreadTypes memoMap[CacheHashKey, *Type] + objectContentTypes internMap[CacheHashKey, *Type] + spreadSymbols memoMap[spreadSymbolKey, *ast.Symbol] + symbolsWithType internMap[symbolWithTypeKey, *ast.Symbol] + paddedProperties internMap[symbolWithTypeKey, *ast.Symbol] + bindingPatternTypes internMap[CacheHashKey, *Type] + intersectionContentTypes internMap[CacheHashKey, *Type] + propertiesTypes memoMap[PropertiesTypesKey, *Type] + diagnostics ast.DiagnosticsCollection + suggestionDiagnostics ast.DiagnosticsCollection + mergedSymbols symbolLinkStore[*ast.Symbol] + lateMergedSymbols memoMap[*ast.Symbol, *ast.Symbol] + // getLateBindableKinds of the merged symbol of a parent of members, with + // lateBindableKnown set once known; see getLateMergedSymbol. + parentLateBindableKinds symbolLinkStore[uint8] + // mergesFrozen is set once global merging is done; mergedSymbols is + // immutable from then on. + mergesFrozen bool + mergedExportsChecked memoSet[*ast.Symbol] + nodeLinks core.LinkStore[*ast.Node, NodeLinks] + signatureLinks nodeLinkStore[SignatureLinks] + symbolNodeLinks nodeLinkStore[SymbolNodeLinks] + typeNodeLinks nodeLinkStore[TypeNodeLinks] + enumMemberLinks core.LinkStore[*ast.Node, EnumMemberLinks] + arrayLiteralLinks core.LinkStore[*ast.Node, ArrayLiteralLinks] + switchStatementLinks core.LinkStore[*ast.Node, SwitchStatementLinks] + jsxElementLinks core.LinkStore[*ast.Node, JsxElementLinks] + computedNameLinks core.LinkStore[*ast.Node, ComputedNameNodeLinks] + symbolReferenceLinks core.LinkStore[*ast.Symbol, SymbolReferenceLinks] + valueSymbolLinks symbolLinkStore[ValueSymbolLinks] + mappedSymbolLinks core.LinkStore[*ast.Symbol, MappedSymbolLinks] + deferredSymbolLinks core.LinkStore[*ast.Symbol, DeferredSymbolLinks] + aliasSymbolLinks core.LinkStore[*ast.Symbol, AliasSymbolLinks] + moduleSymbolLinks core.LinkStore[*ast.Symbol, ModuleSymbolLinks] + lateBoundLinks core.LinkStore[*ast.Symbol, LateBoundLinks] + exportTypeLinks core.LinkStore[*ast.Symbol, ExportTypeLinks] + membersAndExportsLinks core.LinkStore[*ast.Symbol, MembersAndExportsLinks] + typeAliasLinks core.LinkStore[*ast.Symbol, TypeAliasLinks] + declaredTypeLinks core.LinkStore[*ast.Symbol, DeclaredTypeLinks] + spreadLinks core.LinkStore[*ast.Symbol, SpreadLinks] + varianceLinks symbolLinkStore[VarianceLinks] + ReverseMappedSymbolLinks core.LinkStore[*ast.Symbol, ReverseMappedSymbolLinks] + markedAssignmentSymbolLinks core.LinkStore[*ast.Symbol, MarkedAssignmentSymbolLinks] + importedContainingModules memoMap[symbolFileKey, []*ast.Symbol] // Modules imported by a file that export a symbol + extendedContainers memoMap[*ast.Symbol, []*ast.Symbol] // Containers (other than the parent) which a symbol is aliased in + accessibleChains memoMap[accessibleChainCacheKey, []*ast.Symbol] // Accessible symbol chains by location + externalModuleContainers memo[*externalModuleContainerIndex] + sourceFileLinks core.LinkStore[*ast.SourceFile, SourceFileLinks] + patternForType internMap[*Type, *ast.Node] + contextFreeTypes memoMap[*ast.Node, *Type] + anyType *Type + autoType *Type + wildcardType *Type + blockedStringType *Type + errorType *Type + unresolvedType *Type + nonInferrableAnyType *Type + intrinsicMarkerType *Type + unknownType *Type + undefinedType *Type + undefinedWideningType *Type + missingType *Type + undefinedOrMissingType *Type + optionalType *Type + nullType *Type + nullWideningType *Type + stringType *Type + numberType *Type + bigintType *Type + regularFalseType *Type + falseType *Type + regularTrueType *Type + trueType *Type + booleanType *Type + esSymbolType *Type + voidType *Type + neverType *Type + silentNeverType *Type + implicitNeverType *Type + unreachableNeverType *Type + nonPrimitiveType *Type + stringOrNumberType *Type + stringNumberSymbolType *Type + numberOrBigIntType *Type + templateConstraintType *Type + numericStringType *Type + uniqueLiteralType *Type + emptyObjectType *Type + emptyJsxObjectType *Type + emptyFreshJsxObjectType *Type + emptyTypeLiteralType *Type + unknownEmptyObjectType *Type + unknownUnionType *Type + emptyGenericType *Type + anyFunctionType *Type + noConstraintType *Type + circularConstraintType *Type + resolvingDefaultType *Type + markerSuperType *Type + markerSubType *Type + markerOtherType *Type + markerSuperTypeForCheck *Type + markerSubTypeForCheck *Type + noTypePredicate *TypePredicate + anySignature *Signature + unknownSignature *Signature + resolvingSignature *Signature + silentNeverSignature *Signature + cachedArgumentsReferenced memoMap[*ast.Node, bool] + enumNumberIndexInfo *IndexInfo + anyBaseTypeIndexInfo *IndexInfo + patternAmbientModules []*ast.PatternAmbientModule + patternAmbientModuleAugmentations ast.SymbolTable + patternAmbientModuleAugmentationTargets ast.SymbolTable + moduleImportAttributesTypes memoMap[*ast.Symbol, *Type] + globalObjectType *Type + globalFunctionType *Type + globalCallableFunctionType *Type + globalNewableFunctionType *Type + globalArrayType *Type + globalReadonlyArrayType *Type + globalStringType *Type + globalNumberType *Type + globalBooleanType *Type + globalRegExpType *Type + globalThisType *Type + anyArrayType *Type + autoArrayType *Type + anyReadonlyArrayType *Type + deferredGlobalImportMetaExpressionType memo[*Type] + emptyStringType *Type + zeroType *Type + zeroBigIntType *Type + typeofType *Type + flowExpressionTypes memoMap[*ast.Node, *Type] + flowLoopCache internMap[FlowLoopKey, *flowLoopCacheEntry] + flowNodeReachable memoMap[*ast.FlowNode, bool] + flowNodePostSuper memoMap[*ast.FlowNode, bool] + subtypeRelation *Relation + strictSubtypeRelation *Relation + assignableRelation *Relation + comparableRelation *Relation + identityRelation *Relation + enumRelation memoMap[EnumRelationKey, RelationComparisonResult] + emitResolverLinks EmitResolverLinks + _jsxNamespace string + _jsxFactoryEntity *ast.Node + packagesMap map[string]bool + ambientModulesOnce sync.Once + ambientModules []*ast.Symbol + reportedUnreachableNodes memoSet[*ast.Node] + unreachableRuns memoMap[*ast.Node, map[*ast.Node]unreachableRun] + checkedRegularExpressions memoSet[*ast.Node] + nonExistentPropertyNodes collections.Set[*ast.Node] // Property names reported as nonexistent + deferredDiagnosticCallbacks []func(c *Checker) + memoStates map[memoKey]*memoState // Memo state of results computed by queries; see memo.go + stateFilter stateKeyFilter // Memo keys that may have a memo state; see memoState + errorFilter errorKeyFilter // Memo keys that may have reports; see observeMemo + memoPendingCount int // Number of memoStates with unreplayed effects + memoErrorStates int // Number of memoStates with reports; see setReported + + mu sync.Mutex } func NewChecker(program Program, tracer *Tracer) (*Checker, *sync.Mutex) { program.BindSourceFiles() - c := &Checker{} + c := &Checker{memoStore: &memoStore{}, checking: true} + c.initResolutions() + c.root = c c.id = nextCheckerID.Add(1) c.tracer = tracer c.program = program c.compilerOptions = program.Options() c.files = program.SourceFiles() c.fileIndexMap = createFileIndexMap(c.files) - c.compareSymbols = c.compareSymbolsWorker // Closure optimization - c.compareSymbolChains = c.compareSymbolChainsWorker // Closure optimization c.languageVersion = c.compilerOptions.GetEmitScriptTarget() c.moduleKind = c.compilerOptions.GetEmitModuleKind() c.moduleResolutionKind = c.compilerOptions.GetModuleResolutionKind() @@ -995,57 +1089,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.objectLiteralTypes = make(map[CacheHashKey]*Type) - c.spreadTypes = make(map[CacheHashKey]*Type) - c.objectContentTypes = make(map[CacheHashKey]*Type) - c.spreadSymbols = make(map[spreadSymbolKey]*ast.Symbol) - c.symbolsWithType = make(map[symbolWithTypeKey]*ast.Symbol) - c.paddedProperties = make(map[symbolWithTypeKey]*ast.Symbol) - c.bindingPatternTypes = make(map[CacheHashKey]*Type) - c.unionOfUnionTypes = make(map[UnionOfUnionKey]*Type) - c.intersectionTypes = make(map[CacheHashKey]*Type) - c.intersectionContentTypes = 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") @@ -1087,11 +1138,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) @@ -1099,7 +1145,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) @@ -1107,33 +1152,53 @@ func NewChecker(program Program, tracer *Tracer) (*Checker, *sync.Mutex) { c.resolvingDefaultType = c.newAnonymousType(nil /*symbol*/, nil, nil, nil, nil) c.markerSuperType = c.newTypeParameter(nil) c.markerSubType = c.newTypeParameter(nil) - c.markerSubType.AsTypeParameter().constraint = c.markerSuperType + c.markerSubType.AsTypeParameter().constraint.intern(c.markerSuperType) c.markerOtherType = c.newTypeParameter(nil) c.markerSuperTypeForCheck = c.newTypeParameter(nil) c.markerSubTypeForCheck = c.newTypeParameter(nil) - c.markerSubTypeForCheck.AsTypeParameter().constraint = c.markerSuperTypeForCheck + c.markerSubTypeForCheck.AsTypeParameter().constraint.intern(c.markerSuperTypeForCheck) c.noTypePredicate = &TypePredicate{kind: TypePredicateKindIdentifier, parameterIndex: 0, parameterName: "<>", t: c.anyType} c.anySignature = c.newSignature(SignatureFlagsNone, nil, nil, nil, nil, c.anyType, nil, 0) c.unknownSignature = c.newSignature(SignatureFlagsNone, nil, nil, nil, nil, c.errorType, nil, 0) c.resolvingSignature = c.newSignature(SignatureFlagsNone, nil, nil, nil, nil, c.anyType, nil, 0) c.silentNeverSignature = c.newSignature(SignatureFlagsNone, nil, nil, nil, nil, c.silentNeverType, nil, 0) - c.cachedArgumentsReferenced = make(map[*ast.Node]bool) c.enumNumberIndexInfo = &IndexInfo{keyType: c.numberType, valueType: c.stringType, isReadonly: true} c.anyBaseTypeIndexInfo = &IndexInfo{keyType: c.stringType, valueType: c.anyType, isReadonly: false} c.emptyStringType = c.getStringLiteralType("") c.zeroType = c.getNumberLiteralType(0) c.zeroBigIntType = c.getBigIntLiteralType(jsnum.PseudoBigInt{}) c.typeofType = c.getUnionType(core.Map(slices.Sorted(maps.Keys(typeofNEFacts)), c.getStringLiteralType)) - c.flowLoopCache = make(map[FlowLoopKey]flowLoopCacheEntry) - c.flowNodeReachable = make(map[*ast.FlowNode]bool) - c.flowNodePostSuper = make(map[*ast.FlowNode]bool) c.subtypeRelation = &Relation{} c.strictSubtypeRelation = &Relation{} c.assignableRelation = &Relation{} c.comparableRelation = &Relation{} c.identityRelation = &Relation{} - c.enumRelation = make(map[EnumRelationKey]RelationComparisonResult) - c.moduleImportAttributesTypes = make(map[*ast.Symbol]*Type) + for _, r := range []*Relation{c.subtypeRelation, c.strictSubtypeRelation, c.assignableRelation, c.comparableRelation, c.identityRelation} { + r.results.setKeyBits(relationKeyBits) + } + // Re-entering the type of an expression computes it again, like + // re-entering the cell of checkExpressionCachedEx. + c.flowExpressionTypes.setReentry(reentryPartial) + c.initializeChecker() + c.mergesFrozen = true + c.checking = false + c.syncObserving() + return c, &c.mu +} + +// initCheckerState initializes the per-checker state of c, including closures +// that must be bound to this checker rather than the store. +func (c *Checker) initCheckerState() { + c.compareSymbols = c.compareSymbolsWorker // Closure optimization + c.compareSymbolChains = c.compareSymbolChainsWorker // Closure optimization + c.evaluate = evaluator.NewEvaluator(c.evaluateEntity, ast.OEKParentheses) + c.resolveName = c.createNameResolver().Resolve + c.resolveNameForSymbolSuggestion = c.createNameResolverForSuggestion().Resolve + c.uniqueLiteralMapper = newFunctionTypeMapper(c.getUniqueLiteralTypeForTypeParameter) + c.reportUnreliableMapper = newFunctionTypeMapper(c.reportUnreliableWorker) + c.reportUnmeasurableMapper = newFunctionTypeMapper(c.reportUnmeasurableWorker) + c.restrictiveMapper = newFunctionTypeMapper(c.restrictiveMapperWorker) + c.permissiveMapper = newFunctionTypeMapper(c.permissiveMapperWorker) c.getGlobalESSymbolType = c.getGlobalTypeResolver("Symbol", 0 /*arity*/, false /*reportErrors*/) c.getGlobalBigIntType = c.getGlobalTypeResolver("BigInt", 0 /*arity*/, false /*reportErrors*/) c.getGlobalImportMetaType = c.getGlobalTypeResolver("ImportMeta", 0 /*arity*/, true /*reportErrors*/) @@ -1187,8 +1252,24 @@ func NewChecker(program Program, tracer *Tracer) (*Checker, *sync.Mutex) { c.getGlobalClassFieldDecoratorContextType = c.getGlobalTypeResolver("ClassFieldDecoratorContext", 2 /*arity*/, true /*reportErrors*/) c.initializeClosures() c.initializeIterationResolvers() - c.initializeChecker() - return c, &c.mu + // Memos are identified by their addresses, so the cells are allocated + // once all resolvers have their IDs. + if c.globalTypes == nil { + c.globalTypes = make([]memo[resolvedGlobal[*Type]], len(c.globalIDs)) + c.globalSymbols = make([]memo[resolvedGlobal[*ast.Symbol]], len(c.globalIDs)) + } + debug.Assert(len(c.globalTypes) == len(c.globalIDs), "a checker sharing a store resolves a global the store has no cell for") +} + +// Clone returns a new checker sharing c's store. The clone observes and +// contributes to the same memoized state, but has its own resolution stacks. +// Checkers sharing a store must not be used concurrently; acquire the store's +// lock (returned by NewChecker) before use. +func (c *Checker) Clone() *Checker { + clone := &Checker{memoStore: c.memoStore, tracer: c.tracer} + clone.initResolutions() + clone.initCheckerState() + return clone } func createFileIndexMap(files []*ast.SourceFile) map[*ast.SourceFile]int { @@ -1223,39 +1304,102 @@ func (c *Checker) reportUnmeasurableWorker(t *Type) *Type { return t } +// globalKey identifies the resolution of a global by name. Resolutions are +// cached in the store, so all checkers share them. +type globalKey struct { + kind globalKind + name string + arity int + reportErrors bool +} + +// globalID is the small integer standing for a globalKey in the store, so +// that resolving a global hashes an integer rather than a name. Resolvers are +// all created as a checker is initialized, so the first checker of a store +// assigns every ID. +type globalID uint32 + +func (c *Checker) getGlobalID(key globalKey) globalID { + if id, ok := c.globalIDs[key]; ok { + return id + } + if c.globalIDs == nil { + c.globalIDs = make(map[globalKey]globalID) + } + id := globalID(len(c.globalIDs)) + c.globalIDs[key] = id + return id +} + +type globalKind uint8 + +const ( + globalKindType globalKind = iota + globalKindTypeAlias + globalKindValueSymbol + globalKindTypeSymbol +) + // Resolve to the global class or interface by the given name and arity, or emptyObjectType/emptyGenericType otherwise func (c *Checker) getGlobalTypeResolver(name string, arity int, reportErrors bool) func() *Type { - return core.Memoize(func() *Type { - return c.getGlobalType(name, arity, reportErrors) - }) + key := c.getGlobalID(globalKey{globalKindType, name, arity, reportErrors}) + return func() *Type { + m := &c.globalTypes[key] + if r := m.cached(c); r.resolved { + return r.value + } + return c.memoCompute(m, func() resolvedGlobal[*Type] { + return resolvedGlobal[*Type]{c.getGlobalType(name, arity, reportErrors), true} + }).value + } +} + +// resolvedGlobal is the result of resolving a global, which may be nil. +type resolvedGlobal[T any] struct { + value T + resolved bool } // Resolve to the global type alias symbol by the given name and arity, or nil otherwise func (c *Checker) getGlobalTypeAliasResolver(name string, arity int, reportErrors bool) func() *ast.Symbol { - return core.Memoize(func() *ast.Symbol { + return c.getGlobalSymbolResolver(globalKey{globalKindTypeAlias, name, arity, reportErrors}, func() *ast.Symbol { return c.getGlobalTypeAliasSymbol(name, arity, reportErrors) }) } // Resolve to the global value symbol by the given name, or nil otherwise func (c *Checker) getGlobalValueSymbolResolver(name string, reportErrors bool) func() *ast.Symbol { - return core.Memoize(func() *ast.Symbol { + return c.getGlobalSymbolResolver(globalKey{globalKindValueSymbol, name, 0, reportErrors}, func() *ast.Symbol { return c.getGlobalSymbol(name, ast.SymbolFlagsValue, core.IfElse(reportErrors, diagnostics.Cannot_find_global_value_0, nil)) }) } func (c *Checker) getGlobalTypeSymbolResolver(name string, reportErrors bool) func() *ast.Symbol { - return core.Memoize(func() *ast.Symbol { + return c.getGlobalSymbolResolver(globalKey{globalKindTypeSymbol, name, 0, reportErrors}, func() *ast.Symbol { return c.getGlobalSymbol(name, ast.SymbolFlagsType, core.IfElse(reportErrors, diagnostics.Cannot_find_global_type_0, nil)) }) } +func (c *Checker) getGlobalSymbolResolver(k globalKey, resolve func() *ast.Symbol) func() *ast.Symbol { + key := c.getGlobalID(k) + return func() *ast.Symbol { + m := &c.globalSymbols[key] + if r := m.cached(c); r.resolved { + return r.value + } + return c.memoCompute(m, func() resolvedGlobal[*ast.Symbol] { + return resolvedGlobal[*ast.Symbol]{resolve(), true} + }).value + } +} + func (c *Checker) getGlobalTypesResolver(names []string, arity int, reportErrors bool) func() []*Type { - return core.Memoize(func() []*Type { - return core.Map(names, func(name string) *Type { - return c.getGlobalType(name, arity, reportErrors) - }) + resolvers := core.Map(names, func(name string) func() *Type { + return c.getGlobalTypeResolver(name, arity, reportErrors) }) + return func() []*Type { + return core.Map(resolvers, func(resolve func() *Type) *Type { return resolve() }) + } } func (c *Checker) getGlobalTypeAliasSymbol(name string, arity int, reportErrors bool) *ast.Symbol { @@ -1265,7 +1409,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) @@ -1279,6 +1423,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 } @@ -1418,10 +1568,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*/) @@ -1604,6 +1754,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 } @@ -1674,7 +1828,7 @@ func (c *Checker) onFailedToResolveSymbol(errorLocation *ast.Node, name string, // 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.addDeferredDiagnostic(func(c *Checker) { c.reportFailedToResolveSymbol(errorLocation, name, meaning, nameNotFoundMessage) }) } @@ -2273,14 +2427,16 @@ func (c *Checker) getTypeOnlyAliasDeclarationEx(symbol *ast.Symbol, meaning ast. func (c *Checker) getImmediateAliasedSymbol(symbol *ast.Symbol) *ast.Symbol { debug.Assert(symbol.Flags()&ast.SymbolFlagsAlias != 0, "Should only get Alias here.") links := c.aliasSymbolLinks.Get(symbol) - if links.immediateTarget == nil { + if links.immediateTarget.cached(c) == nil { node := c.getDeclarationOfAliasSymbol(symbol) if node == nil { panic("Unexpected nil in getImmediateAliasedSymbol") } - links.immediateTarget = c.getTargetOfAliasDeclaration(node, true /*dontRecursivelyResolve*/) + links.immediateTarget.begin(c) + links.immediateTarget.set(c, c.getTargetOfAliasDeclaration(node, true /*dontRecursivelyResolve*/)) + c.endMemo() } - return links.immediateTarget + return links.immediateTarget.cached(c) } func (c *Checker) addTypeOnlyDeclarationRelatedInfo(diagnostic *ast.Diagnostic, typeOnlyDeclaration *ast.Node, name string) *ast.Diagnostic { @@ -2293,7 +2449,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 @@ -2312,6 +2482,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 { @@ -2320,7 +2494,6 @@ func (c *Checker) checkSourceFile(ctx context.Context, sourceFile *ast.SourceFil } // Grammar checking c.checkGrammarSourceFile(sourceFile) - c.renamedBindingElementsInTypes = nil c.checkSourceElements(sourceFile.Statements.Nodes) c.checkDeferredNodes(sourceFile) if ast.IsExternalOrCommonJSModule(sourceFile) { @@ -2328,10 +2501,10 @@ func (c *Checker) checkSourceFile(ctx context.Context, sourceFile *ast.SourceFil c.registerForUnusedIdentifiersCheck(sourceFile.AsNode()) } if !sourceFile.IsDeclarationFile && !c.isCanceled() { - c.checkUnusedRenamedBindingElements() + c.checkUnusedRenamedBindingElements(sourceFile) } + c.checkExternalHelperRequests(sourceFile) c.produceDeferredDiagnostics() - c.reportedUnreachableNodes.Clear() links.typeChecked = true } if checkUnused && !links.unusedChecked { @@ -2358,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 @@ -2508,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.cached(c, container); ok { + return runs + } + return c.unreachableRuns.compute(c, container, func() map[*ast.Node]unreachableRun { + var runs map[*ast.Node]unreachableRun + isUnreachable := func(n *ast.Node) bool { + return ast.IsPotentiallyExecutableNode(n) && c.isSourceElementUnreachable(n) + } + statements := container.Statements() + for i := 0; i < len(statements); i++ { + if !isUnreachable(statements[i]) { + continue + } + first := i + for i+1 < len(statements) && isUnreachable(statements[i+1]) { + i++ + } + run := unreachableRun{statements[first], statements[i]} + if runs == nil { + runs = make(map[*ast.Node]unreachableRun) + } + for _, statement := range statements[first : i+1] { + runs[statement] = run + } + } + return runs + }) } func (c *Checker) isSourceElementUnreachable(node *ast.Node) bool { @@ -2600,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 { @@ -2622,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: @@ -2653,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) { @@ -3082,17 +3267,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) } } } @@ -3131,7 +3315,7 @@ func (c *Checker) checkTypeReferenceOrImport(node *ast.Node) { c.checkTypeArgumentConstraints(node, typeParameters) } } - symbol := c.getResolvedSymbolOrNil(node) + symbol := c.getSymbolOfTypeNode(node) if symbol != nil { if core.Some(symbol.Declarations(), func(d *ast.Node) bool { return ast.IsTypeDeclaration(d) && c.IsDeprecatedDeclaration(d) }) { c.addDeprecatedSuggestion(c.getDeprecatedSuggestionNode(node), symbol.Declarations(), symbol.Name()) @@ -3255,12 +3439,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*/) @@ -3400,7 +3584,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) { @@ -3422,9 +3606,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} }) { @@ -3434,7 +3616,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) } @@ -3485,7 +3667,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) { @@ -3497,7 +3679,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) @@ -3566,10 +3748,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) { @@ -3944,7 +4123,7 @@ func (c *Checker) checkTestingKnownTruthyType(condExpr *ast.Node, condType *Type if location != condExpr { t = c.checkExpression(location) } - if t.flags&TypeFlagsEnumLiteral != 0 && ast.IsPropertyAccessExpression(location) && core.OrElse(c.getResolvedSymbolOrNil(location.Expression()), c.unknownSymbol).Flags()&ast.SymbolFlagsEnum != 0 { + if t.flags&TypeFlagsEnumLiteral != 0 && ast.IsPropertyAccessExpression(location) && core.OrElse(c.symbolOfCheckedExpression(location.Expression()), c.unknownSymbol).Flags()&ast.SymbolFlagsEnum != 0 { // EnumLiteral type at condition with known value is always truthy or always falsy, likely an error c.error(location, diagnostics.This_condition_will_always_return_0, core.IfElse(evaluator.IsTruthy(t.AsLiteralType().value), "true", "false")) return @@ -4537,9 +4716,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 @@ -4552,7 +4729,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 { @@ -4638,8 +4815,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: @@ -5049,10 +5226,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) { @@ -5156,8 +5332,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) @@ -5168,7 +5343,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) { @@ -5243,8 +5419,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) @@ -5274,7 +5449,7 @@ func (c *Checker) checkEnumDeclaration(node *ast.Node) { } } } - } + }) } func (c *Checker) checkEnumMember(node *ast.Node) { @@ -5407,9 +5582,10 @@ func (c *Checker) getTypeOfModuleDeclarationImportAttributes(attributes *ast.Typ } func (c *Checker) getTypeOfModuleImportAttributes(symbol *ast.Symbol) *Type { - if t, ok := c.moduleImportAttributesTypes[symbol]; ok { + if t, ok := c.moduleImportAttributesTypes.cached(c, symbol); ok { return t } + c.moduleImportAttributesTypes.begin(c, symbol) var result *Type moduleDecl := core.Find(symbol.Declarations(), ast.IsModuleWithStringLiteralName) if moduleDecl == nil { @@ -5417,7 +5593,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 } @@ -5651,19 +5828,19 @@ func (c *Checker) getTypeFromImportAttributes(node *ast.Node) *Type { func (c *Checker) checkImportAttributesExpression(node *ast.Node) *Type { links := c.typeNodeLinks.Get(node) - if links.resolvedType == nil { + if links.resolvedType.cached(c) == nil { symbol := c.newSymbol(ast.SymbolFlagsObjectLiteral, ast.InternalSymbolNameImportAttributes) members := ast.NewSymbolTable() for _, attribute := range node.AsImportAttributes().Attributes.Nodes { member := c.newSymbol(ast.SymbolFlagsProperty, attribute.Name().Text()) - c.valueSymbolLinks.Get(member).resolvedType = c.getRegularTypeOfLiteralType(c.checkExpressionCached(attribute.AsImportAttribute().Value)) + c.valueSymbolLinks.Get(member).resolvedType.setIdentity(c, c.getRegularTypeOfLiteralType(c.checkExpressionCached(attribute.AsImportAttribute().Value))) members.Set(member.Name(), member) } t := c.newAnonymousType(symbol, members, nil, nil, nil) t.objectFlags |= ObjectFlagsObjectLiteral | ObjectFlagsNonInferrableType - links.resolvedType = t + links.resolvedType.set(c, t) } - return links.resolvedType + return links.resolvedType.cached(c) } func (c *Checker) getImportAttributesTypeForModuleSpecifier(moduleSpecifier *ast.Node) *Type { @@ -5930,8 +6107,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. @@ -5969,8 +6145,7 @@ func (c *Checker) checkExternalModuleExports(node *ast.Node) { } } } - links.exportsChecked = true - } + }) } func (c *Checker) hasExportedMembersOfKind(moduleSymbol *ast.Symbol, kind ast.SymbolFlags) bool { @@ -6058,7 +6233,10 @@ func (c *Checker) checkVariableLikeDeclaration(node *ast.Node) { // ^^^^^^ // variable renaming in function type notation is confusing, // so we forbid it even if noUnusedLocals is not enabled - c.renamedBindingElementsInTypes = append(c.renamedBindingElementsInTypes, node) + c.sourceFileLinks.Get(ast.GetSourceFileOfNode(node)).renamedBindingElements.Add(node) + if !c.checking { + return + } // Still resolve the type like the end of this function does for every other declaration, // so implicit any errors are reported by checking instead of by whatever asks for the type later c.getTypeOfSymbol(c.getSymbolOfDeclaration(node)) @@ -6323,11 +6501,11 @@ func (c *Checker) checkDecorator(node *ast.Node) { } // if we fail to get a signature and return type here, we will have already reported a grammar error in `checkDecorators`. decoratorSignature := c.getDecoratorCallSignature(node) - if decoratorSignature == nil || decoratorSignature.resolvedReturnType == nil { + if decoratorSignature == nil { return } var headMessage *diagnostics.Message - expectedReturnType := decoratorSignature.resolvedReturnType + expectedReturnType := c.getReturnTypeOfSignature(decoratorSignature) switch node.Parent.Kind { case ast.KindClassDeclaration, ast.KindClassExpression: headMessage = diagnostics.Decorator_function_return_type_0_is_not_assignable_to_type_1 @@ -6522,20 +6700,24 @@ func (c *Checker) getIterationTypesOfIterable(t *Type, use IterationUse, errorNo if IsTypeAny(t) { return IterationTypes{c.anyType, c.anyType, c.anyType} } - key := IterationTypesKey{typeId: t.id, use: use & IterationUseCacheFlags} - // If we are reporting errors and encounter a cached `noIterationTypes`, we should ignore the cached value and continue as if nothing was cached. - // In addition, we should not cache any new results for this call. - noCache := false - if cached, ok := c.iterationTypesCache[key]; ok { - if errorNode == nil || cached.hasTypes() { - return cached - } - noCache = true + if errorNode != nil { + // Errors belong to errorNode, so compute them here rather than + // cache them with the types every other use of t shares. + return c.getIterationTypesOfIterableWorker(t, use, errorNode) } - result := c.getIterationTypesOfIterableWorker(t, use, errorNode) - if !noCache { - c.iterationTypesCache[key] = result + key := IterationTypesKey{typeId: t.id, use: use & IterationUseCacheFlags} + c.iterationTypesCache.begin(c, key) + result := c.getIterationTypesOfIterableCached(t, use, key) + c.endMemo() + return result +} + +func (c *Checker) getIterationTypesOfIterableCached(t *Type, use IterationUse, key IterationTypesKey) IterationTypes { + if cached, ok := c.iterationTypesCache.cached(c, key); ok { + return cached } + result := c.getIterationTypesOfIterableWorker(t, use, nil /*errorNode*/) + c.iterationTypesCache.set(c, key, result) return result } @@ -6546,7 +6728,7 @@ func (c *Checker) getIterationTypesOfIterableWorker(t *Type, use IterationUse, e iterationTypes := c.getIterationTypesOfIterableWorker(constituent, use, nil) if !iterationTypes.hasTypes() { if errorNode != nil { - c.addDeferredDiagnostic(func() { + c.addDeferredDiagnostic(func(c *Checker) { c.reportTypeNotIterableError(errorNode, t, use&IterationUseAllowsAsyncIterablesFlag != 0) }) } @@ -6599,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) @@ -7176,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 @@ -7294,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) @@ -7567,8 +7757,8 @@ func (c *Checker) isUnreferencedTypeParameter(typeParameter *ast.Node) bool { return c.symbolReferenceLinks.Get(c.getMergedSymbol(typeParameter.Symbol())).referenceKinds&ast.SymbolFlagsTypeParameter == 0 && !isIdentifierThatStartsWithUnderscore(typeParameter.Name()) } -func (c *Checker) checkUnusedRenamedBindingElements() { - for _, node := range c.renamedBindingElementsInTypes { +func (c *Checker) checkUnusedRenamedBindingElements(sourceFile *ast.SourceFile) { + for node := range c.sourceFileLinks.Get(sourceFile).renamedBindingElements.Values() { if c.symbolReferenceLinks.Get(c.getSymbolOfDeclaration(node)).referenceKinds == 0 { wrappingDeclaration := ast.WalkUpBindingElementsAndPatterns(node) debug.Assert(ast.IsPartOfParameterDeclaration(wrappingDeclaration), "Only parameter declaration should be checked here") @@ -7596,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.cached(c, node); ok { + return t + } + c.flowExpressionTypes.begin(c, node) + startInvocationCount := c.flowInvocationCount + t := c.checkExpressionEx(node, CheckModeTypeOnly) + // If control flow analysis was required to determine the type, it is worth caching. + if c.flowInvocationCount != startInvocationCount { + c.flowExpressionTypes.set(c, node, t) + c.endMemo() + } else { + c.endMemoUncached() + } + return t + } + // Within loop analysis, the type may depend on the transient types of the + // loop, so it is only cached until the analysis of the loop is restarted. + key := memoKeyOf(node, memoFlowExpressionType) if cachedType := c.flowTypeCache[node]; cachedType != nil { + if c.memoActive() { + c.observeMemo(key) + } return cachedType } + c.beginMemo(key) startInvocationCount := c.flowInvocationCount t := c.checkExpressionEx(node, CheckModeTypeOnly) - // If control flow analysis was required to determine the type, it is worth caching. if c.flowInvocationCount != startInvocationCount { if c.flowTypeCache == nil { c.flowTypeCache = make(map[*ast.Node]*Type) } c.flowTypeCache[node] = t + c.endMemo() + } else { + c.endMemoUncached() } return t } @@ -7775,7 +7991,21 @@ func (c *Checker) checkExpressionCachedEx(node *ast.Node, checkMode CheckMode) * return c.checkExpressionEx(node, checkMode) } links := c.typeNodeLinks.Get(node) - if links.resolvedType == nil { + if t := links.resolvedType.cached(c); t != nil { + return t + } + links.resolvedType.begin(c) + result := c.checkExpressionCachedExUncached(node, checkMode) + c.endMemo() + return result +} + +func (c *Checker) checkExpressionCachedExUncached(node *ast.Node, checkMode CheckMode) *Type { + if checkMode != CheckModeNormal { + return c.checkExpressionEx(node, checkMode) + } + links := c.typeNodeLinks.Get(node) + if links.resolvedType.cached(c) == nil { // When computing a type that we're going to cache, we need to ignore any ongoing control flow // analysis because variables may have transient types in indeterminable states. Moving flowLoopStart // to the top of the stack ensures all transient types are computed from a known point. @@ -7783,11 +8013,11 @@ func (c *Checker) checkExpressionCachedEx(node *ast.Node, checkMode CheckMode) * saveFlowTypeCache := c.flowTypeCache c.flowLoopStack = nil c.flowTypeCache = nil - links.resolvedType = c.checkExpressionEx(node, checkMode) + links.resolvedType.set(c, c.checkExpressionEx(node, checkMode)) c.flowTypeCache = saveFlowTypeCache c.flowLoopStack = saveFlowLoopStack } - return links.resolvedType + return links.resolvedType.cached(c) } // Returns the type of an expression. Unlike checkExpression, this function is simply concerned @@ -7796,12 +8026,14 @@ func (c *Checker) checkExpressionCachedEx(node *ast.Node, checkMode CheckMode) * // and requesting the contextual type might cause a circularity or other bad behaviour. // It sets the contextual type of the node to any before calling getTypeOfExpression. func (c *Checker) getContextFreeTypeOfExpression(node *ast.Node) *Type { - if cached := c.contextFreeTypes[node]; cached != nil { + if cached, _ := c.contextFreeTypes.cached(c, node); cached != nil { return cached } + c.contextFreeTypes.begin(c, node) c.pushContextualType(node, c.anyType, false /*isCache*/) t := c.checkExpressionEx(node, CheckModeSkipContextSensitive) - c.contextFreeTypes[node] = t + c.contextFreeTypes.set(c, node, t) + c.endMemo() c.popContextualType() return t } @@ -7814,15 +8046,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 } @@ -8101,10 +8337,10 @@ func (c *Checker) checkPrivateIdentifierExpression(node *ast.Node) *Type { func (c *Checker) getSymbolForPrivateIdentifierExpression(node *ast.Node) *ast.Symbol { links := c.symbolNodeLinks.Get(node) - if links.resolvedSymbol == nil { - links.resolvedSymbol = c.lookupSymbolForPrivateIdentifierDeclaration(node.Text(), node) + if links.resolvedSymbol.cached(c) == nil { + links.resolvedSymbol.set(c, c.lookupSymbolForPrivateIdentifierDeclaration(node.Text(), node)) } - return links.resolvedSymbol + return links.resolvedSymbol.cached(c) } func (c *Checker) checkSuperExpression(node *ast.Node) *Type { @@ -8266,11 +8502,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 } @@ -8283,7 +8517,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 { @@ -8361,12 +8595,12 @@ func (c *Checker) createArrayLiteralType(t *Type) *Type { return t } key := CachedTypeKey{kind: CachedTypeKindArrayLiteralType, typeId: t.id} - if cached, ok := c.cachedTypes[key]; ok { + if cached, ok := c.cachedTypes.cached(c, key); ok { return cached } literalType := c.cloneTypeReference(t) literalType.objectFlags |= ObjectFlagsArrayLiteral | ObjectFlagsContainsObjectOrArrayLiteral - c.cachedTypes[key] = literalType + c.cachedTypes.intern(key, literalType) return literalType } @@ -8427,7 +8661,7 @@ func (c *Checker) checkElementAccessExpression(node *ast.Node, exprType *Type, c core.IfElse(c.isGenericObjectType(objectType) && !isThisTypeParameter(objectType), AccessFlagsNoIndexSignatures, 0) } indexedAccessType := core.OrElse(c.getIndexedAccessTypeOrUndefined(objectType, effectiveIndexType, accessFlags, node, nil), c.errorType) - return c.checkIndexedAccessIndexType(c.getFlowTypeOfAccessExpression(node, c.getResolvedSymbolOrNil(node), indexedAccessType, indexExpression, checkMode), node) + return c.checkIndexedAccessIndexType(c.getFlowTypeOfAccessExpression(node, c.symbolOfCheckedExpression(node), indexedAccessType, indexExpression, checkMode), node) } // Return true if given node is an expression consisting of an identifier (possibly parenthesized) @@ -8745,20 +8979,29 @@ func (c *Checker) getResolvedSignature(node *ast.Node, candidatesOutArray *[]*Si // 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 := c.currentNode - c.currentNode = node - result := c.resolveSignatureOfCall(node, candidatesOutArray, checkMode) - c.currentNode = saveCurrentNode + saveCurrentNode, shared := c.enterSharedCurrentNode(node) + if !shared { + saveCurrentNode = c.enterCurrentNode(node) + } + c.signatureLinks.Get(node).resolvedSignature.begin(c) + result := c.getResolvedSignatureUncached(node, candidatesOutArray, checkMode) + c.endMemo() + if !c.exitSharedCurrentNode(saveCurrentNode) { + c.exitCurrentNode(saveCurrentNode) + } return result } -func (c *Checker) resolveSignatureOfCall(node *ast.Node, candidatesOutArray *[]*Signature, checkMode CheckMode) *Signature { +func (c *Checker) getResolvedSignatureUncached(node *ast.Node, candidatesOutArray *[]*Signature, checkMode CheckMode) *Signature { links := c.signatureLinks.Get(node) // If getResolvedSignature has already been called, we will have cached the resolvedSignature. // However, it is possible that either candidatesOutArray was not passed in the first time, // or that a different candidatesOutArray was passed in. Therefore, we need to redo the work // to correctly fill the candidatesOutArray. - cached := links.resolvedSignature + cached := links.resolvedSignature.cached(c) + if cached == c.resolvingSignature && c.isSignatureResolutionHidden(links) { + cached = nil + } if cached != nil && cached != c.resolvingSignature && candidatesOutArray == nil { return cached } @@ -8771,7 +9014,10 @@ func (c *Checker) resolveSignatureOfCall(node *ast.Node, candidatesOutArray *[]* if (ast.IsCallExpression(node) || ast.IsNewExpression(node) || ast.IsTaggedTemplateExpression(node) || ast.IsJsxOpeningLikeElement(node)) && isContextuallyTypedByEnclosingCall(node) { c.getContextualType(node, ContextFlagsNone) } - cached = links.resolvedSignature + cached = links.resolvedSignature.cached(c) + if cached == c.resolvingSignature && c.isSignatureResolutionHidden(links) { + cached = nil + } if cached != nil && cached != c.resolvingSignature && candidatesOutArray == nil { return cached } @@ -8784,34 +9030,65 @@ func (c *Checker) resolveSignatureOfCall(node *ast.Node, candidatesOutArray *[]* // through resolution of the containing function call. By resetting the resolution stack we'll // retry the symbol type resolution with the resolvingSignature marker in place to suppress // the contextual type circularity. - c.resolutionStart = len(c.typeResolutions) + c.resolutionStart = len(c.resolutions) } - links.resolvedSignature = c.resolvingSignature + links.resolvedSignature.swap(c.resolvingSignature) + c.signaturesResolving = append(c.signaturesResolving, links) result := c.resolveSignature(node, candidatesOutArray, checkMode) + c.signaturesResolving = c.signaturesResolving[:len(c.signaturesResolving)-1] c.resolutionStart = saveResolutionStart // When CheckMode.SkipGenericFunctions is set we use resolvingSignature to indicate that call - // resolution should be deferred. - if result != c.resolvingSignature { + // resolution should be deferred. The call is then left as it was, unless a resolution of it + // re-entering this one resolved it. + if result == c.resolvingSignature { + if links.resolvedSignature.cached(c) == c.resolvingSignature { + links.resolvedSignature.swap(cached) + } + } else { // if the signature resolution originated on a node that itself depends on the contextual type // then it's possible that the resolved signature might not be the same as the one that would be computed in source order // since resolving such signature leads to resolving the potential outer signature, its arguments and thus the very same signature // it's possible that this inner resolution sets the resolvedSignature first. // In such a case we ignore the local result and reuse the correct one that was cached. - if links.resolvedSignature != c.resolvingSignature { - result = links.resolvedSignature + if links.resolvedSignature.cached(c) != c.resolvingSignature { + result = links.resolvedSignature.cached(c) } // If signature resolution originated in control flow type analysis (for example to compute the // assigned type in a flow assignment) we don't cache the result as it may be based on temporary // types from the control flow analysis. if len(c.flowLoopStack) == 0 { - links.resolvedSignature = result + c.setResolvedSignature(links, result) } else { - links.resolvedSignature = cached + links.resolvedSignature.swap(cached) } } return result } +// setResolvedSignature caches the signature a call resolves to, in place of +// the marker of its resolution, which is only restored while the resolution +// is still in progress. +func (c *Checker) setResolvedSignature(links *SignatureLinks, signature *Signature) { + setAfterMarker(c, &links.resolvedSignature, signature, links, isStaleSignatureMarker) +} + +func isStaleSignatureMarker(c *Checker, links *SignatureLinks, s *Signature) bool { + return s == c.resolvingSignature && !slices.Contains(c.signaturesResolving, links) +} + +// isSignatureResolutionVisible reports whether the resolution of the call with +// the given links is in progress, other than hidden by a cycle yield. +func (c *Checker) isSignatureResolutionVisible(links *SignatureLinks) bool { + return slices.Contains(c.signaturesResolving[c.visibleSignatures:], links) +} + +// isSignatureResolutionHidden reports whether the resolution of the call +// with the given links is in progress below what is visible; see yieldCycle. +func (c *Checker) isSignatureResolutionHidden(links *SignatureLinks) bool { + i := slices.Index(c.signaturesResolving[c.visibleSignatures:], links) + return i < 0 && c.visibleSignatures > 0 && slices.Contains(c.signaturesResolving[:c.visibleSignatures], links) +} + func (c *Checker) resolveSignature(node *ast.Node, candidatesOutArray *[]*Signature, checkMode CheckMode) *Signature { switch node.Kind { case ast.KindCallExpression: @@ -9293,15 +9570,18 @@ func (c *Checker) resolveCall(node *ast.Node, signatures []*Signature, candidate // is just important for choosing the best signature. So in the case where there is only one // signature, the subtype pass is useless. So skipping it is an optimization. var result *Signature - s.recursiveResolution = slices.Contains(c.callResolutionStack, s.node) - c.callResolutionStack = append(c.callResolutionStack, s.node) + if i := c.resolvingAnywhereIndex(s.node, TypeSystemPropertyNameCallResolution); i >= 0 && !c.yieldCycle(i) { + c.markTypeResolutionCircular(i) + s.recursiveResolution = true + } + c.beginTypeResolution(s.node, TypeSystemPropertyNameCallResolution, nil) if len(s.candidates) > 1 { result = c.chooseOverload(&s, c.subtypeRelation) } if result == nil { result = c.chooseOverload(&s, c.assignableRelation) } - c.callResolutionStack = c.callResolutionStack[:len(c.callResolutionStack)-1] + c.popTypeResolution() if result != nil { return result } @@ -9313,7 +9593,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, @@ -9389,12 +9669,14 @@ func (c *Checker) getOptionalCallSignature(signature *Signature, callChainFlags return signature } key := CachedSignatureKey{sig: signature, key: core.IfElse(callChainFlags == SignatureFlagsIsInnerCallChain, SignatureKeyInner, SignatureKeyOuter)} - if cached := c.cachedSignatures[key]; cached != nil { + if cached, _ := c.cachedSignatures.cached(c, key); cached != nil { return cached } + c.cachedSignatures.begin(c, key) result := c.cloneSignature(signature) result.flags |= callChainFlags - c.cachedSignatures[key] = result + c.cachedSignatures.set(c, key, result) + c.endMemo() return result } @@ -10362,7 +10644,7 @@ func (c *Checker) invocationErrorDetails(errorTarget *ast.Node, apparentType *Ty headMessage := core.IfElse(isCall, diagnostics.This_expression_is_not_callable, diagnostics.This_expression_is_not_constructable) // Diagnose get accessors incorrectly called as functions if ast.IsCallExpression(errorTarget.Parent) && len(errorTarget.Parent.Arguments()) == 0 { - resolvedSymbol := c.getResolvedSymbolOrNil(errorTarget) + resolvedSymbol := c.symbolOfCheckedExpression(errorTarget) if resolvedSymbol != nil && resolvedSymbol.Flags()&ast.SymbolFlagsGetAccessor != 0 { headMessage = diagnostics.This_expression_is_not_callable_because_it_is_a_get_accessor_Did_you_mean_to_use_it_without } @@ -10507,14 +10789,16 @@ func (c *Checker) checkFunctionExpressionOrObjectLiteralMethod(node *ast.Node, c // Return plain anyFunctionType if there is no possibility we'll make inferences from the return type contextualSignature := c.getContextualSignature(node) if contextualSignature != nil && c.couldContainTypeVariables(c.getReturnTypeOfSignature(contextualSignature)) { - if cached, ok := c.contextFreeTypes[node]; ok { + if cached, ok := c.contextFreeTypes.cached(c, node); ok { return cached } + c.contextFreeTypes.begin(c, node) returnType := c.getReturnTypeFromBody(node, checkMode) returnOnlySignature := c.newSignature(SignatureFlagsIsNonInferrable, nil, nil /*typeParameters*/, nil /*thisParameter*/, nil, returnType, nil /*resolvedTypePredicate*/, 0) returnOnlyType := c.newAnonymousType(node.Symbol(), nil, []*Signature{returnOnlySignature}, nil, nil) returnOnlyType.objectFlags |= ObjectFlagsNonInferrableType - c.contextFreeTypes[node] = returnOnlyType + c.contextFreeTypes.set(c, node, returnOnlyType) + c.endMemo() return returnOnlyType } } @@ -10536,19 +10820,38 @@ func (c *Checker) checkFunctionExpressionOrObjectLiteralMethod(node *ast.Node, c func (c *Checker) contextuallyCheckFunctionExpressionOrObjectLiteralMethod(node *ast.Node, checkMode CheckMode) { c.assignContextualParameterTypesOfFunction(node, checkMode) + key := memoKeyOf(node, memoContextChecked) + // A check in progress below a cycle yield is hidden, so the function is + // checked again as if it were not, as computing from scratch would. + i, ok := c.resolving.get(key) + hidden := ok && int(i) < c.visibleStart + c.beginMemo(key) + c.contextuallyCheckFunctionExpressionOrObjectLiteralMethodUncached(node, checkMode, hidden) + c.endMemo() +} + +func (c *Checker) contextuallyCheckFunctionExpressionOrObjectLiteralMethodUncached(node *ast.Node, checkMode CheckMode, hidden bool) { links := c.nodeLinks.Get(node) - if links.flags&NodeCheckFlagsContextChecked == 0 || links.flags&NodeCheckFlagsSignatureContextChecked != 0 { + if links.flags&NodeCheckFlagsContextChecked == 0 || links.flags&NodeCheckFlagsSignatureContextChecked != 0 && !hidden { return } - links.flags |= NodeCheckFlagsSignatureContextChecked + setFlagMemoBits(c, memoKeyOf(node, memoContextChecked), &links.flags, NodeCheckFlagsSignatureContextChecked, NodeCheckFlagsSignatureContextChecked) signature := c.getSignatureFromDeclarationUncontextual(node) contextualSignature := c.getContextualSignature(node) - if contextualSignature != nil && c.getReturnTypeFromAnnotation(node) == nil && signature.resolvedReturnType == nil { + // 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 && checkMode&^CheckModeTypeOnly == CheckModeNormal && c.getReturnTypeFromAnnotation(node) == nil && !c.isResolvingReturnTypeOfSignature(signature) { + c.getReturnTypeOfSignature(signature) + } else if contextualSignature != nil && c.getReturnTypeFromAnnotation(node) == nil && signature.resolvedReturnType.cached(c) == nil && !c.isResolvingReturnTypeOfSignature(signature) && c.pushTypeResolution(signature, TypeSystemPropertyNameResolvedReturnType, 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 + if !c.popTypeResolution() { + returnType = c.circularReturnType(signature) + } + if signature.resolvedReturnType.cached(c) == nil { + signature.resolvedReturnType.set(c, returnType) } } c.checkSignatureDeclaration(node) @@ -10560,6 +10863,12 @@ func (c *Checker) contextuallyCheckFunctionExpressionOrObjectLiteralMethod(node // 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) if links.flags&NodeCheckFlagsContextChecked == 0 { contextualSignature := c.getContextualSignature(node) @@ -10567,8 +10876,12 @@ func (c *Checker) assignContextualParameterTypesOfFunction(node *ast.Node, check // 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 + // The flag guards against assigning the parameter types again + // from within the assignment, so it is set now. + flagLogged := c.logResults() + setFlagMemoBits(c, memoKeyOf(node, memoContextualParameters), &links.flags, NodeCheckFlagsContextChecked, NodeCheckFlagsContextChecked) signature := c.getSignatureFromDeclarationUncontextual(node) + c.beginTypeResolution(node, TypeSystemPropertyNameContextChecked, nil) if c.isContextSensitive(node) { if contextualSignature != nil { inferenceContext := c.getInferenceContext(node) @@ -10598,8 +10911,17 @@ func (c *Checker) assignContextualParameterTypesOfFunction(node *ast.Node, check c.inferFromAnnotatedParametersAndReturn(signature, contextualSignature, inferenceContext) } } + c.popTypeResolution() + if !flagLogged && c.logResults() { + // A cycle detected since the flag was set discards the + // parameter types assigned since. The flag is discarded with + // them, so that they are assigned again. + c.logMemoDiscard(nil, memoKeyOf(node, memoContextualParameters), func() { links.flags &^= NodeCheckFlagsContextChecked }) + } + return } } + c.observeResolutionInProgress(node, TypeSystemPropertyNameContextChecked) } func (c *Checker) checkFunctionExpressionOrObjectLiteralMethodDeferred(node *ast.Node) { @@ -10754,6 +11076,9 @@ func (c *Checker) assignContextualParameterTypes(sig *Signature, context *Signat // This signature has already has a contextual inference performed and cached on it return } + if c.logResults() { + c.logRestore(func() { sig.setTypeParameters(c, nil) }) + } sig.setTypeParameters(c, context.TypeParameters()) } if context.ThisParameter() != nil { @@ -10847,7 +11172,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.cached(c) != nil { return } declaration := parameter.ValueDeclaration() @@ -10859,13 +11184,13 @@ func (c *Checker) assignParameterType(parameter *ast.Symbol, contextualType *Typ t = c.getTypeOfSymbol(parameter) } } - links.resolvedType = c.addOptionalityEx(t, false, declaration != nil && declaration.Initializer() == nil && isOptionalDeclaration(declaration)) + links.resolvedType.set(c, c.addOptionalityEx(t, false, declaration != nil && declaration.Initializer() == nil && isOptionalDeclaration(declaration))) if declaration != nil && !ast.IsIdentifier(declaration.Name()) { // if inference didn't come up with anything but unknown, fall back to the binding pattern if present. - if links.resolvedType == c.unknownType { - links.resolvedType = c.getTypeFromBindingPattern(declaration.Name(), false, false) + if links.resolvedType.cached(c) == c.unknownType { + links.resolvedType.set(c, c.getTypeFromBindingPattern(declaration.Name(), false, false)) } - c.assignBindingElementTypes(declaration.Name(), links.resolvedType) + c.assignBindingElementTypes(declaration.Name(), links.resolvedType.cached(c)) } } @@ -10877,7 +11202,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) } @@ -10983,7 +11308,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) }) } @@ -11017,7 +11342,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) }) } @@ -11107,9 +11432,26 @@ func (c *Checker) getInstantiationExpressionType(exprType *Type, node *ast.Node) return exprType } key := InstantiationExpressionKey{nodeId: ast.GetNodeId(node), typeId: exprType.id} - if cached := c.instantiationExpressionTypes[key]; cached != nil { - return cached - } + entry, _ := c.instantiationExpressionTypes.get(key) + if entry == nil { + entry = &instantiationExpressionEntry{} + c.instantiationExpressionTypes.intern(key, entry) + } + if entry.t != nil { + c.observeFlagMemo(memoKeyOf(entry, memoInstantiationExpressionType)) + return entry.t + } + c.beginMemo(memoKeyOf(entry, memoInstantiationExpressionType)) + result := c.getInstantiationExpressionTypeUncached(exprType, node, typeArguments, entry) + c.endMemo() + return result +} + +type instantiationExpressionEntry struct { + t *Type +} + +func (c *Checker) getInstantiationExpressionTypeUncached(exprType *Type, node *ast.Node, typeArguments *ast.NodeList, entry *instantiationExpressionEntry) *Type { hasSomeApplicableSignature := false var nonApplicableType *Type getInstantiatedSignatures := func(signatures []*Signature) []*Signature { @@ -11122,7 +11464,7 @@ func (c *Checker) getInstantiationExpressionType(exprType *Type, node *ast.Node) // checked once the types they need are resolved: checking them // can need the variances of a type whose members include this // expression. - c.addDeferredDiagnostic(func() { + c.addDeferredDiagnostic(func(c *Checker) { c.checkTypeArguments(sig, typeArguments.Nodes, true /*reportErrors*/, nil) }) return c.getSignatureInstantiation(sig, core.Map(typeArguments.Nodes, c.getTypeFromTypeNode), ast.IsInJSFile(sig.declaration), nil) @@ -11145,7 +11487,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 } @@ -11174,7 +11516,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 @@ -11264,7 +11606,7 @@ func (c *Checker) checkDeleteExpression(node *ast.Node) *Type { if ast.IsPropertyAccessExpression(expr) && ast.IsPrivateIdentifier(expr.Name()) { c.error(expr, diagnostics.The_operand_of_a_delete_operator_cannot_be_a_private_identifier) } - symbol := c.getExportSymbolOfValueSymbolIfExported(c.getResolvedSymbolOrNil(expr)) + symbol := c.getExportSymbolOfValueSymbolIfExported(c.symbolOfCheckedExpression(expr)) if symbol != nil { if c.isReadonlySymbol(symbol) { c.error(expr, diagnostics.The_operand_of_a_delete_operator_cannot_be_a_read_only_property) @@ -11670,9 +12012,16 @@ func (c *Checker) removeOptionalityFromDeclaredType(declaredType *Type, declarat } func (c *Checker) parameterInitializerContainsUndefined(declaration *ast.Node) bool { + c.beginMemo(memoKeyOf(declaration, memoInitializerIsUndefined)) + result := c.parameterInitializerContainsUndefinedUncached(declaration) + c.endMemo() + return result +} + +func (c *Checker) parameterInitializerContainsUndefinedUncached(declaration *ast.Node) bool { links := c.nodeLinks.Get(declaration) if links.flags&NodeCheckFlagsInitializerIsUndefinedComputed == 0 { - if !c.pushTypeResolution(declaration, TypeSystemPropertyNameInitializerIsUndefined) { + if !c.pushTypeResolution(declaration, TypeSystemPropertyNameInitializerIsUndefined, nil) { c.reportCircularityError(declaration.Symbol()) return true } @@ -11682,7 +12031,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 @@ -11709,7 +12058,7 @@ func (c *Checker) checkPropertyAccessChain(node *ast.Node, checkMode CheckMode) } func (c *Checker) checkPropertyAccessExpressionOrQualifiedName(node *ast.Node, left *ast.Node, leftType *Type, right *ast.Node, checkMode CheckMode, writeOnly bool) *Type { - parentSymbol := c.getResolvedSymbolOrNil(left) + parentSymbol := c.symbolOfCheckedExpression(left) assignmentKind := getAssignmentTargetKind(node) widenedType := leftType if assignmentKind != AssignmentKindNone || c.isMethodAccessForCall(node) { @@ -11797,7 +12146,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) }) @@ -11824,7 +12173,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()) @@ -11982,19 +12331,30 @@ 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 } + // Building the diagnostic prints types and looks up suggestions, which + // can reach computations in progress, so it waits for the end of the + // check in progress, outside the computations reporting it, whether + // checking or a query reached it. + c.addDeferredDiagnostic(func(c *Checker) { + diagnostic := c.getNonexistentPropertyDiagnostic(propNode, containingType, isUncheckedJS) + c.addErrorOrSuggestion(!isUncheckedJS || diagnostic.Code() != diagnostics.Property_0_may_not_exist_on_type_1_Did_you_mean_2.Code(), diagnostic) + }) +} + +func (c *Checker) getNonexistentPropertyDiagnostic(propNode *ast.Node, containingType *Type, isUncheckedJS bool) *ast.Diagnostic { var diagnostic *ast.Diagnostic if !ast.IsPrivateIdentifier(propNode) && containingType.flags&TypeFlagsUnion != 0 && containingType.flags&TypeFlagsPrimitive == 0 { for _, subtype := range containingType.Types() { @@ -12041,7 +12401,7 @@ func (c *Checker) reportNonexistentProperty(propNode *ast.Node, containingType * } } } - c.addErrorOrSuggestion(!isUncheckedJS || diagnostic.Code() != diagnostics.Property_0_may_not_exist_on_type_1_Did_you_mean_2.Code(), diagnostic) + return diagnostic } func (c *Checker) getSuggestedLibForNonExistentProperty(missingProperty string, containingType *Type) string { @@ -12755,7 +13115,7 @@ func (c *Checker) checkAssertion(node *ast.Node, checkMode CheckMode) *Type { var exprType *Type if isConst { exprType = c.checkExpressionEx(node.Expression(), checkMode) - } else if c.resolvingAssertionOperands.AddIfAbsent(node) { + } 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 @@ -12765,10 +13125,11 @@ func (c *Checker) checkAssertion(node *ast.Node, checkMode CheckMode) *Type { // assertion is re-entered when the operand's flow type depends on // a call containing it within a loop; the enclosing computation // then provides the cached type. + c.beginTypeResolution(node, TypeSystemPropertyNameAssertionOperand, nil) c.pushInferenceContext(node.Expression(), nil) c.checkExpressionCached(node.Expression()) c.popInferenceContext() - c.resolvingAssertionOperands.Delete(node) + 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 @@ -13238,7 +13599,7 @@ func (c *Checker) checkAssignmentOperator(left *ast.Node, operator ast.Kind, rig if ast.IsAssignmentOperator(operator) { // We ignore assignments of undefined to CommonJS exports when there are multiple assignment declarations if ast.IsDeclarationNode(left.Parent) && ast.GetAssignmentDeclarationKind(left.Parent) == ast.JSDeclarationKindExportsProperty { - if symbol := c.symbolNodeLinks.Get(left).resolvedSymbol; symbol != nil && len(symbol.Declarations()) > 1 && rightType.flags&TypeFlagsUndefined != 0 { + if symbol := c.symbolOfCheckedExpression(left); symbol != nil && len(symbol.Declarations()) > 1 && rightType.flags&TypeFlagsUndefined != 0 { return } } @@ -13566,7 +13927,7 @@ func (c *Checker) checkInExpression(left *ast.Expression, right *ast.Expression, } // Unlike in 'checkPrivateIdentifierExpression' we now have access to the RHS type // which provides us with the opportunity to emit more detailed errors - if c.symbolNodeLinks.Get(left).resolvedSymbol == nil && ast.GetContainingClass(left) != nil { + if c.getSymbolForPrivateIdentifierExpression(left) == nil && ast.GetContainingClass(left) != nil { isUncheckedJS := c.isUncheckedJSSuggestion(left, rightType.symbol, true /*excludeClasses*/) c.reportNonexistentProperty(left, rightType, isUncheckedJS) } @@ -13647,7 +14008,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 } } @@ -13689,16 +14050,18 @@ func (c *Checker) checkObjectLiteral(node *ast.Node, checkMode CheckMode) *Type if patternWithComputedProperties { flags |= ObjectFlagsObjectLiteralPatternWithComputedProperties } - key := c.getObjectLiteralTypeKey(node, flags, propertiesTable, indexInfos) - if existing := c.objectLiteralTypes[key]; existing != nil { - return existing + 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[key] = result + c.objectLiteralTypes.intern(node, append(existingTypes, objectLiteralType{flags, propertiesTable, indexInfos, result})) return result } for _, memberDecl := range node.Properties() { @@ -13749,7 +14112,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 { @@ -13948,7 +14311,7 @@ func (c *Checker) getSpreadType(left *Type, right *Type, symbol *ast.Symbol, obj b.writeByte(0) } key := b.hash() - if existing := c.spreadTypes[key]; existing != nil { + if existing, _ := c.spreadTypes.cached(c, key); existing != nil { return existing } members := ast.NewSymbolTable() @@ -13976,7 +14339,7 @@ func (c *Checker) getSpreadType(left *Type, right *Type, symbol *ast.Symbol, obj rightType := c.getTypeOfSymbol(rightProp) if rightProp.Flags()&ast.SymbolFlagsOptional != 0 { key := spreadSymbolKey{left: leftProp, right: rightProp} - if existing := c.spreadSymbols[key]; existing != nil { + if existing, _ := c.spreadSymbols.cached(c, key); existing != nil { members.Set(leftProp.Name(), existing) continue } @@ -13992,15 +14355,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[key] = result + c.spreadSymbols.set(c, key, result) members.Set(leftProp.Name(), result) } } else { @@ -14014,14 +14377,14 @@ func (c *Checker) getSpreadType(left *Type, right *Type, symbol *ast.Symbol, obj // 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[contentKey]; existing != nil { - c.spreadTypes[key] = existing + 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 |= flags - c.objectContentTypes[contentKey] = spread - c.spreadTypes[key] = spread + c.objectContentTypes.intern(contentKey, spread) + c.spreadTypes.set(c, key, spread) return spread } @@ -14092,9 +14455,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()) @@ -14119,21 +14482,21 @@ func (c *Checker) getSpreadSymbol(prop *ast.Symbol, readonly bool) *ast.Symbol { return prop } key := spreadSymbolKey{right: prop, readonly: readonly} - if existing := c.spreadSymbols[key]; existing != nil { + if existing, _ := c.spreadSymbols.cached(c, key); existing != nil { return existing } flags := ast.SymbolFlagsProperty | (prop.Flags() & ast.SymbolFlagsOptional) result := c.newSymbolEx(flags, prop.Name(), prop.CheckFlags()&ast.CheckFlagsLate|core.IfElse(readonly, ast.CheckFlagsReadonly, 0)) links := c.valueSymbolLinks.Get(result) if isSetonlyAccessor { - links.resolvedType = c.undefinedType + links.resolvedType.setIdentity(c, c.undefinedType) } else { - links.resolvedType = c.getTypeOfSymbol(prop) + links.resolvedType.setIdentity(c, c.getTypeOfSymbol(prop)) } result.SetDeclarations(prop.Declarations()) links.setNameType(c, c.valueSymbolLinks.Get(prop).getNameType()) c.mappedSymbolLinks.Get(result).syntheticOrigin = prop - c.spreadSymbols[key] = result + c.spreadSymbols.set(c, key, result) return result } @@ -14361,16 +14724,15 @@ func (c *Checker) getNarrowedTypeOfSymbol(symbol *ast.Symbol, location *ast.Node } parent := declaration.Parent.Parent if ast.IsVariableDeclaration(rootDeclaration) && c.getCombinedNodeFlagsCached(rootDeclaration)&ast.NodeFlagsConstant != 0 || ast.IsParameterDeclaration(rootDeclaration) { - links := c.nodeLinks.Get(parent) - if links.flags&NodeCheckFlagsInCheckIdentifier == 0 { - links.flags |= NodeCheckFlagsInCheckIdentifier + if !c.isResolvingAnywhere(parent, TypeSystemPropertyNameBindingElementParent) { + c.beginTypeResolution(parent, TypeSystemPropertyNameBindingElementParent, nil) parentType := c.getTypeForBindingElementParent(parent, CheckModeNormal) var parentTypeConstraint *Type if parentType != nil { parentTypeConstraint = c.mapType(parentType, c.getBaseConstraintOrType) } // Guard parent-type resolution only; flow analysis should allow re-entrant narrowing - links.flags &^= NodeCheckFlagsInCheckIdentifier + c.popTypeResolution() if parentTypeConstraint != nil && parentTypeConstraint.flags&TypeFlagsUnion != 0 && !(ast.IsParameterDeclaration(rootDeclaration) && c.isSomeSymbolAssigned(rootDeclaration)) { pattern := declaration.Parent narrowedType := c.getFlowTypeOfReferenceEx(pattern, parentTypeConstraint, parentTypeConstraint, nil /*flowContainer*/, getFlowNodeOfNode(location)) @@ -14491,26 +14853,76 @@ func (c *Checker) checkExpressionForMutableLocation(node *ast.Node, checkMode Ch func (c *Checker) getResolvedSymbol(node *ast.Node) *ast.Symbol { links := c.symbolNodeLinks.Get(node) - if links.resolvedSymbol == nil { + if symbol := links.resolvedSymbol.cached(c); symbol != nil { + return symbol + } + links.resolvedSymbol.begin(c) + result := c.getResolvedSymbolUncached(node) + c.endMemo() + return result +} + +func (c *Checker) getResolvedSymbolUncached(node *ast.Node) *ast.Symbol { + links := c.symbolNodeLinks.Get(node) + if links.resolvedSymbol.cached(c) == nil { var symbol *ast.Symbol if !ast.NodeIsMissing(node) { symbol = c.resolveName(node, node.Text(), ast.SymbolFlagsValue|ast.SymbolFlagsExportValue, c.getCannotFindNameDiagnosticForName(node), !ast.IsWriteOnlyAccess(node), false /*excludeGlobals*/) } - links.resolvedSymbol = core.OrElse(symbol, c.unknownSymbol) + links.resolvedSymbol.set(c, core.OrElse(symbol, c.unknownSymbol)) } - return links.resolvedSymbol + return links.resolvedSymbol.cached(c) } -func (c *Checker) getResolvedSymbolOrNil(node *ast.Node) *ast.Symbol { - return c.symbolNodeLinks.Get(node).resolvedSymbol +// getSymbolOfExpression returns the symbol the expression node resolves to, +// which checking it caches. Once the check of its file has found a symbol, it +// is read from there, rather than checking the expression again. +func (c *Checker) getSymbolOfExpression(node *ast.Node) *ast.Symbol { + links := c.symbolNodeLinks.Get(node) + if c.sourceFileLinks.Get(ast.GetSourceFileOfNode(node)).typeChecked { + if symbol := links.resolvedSymbol.cached(c); symbol != nil { + return symbol + } + } + c.checkExpressionCached(node) + return links.resolvedSymbol.cached(c) } -func (c *Checker) getReferencedValueOrAliasSymbol(reference *ast.Node) *ast.Symbol { - resolvedSymbol := c.symbolNodeLinks.Get(reference).resolvedSymbol - if resolvedSymbol != nil && resolvedSymbol != c.unknownSymbol { - return resolvedSymbol +// getSymbolOfReferenceForEmit returns the symbol of a member access emit +// refers to. Emit resolves other names itself. +func (c *Checker) getSymbolOfReferenceForEmit(node *ast.Node) *ast.Symbol { + if ast.IsAccessExpression(node) { + return c.getSymbolOfExpression(node) + } + return nil +} + +// symbolOfCheckedExpression returns the symbol the expression node resolved +// to when the current computation checked it. Checking it again would +// re-enter that check. +func (c *Checker) symbolOfCheckedExpression(node *ast.Node) *ast.Symbol { + return c.symbolNodeLinks.Get(node).resolvedSymbol.cached(c) +} + +// getSymbolOfTypeNode returns the symbol the type node resolves to, which +// resolving its type caches. +func (c *Checker) getSymbolOfTypeNode(node *ast.Node) *ast.Symbol { + return c.getSymbolOfTypeNodePart(node, node) +} + +// getSymbolOfTypeNodePart returns the symbol the part of the type node +// resolves to, such as a name in the qualifier of an import type, which +// resolving the type caches. +func (c *Checker) getSymbolOfTypeNodePart(typeNode *ast.Node, part *ast.Node) *ast.Symbol { + c.getTypeFromTypeNode(typeNode) + if links := c.symbolNodeLinks.TryGet(part); links != nil { + return links.resolvedSymbol.cached(c) } + return nil +} + +func (c *Checker) getReferencedValueOrAliasSymbol(reference *ast.Node) *ast.Symbol { return c.resolveName(reference, reference.Text(), ast.SymbolFlagsValue|ast.SymbolFlagsExportValue|ast.SymbolFlagsAlias, nil, false /*isUse*/, false /*excludeGlobals*/) } @@ -14570,24 +14982,37 @@ 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() + for len(c.deferredDiagnosticCallbacks) != 0 { + callbacks := c.deferredDiagnosticCallbacks + c.deferredDiagnosticCallbacks = nil + for _, cb := range callbacks { + cb(c) + } } - c.deferredDiagnosticCallbacks = nil } func (c *Checker) addDiagnostic(diagnostic *ast.Diagnostic) *ast.Diagnostic { // Discard diagnostics created while at the maximum number of recursive TypeToString invocations. - if c.serializationLevel < maxSerializationLevel { + if !c.depthLimitReached(&c.serializationLevel, maxSerializationLevel) { + if !c.checking { + c.recordEffect(func(c *Checker) { c.diagnostics.Add(diagnostic) }) + return diagnostic + } return c.diagnostics.Add(diagnostic) } return diagnostic @@ -14595,7 +15020,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 @@ -14605,6 +15034,50 @@ func (c *Checker) error(location *ast.Node, message *diagnostics.Message, args . return c.addDiagnostic(NewDiagnosticForNode(location, message, args...)) } +// errorAtCurrentNode reports an error at the node currently being checked. +// When a result is computed outside of checking, there is no such node; the +// location is then resolved when checking first observes the result, which +// is where the error would have been reported had checking computed it. +func (c *Checker) errorAtCurrentNode(message *diagnostics.Message, args ...any) { + c.reportAtCurrentNode(func(c *Checker, node *ast.Node) { c.error(node, message, args...) }) +} + +// reportAtCurrentNode reports an error located at whichever node's check +// reached it, so that every node reaching it reports it, as it would if it +// were checked first. Results cached from now until the current node is left +// were computed for that node, and are discarded so that other nodes +// compute them again. +func (c *Checker) reportAtCurrentNode(report func(c *Checker, node *ast.Node)) { + c.reportNode(¤tNodeError{report}) +} + +func (c *Checker) reportNode(r *currentNodeError) { + c.markCurrentNodeCircular() + if c.currentNodeErrorCollectors != 0 { + c.currentNodeErrors = append(c.currentNodeErrors, r) + } + c.reportAtCurrentNodeOnce(r.report) +} + +// reportAtCurrentNodeOnce is reportAtCurrentNode for an error whose result +// is kept, so that only the node reaching it first reports it. +func (c *Checker) reportAtCurrentNodeOnce(report func(c *Checker, node *ast.Node)) { + if !c.checking { + // A node the computation started at is where the computation was + // requested from, so it is located wherever the result is reused. + node := c.currentNode + if c.atMemoStartNode() { + node = nil + } + if c.memoTop != 0 { + c.resolutions[c.memoTop-1].reportsAtCurrentNode = true + } + c.recordEffect(func(c *Checker) { report(c, core.OrElse(node, c.currentNode)) }) + return + } + report(c, c.currentNode) +} + func (c *Checker) errorSkippedOnNoEmit(location *ast.Node, message *diagnostics.Message, args ...any) *ast.Diagnostic { diagnostic := c.error(location, message, args...) diagnostic.SetSkippedOnNoEmit() @@ -14693,13 +15166,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 } @@ -14710,10 +15183,20 @@ 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) - c.mergeSymbolTable(combined, second, false, nil) - return combined + // Late binding has merged into early symbols already; the merges are + // looked up without resolving the table, whose resolution is this one. + combined := ast.NewSymbolTableWithCapacity(first.Len() + second.Len()) + for id, symbol := range first.All() { + if merged := c.mergedSymbolOf(symbol); merged != nil { + symbol = merged + } + if merged, _ := c.lateMergedSymbols.cached(c, symbol); merged != nil { + symbol = merged + } + combined.Set(id, symbol) + } + c.mergeSymbolTable(combined, second, false, nil) + return combined } func (c *Checker) mergeSymbolTable(target ast.SymbolTable, source ast.SymbolTable, unidirectional bool, mergedParent *ast.Symbol) { @@ -14957,14 +15440,99 @@ func (c *Checker) cloneSymbol(symbol *ast.Symbol) *ast.Symbol { } func (c *Checker) getMergedSymbol(symbol *ast.Symbol) *ast.Symbol { - if symbol != nil { - if merged := c.mergedSymbols.TryGet(symbol); merged != nil && *merged != nil { - return *merged + if symbol == nil { + return nil + } + if merged := c.mergedSymbolOf(symbol); merged != nil { + symbol = merged + } + if symbol.Flags()&(ast.SymbolFlagsClassMember|ast.SymbolFlagsSignature) != 0 { + return c.getLateMergedSymbol(symbol) + } + return symbol +} + +// getLateMergedSymbol returns the symbol a member is merged into when its +// parent's late-bound members are resolved, resolving them if they could +// merge with the member. The answer is thus the same whether or not anything +// has resolved the parent's members yet. +func (c *Checker) getLateMergedSymbol(symbol *ast.Symbol) *ast.Symbol { + if !c.mergesFrozen || symbol.Parent() == nil { + return symbol + } + late := symbol.CheckFlags()&ast.CheckFlagsLate != 0 + var lateBindable uint8 + if !late { + // Most members cannot merge, which depends only on syntax and on + // the merges done before checking, so it is looked up cheaply. + if symbol.Parent() != c.lastLateBindableParent { + known := c.parentLateBindableKinds.Get(symbol.Parent()) + if *known == 0 { + *known = c.getLateBindableKinds(c.getMergedSymbol(symbol.Parent())) | lateBindableKnown + } + c.lastLateBindableParent = symbol.Parent() + c.lastLateBindableKinds = *known &^ lateBindableKnown + } + lateBindable = c.lastLateBindableKinds + if lateBindable == 0 { + return symbol + } + } + parent := c.getMergedSymbol(symbol.Parent()) + var kind MembersOrExportsResolutionKind + switch symbol { + case parent.Members().Get(symbol.Name()): + kind = MembersOrExportsResolutionKindResolvedMembers + case parent.Exports().Get(symbol.Name()): + kind = MembersOrExportsResolutionKindResolvedExports + default: + if !late { + return symbol + } + // Late-bound symbols are created by resolving their parent's members. + } + if !late { + if lateBindable&(1<= 0 { + return c.yieldMembers(key, symbol, resolutionKind, floor) + } + c.beginMemo(key) + c.currentResolution().memberSymbol = symbol + result := c.getResolvedMembersOrExportsOfSymbolUncached(symbol, resolutionKind) + c.endMemo() + return result +} + +// findEarlierMembersInCycle handles re-entering the member table of symbol, +// identified by key, while it is resolved. Re-entry observes the part of the +// table published so far, so when the tables of several symbols are resolved +// in a cycle, the result depends on which table was entered first. If the +// table of a symbol declared before this one is resolved since this table +// was entered, it returns the index in resolutions of the first declared, +// the table the cycle canonically enters at; otherwise -1. +func (c *Checker) findEarlierMembersInCycle(key memoKey, symbol *ast.Symbol) int { + i, ok := c.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 f.memberSymbol != nil && c.compareSymbols(f.memberSymbol, symbol) < 0 { + return int(i) + 1 + } + } + return -1 +} + +// yieldMembers computes the member table of symbol again, as if the cycle +// in progress had been entered at the table of a symbol declared before it: +// with the computation of the table in progress, which starts at floor, +// hidden. Re-entry observes the incomplete table, so what is computed since +// it started is in a cycle. The table in progress is the one cached once it +// is complete, so whatever computing it again caches is discarded, keeping +// only its result and effects for the caller. +func (c *Checker) yieldMembers(key memoKey, symbol *ast.Symbol, resolutionKind MembersOrExportsResolutionKind, floor int) ast.SymbolTable { + c.markCircular(floor - 1) + mark := c.markDiscard() + links := c.membersAndExportsLinks.Get(symbol) + saved := links[resolutionKind] + links[resolutionKind] = nil + c.beginCycleYield(key, TypeSystemPropertyNameStructuredMembers, -1, floor) + c.beginMemo(key) + c.currentResolution().memberSymbol = symbol + result := c.resolveMembersOrExportsOfSymbol(symbol, resolutionKind, links) + c.endMemoUncached() + c.endCycleYield() + links[resolutionKind] = saved + c.discardLogSince(mark.discardLog) + c.releaseDiscardMark(mark) + return result +} + +func (c *Checker) getResolvedMembersOrExportsOfSymbolUncached(symbol *ast.Symbol, resolutionKind MembersOrExportsResolutionKind) ast.SymbolTable { links := c.membersAndExportsLinks.Get(symbol) if links[resolutionKind] == nil { - isStatic := resolutionKind == MembersOrExportsResolutionKindResolvedExports - earlySymbols := symbol.Exports() - switch { - case !isStatic: - earlySymbols = symbol.Members() - case symbol.Flags()&ast.SymbolFlagsModule != 0: - earlySymbols, _ = c.getExportsOfModuleWorker(symbol) - } - links[resolutionKind] = earlySymbols - // fill in any as-yet-unresolved late-bound members. - var lateSymbols ast.SymbolTable - for _, decl := range symbol.Declarations() { - for _, member := range getMembersOfDeclaration(decl) { - if isStatic == ast.HasStaticModifier(member) { - switch { - case c.hasLateBindableName(member): - if lateSymbols == nil { - lateSymbols = ast.NewSymbolTable() - } - c.lateBindMember(symbol, earlySymbols, lateSymbols, member) - case c.hasLateBindableIndexSignature(member): - if lateSymbols == nil { - lateSymbols = ast.NewSymbolTable() - } - c.lateBindIndexSignature(symbol, earlySymbols, lateSymbols, member.AsNode() /* as LateBoundDeclaration | LateBoundBinaryExpressionDeclaration */) + c.resolveMembersOrExportsOfSymbol(symbol, resolutionKind, links) + if c.logResults() { + c.logMemoDiscard(nil, memoKeyOf(symbol, memoResolvedMembers+memoField(resolutionKind)), func() { links[resolutionKind] = nil }) + } + } + return links[resolutionKind] +} + +func (c *Checker) resolveMembersOrExportsOfSymbol(symbol *ast.Symbol, resolutionKind MembersOrExportsResolutionKind, links *MembersAndExportsLinks) ast.SymbolTable { + isStatic := resolutionKind == MembersOrExportsResolutionKindResolvedExports + earlySymbols := symbol.Exports() + switch { + case !isStatic: + earlySymbols = symbol.Members() + case symbol.Flags()&ast.SymbolFlagsModule != 0: + earlySymbols, _ = c.getExportsOfModuleWorker(symbol) + } + links[resolutionKind] = earlySymbols + // fill in any as-yet-unresolved late-bound members. + var lateSymbols ast.SymbolTable + for _, decl := range symbol.Declarations() { + for _, member := range getMembersOfDeclaration(decl) { + if isStatic == ast.HasStaticModifier(member) { + switch { + case c.hasLateBindableName(member): + if lateSymbols == nil { + lateSymbols = ast.NewSymbolTable() + } + c.lateBindMember(symbol, earlySymbols, lateSymbols, member) + case c.hasLateBindableIndexSignature(member): + if lateSymbols == nil { + lateSymbols = ast.NewSymbolTable() } + c.lateBindIndexSignature(symbol, earlySymbols, lateSymbols, member.AsNode() /* as LateBoundDeclaration | LateBoundBinaryExpressionDeclaration */) } } } - if isStatic { - if assignmentSymbol := symbol.Exports().Get(ast.InternalSymbolNameAssignmentDeclaration); assignmentSymbol != nil { - for _, member := range assignmentSymbol.Declarations() { - if c.hasLateBindableName(member) { - if lateSymbols == nil { - lateSymbols = ast.NewSymbolTable() - } - c.lateBindMember(symbol, earlySymbols, lateSymbols, member) + } + if isStatic { + if assignmentSymbol := symbol.Exports().Get(ast.InternalSymbolNameAssignmentDeclaration); assignmentSymbol != nil { + for _, member := range assignmentSymbol.Declarations() { + if c.hasLateBindableName(member) { + if lateSymbols == nil { + lateSymbols = ast.NewSymbolTable() } + c.lateBindMember(symbol, earlySymbols, lateSymbols, member) } } } - links[resolutionKind] = c.combineSymbolTables(earlySymbols, lateSymbols) } + links[resolutionKind] = c.combineSymbolTables(earlySymbols, lateSymbols) return links[resolutionKind] } @@ -16804,10 +17461,10 @@ func (c *Checker) getResolvedMembersOrExportsOfSymbol(symbol *ast.Symbol, resolu func (c *Checker) lateBindMember(parent *ast.Symbol, earlySymbols ast.SymbolTable, lateSymbols ast.SymbolTable, decl *ast.Node) *ast.Symbol { debug.Assert(decl.Symbol() != nil, "The member is expected to have a symbol.") links := c.symbolNodeLinks.Get(decl) - if links.resolvedSymbol == nil { + if links.resolvedSymbol.cached(c) == nil { // In the event we attempt to resolve the late-bound name of this member recursively, // fall back to the early-bound name of this member. - links.resolvedSymbol = decl.Symbol() + links.resolvedSymbol.set(c, decl.Symbol()) var declName *ast.Node if ast.IsBinaryExpression(decl) { declName = decl.AsBinaryExpression().Left @@ -16858,10 +17515,10 @@ func (c *Checker) lateBindMember(parent *ast.Symbol, earlySymbols ast.SymbolTabl if lateSymbol.Parent() == nil { lateSymbol.SetParent(parent) } - links.resolvedSymbol = lateSymbol + links.resolvedSymbol.set(c, lateSymbol) } } - return links.resolvedSymbol + return links.resolvedSymbol.cached(c) } func (c *Checker) lateBindIndexSignature(parent *ast.Symbol, earlySymbols ast.SymbolTable, lateSymbols ast.SymbolTable, decl *ast.Node) { @@ -16929,10 +17586,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 } @@ -17064,12 +17733,23 @@ func (c *Checker) ResolveAlias(symbol *ast.Symbol) (*ast.Symbol, bool) { // meaning. Pure aliases are eagerly resolved and any type-only markers are back-propagated to the original // symbol. The function panics if the argument is not a symbol with an alias meaning. func (c *Checker) resolveAlias(symbol *ast.Symbol) *ast.Symbol { + links := c.aliasSymbolLinks.Get(symbol) + if target := links.aliasTarget.cached(c); target != nil { + return target + } + links.aliasTarget.begin(c) + result := c.resolveAliasUncached(symbol) + c.endMemo() + return result +} + +func (c *Checker) resolveAliasUncached(symbol *ast.Symbol) *ast.Symbol { if symbol.Flags()&ast.SymbolFlagsAlias == 0 { panic("Should only get alias here") } links := c.aliasSymbolLinks.Get(symbol) - if links.aliasTarget == nil { - if !c.pushTypeResolution(symbol, TypeSystemPropertyNameAliasTarget) { + if links.aliasTarget.cached(c) == nil { + if !c.pushTypeResolution(symbol, TypeSystemPropertyNameAliasTarget, &links.aliasTarget.memoHeader) { return c.unknownSymbol } node := c.getDeclarationOfAliasSymbol(symbol) @@ -17081,13 +17761,13 @@ func (c *Checker) resolveAlias(symbol *ast.Symbol) *ast.Symbol { // When the target is a pure alias, we transitively resolve and propagate any typeOnlyDeclaration target = c.resolveIndirectionAlias(symbol, target) } - links.aliasTarget = core.OrElse(target, c.unknownSymbol) + links.aliasTarget.set(c, core.OrElse(target, c.unknownSymbol)) if !c.popTypeResolution() { c.error(node, diagnostics.Circular_definition_of_import_alias_0, c.symbolToString(symbol)) - links.aliasTarget = c.unknownSymbol + links.aliasTarget.set(c, c.unknownSymbol) } } - return links.aliasTarget + return links.aliasTarget.cached(c) } func (c *Checker) resolveIndirectionAlias(source *ast.Symbol, target *ast.Symbol) *ast.Symbol { @@ -17101,8 +17781,7 @@ func (c *Checker) resolveIndirectionAlias(source *ast.Symbol, target *ast.Symbol } func (c *Checker) tryResolveAlias(symbol *ast.Symbol) *ast.Symbol { - links := c.aliasSymbolLinks.Get(symbol) - if links.aliasTarget != nil || c.findResolutionCycleStartIndex(symbol, TypeSystemPropertyNameAliasTarget) < 0 { + if c.findResolutionCycleStartIndex(symbol, TypeSystemPropertyNameAliasTarget) < 0 { return c.resolveAlias(symbol) } return nil @@ -17200,20 +17879,20 @@ func (c *Checker) getDeclarationOfAliasSymbol(symbol *ast.Symbol) *ast.Node { func (c *Checker) getTypeOfSymbolWithDeferredType(symbol *ast.Symbol) *Type { links := c.valueSymbolLinks.Get(symbol) - if links.resolvedType == nil { + if links.resolvedType.cached(c) == nil { deferred := c.deferredSymbolLinks.Get(symbol) if deferred.parent.flags&TypeFlagsUnion != 0 { - links.resolvedType = c.getUnionType(deferred.constituents) + links.resolvedType.set(c, c.getUnionType(deferred.constituents)) } else { - links.resolvedType = c.getIntersectionType(deferred.constituents) + links.resolvedType.set(c, c.getIntersectionType(deferred.constituents)) } } - return links.resolvedType + return links.resolvedType.cached(c) } func (c *Checker) getWriteTypeOfSymbolWithDeferredType(symbol *ast.Symbol) *Type { links := c.valueSymbolLinks.Get(symbol) - if links.getWriteType() == nil { + if links.cachedWriteType(c) == nil { deferred := c.deferredSymbolLinks.Get(symbol) if len(deferred.writeConstituents) != 0 { if deferred.parent.flags&TypeFlagsUnion != 0 { @@ -17225,19 +17904,26 @@ func (c *Checker) getWriteTypeOfSymbolWithDeferredType(symbol *ast.Symbol) *Type links.setWriteType(c, c.getTypeOfSymbolWithDeferredType(symbol)) } } - return links.getWriteType() + return links.cachedWriteType(c) } // Distinct write types come only from set accessors, but synthetic union and intersection // properties deriving from set accessors will either pre-compute or defer the union or // intersection of the writeTypes of their constituents. func (c *Checker) getWriteTypeOfSymbol(symbol *ast.Symbol) *Type { + c.beginMemo(memoKeyOf(symbol, memoWriteType)) + result := c.getWriteTypeOfSymbolUncached(symbol) + c.endMemo() + return result +} + +func (c *Checker) getWriteTypeOfSymbolUncached(symbol *ast.Symbol) *Type { if symbol.CheckFlags()&ast.CheckFlagsSyntheticProperty != 0 { if symbol.CheckFlags()&ast.CheckFlagsDeferredType != 0 { return c.getWriteTypeOfSymbolWithDeferredType(symbol) } links := c.valueSymbolLinks.Get(symbol) - return core.OrElse(links.getWriteType(), links.resolvedType) + return core.OrElse(links.writeTypeOfCreation(), c.getTypeOfSymbol(symbol)) } if symbol.Flags()&ast.SymbolFlagsProperty != 0 { return c.removeMissingType(c.getTypeOfSymbol(symbol), symbol.Flags()&ast.SymbolFlagsOptional != 0) @@ -17295,7 +17981,7 @@ func (c *Checker) GetTypeOfSymbolAtLocation(symbol *ast.Symbol, location *ast.No // 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 + resolved := c.symbolOfCheckedExpression(location) if resolved == nil && symbol.CheckFlags()&ast.CheckFlagsIndexSymbol != 0 && ast.IsPropertyAccessExpression(location) && !ast.IsPrivateIdentifier(location.Name()) { resolved = c.getApplicableIndexSymbol(c.checkExpressionCached(location.Expression()), c.getLiteralTypeFromPropertyName(location.Name())) } @@ -17303,6 +17989,17 @@ func (c *Checker) resolvedSymbolAtLocation(location *ast.Node, symbol *ast.Symbo } func (c *Checker) getTypeOfSymbol(symbol *ast.Symbol) *Type { + links := c.valueSymbolLinks.Get(symbol) + if t := links.resolvedType.cached(c); t != nil { + return t + } + links.resolvedType.begin(c) + result := c.getTypeOfSymbolUncached(symbol) + c.endMemo() + return result +} + +func (c *Checker) getTypeOfSymbolUncached(symbol *ast.Symbol) *Type { if symbol.CheckFlags()&ast.CheckFlagsDeferredType != 0 { return c.getTypeOfSymbolWithDeferredType(symbol) } @@ -17339,21 +18036,21 @@ 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 { + if links.resolvedType.cached(c) == nil { var t *Type if from := c.instantiatedFromUnaffected(links); from != nil { t = c.getTypeOfSymbol(from) } else { t = c.instantiateType(c.getTypeOfSymbol(links.target), links.mapper) } - links.resolvedType = t + links.resolvedType.set(c, t) } - return links.resolvedType + return links.resolvedType.cached(c) } func (c *Checker) getWriteTypeOfInstantiatedSymbol(symbol *ast.Symbol) *Type { links := c.valueSymbolLinks.Get(symbol) - if links.getWriteType() == nil { + if links.cachedWriteType(c) == nil { var t *Type if from := c.instantiatedFromUnaffected(links); from != nil { t = c.getWriteTypeOfSymbol(from) @@ -17362,7 +18059,7 @@ func (c *Checker) getWriteTypeOfInstantiatedSymbol(symbol *ast.Symbol) *Type { } links.setWriteType(c, t) } - return links.getWriteType() + return links.cachedWriteType(c) } // instantiatedFromUnaffected returns the instantiated symbol that the @@ -17384,17 +18081,17 @@ func (c *Checker) instantiatedFromUnaffected(links *ValueSymbolLinks) *ast.Symbo func (c *Checker) getTypeOfVariableOrParameterOrProperty(symbol *ast.Symbol) *Type { links := c.valueSymbolLinks.Get(symbol) - if links.resolvedType == nil { + if links.resolvedType.cached(c) == nil { if fn := c.getContextSensitiveFunctionOfParameter(symbol); fn != nil { // The type of a parameter of a context-sensitive function is the // one its contextual parameter types assign it, as for the // signature of the function (see getTypeOfFuncClassEnumModule). - if c.nodeLinks.Get(fn).flags&NodeCheckFlagsContextChecked == 0 { + if c.resolvingIndex(memoKeyOf(fn, memoContextualParameters)) == 0 { c.assignContextualParameterTypesOfFunction(fn, CheckModeNormal) } else { c.assignContextualParameterTypeInProgress(fn, symbol) } - if assigned := links.resolvedType; assigned != nil { + if assigned := links.resolvedType.cached(c); assigned != nil { return assigned } } @@ -17407,15 +18104,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 assigned := links.resolvedType; assigned != nil { + if assigned := links.resolvedType.cached(c); assigned != nil { return assigned } if !c.isParameterOfContextSensitiveSignature(symbol) { - links.resolvedType = t + links.resolvedType.set(c, t) } return t } - return links.resolvedType + return links.resolvedType.cached(c) } func (c *Checker) isParameterOfContextSensitiveSignature(symbol *ast.Symbol) bool { @@ -17457,17 +18154,35 @@ func (c *Checker) getTypeOfVariableOrParameterOrPropertyWorker(symbol *ast.Symbo } return c.getWidenedType(c.getWidenedLiteralType(c.checkExpression(statements[0].Expression()))) } + if ast.IsBindingElement(declaration) && c.strictNullChecks { + // The type of a binding element depends on the type of the + // initializer its pattern destructures (see + // getBindingElementTypeFromParentType), which may in turn depend on + // the element. Resolving the initializer first, as for any element of + // the pattern, makes the cycle resolve the same way whichever element + // is requested first. + if initializer := declaration.Parent.Parent.Initializer(); initializer != nil && !c.isResolutionInProgress(initializer, TypeSystemPropertyNamePatternInitializer) { + c.beginTypeResolution(initializer, TypeSystemPropertyNamePatternInitializer, nil) + c.getTypeOfInitializer(initializer) + c.popTypeResolution() + } + } // Handle variable, parameter or property - if !c.pushTypeResolution(symbol, TypeSystemPropertyNameType) { + if !c.pushTypeResolution(symbol, TypeSystemPropertyNameType, &c.valueSymbolLinks.Get(symbol).resolvedType.memoHeader) { return c.reportCircularityError(symbol) } + var result *Type if symbol.Flags()&ast.SymbolFlagsModuleExports != 0 { if symbol.Name() == "exports" { - return c.getTypeOfSymbol(c.resolveExternalModuleSymbol(symbol.ValueDeclaration().Symbol(), false /*dontResolveAlias*/)) + result = c.getTypeOfSymbol(c.resolveExternalModuleSymbol(symbol.ValueDeclaration().Symbol(), false /*dontResolveAlias*/)) + } else { + result = c.newAnonymousType(symbol, symbol.Members(), nil, nil, nil) + } + 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: @@ -17706,11 +18421,11 @@ func (c *Checker) padObjectLiteralType(t *Type, pattern *ast.Node) *Type { name := c.getPropertyNameFromBindingElement(e) propType := c.getTypeFromBindingElement(e, false /*includePatternInType*/, true /*reportErrors*/) key := symbolWithTypeKey{name: name, t: propType} - symbol := c.paddedProperties[key] + symbol, _ := c.paddedProperties.get(key) if symbol == nil { symbol = c.newSymbol(ast.SymbolFlagsProperty|ast.SymbolFlagsOptional, name) - c.valueSymbolLinks.Get(symbol).resolvedType = propType - c.paddedProperties[key] = symbol + c.valueSymbolLinks.Get(symbol).resolvedType.setIdentity(c, propType) + c.paddedProperties.intern(key, symbol) } members.Set(symbol.Name(), symbol) } @@ -17778,8 +18493,8 @@ func (c *Checker) getWidenedLiteralTypeForInitializer(declaration *ast.Node, t * func (c *Checker) getTypeOfFuncClassEnumModule(symbol *ast.Symbol) *Type { links := c.valueSymbolLinks.Get(symbol) - if links.resolvedType == nil { - links.resolvedType = c.getTypeOfFuncClassEnumModuleWorker(symbol) + if links.resolvedType.cached(c) == nil { + links.resolvedType.set(c, c.getTypeOfFuncClassEnumModuleWorker(symbol)) } if declaration := symbol.ValueDeclaration(); declaration != nil && c.isContextSensitiveFunctionOrObjectLiteralMethod(declaration) { // Complete the signature before anything resolves the members of the @@ -17787,7 +18502,7 @@ func (c *Checker) getTypeOfFuncClassEnumModule(symbol *ast.Symbol) *Type { // members of the type. c.assignContextualParameterTypesOfFunction(declaration, CheckModeNormal) } - return links.resolvedType + return links.resolvedType.cached(c) } func (c *Checker) getTypeOfFuncClassEnumModuleWorker(symbol *ast.Symbol) *Type { @@ -17836,16 +18551,23 @@ func (c *Checker) getBaseTypeVariableOfClass(symbol *ast.Symbol) *Type { * * an object type with at least one construct signature. */ func (c *Checker) getBaseConstructorTypeOfClass(t *Type) *Type { + t.AsInterfaceType().resolvedBaseConstructorType.begin(c) + result := c.getBaseConstructorTypeOfClassUncached(t) + c.endMemo() + return result +} + +func (c *Checker) getBaseConstructorTypeOfClassUncached(t *Type) *Type { data := t.AsInterfaceType() - if data.resolvedBaseConstructorType != nil { - return data.resolvedBaseConstructorType + if data.resolvedBaseConstructorType.cached(c) != nil { + return data.resolvedBaseConstructorType.cached(c) } baseTypeNode := getBaseTypeNodeOfClass(t) if baseTypeNode == nil { - data.resolvedBaseConstructorType = c.undefinedType - return data.resolvedBaseConstructorType + data.resolvedBaseConstructorType.set(c, c.undefinedType) + return data.resolvedBaseConstructorType.cached(c) } - if !c.pushTypeResolution(t, TypeSystemPropertyNameResolvedBaseConstructorType) { + if !c.pushTypeResolution(t, TypeSystemPropertyNameResolvedBaseConstructorType, &data.resolvedBaseConstructorType.memoHeader) { return c.errorType } baseConstructorType := c.checkExpression(baseTypeNode.Expression()) @@ -17856,10 +18578,10 @@ func (c *Checker) getBaseConstructorTypeOfClass(t *Type) *Type { } if !c.popTypeResolution() { c.error(t.symbol.ValueDeclaration(), diagnostics.X_0_is_referenced_directly_or_indirectly_in_its_own_base_expression, c.symbolToString(t.symbol)) - if data.resolvedBaseConstructorType == nil { - data.resolvedBaseConstructorType = c.errorType + if data.resolvedBaseConstructorType.cached(c) == nil { + data.resolvedBaseConstructorType.set(c, c.errorType) } - return data.resolvedBaseConstructorType + return data.resolvedBaseConstructorType.cached(c) } if baseConstructorType.flags&TypeFlagsAny == 0 && baseConstructorType != c.nullWideningType && !c.isConstructorType(baseConstructorType) { err := c.error(baseTypeNode.Expression(), diagnostics.Type_0_is_not_a_constructor_function_type, c.TypeToString(baseConstructorType)) @@ -17876,15 +18598,15 @@ func (c *Checker) getBaseConstructorTypeOfClass(t *Type) *Type { err.AddRelatedInfo(createDiagnosticForNode(baseConstructorType.symbol.Declarations()[0], diagnostics.Did_you_mean_for_0_to_be_constrained_to_type_new_args_Colon_any_1, c.symbolToString(baseConstructorType.symbol), c.TypeToString(ctorReturn))) } } - if data.resolvedBaseConstructorType == nil { - data.resolvedBaseConstructorType = c.errorType + if data.resolvedBaseConstructorType.cached(c) == nil { + data.resolvedBaseConstructorType.set(c, c.errorType) } - return data.resolvedBaseConstructorType + return data.resolvedBaseConstructorType.cached(c) } - if data.resolvedBaseConstructorType == nil { - data.resolvedBaseConstructorType = baseConstructorType + if data.resolvedBaseConstructorType.cached(c) == nil { + data.resolvedBaseConstructorType.set(c, baseConstructorType) } - return data.resolvedBaseConstructorType + return data.resolvedBaseConstructorType.cached(c) } func (c *Checker) isFunctionType(t *Type) bool { @@ -17938,6 +18660,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) } @@ -17955,7 +18688,7 @@ func (c *Checker) getConstraintFromTypeParameter(t *Type) *Type { } tp := t.AsTypeParameter() - if tp.constraint == nil { + if tp.constraint.cached(c) == nil { var constraint *Type if tp.target != nil { constraint = c.instantiateType(c.getConstraintOfTypeParameter(tp.target), tp.mapper) @@ -17979,10 +18712,10 @@ func (c *Checker) getConstraintFromTypeParameter(t *Type) *Type { if constraint == nil { constraint = c.noConstraintType } - tp.constraint = constraint + tp.constraint.set(c, constraint) } - if tp.constraint != c.noConstraintType { - return tp.constraint + if tp.constraint.cached(c) != c.noConstraintType { + return tp.constraint.cached(c) } return nil } @@ -18068,7 +18801,7 @@ func (c *Checker) getInferredTypeParameterConstraint(t *Type, omitTypeReferences func (c *Checker) getTypeParametersForTypeReferenceOrImport(node *ast.Node) []*Type { t := c.getTypeFromTypeNode(node) if !c.isErrorType(t) { - symbol := c.getResolvedSymbolOrNil(node) + symbol := c.getSymbolOfTypeNode(node) if symbol != nil { return c.getTypeParametersForTypeAndSymbol(t, symbol) } @@ -18105,7 +18838,7 @@ func (c *Checker) getDeclaredTypeParametersOfTypeReference(node *ast.Node) []*Ty 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 } } @@ -18170,7 +18903,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, @@ -18179,19 +18912,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 @@ -18203,7 +18935,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 && !d.restrictive { constraint := c.getSimplifiedType(d.checkType, false /*writing*/) if constraint == d.checkType { // A conditional check type whose base constraint is circular @@ -18218,25 +18950,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.cached(c) == nil { kind := core.IfElse(symbol.Flags()&ast.SymbolFlagsClass != 0, ObjectFlagsClass, ObjectFlagsInterface) t := c.newObjectType(kind, symbol) - links.declaredType = t + links.declaredType.setIdentity(c, t) outerTypeParameters := c.getOuterTypeParametersOfClassOrInterface(symbol) typeParameters := c.appendLocalTypeParametersOfClassOrInterfaceOrTypeAlias(outerTypeParameters, symbol) // A class or interface is generic if it has type parameters or a "this" type. We always give classes a "this" type @@ -18249,16 +18980,15 @@ func (c *Checker) getDeclaredTypeOfClassOrInterface(symbol *ast.Symbol) *Type { d := t.AsInterfaceType() d.thisType = c.newTypeParameter(symbol) d.thisType.AsTypeParameter().isThisType = true - d.thisType.AsTypeParameter().constraint = t + d.thisType.AsTypeParameter().constraint.intern(t) d.allTypeParameters = append(typeParameters, d.thisType) d.outerTypeParameterCount = len(outerTypeParameters) - d.resolvedTypeArguments = d.TypeParameters() - d.instantiations = make(map[CacheHashKey]*Type) - d.instantiations[getTypeListKey(d.resolvedTypeArguments)] = t + d.resolvedTypeArguments.intern(d.TypeParameters()) + d.instantiations.intern(getTypeListKey(d.TypeParameters()), t) d.target = t } } - return links.declaredType + return links.declaredType.cached(c) } /** @@ -18386,15 +19116,15 @@ func (b *keyBuilder) writeAlias(alias *TypeAlias) { } } -func (b *keyBuilder) writeGenericTypeReferences(source *Type, target *Type, ignoreConstraints bool) bool { +func (b *keyBuilder) writeGenericTypeReferences(c *Checker, source *Type, target *Type, ignoreConstraints bool) bool { var constrained bool typeParameters := make([]*Type, 0, 8) var writeTypeReference func(*Type, int) writeTypeReference = func(ref *Type, depth int) { b.writeType(ref.Target()) - for _, t := range ref.AsTypeReference().resolvedTypeArguments { + for _, t := range c.getTypeArguments(ref) { if t.flags&TypeFlagsTypeParameter != 0 { - if ignoreConstraints || t.checker.getConstraintOfTypeParameter(t) == nil { + if ignoreConstraints || c.getConstraintOfTypeParameter(t) == nil { index := slices.Index(typeParameters, t) if index < 0 { index = len(typeParameters) @@ -18405,7 +19135,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('>') @@ -18431,52 +19161,49 @@ func (b *keyBuilder) writeNode(node *ast.Node) { } } -// getObjectLiteralTypeKey identifies the content of an object literal type, so -// that checking the same object literal again with the same results yields the -// same type. -func (c *Checker) getObjectLiteralTypeKey(node *ast.Node, flags ObjectFlags, properties ast.SymbolTable, indexInfos []*IndexInfo) CacheHashKey { - var b keyBuilder - b.writeNode(node) - b.writeUint32(uint32(flags)) - names := slices.Sorted(properties.Keys()) - b.writeInt(len(names)) - for _, name := range names { - prop := properties.Get(name) - b.writeString(name) - b.writeByte(0) - b.writeUint32(uint32(prop.Flags())) - b.writeUint32(uint32(prop.CheckFlags())) - // Members created by this object literal have their types set at +// 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) - if links == nil || links.target == nil { - b.writeByte(2) - b.writeSymbol(prop) + otherLinks := c.valueSymbolLinks.TryGet(other) + if links == nil || links.target == nil || otherLinks == nil || otherLinks.target == nil { + if prop != other { + return false + } continue } - if nameType := links.getNameType(); nameType != nil { - b.writeByte(1) - b.writeType(nameType) - } else { - b.writeByte(0) - } - b.writeType(links.resolvedType) - } - 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) - } - b.writeInt(len(info.components)) - for _, n := range info.components { - b.writeNode(n) + if links.getNameType() != otherLinks.getNameType() || links.typeOfCreation() != otherLinks.typeOfCreation() { + return false } } - return b.hash() + return true } func getTypeListKey(types []*Type) CacheHashKey { @@ -18596,15 +19323,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) @@ -18623,9 +19357,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) }) } @@ -18926,7 +19660,7 @@ 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 @@ -18944,24 +19678,23 @@ func (c *Checker) getTypeFromObjectBindingPattern(pattern *ast.Node, includePatt } b.writeUint32(uint32(objectFlags)) b.writeInt(len(indexInfos)) - names := slices.Sorted(members.Keys()) - for _, name := range names { + for name, member := range members.All() { b.writeString(name) b.writeByte(0) - b.writeUint32(uint32(members.Get(name).Flags())) - b.writeType(c.valueSymbolLinks.Get(members.Get(name)).resolvedType) + b.writeUint32(uint32(member.Flags())) + b.writeType(c.valueSymbolLinks.Get(member).typeOfCreation()) } key := b.hash() - if existing := c.bindingPatternTypes[key]; existing != nil { + 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[key] = result + c.bindingPatternTypes.intern(key, result) return result } @@ -19009,13 +19742,13 @@ func (c *Checker) getTypeFromArrayBindingPattern(pattern *ast.Node, includePatte b.writeNode(pattern) b.writeType(result) key := b.hash() - if existing := c.bindingPatternTypes[key]; existing != nil { + 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[key] = result + c.bindingPatternTypes.intern(key, result) } return result } @@ -19208,16 +19941,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 @@ -19248,8 +19982,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 } @@ -19383,9 +20116,12 @@ func (c *Checker) getWidenedType(t *Type) *Type { func (c *Checker) getWidenedTypeWithContext(t *Type, context *WideningContext) *Type { if t.objectFlags&ObjectFlagsRequiresWidening != 0 { if context == nil { - if cached := c.cachedTypes[CachedTypeKey{kind: CachedTypeKindWidened, typeId: t.id}]; cached != nil { + key := CachedTypeKey{kind: CachedTypeKindWidened, typeId: t.id} + if cached, _ := c.cachedTypes.cached(c, key); cached != nil { return cached } + c.cachedTypes.begin(c, key) + defer c.endMemo() } var result *Type switch { @@ -19414,7 +20150,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) } @@ -19520,27 +20256,36 @@ func (c *Checker) getSiblingsOfContext(context *WideningContext) []*Type { } func (c *Checker) getUndefinedProperty(prop *ast.Symbol) *ast.Symbol { - if cached := c.undefinedProperties[prop]; cached != nil { + if cached, _ := c.undefinedProperties.cached(c, prop); cached != nil { return cached } + c.undefinedProperties.begin(c, prop) result := c.createSymbolWithType(prop, c.undefinedOrMissingType) result.SetFlags(result.Flags() | ast.SymbolFlagsOptional) - c.undefinedProperties[prop] = result + c.undefinedProperties.set(c, prop, result) + c.endMemo() return result } func (c *Checker) getTypeOfEnumMember(symbol *ast.Symbol) *Type { links := c.valueSymbolLinks.Get(symbol) - if links.resolvedType == nil { - links.resolvedType = c.getDeclaredTypeOfEnumMember(symbol) + if links.resolvedType.cached(c) == nil { + links.resolvedType.set(c, c.getDeclaredTypeOfEnumMember(symbol)) } - return links.resolvedType + return links.resolvedType.cached(c) } func (c *Checker) getTypeOfAccessors(symbol *ast.Symbol) *Type { + c.beginMemo(memoKeyOf(symbol, memoAccessorType)) + result := c.getTypeOfAccessorsUncached(symbol) + c.endMemo() + return result +} + +func (c *Checker) getTypeOfAccessorsUncached(symbol *ast.Symbol) *Type { links := c.valueSymbolLinks.Get(symbol) - if links.resolvedType == nil { - if !c.pushTypeResolution(symbol, TypeSystemPropertyNameType) { + if links.resolvedType.cached(c) == nil { + if !c.pushTypeResolution(symbol, TypeSystemPropertyNameType, &links.resolvedType.memoHeader) { return c.errorType } getter := ast.GetDeclarationOfKind(symbol, ast.KindGetAccessor) @@ -19585,17 +20330,20 @@ func (c *Checker) getTypeOfAccessors(symbol *ast.Symbol) *Type { } t = c.anyType } - if links.resolvedType == nil { - links.resolvedType = t + if links.resolvedType.cached(c) == nil { + links.resolvedType.set(c, t) } } - return links.resolvedType + return links.resolvedType.cached(c) } func (c *Checker) getWriteTypeOfAccessors(symbol *ast.Symbol) *Type { links := c.valueSymbolLinks.Get(symbol) - if links.getWriteType() == nil { - if !c.pushTypeResolution(symbol, TypeSystemPropertyNameWriteType) { + if links.cachedWriteType(c) == nil { + if links.extra == nil { + links.extra = c.valueSymbolExtraArena.New() + } + if !c.pushTypeResolution(symbol, TypeSystemPropertyNameWriteType, &links.extra.writeType.memoHeader) { return c.errorType } setter := ast.GetDeclarationOfKind(symbol, ast.KindSetAccessor) @@ -19613,7 +20361,7 @@ func (c *Checker) getWriteTypeOfAccessors(symbol *ast.Symbol) *Type { writeType = c.anyType } // Absent an explicit setter type annotation we use the read type of the accessor. - if links.getWriteType() == nil { + if links.cachedWriteType(c) == nil { if writeType != nil { links.setWriteType(c, writeType) } else { @@ -19621,13 +20369,13 @@ func (c *Checker) getWriteTypeOfAccessors(symbol *ast.Symbol) *Type { } } } - return links.getWriteType() + return links.cachedWriteType(c) } func (c *Checker) getTypeOfAlias(symbol *ast.Symbol) *Type { links := c.valueSymbolLinks.Get(symbol) - if links.resolvedType == nil { - if !c.pushTypeResolution(symbol, TypeSystemPropertyNameType) { + if links.resolvedType.cached(c) == nil { + if !c.pushTypeResolution(symbol, TypeSystemPropertyNameType, &links.resolvedType.memoHeader) { return c.errorType } targetSymbol := c.resolveAlias(symbol) @@ -19637,22 +20385,22 @@ func (c *Checker) getTypeOfAlias(symbol *ast.Symbol) *Type { // type symbol, call getDeclaredTypeOfSymbol. // This check is important because without it, a call to getTypeOfSymbol could end // up recursively calling getTypeOfAlias, causing a stack overflow. - if links.resolvedType == nil { + if links.resolvedType.cached(c) == nil { if c.getSymbolFlags(targetSymbol)&ast.SymbolFlagsValue != 0 { - links.resolvedType = c.getTypeOfSymbol(targetSymbol) + links.resolvedType.set(c, c.getTypeOfSymbol(targetSymbol)) } else { - links.resolvedType = c.errorType + links.resolvedType.set(c, c.errorType) } } if !c.popTypeResolution() { c.reportCircularityError(core.OrElse(exportSymbol, symbol)) - if links.resolvedType == nil { - links.resolvedType = c.errorType + if links.resolvedType.cached(c) == nil { + links.resolvedType.set(c, c.errorType) } - return links.resolvedType + return links.resolvedType.cached(c) } } - return links.resolvedType + return links.resolvedType.cached(c) } func (c *Checker) addOptionality(t *Type) *Type { @@ -19737,12 +20485,13 @@ func (c *Checker) getEffectivePropertyNameForPropertyNameNode(node *ast.Property case ast.IsComputedPropertyName(node): // This is cached so `getTypeOfExpression` isn't constantly reinvoked for every property name lookup links := c.computedNameLinks.Get(node) - if links != nil && !links.hasName.IsUnknown() { - return links.name, links.hasName.IsTrue() + if result := links.name.cached(c); !result.exists.IsUnknown() { + return result.name, result.exists.IsTrue() } + links.name.begin(c) name, exists := c.tryGetNameFromType(c.getTypeOfExpression(node.Expression())) - links.name = name - links.hasName = core.BoolToTristate(exists) + links.name.set(c, computedName{name: name, exists: core.BoolToTristate(exists)}) + c.endMemo() return name, exists } return "", false @@ -19783,73 +20532,483 @@ func (c *Checker) getCombinedModifierFlagsCached(node *ast.Node) ast.ModifierFla * * @param target The symbol, type, or signature whose type is being queried * @param propertyName The property name that should be used to query the target for its type + * @param memo The memo that caches the result of the resolution, or nil */ -func (c *Checker) pushTypeResolution(target TypeSystemEntity, propertyName TypeSystemPropertyName) bool { +func (c *Checker) pushTypeResolution(target TypeSystemEntity, propertyName TypeSystemPropertyName, memo *memoHeader) bool { resolutionCycleStartIndex := c.findResolutionCycleStartIndex(target, propertyName) if resolutionCycleStartIndex >= 0 { - // A cycle was found - for i := resolutionCycleStartIndex; i < len(c.typeResolutions); i++ { - c.typeResolutions[i].result = false + if !c.yieldCycleToMembers(resolutionCycleStartIndex) { + return false } + } + c.beginTypeResolution(target, propertyName, memo) + return true +} + +// cycleYield is a canonical recomputation in progress; see yieldCycle. +type cycleYield struct { + end int // Index in resolutions of the resolution whose pop ends it, or -1 + target TypeSystemEntity + propertyName TypeSystemPropertyName + savedResolutionStart int + savedVisibleStart int + savedVisibleSigs int + savedDepths [3]depthLimit + shadowed []shadowedResolving +} + +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 the +// types of symbols declared before the one re-entered (if it is one) +// fails at the first of those instead, as if that symbol had been resolved +// first: its type 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 + var first *ast.Symbol + if r.propertyName == TypeSystemPropertyNameType { + first = r.target.(*ast.Symbol) + } + entered := first + for i := start + 1; i < len(c.resolutions); i++ { + if f := &c.resolutions[i]; f.isTypeResolution && f.typeResolution.propertyName == TypeSystemPropertyNameType { + if s := f.typeResolution.target.(*ast.Symbol); first == nil || c.compareSymbols(s, first) < 0 { + first = s + } + } + } + if first == nil || first == entered || c.isYieldingTo(first, TypeSystemPropertyNameType) || c.isYieldingTo(r.target, r.propertyName) { return false } - c.typeResolutions = append(c.typeResolutions, TypeResolution{target: target, propertyName: propertyName, result: true}) + c.beginCycleYield(first, TypeSystemPropertyNameType, -1, len(c.resolutions)) + c.getTypeOfSymbol(first) + c.endCycleYield() + 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 +// yieldCycleToMembers handles re-entering the type resolution in progress +// at start, a cycle that would fail it, when the cycle passes through a +// member table. Entering the cycle at the member table instead would not +// fail, as the table is available while it is resolved, so the resolution +// re-entered is computed again as if the table had been entered first: by +// the caller, with everything entered before the table hidden. A module +// table is instead resolved again itself, as if entered first (see +// resolveModuleTableMembers), so everything above it fails until then, to +// be discarded. Otherwise it yields as yieldCycle does. It reports whether +// the resolution re-entered may be pushed. +func (c *Checker) yieldCycleToMembers(start int) bool { + if m := c.findMembersInCycle(start); m >= 0 { + r := &c.resolutions[start].typeResolution + if c.isYieldingTo(r.target, r.propertyName) { + c.markResolutionCycle(start) + return false + } + if t := &c.resolutions[m].typeResolution; r.propertyName == TypeSystemPropertyNameResolvedTypeArguments && t.target == r.target { + // The members of a type reference are available only once its type + // arguments are resolved, so entering the cycle at them fails too. + c.markResolutionCycle(start) + return false + } + if t := &c.resolutions[m].typeResolution; t.propertyName == TypeSystemPropertyNameStructuredMembers && c.isModuleTableType(t.target.(*Type)) { + t.restartHidden = true + c.markResolutionCycle(m) + return false + } + c.beginCycleYield(r.target, r.propertyName, len(c.resolutions), m) + return true + } + if !c.yieldCycle(start) { + c.markResolutionCycle(start) + return false + } + return true } -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 +// 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 resolution.target == target && resolution.propertyName == propertyName { + if f.memberSymbol != nil { return i } } return -1 } -func (c *Checker) typeResolutionHasProperty(r *TypeResolution) bool { - switch r.propertyName { - case TypeSystemPropertyNameType: - return c.valueSymbolLinks.Get(r.target.(*ast.Symbol)).resolvedType != nil - case TypeSystemPropertyNameDeclaredType: - return c.typeAliasLinks.Get(r.target.(*ast.Symbol)).declaredType != nil - case TypeSystemPropertyNameResolvedTypeArguments: - return r.target.(*Type).AsTypeReference().resolvedTypeArguments != nil - case TypeSystemPropertyNameResolvedBaseTypes: - return r.target.(*Type).AsInterfaceType().baseTypesResolved - case TypeSystemPropertyNameResolvedBaseConstructorType: - return r.target.(*Type).AsInterfaceType().resolvedBaseConstructorType != nil - case TypeSystemPropertyNameResolvedReturnType: - return r.target.(*Signature).resolvedReturnType != nil - case TypeSystemPropertyNameResolvedBaseConstraint: - return r.target.(*Type).AsConstrainedType().resolvedBaseConstraint != nil - case TypeSystemPropertyNameInitializerIsUndefined: - return c.nodeLinks.Get(r.target.(*ast.Node)).flags&NodeCheckFlagsInitializerIsUndefinedComputed != 0 - case TypeSystemPropertyNameWriteType: - return c.valueSymbolLinks.Get(r.target.(*ast.Symbol)).getWriteType() != nil - case TypeSystemPropertyNameAliasTarget: - return c.aliasSymbolLinks.Get(r.target.(*ast.Symbol)).aliasTarget != nil - case TypeSystemPropertyNameComputedPropertyName: - return c.typeNodeLinks.Get(r.target.(*ast.Node)).resolvedType != nil - case TypeSystemPropertyNameBaseConstraintInWalk: +func (c *Checker) isYieldingTo(target TypeSystemEntity, propertyName TypeSystemPropertyName) bool { + return slices.ContainsFunc(c.cycleYields, func(y cycleYield) bool { return y.target == target && y.propertyName == propertyName }) +} + +// beginCycleYield hides the resolutions in progress below floor until +// endCycleYield, which popping the resolution at end calls if it is not -1. +func (c *Checker) beginCycleYield(target TypeSystemEntity, propertyName TypeSystemPropertyName, end int, floor int) { + n := floor + c.cycleYields = append(c.cycleYields, cycleYield{ + end: end, + target: target, + propertyName: propertyName, + savedResolutionStart: c.resolutionStart, + savedVisibleStart: c.visibleStart, + savedVisibleSigs: c.visibleSignatures, + savedDepths: [3]depthLimit{c.serializationLevel, c.inlineLevel, c.conditionalConstraintDepth}, + }) + c.resolutionStart = n + c.visibleStart = n + c.visibleSignatures = len(c.signaturesResolving) + c.serializationLevel, c.inlineLevel, c.conditionalConstraintDepth = depthLimit{}, depthLimit{}, depthLimit{} +} + +func (c *Checker) endCycleYield() { + y := &c.cycleYields[len(c.cycleYields)-1] + c.resolutionStart = y.savedResolutionStart + c.visibleStart = y.savedVisibleStart + c.visibleSignatures = y.savedVisibleSigs + c.serializationLevel, c.inlineLevel, c.conditionalConstraintDepth = y.savedDepths[0], y.savedDepths[1], y.savedDepths[2] + 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) && r.memo != nil { + c.cycleParticipants = append(c.cycleParticipants, r.memo) + } + r.result = false + } + } + c.markTypeResolutionCircular(start) +} + +func (c *Checker) isRecomputedByYield(i int) bool { + for j := range c.cycleYields { + if c.cycleYields[j].end == i { + return true + } + } + return false +} + +// observeResolutionInProgress is for computations that are skipped rather +// than failed when re-entered. Skipping still observes the incomplete +// computation, so everything on the stack since it started is in a cycle. +func (c *Checker) observeResolutionInProgress(target TypeSystemEntity, propertyName TypeSystemPropertyName) { + if start := c.findResolutionCycleStartIndex(target, propertyName); start >= 0 { + c.markResolutionCycle(start) + } +} + +// isResolutionInProgress reports whether a resolution is on the stack, for +// computations that deliberately take another path to avoid a circularity. +// The answer depends on the incomplete resolution, so results cached while it +// is in progress must not outlive it, but nothing fails. +func (c *Checker) isResolutionInProgress(target TypeSystemEntity, propertyName TypeSystemPropertyName) bool { + start := c.findResolutionCycleStartIndex(target, propertyName) + if start < 0 { + return false + } + c.markTypeResolutionCircular(start) + return true +} + +// isResolvingAnywhere reports whether the property of target is being +// resolved. A computation finding it so fails, as computing it from scratch +// would, so the results cached since it started are discarded when it +// finishes, like those of any other failure, and every caller computes them +// again and reports the failure. Unlike isResolutionInProgress, it searches +// the whole stack, for computations that would not otherwise stop. +func (c *Checker) isResolvingAnywhere(target TypeSystemEntity, propertyName TypeSystemPropertyName) bool { + if i := c.resolvingAnywhereIndex(target, propertyName); i >= 0 { + c.markTypeResolutionCircular(i) + return true + } + return false +} + +// resolvingAnywhereIndex returns the index in resolutions of the visible +// resolution of the property of target in progress, or -1. +func (c *Checker) resolvingAnywhereIndex(target TypeSystemEntity, propertyName TypeSystemPropertyName) int { + for i := c.typeResolutionTop - 1; i >= c.visibleStart; i = int(c.resolutions[i].prevTypeResolution) - 1 { + if r := &c.resolutions[i].typeResolution; r.target == target && r.propertyName == propertyName { + return i + } + } + return -1 +} + +// observeCircularHead is for computations where re-entering one in progress +// fails only that computation, while the others complete from its failed +// result. Which member fails then depends on which was entered first, so the +// cycle records its canonical member, the first in program order, and the +// head resolves that member first when it finishes; see popCircularHead. +// Everything else cached during the cycle is discarded like for +// isResolutionInProgress. It returns the index in resolutions of the head, or +// -1 if target is not in progress. +func (c *Checker) observeCircularHead(target TypeSystemEntity, propertyName TypeSystemPropertyName, compare func(a, b TypeSystemEntity) int) int { + start := c.findResolutionCycleStartIndex(target, propertyName) + if start < 0 { + return -1 + } + c.markTypeResolutionCircular(start) + head := &c.resolutions[start].typeResolution + canonical := core.OrElse(head.canonical, head.target) + for i := start + 1; i < len(c.resolutions); i++ { + if r := &c.resolutions[i].typeResolution; c.resolutions[i].isTypeResolution && r.propertyName == propertyName && compare(r.target, canonical) < 0 { + canonical = r.target + } + } + head.canonical = canonical + return start +} + +// addCycleParticipants keeps the results of the type resolutions from start +// to the top of the stack when the cycle in progress ends, as they would be +// kept had the resolution at start been entered first. +func (c *Checker) addCycleParticipants(start int) { + for i := start; i < len(c.resolutions); i++ { + if r := &c.resolutions[i].typeResolution; c.resolutions[i].isTypeResolution && r.result && !r.participant && r.memo != nil { + r.participant = true + c.cycleParticipants = append(c.cycleParticipants, r.memo) + } + } +} + +// popCircularHead pops a resolution that may head a cycle observed by +// observeCircularHead. It returns the cycle's canonical member when that is +// not the head itself, in which case everything cached since mark has been +// discarded, including the results of the cycle's participants, and the +// caller must resolve the canonical member before resolving the head again. +func (c *Checker) popCircularHead(mark discardMark) TypeSystemEntity { + r := c.topTypeResolution() + canonical := r.canonical + if canonical == r.target { + canonical = nil + } + if canonical != nil { + // Discard while the cycle is still in progress, so that the results + // of its participants are discarded too. + c.discardSince(mark) + } + c.popTypeResolution() + return canonical +} + +// enterSharedCurrentNode is enterCurrentNode for a node that shares the +// resolution of the enclosing node, small enough to inline for the common +// case. It reports false, changing nothing, if the node needs its own. +func (c *Checker) enterSharedCurrentNode(node *ast.Node) (savedCurrentNode, bool) { + save := savedCurrentNode{node: c.currentNode, resolution: c.currentNodeResolution} + if c.currentNodeResolution == 0 || c.currentNodeResolution != len(c.resolutions) || c.circularityStart != 0 || len(c.innerCycles) != 0 { + return save, false + } + c.currentNode = node + return save, true +} + +// exitSharedCurrentNode is exitCurrentNode for a node entered without a +// resolution of its own, when that ends no cycle. It reports false, changing +// nothing, otherwise. +func (c *Checker) exitSharedCurrentNode(save savedCurrentNode) bool { + if c.currentNodeResolution != save.resolution || c.circularityStart >= save.resolution || len(c.innerCycles) != 0 { + return false + } + c.currentNode = save.node + return true +} + +// enterCurrentNode makes node the node being checked, until the matching +// exitCurrentNode. Its resolution delimits the results that errors located at +// node (see reportAtCurrentNode) depend on. +func (c *Checker) enterCurrentNode(node *ast.Node) savedCurrentNode { + save := savedCurrentNode{node: c.currentNode, resolution: c.currentNodeResolution} + if c.circularityStart != 0 && c.circularityStart == c.currentNodeResolution && c.typeResolutionTop < c.currentNodeResolution { + // The results discarded when the current node is left depend on errors + // located at it, so a node within it must not reuse them either. + c.endCircularity() + } + c.currentNode = node + if c.currentNodeResolution != 0 && c.currentNodeResolution == len(c.resolutions) && c.circularityStart == 0 && len(c.innerCycles) == 0 { + // Nothing separates the node from the one enclosing it, so the + // resolution of that one stands in for it: a cycle through the node + // starts at that resolution, and nothing else can until the node is + // left, where exitCurrentNode ends it as popping the node's own + // resolution would. + return save + } + // The node's resolution shares the work of the one below it, as a type + // resolution does. + f := c.pushResolution() + parent := &c.resolutions[len(c.resolutions)-2] + f.depthStart = parent.depthStart + f.serial = parent.serial + c.currentNodeResolution = len(c.resolutions) + return save +} + +func (c *Checker) exitCurrentNode(save savedCurrentNode) { + if c.currentNodeResolution == save.resolution { + // The node had no resolution of its own; see enterCurrentNode. + c.endCyclesAt(save.resolution - 1) + c.currentNode = save.node + return + } + debug.Assert(c.currentNodeResolution == len(c.resolutions), "resolutions left on the stack") + c.dropResolution(c.currentNodeResolution - 1) + c.currentNode = save.node + c.currentNodeResolution = save.resolution +} + +// enterQuery starts a query made outside of checking, unless one is already +// in progress. Results that depend on errors located at the current node are +// discarded when the query finishes (see reportAtCurrentNode), so a query +// that reads results back from caches after computing them must do so before +// then. +func (c *Checker) enterQuery() (savedCurrentNode, bool) { + if c.memoTop != 0 || c.currentNodeResolution != 0 { + return savedCurrentNode{}, false + } + return c.enterCurrentNode(c.currentNode), true +} + +func (c *Checker) exitQuery(save savedCurrentNode, ok bool) { + if ok { + c.exitCurrentNode(save) + } +} + +type savedCurrentNode struct { + node *ast.Node + resolution int +} + +// markCurrentNodeCircular records that results cached until the current node +// is left depend on that node. +func (c *Checker) markCurrentNodeCircular() { + if c.currentNodeResolution != 0 { + c.extendCircularity(c.currentNodeResolution) + } +} + +// markTypeResolutionCircular records that the computations from start to the +// top of the stack observed the incomplete resolution at start without +// failing, so results cached while it is in progress are discarded when it +// finishes. +func (c *Checker) markTypeResolutionCircular(start int) { + c.recordFromCheck() + if !c.checking { + c.memoCycle(int(c.resolutions[start].prevMemo)) + } + c.markCircular(start) +} + +// 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 } - panic("Unhandled case in typeResolutionHasProperty") + c.markCircular(int(l.start)) + return true +} + +func (c *Checker) enterDepthLimit(l *depthLimit) { + if l.depth == 0 { + l.start = int32(len(c.resolutions) - 1) + } + l.depth++ +} + +// exitDepthLimit leaves a level of l. If counting started with no computation +// in progress, as in a query, reaching the limit marked a cycle headed at the +// bottom of the stack, which never finishes, so the cycle ends when counting +// does instead. +func (c *Checker) exitDepthLimit(l *depthLimit) { + l.depth-- + if l.depth == 0 && l.start == 0 { + c.endCyclesAt(0) + } +} + +/** + * Pop an entry from the type resolution stack and return its associated result value. The result value will + * be true if no circularities were detected, or false if a circularity was found. + */ +func (c *Checker) popTypeResolution() bool { + n := len(c.resolutions) - 1 + debug.Assert(c.typeResolutionTop == n+1, "resolutions left above a type resolution") + f := &c.resolutions[n] + result := f.typeResolution.result + c.typeResolutionTop = int(f.prevTypeResolution) + c.dropResolution(n) + if len(c.cycleYields) != 0 && c.cycleYields[len(c.cycleYields)-1].end == n { + c.endCycleYield() + } + return result +} + +// beginTypeResolution starts the resolution of propertyName for target, which +// re-entering detects as a cycle. Its resolution shares the work of the +// resolution below it. memo caches its result, if any. +func (c *Checker) beginTypeResolution(target TypeSystemEntity, propertyName TypeSystemPropertyName, memo *memoHeader) { + f := c.pushResolution() + parent := &c.resolutions[len(c.resolutions)-2] + f.depthStart = parent.depthStart + f.serial = parent.serial + f.prevMemo = int32(c.memoTop) + f.isTypeResolution = true + f.prevTypeResolution = int32(c.typeResolutionTop) + f.typeResolution.target = target + f.typeResolution.memo = memo + f.typeResolution.propertyName = propertyName + f.typeResolution.result = true + c.typeResolutionTop = len(c.resolutions) +} + +// topTypeResolution returns the innermost resolution, which must be the +// innermost resolution. +func (c *Checker) topTypeResolution() *TypeResolution { + debug.Assert(c.typeResolutionTop == len(c.resolutions), "resolutions left above a type resolution") + return &c.resolutions[len(c.resolutions)-1].typeResolution } func (c *Checker) reportCircularityError(symbol *ast.Symbol) *Type { @@ -19886,7 +21045,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 } @@ -19917,28 +21076,31 @@ func (c *Checker) getLazyStateOfType(t *Type) *LazyState { func (c *Checker) getPropertiesOfUnionOrIntersectionType(t *Type) []*ast.Symbol { d := t.AsUnionOrIntersectionType() - if d.resolvedProperties == nil { - var checked collections.Set[string] - props := []*ast.Symbol{} - for _, current := range d.types { - for _, prop := range c.getPropertiesOfType(current) { - if !checked.Has(prop.Name()) { - checked.Add(prop.Name()) - combinedProp := c.getPropertyOfUnionOrIntersectionType(t, prop.Name(), t.flags&TypeFlagsIntersection != 0 /*skipObjectFunctionPropertyAugment*/) - if combinedProp != nil { - props = append(props, combinedProp) - } + if props := d.resolvedProperties.cached(c); props != nil { + return props + } + d.resolvedProperties.begin(c) + var checked collections.Set[string] + props := []*ast.Symbol{} + for _, current := range d.types { + for _, prop := range c.getPropertiesOfType(current) { + if !checked.Has(prop.Name()) { + checked.Add(prop.Name()) + combinedProp := c.getPropertyOfUnionOrIntersectionType(t, prop.Name(), t.flags&TypeFlagsIntersection != 0 /*skipObjectFunctionPropertyAugment*/) + if combinedProp != nil { + props = append(props, combinedProp) } } - // The properties of a union type are those that are present in all constituent types, so - // we only need to check the properties of the first type without index signature - if t.flags&TypeFlagsUnion != 0 && len(c.getIndexInfosOfType(current)) == 0 { - break - } } - d.resolvedProperties = props + // The properties of a union type are those that are present in all constituent types, so + // we only need to check the properties of the first type without index signature + if t.flags&TypeFlagsUnion != 0 && len(c.getIndexInfosOfType(current)) == 0 { + break + } } - return d.resolvedProperties + d.resolvedProperties.set(c, props) + c.endMemo() + return props } func (c *Checker) getPropertyOfType(t *Type, name string) *ast.Symbol { @@ -19963,7 +21125,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 @@ -20013,9 +21175,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) { @@ -20157,30 +21325,239 @@ 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, nil) + defer func() { + c.popTypeResolution() + if outermost { + t.objectFlags |= ObjectFlagsMembersResolved + } else { + c.resolutions[enclosing].membersPublished = true + } + if c.logResults() { + c.logMembersDiscard(t) + } + }() + switch { + case t.flags&TypeFlagsObject != 0: + switch { + case t.objectFlags&(ObjectFlagsClassOrInterface|ObjectFlagsReference) != 0: + c.resolveObjectTypeMembers(t) + case t.objectFlags&ObjectFlagsReverseMapped != 0: + c.resolveReverseMappedTypeMembers(t) + case t.objectFlags&ObjectFlagsAnonymous != 0: + c.resolveAnonymousTypeMembers(t) + case t.objectFlags&ObjectFlagsMapped != 0: + c.resolveMappedTypeMembers(t) default: panic("Unhandled case in resolveStructuredTypeMembers") } + case t.flags&TypeFlagsUnion != 0: + c.resolveUnionTypeMembers(t) + case t.flags&TypeFlagsIntersection != 0: + c.resolveIntersectionTypeMembers(t) + default: + panic("Unhandled case in resolveStructuredTypeMembers") } - 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) { + mark := c.markDiscard() + hidden := false + for { + c.beginTypeResolution(t, TypeSystemPropertyNameStructuredMembers, nil) + c.resolveAnonymousTypeMembers(t) + restart := c.topTypeResolution().restartHidden && !hidden + if restart { + // Discard while the cycle is still in progress, as + // popCircularHead does. + c.discardSince(mark) + } + canonical := c.popCircularHead(mark) + if canonical == nil && !restart { + break + } + 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.logRestore(func() { + if _, ok := c.resolvingAnyIndex(memoKeyOf(t, memoStructuredMembers)); ok { + // An enclosing resolution of the same members sets them again. + return + } + c.clearStructuredMembers(t) + if t.objectFlags&(ObjectFlagsClassOrInterface|ObjectFlagsReference) != 0 { + t.AsTypeReference().lazy = nil + } + }) +} + +// logPropertySlotDiscard discards the property in slot index of t, filled on +// first use during a cycle, when the cycle ends. The property may be one of a +// base type whose members the cycle discards. +// +//go:noinline +func (c *Checker) logPropertySlotDiscard(t *StructuredType, lazy *LazyState, index int) { + properties := t.properties + c.logRestore(func() { + properties[index] = nil + lazy.propertiesResolved = false + if t.AsType().AsTypeReference().lazy == lazy { + t.members = nil + } + }) } func (c *Checker) resolveObjectTypeMembers(t *Type) { @@ -20237,7 +21614,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 @@ -20268,15 +21645,12 @@ func (c *Checker) getMemberLayout(t *Type, baseTypes []*Type) *MemberLayout { } source := c.getTargetType(t) key := c.getMemberLayoutKey(source, baseTypes) - layout := c.memberLayoutCache[key] - if layout == nil { - layout = c.createMemberLayout(source, baseTypes) - if c.memberLayoutCache == nil { - c.memberLayoutCache = make(map[CacheHashKey]*MemberLayout) - } - c.memberLayoutCache[key] = layout + if layout, ok := c.memberLayoutCache.cached(c, key); ok { + return layout } - return layout + return c.memberLayoutCache.compute(c, key, func() *MemberLayout { + return c.createMemberLayout(source, baseTypes) + }) } func (c *Checker) getMemberLayoutKey(t *Type, baseTypes []*Type) CacheHashKey { @@ -20355,17 +21729,36 @@ func findIndexInfo(indexInfos []*IndexInfo, keyType *Type) *IndexInfo { } func (c *Checker) getBaseTypes(t *Type) []*Type { + if t.objectFlags&(ObjectFlagsClassOrInterface|ObjectFlagsTuple) == 0 { + return nil + } + if data := t.AsInterfaceType(); data.baseTypesResolved { + // Observing the result is what re-entering its computation amounts + // to, without the resolution. Walks over base types such as + // hasBaseType revisit shared bases many times. + if c.memoActive() { + c.observeMemo(memoKeyOf(t, memoBaseTypes)) + } + return data.resolvedBaseTypes.cached(c) + } + c.beginMemo(memoKeyOf(t, memoBaseTypes)) + result := c.getBaseTypesUncached(t) + c.endMemo() + return result +} + +func (c *Checker) getBaseTypesUncached(t *Type) []*Type { if t.objectFlags&(ObjectFlagsClassOrInterface|ObjectFlagsTuple) == 0 { return nil } data := t.AsInterfaceType() if !data.baseTypesResolved { - if !c.pushTypeResolution(t, TypeSystemPropertyNameResolvedBaseTypes) { - return data.resolvedBaseTypes + if !c.pushTypeResolution(t, TypeSystemPropertyNameResolvedBaseTypes, &data.resolvedBaseTypes.memoHeader) { + return data.resolvedBaseTypes.cached(c) } switch { case t.objectFlags&ObjectFlagsTuple != 0: - data.resolvedBaseTypes = []*Type{c.getTupleBaseType(t)} + data.resolvedBaseTypes.set(c, []*Type{c.getTupleBaseType(t)}) case t.symbol.Flags()&(ast.SymbolFlagsClass|ast.SymbolFlagsInterface) != 0: if t.symbol.Flags()&ast.SymbolFlagsClass != 0 { c.resolveBaseTypesOfClass(t) @@ -20389,8 +21782,11 @@ func (c *Checker) getBaseTypes(t *Type) []*Type { // See https://github.com/microsoft/TypeScript/issues/16861 for an example. t.objectFlags &^= ObjectFlagsMembersResolved data.baseTypesResolved = true + if c.logResults() { + c.discardLog = append(c.discardLog, discardEntry{memo: &data.resolvedBaseTypes.memoHeader, restore: func() { data.baseTypesResolved = false }}) + } } - return data.resolvedBaseTypes + return data.resolvedBaseTypes.cached(c) } func (c *Checker) getTupleBaseType(t *Type) *Type { @@ -20451,7 +21847,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 { @@ -20490,7 +21886,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 } } @@ -20507,10 +21903,12 @@ func (c *Checker) cloneSignature(sig *Signature) *Signature { func (c *Checker) getSignatureInstantiationWithoutFillingInTypeArguments(sig *Signature, typeArguments []*Type) *Signature { key := CachedSignatureKey{sig: sig, key: getTypeListKey(typeArguments)} - instantiation := c.cachedSignatures[key] + instantiation, _ := c.cachedSignatures.cached(c, key) if instantiation == nil { + c.cachedSignatures.begin(c, key) instantiation = c.createSignatureInstantiation(sig, typeArguments) - c.cachedSignatures[key] = instantiation + c.cachedSignatures.set(c, key, instantiation) + c.endMemo() } return instantiation } @@ -20588,10 +21986,12 @@ func (c *Checker) getErasedSignature(signature *Signature) *Signature { return signature } key := CachedSignatureKey{sig: signature, key: SignatureKeyErased} - erased := c.cachedSignatures[key] + erased, _ := c.cachedSignatures.cached(c, key) if erased == nil { + c.cachedSignatures.begin(c, key) erased = c.instantiateSignatureEx(signature, newArrayToSingleTypeMapper(signature.TypeParameters(), c.anyType), true /*eraseTypeParameters*/) - c.cachedSignatures[key] = erased + c.cachedSignatures.set(c, key, erased) + c.endMemo() } return erased } @@ -20601,10 +22001,12 @@ func (c *Checker) getCanonicalSignature(signature *Signature) *Signature { return signature } key := CachedSignatureKey{sig: signature, key: SignatureKeyCanonical} - canonical := c.cachedSignatures[key] + canonical, _ := c.cachedSignatures.cached(c, key) if canonical == nil { + c.cachedSignatures.begin(c, key) canonical = c.createCanonicalSignature(signature) - c.cachedSignatures[key] = canonical + c.cachedSignatures.set(c, key, canonical) + c.endMemo() } return canonical } @@ -20631,9 +22033,10 @@ func (c *Checker) getBaseSignature(signature *Signature) *Signature { return signature } key := CachedSignatureKey{sig: signature, key: SignatureKeyBase} - if cached := c.cachedSignatures[key]; cached != nil { + if cached, _ := c.cachedSignatures.cached(c, key); cached != nil { return cached } + c.cachedSignatures.begin(c, key) baseConstraintMapper := newTypeMapper(typeParameters, core.Map(typeParameters, func(tp *Type) *Type { return core.OrElse(c.getConstraintOfTypeParameter(tp), c.unknownType) })) @@ -20648,7 +22051,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 } @@ -20694,7 +22098,7 @@ func (c *Checker) resolveBaseTypesOfInterface(t *Type) { if !c.isErrorType(baseType) { if c.isValidBaseType(baseType) { if t != baseType && !c.hasBaseType(baseType, t) { - data.resolvedBaseTypes = append(data.resolvedBaseTypes, baseType) + data.resolvedBaseTypes.set(c, append(data.resolvedBaseTypes.cached(c), baseType)) } else { c.reportCircularBaseType(declaration, t) } @@ -20808,16 +22212,28 @@ func (c *Checker) addInheritedMembers(symbols ast.SymbolTable, baseSymbols []*as } func (c *Checker) resolveDeclaredMembers(t *Type) *InterfaceType { + d := t.AsInterfaceType() + key := memoKeyOf(t, memoDeclaredMembers) + if d.declaredMembersResolved { + c.observeFlagMemo(key) + return d + } + c.beginMemo(key) + c.resolveDeclaredMembersUncached(t) + c.endMemo() + return d +} + +func (c *Checker) resolveDeclaredMembersUncached(t *Type) { d := t.AsInterfaceType() if !d.declaredMembersResolved { members := c.getMembersOfSymbol(t.symbol) - d.declaredMembersResolved = true + c.setFlagMemoValue(memoKeyOf(t, memoDeclaredMembers), &d.declaredMembersResolved, true) d.declaredMembers = members d.declaredCallSignatures = c.getSignaturesOfSymbol(d.declaredMembers.Get(ast.InternalSymbolNameCall)) d.declaredConstructSignatures = c.getSignaturesOfSymbol(d.declaredMembers.Get(ast.InternalSymbolNameNew)) d.declaredIndexInfos = c.getIndexInfosOfSymbol(t.symbol) } - return d } func (c *Checker) getIndexInfosOfSymbol(symbol *ast.Symbol) []*IndexInfo { @@ -21044,8 +22460,8 @@ func (c *Checker) getSignatureFromDeclaration(declaration *ast.Node) *Signature // of context-sensitive functions. func (c *Checker) getSignatureFromDeclarationUncontextual(declaration *ast.Node) *Signature { links := c.signatureLinks.Get(declaration) - if links.resolvedSignature != nil { - return links.resolvedSignature + if links.resolvedSignature.cached(c) != nil { + return links.resolvedSignature.cached(c) } var parameters []*ast.Symbol var flags SignatureFlags @@ -21114,14 +22530,14 @@ func (c *Checker) getSignatureFromDeclarationUncontextual(declaration *ast.Node) if ast.IsConstructorTypeNode(declaration) && ast.HasSyntacticModifier(declaration, ast.ModifierFlagsAbstract) || ast.IsConstructorDeclaration(declaration) && ast.HasSyntacticModifier(declaration.Parent, ast.ModifierFlagsAbstract) { flags |= SignatureFlagsAbstract } - if links.resolvedSignature != nil { + if existing := links.resolvedSignature.cached(c); existing != nil { // Computing the signature reached the enclosing call, which // contextually typed the function with a signature of its own, as // when the call is checked first. Keep that one. - return links.resolvedSignature + return existing } - links.resolvedSignature = c.newSignature(flags, declaration, typeParameters, thisParameter, parameters, nil /*resolvedReturnType*/, nil /*resolvedTypePredicate*/, minArgumentCount) - return links.resolvedSignature + links.resolvedSignature.set(c, c.newSignature(flags, declaration, typeParameters, thisParameter, parameters, nil /*resolvedReturnType*/, nil /*resolvedTypePredicate*/, minArgumentCount)) + return links.resolvedSignature.cached(c) } func (c *Checker) getTypeParametersFromDeclaration(declaration *ast.Node) []*Type { @@ -21214,8 +22630,18 @@ func isLateBindableAST(node *ast.Node) bool { } func (c *Checker) getReturnTypeOfSignature(sig *Signature) *Type { - if sig.resolvedReturnType != nil { - return sig.resolvedReturnType + if t := sig.resolvedReturnType.cached(c); t != nil { + return t + } + sig.resolvedReturnType.begin(c) + result := c.getReturnTypeOfSignatureUncached(sig) + c.endMemo() + return result +} + +func (c *Checker) getReturnTypeOfSignatureUncached(sig *Signature) *Type { + if sig.resolvedReturnType.cached(c) != nil { + return sig.resolvedReturnType.cached(c) } if d := sig.declaration; d != nil && sig.target == nil && ast.IsGetAccessorDeclaration(d) && d.Type() == nil { // The type of the accessor infers the same return type separately, and @@ -21223,11 +22649,11 @@ func (c *Checker) getReturnTypeOfSignature(sig *Signature) *Type { // this return type instead, a cycle through the accessor would be // detected at the accessor rather than here. c.getTypeOfSymbol(c.getSymbolOfDeclaration(d)) - if sig.resolvedReturnType != nil { - return sig.resolvedReturnType + if sig.resolvedReturnType.cached(c) != nil { + return sig.resolvedReturnType.cached(c) } } - if !c.pushTypeResolution(sig, TypeSystemPropertyNameResolvedReturnType) { + if !c.pushTypeResolution(sig, TypeSystemPropertyNameResolvedReturnType, &sig.resolvedReturnType.memoHeader) { return c.errorType } var t *Type @@ -21252,25 +22678,31 @@ func (c *Checker) getReturnTypeOfSignature(sig *Signature) *Type { t = c.getOptionalType(t, false /*isProperty*/) } if !c.popTypeResolution() { - if sig.declaration != nil { - typeNode := sig.declaration.Type() - if typeNode != nil { - c.error(typeNode, diagnostics.Return_type_annotation_circularly_references_itself) - } else if c.noImplicitAny { - name := ast.GetNameOfDeclaration(sig.declaration) - if name != nil { - c.error(name, diagnostics.X_0_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions, scanner.DeclarationNameToString(name)) - } else { - c.error(sig.declaration, diagnostics.Function_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions) - } + t = c.circularReturnType(sig) + } + if sig.resolvedReturnType.cached(c) == nil { + sig.resolvedReturnType.set(c, t) + } + return sig.resolvedReturnType.cached(c) +} + +// circularReturnType reports a return type that depends on itself and returns +// the type it resolves to instead. +func (c *Checker) circularReturnType(sig *Signature) *Type { + if sig.declaration != nil { + typeNode := sig.declaration.Type() + if typeNode != nil { + c.error(typeNode, diagnostics.Return_type_annotation_circularly_references_itself) + } else if c.noImplicitAny { + name := ast.GetNameOfDeclaration(sig.declaration) + if name != nil { + c.error(name, diagnostics.X_0_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions, scanner.DeclarationNameToString(name)) + } else { + c.error(sig.declaration, diagnostics.Function_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions) } } - t = c.anyType - } - if sig.resolvedReturnType == nil { - sig.resolvedReturnType = t } - return sig.resolvedReturnType + return c.anyType } func (c *Checker) getNonCircularReturnTypeOfSignature(sig *Signature) *Type { @@ -21875,22 +23307,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 @@ -21915,7 +23347,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())) @@ -21923,7 +23355,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) @@ -22086,7 +23518,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 { @@ -22102,7 +23534,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) @@ -22185,15 +23617,24 @@ func (c *Checker) resolveMappedTypeMembers(t *Type) { } else { forEachType(c.getLowerBoundOfKeyType(constraintType), addMemberForKeyType) } - c.setStructuredTypeMembers(t, members, nil, nil, indexInfos) + c.publishStructuredTypeMembers(t, members, nil, nil, indexInfos) +} + +// mappedTypeContainsError reports whether the type of a property of the +// mapped type t circularly references itself. +func (c *Checker) mappedTypeContainsError(t *Type) bool { + for _, prop := range c.getPropertiesOfType(t) { + c.getTypeOfSymbol(prop) + } + return t.AsMappedType().containsError.cached(c) } func (c *Checker) getTypeOfMappedSymbol(symbol *ast.Symbol) *Type { links := c.valueSymbolLinks.Get(symbol) - if links.resolvedType == nil { + if links.resolvedType.cached(c) == nil { mappedType := links.getContainingType() - if !c.pushTypeResolution(symbol, TypeSystemPropertyNameType) { - mappedType.AsMappedType().containsError = true + if !c.pushTypeResolution(symbol, TypeSystemPropertyNameType, &links.resolvedType.memoHeader) { + mappedType.AsMappedType().containsError.setIdentity(c, true) return c.errorType } templateType := c.getTemplateTypeFromMappedType(core.OrElse(mappedType.AsMappedType().target, mappedType)) @@ -22209,17 +23650,17 @@ func (c *Checker) getTypeOfMappedSymbol(symbol *ast.Symbol) *Type { propType = c.removeMissingOrUndefinedType(propType) } if c.popTypeResolution() { - if links.resolvedType == nil { - links.resolvedType = propType + if links.resolvedType.cached(c) == nil { + links.resolvedType.set(c, propType) } } else { - if links.resolvedType == nil { - links.resolvedType = c.errorType + if links.resolvedType.cached(c) == nil { + links.resolvedType.set(c, c.errorType) } - c.error(c.currentNode, diagnostics.Type_of_property_0_circularly_references_itself_in_mapped_type_1, c.symbolToString(symbol), c.TypeToString(mappedType)) + c.errorAtCurrentNode(diagnostics.Type_of_property_0_circularly_references_itself_in_mapped_type_1, c.symbolToString(symbol), c.TypeToString(mappedType)) } } - return links.resolvedType + return links.resolvedType.cached(c) } // Return the lower bound of the key type in a mapped type. Intuitively, the lower @@ -22272,7 +23713,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 { @@ -22474,18 +23915,18 @@ func (c *Checker) combineUnionOrIntersectionParameters(left *Signature, right *S core.IfElse(isRestParam, ast.CheckFlagsRestParameter, core.IfElse(isOptional, ast.CheckFlagsOptionalParameter, 0))) links := c.valueSymbolLinks.Get(paramSymbol) if isRestParam { - links.resolvedType = c.createArrayType(combinedParamType) + links.resolvedType.setIdentity(c, c.createArrayType(combinedParamType)) } else { - links.resolvedType = combinedParamType + links.resolvedType.setIdentity(c, combinedParamType) } params[i] = paramSymbol } if needsExtraRestElement { restParamSymbol := c.newSymbolEx(ast.SymbolFlagsFunctionScopedVariable, "args", ast.CheckFlagsRestParameter) links := c.valueSymbolLinks.Get(restParamSymbol) - links.resolvedType = c.createArrayType(c.getTypeAtPosition(shorter, longestCount)) + links.resolvedType.setIdentity(c, c.createArrayType(c.getTypeAtPosition(shorter, longestCount))) if shorter == right { - links.resolvedType = c.instantiateType(links.resolvedType, mapper) + links.resolvedType.setIdentity(c, c.instantiateType(links.resolvedType.cached(c), mapper)) } params[longestCount] = restParamSymbol } @@ -22525,7 +23966,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 }) } @@ -22536,7 +23977,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 { @@ -22610,7 +24051,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 } @@ -22633,29 +24074,21 @@ func (c *Checker) getPropertyOfUnionOrIntersectionType(t *Type, name string, ski // these partial properties when identifying discriminant properties, but otherwise they are filtered out // and do not appear to be present in the union type. func (c *Checker) getUnionOrIntersectionProperty(t *Type, name string, skipObjectFunctionPropertyAugment bool) *ast.Symbol { - data := t.AsUnionOrIntersectionType() + d := t.AsUnionOrIntersectionType() + cache := &d.propertyCache if skipObjectFunctionPropertyAugment { - if prop := data.propertyCacheWithoutFunctionPropertyAugment.Get(name); prop != nil { - return prop - } - } else { - if prop := data.propertyCache.Get(name); prop != nil { - return prop - } - // Complete non-augmented properties are also valid for augmented - // lookup. Share the entry instead of retaining it in both tables. - if prop := data.propertyCacheWithoutFunctionPropertyAugment.Get(name); prop != nil && prop.CheckFlags()&ast.CheckFlagsPartial == 0 { - return prop - } + cache = &d.propertyCacheWithoutFunctionPropertyAugment + } + if prop, _ := cache.cached(c, name); prop != nil { + return prop } + // The property is created once, so its identity is kept. + cache.begin(c, name) prop := c.createUnionOrIntersectionProperty(t, name, skipObjectFunctionPropertyAugment) if prop != nil { - if skipObjectFunctionPropertyAugment { - ast.GetSymbolTable(&data.propertyCacheWithoutFunctionPropertyAugment).Set(name, prop) - } else { - ast.GetSymbolTable(&data.propertyCache).Set(name, prop) - } + cache.setIdentity(c, name, prop) } + c.endMemo() return prop } @@ -22800,7 +24233,7 @@ func (c *Checker) createUnionOrIntersectionProperty(containingType *Type, name s var singlePropMapper *TypeMapper if singleProp.Flags()&ast.SymbolFlagsTransient != 0 { links := c.valueSymbolLinks.Get(singleProp) - singlePropType = links.resolvedType + singlePropType = links.resolvedType.cached(c) singlePropMapper = links.mapper } clone := c.createSymbolWithType(singleProp, singlePropType) @@ -22810,7 +24243,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 { @@ -22876,15 +24309,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 @@ -22941,11 +24374,11 @@ type symbolWithTypeKey struct { // 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[key]; existing != nil { + if existing, _ := c.symbolsWithType.get(key); existing != nil { return existing } result := c.createSymbolWithType(source, t) - c.symbolsWithType[key] = result + c.symbolsWithType.intern(key, result) return result } @@ -22953,11 +24386,11 @@ func (c *Checker) getSymbolWithType(source *ast.Symbol, t *Type) *ast.Symbol { // 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[key]; existing != nil { + if existing, _ := c.objectContentTypes.get(key); existing != nil { return existing } result := create() - c.objectContentTypes[key] = result + c.objectContentTypes.intern(key, result) return result } @@ -22967,7 +24400,7 @@ func (c *Checker) createSymbolWithType(source *ast.Symbol, t *Type) *ast.Symbol 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 @@ -23024,10 +24457,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 { @@ -23057,16 +24487,17 @@ func (c *Checker) getResolvedApparentTypeOfMappedType(t *Type) *Type { func (c *Checker) getApparentTypeOfIntersectionType(t *Type, thisArgument *Type) *Type { if t == thisArgument { d := t.AsIntersectionType() - if d.resolvedApparentType == nil { - d.resolvedApparentType = c.getTypeWithThisArgument(t, thisArgument, true /*needApparentType*/) - } - return d.resolvedApparentType + return c.memoCompute(&d.resolvedApparentType, func() *Type { + return c.getTypeWithThisArgument(t, thisArgument, true /*needApparentType*/) + }) } key := CachedTypeKey{kind: CachedTypeKindApparentType, typeId: thisArgument.id} - result := c.cachedTypes[key] + result, _ := c.cachedTypes.cached(c, key) if result == nil { + c.cachedTypes.begin(c, key) result = c.getTypeWithThisArgument(t, thisArgument, true /*needApparentType*/) - c.cachedTypes[key] = result + c.cachedTypes.set(c, key, result) + c.endMemo() } return result } @@ -23081,27 +24512,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 { @@ -23150,7 +24583,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 } @@ -23168,7 +24601,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)) @@ -23194,42 +24627,56 @@ func isConflictingPrivateProperty(prop *ast.Symbol) bool { func (c *Checker) getTypeArguments(t *Type) []*Type { d := t.AsTypeReference() - if d.resolvedTypeArguments == nil { - n := d.target.AsInterfaceType() - if !c.pushTypeResolution(t, TypeSystemPropertyNameResolvedTypeArguments) { - return slices.Repeat([]*Type{c.errorType}, len(n.TypeParameters())) + if typeArguments := d.resolvedTypeArguments.cached(c); typeArguments != nil { + return typeArguments + } + d.resolvedTypeArguments.begin(c) + result := c.getTypeArgumentsUncached(t) + c.endMemo() + return result +} + +func (c *Checker) getTypeArgumentsUncached(t *Type) []*Type { + d := t.AsTypeReference() + n := d.target.AsInterfaceType() + if !c.pushTypeResolution(t, TypeSystemPropertyNameResolvedTypeArguments, &d.resolvedTypeArguments.memoHeader) { + return slices.Repeat([]*Type{c.errorType}, len(n.TypeParameters())) + } + var typeArguments []*Type + node := t.AsTypeReference().node + if node != nil { + switch node.Kind { + case ast.KindTypeReference: + typeArguments = append(n.OuterTypeParameters(), c.getEffectiveTypeArguments(node, n.LocalTypeParameters())...) + case ast.KindArrayType: + typeArguments = []*Type{c.getTypeFromTypeNode(node.AsArrayTypeNode().ElementType)} + case ast.KindTupleType: + typeArguments = core.Map(node.Elements(), c.getTypeFromTypeNode) + default: + panic("Unhandled case in getTypeArguments") } - var typeArguments []*Type - node := t.AsTypeReference().node - if node != nil { - switch node.Kind { - case ast.KindTypeReference: - typeArguments = append(n.OuterTypeParameters(), c.getEffectiveTypeArguments(node, n.LocalTypeParameters())...) - case ast.KindArrayType: - typeArguments = []*Type{c.getTypeFromTypeNode(node.AsArrayTypeNode().ElementType)} - case ast.KindTupleType: - typeArguments = core.Map(node.Elements(), c.getTypeFromTypeNode) - default: - panic("Unhandled case in getTypeArguments") - } + } + if c.popTypeResolution() { + if d.resolvedTypeArguments.peek() == nil { + d.resolvedTypeArguments.set(c, c.instantiateTypes(typeArguments, d.mapper)) } - if c.popTypeResolution() { - if d.resolvedTypeArguments == nil { - d.resolvedTypeArguments = c.instantiateTypes(typeArguments, d.mapper) - } + } else { + if d.resolvedTypeArguments.peek() == nil { + d.resolvedTypeArguments.set(c, slices.Repeat([]*Type{c.errorType}, len(n.TypeParameters()))) + } + message := diagnostics.Tuple_type_arguments_circularly_reference_themselves + var args []any + if d.target.symbol != nil { + message = diagnostics.Type_arguments_for_0_circularly_reference_themselves + args = []any{c.symbolToString(d.target.symbol)} + } + if node != nil { + c.error(node, message, args...) } else { - if d.resolvedTypeArguments == nil { - d.resolvedTypeArguments = slices.Repeat([]*Type{c.errorType}, len(n.TypeParameters())) - } - errorNode := core.IfElse(node != nil, node, c.currentNode) - if d.target.symbol != nil { - c.error(errorNode, diagnostics.Type_arguments_for_0_circularly_reference_themselves, c.symbolToString(d.target.symbol)) - } else { - c.error(errorNode, diagnostics.Tuple_type_arguments_circularly_reference_themselves) - } + c.errorAtCurrentNode(message, args...) } } - return d.resolvedTypeArguments + return d.resolvedTypeArguments.peek() } func (c *Checker) getEffectiveTypeArguments(node *ast.Node, typeParameters []*Type) []*Type { @@ -23296,6 +24743,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 } @@ -23308,39 +24766,69 @@ func (c *Checker) getDefaultFromTypeParameter(t *Type) *Type { func (c *Checker) getResolvedTypeParameterDefault(t *Type) *Type { d := t.AsTypeParameter() - if d.resolvedDefaultType == nil { + if d.resolvedDefaultType.cached(c) == nil { if d.target != nil { targetDefault := c.getResolvedTypeParameterDefault(d.target) if targetDefault != nil { - d.resolvedDefaultType = c.instantiateType(targetDefault, d.mapper) + d.resolvedDefaultType.set(c, c.instantiateType(targetDefault, d.mapper)) } else { - d.resolvedDefaultType = c.noConstraintType + d.resolvedDefaultType.set(c, c.noConstraintType) } } else { - // To block recursion, set the initial value to the resolvingDefaultType. - d.resolvedDefaultType = c.resolvingDefaultType - defaultType := c.noConstraintType - if t.symbol != nil { - defaultDeclaration := core.FirstNonNil(t.symbol.Declarations(), func(decl *ast.Node) *ast.Node { - if ast.IsTypeParameterDeclaration(decl) { - return decl.AsTypeParameterDeclaration().DefaultType - } - return nil - }) - if defaultDeclaration != nil { - defaultType = c.getTypeFromTypeNode(defaultDeclaration) + c.resolveTypeParameterDefault(t) + } + } else if d.resolvedDefaultType.cached(c) == c.resolvingDefaultType { + // If we are called recursively for this type parameter, mark the default as circular. + c.observeCircularHead(t, TypeSystemPropertyNameDefaultType, c.compareTypeParameterDeclarations) + d.resolvedDefaultType.swap(c.circularConstraintType) + return c.circularConstraintType + } + return d.resolvedDefaultType.cached(c) +} + +// resolveTypeParameterDefault resolves the default of a declared type +// parameter. When defaults form a cycle, the first default resolved is the +// one found to be circular, so the default first in program order is always +// resolved first, discarding whatever was computed starting from another. +func (c *Checker) resolveTypeParameterDefault(t *Type) { + d := t.AsTypeParameter() + d.resolvedDefaultType.begin(c) + mark := c.markDiscard() + for { + // To block recursion, set the initial value to the resolvingDefaultType. + // Markers of a resolution in progress are never observed once it + // finishes, so they are not results to discard. + d.resolvedDefaultType.swap(c.resolvingDefaultType) + c.beginTypeResolution(t, TypeSystemPropertyNameDefaultType, nil) + defaultType := c.noConstraintType + if t.symbol != nil { + defaultDeclaration := core.FirstNonNil(t.symbol.Declarations(), func(decl *ast.Node) *ast.Node { + if ast.IsTypeParameterDeclaration(decl) { + return decl.AsTypeParameterDeclaration().DefaultType } - } - if d.resolvedDefaultType == c.resolvingDefaultType { - // If we have not been called recursively, set the correct default type. - d.resolvedDefaultType = defaultType + return nil + }) + if defaultDeclaration != nil { + defaultType = c.getTypeFromTypeNode(defaultDeclaration) } } - } else if d.resolvedDefaultType == c.resolvingDefaultType { - // If we are called recursively for this type parameter, mark the default as circular. - d.resolvedDefaultType = c.circularConstraintType + if d.resolvedDefaultType.swap(nil) != c.resolvingDefaultType { + // We were called recursively, so the default is circular. + defaultType = c.circularConstraintType + } + canonical := c.popCircularHead(mark) + if canonical == nil { + d.resolvedDefaultType.set(c, defaultType) + break + } + c.getResolvedTypeParameterDefault(canonical.(*Type)) } - return d.resolvedDefaultType + c.releaseDiscardMark(mark) + c.endMemo() +} + +func (c *Checker) compareTypeParameterDeclarations(a, b TypeSystemEntity) int { + return c.compareSymbols(a.(*Type).symbol, b.(*Type).symbol) } func (c *Checker) getDefaultOrUnknownFromTypeParameter(t *Type) *Type { @@ -23386,21 +24874,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 } @@ -23411,8 +24911,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++ @@ -23422,13 +24925,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 { @@ -23444,7 +24952,14 @@ 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 { + // 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 + if len(stack) != instantiationTotalDepthLimit { + stack = stack[c.currentResolution().depthStart:] + } + for _, t := range stack { typeCounts[t] = typeCounts[t] + 1 if typeCounts[t] == 3 { symbol := t.symbol @@ -23469,7 +24984,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]{}) } } @@ -23500,16 +25015,21 @@ func (c *Checker) couldContainTypeVariablesWorker(t *Type) bool { if t.flags&TypeFlagsStructuredOrInstantiable == 0 { return false } - objectFlags := t.objectFlags - if objectFlags&ObjectFlagsCouldContainTypeVariablesComputed != 0 { - return objectFlags&ObjectFlagsCouldContainTypeVariables != 0 + if c.objectFlagsKnown(t, ObjectFlagsCouldContainTypeVariablesComputed) { + return t.objectFlags&ObjectFlagsCouldContainTypeVariables != 0 } + return c.objectFlagsCell(t, memoCouldContainTypeVariables, ObjectFlagsCouldContainTypeVariablesComputed, ObjectFlagsCouldContainTypeVariables, false /*inProgress*/, func() ObjectFlags { + return core.IfElse(c.computeCouldContainTypeVariables(t), ObjectFlagsCouldContainTypeVariables, 0) + }) != 0 +} + +func (c *Checker) computeCouldContainTypeVariables(t *Type) bool { + objectFlags := t.objectFlags result := t.flags&TypeFlagsInstantiable != 0 || t.flags&TypeFlagsObject != 0 && !c.isNonGenericTopLevelType(t) && (objectFlags&ObjectFlagsReference != 0 && (t.AsTypeReference().node != nil || core.Some(c.getTypeArguments(t), c.couldContainTypeVariables)) || objectFlags&ObjectFlagsAnonymous != 0 && t.symbol != nil && t.symbol.Flags()&(ast.SymbolFlagsFunction|ast.SymbolFlagsMethod|ast.SymbolFlagsClass|ast.SymbolFlagsTypeLiteral|ast.SymbolFlagsObjectLiteral) != 0 && t.symbol.Declarations() != nil && !isModuleWrapperSymbol(t.symbol) || objectFlags&(ObjectFlagsMapped|ObjectFlagsReverseMapped|ObjectFlagsObjectRestType|ObjectFlagsInstantiationExpressionType) != 0) || t.flags&TypeFlagsUnionOrIntersection != 0 && t.flags&TypeFlagsEnumLiteral == 0 && !c.isNonGenericTopLevelType(t) && core.Some(t.Types(), c.couldContainTypeVariables) - t.objectFlags |= ObjectFlagsCouldContainTypeVariablesComputed | core.IfElse(result, ObjectFlagsCouldContainTypeVariables, 0) return result } @@ -23541,7 +25061,7 @@ func (c *Checker) instantiateTypeWorker(t *Type, m *TypeMapper, alias *TypeAlias objectFlags := t.objectFlags if objectFlags&(ObjectFlagsReference|ObjectFlagsAnonymous|ObjectFlagsMapped) != 0 { if objectFlags&ObjectFlagsReference != 0 && t.AsTypeReference().node == nil { - resolvedTypeArguments := t.AsTypeReference().resolvedTypeArguments + resolvedTypeArguments := t.AsTypeReference().typeArgumentsOfCreation() newTypeArguments := c.instantiateTypes(resolvedTypeArguments, m) if core.Same(newTypeArguments, resolvedTypeArguments) { return t @@ -23630,14 +25150,15 @@ func (c *Checker) getObjectTypeInstantiation(t *Type, m *TypeMapper, alias *Type links := c.typeNodeLinks.Get(declaration) switch { case t.objectFlags&ObjectFlagsReference != 0: // Deferred type reference - target = links.resolvedType + target = c.getTypeFromTypeNodeWorker(declaration) case t.objectFlags&ObjectFlagsInstantiated != 0: target = t.Target() default: target = t } - typeParameters = links.getOuterTypeParameters() + typeParameters = links.cachedOuterTypeParameters(c) if typeParameters == nil { + links.outerTypeParameters.begin(c) // The first time an anonymous type is instantiated we compute and store a list of the type // parameters that are in scope (and therefore potentially referenced). For type literals that // aren't the right hand side of a generic type alias declaration we optimize by reducing the @@ -23660,6 +25181,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 @@ -23693,25 +25215,33 @@ func (c *Checker) getObjectTypeInstantiation(t *Type, m *TypeMapper, alias *Type } data := target.AsObjectType() key := getTypeInstantiationKey(typeArguments, newAlias, t.objectFlags&ObjectFlagsSingleSignatureType != 0) - if data.instantiations == nil { - data.instantiations = make(map[CacheHashKey]*Type) - data.instantiations[getTypeInstantiationKey(typeParameters, target.alias, false)] = target + if data.instantiations.isEmpty() { + data.instantiations.intern(getTypeInstantiationKey(typeParameters, target.alias, false), target) } - result := data.instantiations[key] + result, _ := data.instantiations.cached(c, key) if result == nil { + reports := c.startCurrentNodeErrors() + data.instantiations.begin(c, key) result = instantiate(newTypeMapper(typeParameters, typeArguments)) - data.instantiations[key] = result + data.instantiations.setReported(c, key, result, c.endCurrentNodeErrors(reports)) + c.endMemo() if result.flags&TypeFlagsObjectFlagsType != 0 && result.objectFlags&ObjectFlagsCouldContainTypeVariablesComputed == 0 { // if `result` is one of the object types we tried to make (it may not be, due to how `instantiateMappedType` works), we can carry forward the type variable containment check from the input type arguments resultCouldContainObjectFlags := core.Some(typeArguments, c.couldContainTypeVariables) if result.objectFlags&ObjectFlagsCouldContainTypeVariablesComputed == 0 { + // The flags are part of creating the type, so they are kept for + // as long as the type is, even if created in a cycle that is + // discarded; computed again from the structure of the type, they + // may differ. if result.objectFlags&(ObjectFlagsMapped|ObjectFlagsAnonymous|ObjectFlagsReference) != 0 { result.objectFlags |= ObjectFlagsCouldContainTypeVariablesComputed | core.IfElse(resultCouldContainObjectFlags, ObjectFlagsCouldContainTypeVariables, 0) - } else { + c.setFlagMemo(memoKeyOf(result, memoCouldContainTypeVariables)) + } else if !resultCouldContainObjectFlags { // If none of the type arguments for the outer type parameters contain type variables, it follows // that the instantiated type doesn't reference type variables. // Intrinsics have `CouldContainTypeVariablesComputed` pre-set, so this should only cover unions and intersections resulting from `instantiateMappedType` - result.objectFlags |= core.IfElse(!resultCouldContainObjectFlags, ObjectFlagsCouldContainTypeVariablesComputed, 0) + result.objectFlags |= ObjectFlagsCouldContainTypeVariablesComputed + c.setFlagMemo(memoKeyOf(result, memoCouldContainTypeVariables)) } } } @@ -23782,7 +25312,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: @@ -23809,8 +25339,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.cached(c, key) if result == nil { + reports := c.startCurrentNodeErrors() + root.instantiations.begin(c, key) newMapper := newTypeMapper(root.outerTypeParameters, typeArguments) checkType := root.checkType var distributionType *Type @@ -23827,7 +25359,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 } @@ -23988,18 +25521,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 { @@ -24007,22 +25538,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 { @@ -24124,26 +25652,59 @@ 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) + // The kinds whose type is cached in the node's links can read it, at a + // location where getConditionalFlowTypeOfType leaves it unchanged. + switch node.Kind { + case ast.KindTypeReference, ast.KindExpressionWithTypeArguments, ast.KindUnionType, ast.KindIntersectionType, + ast.KindConditionalType, ast.KindIndexedAccessType, ast.KindArrayType, ast.KindTupleType, ast.KindThisType, + ast.KindTypeOperator, ast.KindLiteralType: + if links := c.typeNodeLinks.TryGet(node); links != nil { + if t := links.resolvedType.peek(); t != nil && !isConditionalFlowTypeLocation(node) && c.readsWithoutMemo(key) { + return t + } + } + } + c.beginMemo(key) + result := c.getTypeFromTypeNodeUncached(node) + c.endMemo() + return result } -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 { + c.typeNodeLinks.Get(node).resolvedType.begin(c) + result := worker(c, node) + c.endMemo() + return result +} + +// 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: @@ -24168,6 +25729,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: @@ -24218,10 +25805,10 @@ func (c *Checker) getTypeFromTypeNodeWorker(node *ast.Node) *Type { func (c *Checker) getTypeFromThisTypeNode(node *ast.Node) *Type { links := c.typeNodeLinks.Get(node) - if links.resolvedType == nil { - links.resolvedType = c.getThisType(node) + if links.resolvedType.cached(c) == nil { + links.resolvedType.set(c, c.getThisType(node)) } - return links.resolvedType + return links.resolvedType.cached(c) } func (c *Checker) getThisType(node *ast.Node) *Type { @@ -24243,66 +25830,66 @@ func (c *Checker) getTypeFromLiteralTypeNode(node *ast.Node) *Type { return c.nullType } links := c.typeNodeLinks.Get(node) - if links.resolvedType == nil { - links.resolvedType = c.getRegularTypeOfLiteralType(c.checkExpression(node.AsLiteralTypeNode().Literal)) + if links.resolvedType.cached(c) == nil { + links.resolvedType.set(c, c.getRegularTypeOfLiteralType(c.checkExpression(node.AsLiteralTypeNode().Literal))) } - return links.resolvedType + return links.resolvedType.cached(c) } func (c *Checker) getTypeFromTypeLiteralOrFunctionOrConstructorTypeNode(node *ast.Node) *Type { links := c.typeNodeLinks.Get(node) - if links.resolvedType == nil { + if links.resolvedType.cached(c) == nil { // Deferred resolution of members is handled by resolveObjectTypeMembers alias := c.getAliasForTypeNode(node) if sym := node.Symbol(); sym == nil || c.getMembersOfSymbol(sym).Len() == 0 && alias == nil { - links.resolvedType = c.emptyTypeLiteralType + links.resolvedType.set(c, c.emptyTypeLiteralType) } else { t := c.newObjectType(ObjectFlagsAnonymous, node.Symbol()) t.alias = alias - links.resolvedType = t + links.resolvedType.set(c, t) } } - return links.resolvedType + return links.resolvedType.cached(c) } func (c *Checker) getTypeFromIndexedAccessTypeNode(node *ast.Node) *Type { links := c.typeNodeLinks.Get(node) - if links.resolvedType == nil { + if links.resolvedType.cached(c) == nil { objectType := c.getTypeFromTypeNode(node.AsIndexedAccessTypeNode().ObjectType) indexType := c.getTypeFromTypeNode(node.AsIndexedAccessTypeNode().IndexType) potentialAlias := c.getAliasForTypeNode(node) - links.resolvedType = c.getIndexedAccessTypeEx(objectType, indexType, AccessFlagsNone, node, potentialAlias) + links.resolvedType.set(c, c.getIndexedAccessTypeEx(objectType, indexType, AccessFlagsNone, node, potentialAlias)) } - return links.resolvedType + return links.resolvedType.cached(c) } func (c *Checker) getTypeFromTypeOperatorNode(node *ast.Node) *Type { links := c.typeNodeLinks.Get(node) - if links.resolvedType == nil { + if links.resolvedType.cached(c) == nil { argType := node.Type() switch node.AsTypeOperatorNode().Operator { case ast.KindKeyOfKeyword: - links.resolvedType = c.getIndexType(c.getTypeFromTypeNode(argType)) + links.resolvedType.set(c, c.getIndexType(c.getTypeFromTypeNode(argType))) case ast.KindUniqueKeyword: if argType.Kind == ast.KindSymbolKeyword { - links.resolvedType = c.getESSymbolLikeTypeForNode(ast.WalkUpParenthesizedTypes(node.Parent)) + links.resolvedType.set(c, c.getESSymbolLikeTypeForNode(ast.WalkUpParenthesizedTypes(node.Parent))) } else { - links.resolvedType = c.errorType + links.resolvedType.set(c, c.errorType) } case ast.KindReadonlyKeyword: - links.resolvedType = c.getTypeFromTypeNode(argType) + links.resolvedType.set(c, c.getTypeFromTypeNode(argType)) default: panic("Unhandled case in getTypeFromTypeOperatorNode") } } - return links.resolvedType + return links.resolvedType.cached(c) } func (c *Checker) getESSymbolLikeTypeForNode(node *ast.Node) *Type { if isValidESSymbolDeclaration(node) { symbol := c.getSymbolOfNode(node) if symbol != nil { - uniqueType := c.uniqueESSymbolTypes[symbol] + uniqueType, _ := c.uniqueESSymbolTypes.get(symbol) if uniqueType == nil { var b strings.Builder b.WriteString(ast.InternalSymbolNamePrefix) @@ -24311,7 +25898,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 } @@ -24321,19 +25908,25 @@ func (c *Checker) getESSymbolLikeTypeForNode(node *ast.Node) *Type { func (c *Checker) getTypeFromTypeReference(node *ast.Node) *Type { links := c.typeNodeLinks.Get(node) - if links.resolvedType == nil { + if links.resolvedType.cached(c) == nil { // Cache both the resolved symbol and the resolved type. The resolved symbol is needed when we check the // type reference in checkTypeReferenceNode. // handle LS queries on the `const` in `x as const` by resolving to the type of `x` if isConstTypeReference(node) && ast.IsAssertionExpression(node.Parent) { - links.resolvedType = c.checkExpressionCached(node.Parent.Expression()) + links.resolvedType.set(c, c.checkExpressionCached(node.Parent.Expression())) } else if t := c.getIntendedTypeFromJSDocTypeReference(node); t != nil { - links.resolvedType = t + links.resolvedType.set(c, t) } else { - links.resolvedType = c.getDistributedTypeParameter(node, c.getTypeReferenceType(node, c.getSymbolFromTypeReference(node))) + t := c.getDistributedTypeParameter(node, c.getTypeReferenceType(node, c.getSymbolFromTypeReference(node))) + if t.objectFlags&ObjectFlagsReference != 0 && t.AsTypeReference().node == node { + // A deferred reference is identified by the node, so it outlives a cycle. + links.resolvedType.setIdentity(c, t) + } else { + links.resolvedType.set(c, t) + } } } - return links.resolvedType + return links.resolvedType.cached(c) } func (c *Checker) getDistributedTypeParameter(node *ast.Node, t *Type) *Type { @@ -24355,15 +25948,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 } @@ -24430,13 +26025,20 @@ func (c *Checker) getIntendedTypeFromJSDocTypeReference(node *ast.Node) *Type { } func (c *Checker) getSymbolFromTypeReference(node *ast.Node) *ast.Symbol { + c.symbolNodeLinks.Get(node).resolvedSymbol.begin(c) + result := c.getSymbolFromTypeReferenceCached(node) + c.endMemo() + return result +} + +func (c *Checker) getSymbolFromTypeReferenceCached(node *ast.Node) *ast.Symbol { links := c.symbolNodeLinks.Get(node) - if links.resolvedSymbol == nil { + if links.resolvedSymbol.cached(c) == nil { // The `const` in a `const` assertion resolves to nothing; resolveName knows not to // report an error for it, so no special-casing is needed here. - links.resolvedSymbol = c.resolveTypeReferenceName(node, ast.SymbolFlagsType, false /*ignoreErrors*/) + links.resolvedSymbol.set(c, c.resolveTypeReferenceName(node, ast.SymbolFlagsType, false /*ignoreErrors*/)) } - return links.resolvedSymbol + return links.resolvedSymbol.cached(c) } func (c *Checker) resolveTypeReferenceName(typeReference *ast.Node, meaning ast.SymbolFlags, ignoreErrors bool) *ast.Symbol { @@ -24479,12 +26081,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 } @@ -24728,10 +26330,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(c.currentNode != nil && 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. @@ -24933,16 +26536,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) @@ -25004,13 +26607,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.cached(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 { @@ -25019,6 +26622,28 @@ func isLocalTypeAlias(symbol *ast.Symbol) bool { } func (c *Checker) getDeclaredTypeOfSymbol(symbol *ast.Symbol) *Type { + key := memoKeyOf(symbol, memoDeclaredType) + var t *Type + switch { + case symbol.Flags()&ast.SymbolFlagsTypeAlias != 0 && symbol.Flags()&(ast.SymbolFlagsClass|ast.SymbolFlagsInterface|ast.SymbolFlagsTypeParameter) == 0: + if links := c.typeAliasLinks.TryGet(symbol); links != nil && c.memoErrorStates == 0 { + t = links.declaredType.peek() + } + case symbol.Flags()&(ast.SymbolFlagsClass|ast.SymbolFlagsInterface|ast.SymbolFlagsTypeParameter|ast.SymbolFlagsEnum|ast.SymbolFlagsEnumMember|ast.SymbolFlagsAlias) != 0: + if links := c.declaredTypeLinks.TryGet(symbol); links != nil { + t = links.declaredType.peek() + } + } + if t != nil && c.readsWithoutMemo(key) { + return t + } + c.beginMemo(key) + result := c.getDeclaredTypeOfSymbolUncached(symbol) + c.endMemo() + return result +} + +func (c *Checker) getDeclaredTypeOfSymbolUncached(symbol *ast.Symbol) *Type { result := c.tryGetDeclaredTypeOfSymbol(symbol) if result == nil { result = c.errorType @@ -25188,20 +26813,21 @@ func (c *Checker) appendTypeParameters(typeParameters []*Type, declarations []*a func (c *Checker) getDeclaredTypeOfTypeParameter(symbol *ast.Symbol) *Type { links := c.declaredTypeLinks.Get(symbol) - if links.declaredType == nil { - links.declaredType = c.newTypeParameter(symbol) + if links.declaredType.cached(c) == nil { + links.declaredType.setIdentity(c, c.newTypeParameter(symbol)) } - return links.declaredType + return links.declaredType.cached(c) } func (c *Checker) getDeclaredTypeOfTypeAlias(symbol *ast.Symbol) *Type { links := c.typeAliasLinks.Get(symbol) - if links.declaredType == nil { + if links.declaredType.cached(c) == nil { // Note that we use the links object as the target here because the symbol object is used as the unique // identity for resolution of the 'type' property in SymbolLinks. - if !c.pushTypeResolution(symbol, TypeSystemPropertyNameDeclaredType) { + if !c.pushTypeResolution(symbol, TypeSystemPropertyNameDeclaredType, &links.declaredType.memoHeader) { return c.errorType } + reports := c.startCurrentNodeErrors() declaration := core.Find(symbol.Declarations(), ast.IsTypeOrJSTypeAliasDeclaration) typeNode := declaration.Type() t := c.getTypeFromTypeNode(typeNode) @@ -25211,8 +26837,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() @@ -25225,16 +26850,18 @@ func (c *Checker) getDeclaredTypeOfTypeAlias(symbol *ast.Symbol) *Type { c.error(errorNode, diagnostics.Type_alias_0_circularly_references_itself, c.symbolToString(symbol)) t = c.errorType } - if links.declaredType == nil { - links.declaredType = t + nodeReports := c.endCurrentNodeErrors(reports) + if links.declaredType.peek() == nil { + links.declaredType.setReported(c, t, nodeReports) } + return links.declaredType.peek() } - return links.declaredType + return links.declaredType.cached(c) } func (c *Checker) getDeclaredTypeOfEnum(symbol *ast.Symbol) *Type { links := c.declaredTypeLinks.Get(symbol) - if !(links.declaredType != nil) { + if !(links.declaredType.cached(c) != nil) { var memberTypeList []*Type for _, declaration := range symbol.Declarations() { if declaration.Kind == ast.KindEnumDeclaration { @@ -25248,7 +26875,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) } } @@ -25264,9 +26891,9 @@ func (c *Checker) getDeclaredTypeOfEnum(symbol *ast.Symbol) *Type { enumType.flags |= TypeFlagsEnumLiteral enumType.symbol = symbol } - links.declaredType = enumType + links.declaredType.setIdentity(c, enumType) } - return links.declaredType + return links.declaredType.cached(c) } func (c *Checker) getEnumMemberValue(node *ast.Node) evaluator.Result { @@ -25286,19 +26913,25 @@ func (c *Checker) createComputedEnumType(symbol *ast.Symbol) *Type { func (c *Checker) getDeclaredTypeOfEnumMember(symbol *ast.Symbol) *Type { links := c.declaredTypeLinks.Get(symbol) - if !(links.declaredType != nil) { + if !(links.declaredType.cached(c) != nil) { enumType := c.getDeclaredTypeOfEnum(c.getParentOfSymbol(symbol)) - if links.declaredType == nil { - links.declaredType = enumType + if links.declaredType.cached(c) == nil { + links.declaredType.setIdentity(c, enumType) } } - return links.declaredType + return links.declaredType.cached(c) } func (c *Checker) computeEnumMemberValues(node *ast.Node) { + c.beginMemo(memoKeyOf(node, memoEnumMemberValue)) + c.computeEnumMemberValuesUncached(node) + c.endMemo() +} + +func (c *Checker) computeEnumMemberValuesUncached(node *ast.Node) { nodeLinks := c.nodeLinks.Get(node) - if !(nodeLinks.flags&NodeCheckFlagsEnumValuesComputed != 0) { - nodeLinks.flags |= NodeCheckFlagsEnumValuesComputed + if nodeLinks.flags&NodeCheckFlagsEnumValuesComputed == 0 { + setFlagMemoBits(c, memoKeyOf(node, memoEnumMemberValue), &nodeLinks.flags, NodeCheckFlagsEnumValuesComputed, NodeCheckFlagsEnumValuesComputed) autoValue := new(jsnum.Number) var previous *ast.Node for _, member := range node.Members() { @@ -25451,36 +27084,37 @@ func (c *Checker) evaluateEnumMember(expr *ast.Node, symbol *ast.Symbol, locatio func (c *Checker) getDeclaredTypeOfAlias(symbol *ast.Symbol) *Type { links := c.declaredTypeLinks.Get(symbol) - if links.declaredType == nil { - links.declaredType = c.getDeclaredTypeOfSymbol(c.resolveAlias(symbol)) + if links.declaredType.cached(c) == nil { + links.declaredType.set(c, c.getDeclaredTypeOfSymbol(c.resolveAlias(symbol))) } - return links.declaredType + return links.declaredType.cached(c) } func (c *Checker) getTypeFromTypeQueryNode(node *ast.Node) *Type { links := c.typeNodeLinks.Get(node) - if links.resolvedType == nil { + if links.resolvedType.cached(c) == nil { // TypeScript 1.0 spec (April 2014): 3.6.3 // The expression is processed as an identifier expression (section 4.3) // or property access expression(section 4.10), // the widened type(section 3.9) of which becomes the result. t := c.checkExpressionWithTypeArguments(node) - links.resolvedType = c.getRegularTypeOfLiteralType(c.getWidenedType(t)) + links.resolvedType.set(c, c.getRegularTypeOfLiteralType(c.getWidenedType(t))) } - return links.resolvedType + return links.resolvedType.cached(c) } func (c *Checker) getTypeFromArrayOrTupleTypeNode(node *ast.Node) *Type { links := c.typeNodeLinks.Get(node) - if links.resolvedType == nil { + if links.resolvedType.cached(c) == nil { target := c.getArrayOrTupleTargetType(node) if target == c.emptyGenericType { - links.resolvedType = c.emptyObjectType + links.resolvedType.set(c, c.emptyObjectType) } else if !(node.Kind == ast.KindTupleType && core.Some(node.Elements(), c.isVariadicTupleElement)) && c.isDeferredTypeReferenceNode(node, false) { if node.Kind == ast.KindTupleType && len(node.Elements()) == 0 { - links.resolvedType = target + links.resolvedType.set(c, target) } else { - links.resolvedType = c.createDeferredTypeReference(target, node, nil /*mapper*/, nil /*alias*/) + // The deferred reference is identified by the node, so it outlives a cycle. + links.resolvedType.setIdentity(c, c.createDeferredTypeReference(target, node, nil /*mapper*/, nil /*alias*/)) } } else { var elementTypes []*Type @@ -25490,13 +27124,13 @@ func (c *Checker) getTypeFromArrayOrTupleTypeNode(node *ast.Node) *Type { elementTypes = core.Map(node.Elements(), c.getTypeFromTypeNode) } if target.objectFlags&ObjectFlagsTuple != 0 { - links.resolvedType = c.createNormalizedTupleType(target, elementTypes) + links.resolvedType.set(c, c.createNormalizedTupleType(target, elementTypes)) } else { - links.resolvedType = c.createTypeReference(target, elementTypes) + links.resolvedType.set(c, c.createTypeReference(target, elementTypes)) } } } - return links.resolvedType + return links.resolvedType.cached(c) } func (c *Checker) isVariadicTupleElement(node *ast.Node) bool { @@ -25521,14 +27155,14 @@ func (c *Checker) isReadonlyTypeOperator(node *ast.Node) bool { func (c *Checker) getTypeFromNamedTupleTypeNode(node *ast.Node) *Type { links := c.typeNodeLinks.Get(node) - if links.resolvedType == nil { + if links.resolvedType.cached(c) == nil { if node.AsNamedTupleMember().DotDotDotToken != nil { - links.resolvedType = c.getTypeFromRestTypeNode(node) + links.resolvedType.set(c, c.getTypeFromRestTypeNode(node)) } else { - links.resolvedType = c.addOptionalityEx(c.getTypeFromTypeNode(node.Type()), true /*isProperty*/, node.QuestionToken() != nil) + links.resolvedType.set(c, c.addOptionalityEx(c.getTypeFromTypeNode(node.Type()), true /*isProperty*/, node.QuestionToken() != nil)) } } - return links.resolvedType + return links.resolvedType.cached(c) } func (c *Checker) getTypeFromRestTypeNode(node *ast.Node) *Type { @@ -25566,16 +27200,16 @@ func (c *Checker) getTypeFromOptionalTypeNode(node *ast.Node) *Type { func (c *Checker) getTypeFromUnionTypeNode(node *ast.Node) *Type { links := c.typeNodeLinks.Get(node) - if links.resolvedType == nil { + if links.resolvedType.cached(c) == nil { alias := c.getAliasForTypeNode(node) - links.resolvedType = c.getUnionTypeEx(core.Map(node.AsUnionTypeNode().Types.Nodes, c.getTypeFromTypeNode), UnionReductionLiteral, alias, nil /*origin*/) + links.resolvedType.set(c, c.getUnionTypeEx(core.Map(node.AsUnionTypeNode().Types.Nodes, c.getTypeFromTypeNode), UnionReductionLiteral, alias, nil /*origin*/)) } - return links.resolvedType + return links.resolvedType.cached(c) } func (c *Checker) getTypeFromIntersectionTypeNode(node *ast.Node) *Type { links := c.typeNodeLinks.Get(node) - if links.resolvedType == nil { + if links.resolvedType.cached(c) == nil { alias := c.getAliasForTypeNode(node) types := core.Map(node.AsIntersectionTypeNode().Types.Nodes, c.getTypeFromTypeNode) // We perform no supertype reduction for X & {} or {} & X, where X is one of string, number, bigint, @@ -25589,14 +27223,14 @@ func (c *Checker) getTypeFromIntersectionTypeNode(node *ast.Node) *Type { noSupertypeReduction = t.flags&(TypeFlagsString|TypeFlagsNumber|TypeFlagsBigInt) != 0 || t.flags&TypeFlagsTemplateLiteral != 0 && c.isPatternLiteralType(t) } } - links.resolvedType = c.getIntersectionTypeEx(types, core.IfElse(noSupertypeReduction, IntersectionFlagsNoSupertypeReduction, 0), alias) + links.resolvedType.set(c, c.getIntersectionTypeEx(types, core.IfElse(noSupertypeReduction, IntersectionFlagsNoSupertypeReduction, 0), alias)) } - return links.resolvedType + return links.resolvedType.cached(c) } func (c *Checker) getTypeFromTemplateTypeNode(node *ast.Node) *Type { links := c.typeNodeLinks.Get(node) - if links.resolvedType == nil { + if links.resolvedType.cached(c) == nil { spans := node.AsTemplateLiteralTypeNode().TemplateSpans texts := make([]string, len(spans.Nodes)+1) types := make([]*Type, len(spans.Nodes)) @@ -25605,28 +27239,28 @@ func (c *Checker) getTypeFromTemplateTypeNode(node *ast.Node) *Type { texts[i+1] = span.AsTemplateLiteralTypeSpan().Literal.Text() types[i] = c.getTypeFromTypeNode(span.Type()) } - links.resolvedType = c.getTemplateLiteralType(texts, types) + links.resolvedType.set(c, c.getTemplateLiteralType(texts, types)) } - return links.resolvedType + return links.resolvedType.cached(c) } func (c *Checker) getTypeFromMappedTypeNode(node *ast.Node) *Type { links := c.typeNodeLinks.Get(node) - if links.resolvedType == nil { + if links.resolvedType.cached(c) == nil { t := c.newObjectType(ObjectFlagsMapped, node.Symbol()) t.AsMappedType().declaration = node.AsMappedTypeNode() t.alias = c.getAliasForTypeNode(node) - links.resolvedType = t + links.resolvedType.set(c, 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 + return links.resolvedType.cached(c) } func (c *Checker) getTypeFromConditionalTypeNode(node *ast.Node) *Type { links := c.typeNodeLinks.Get(node) - if links.resolvedType == nil { + if links.resolvedType.cached(c) == nil { checkType := c.getTypeFromTypeNode(node.AsConditionalTypeNode().CheckType) alias := c.getAliasForTypeNode(node) allOuterTypeParameters := c.getOuterTypeParameters(node, true /*includeThisTypes*/) @@ -25643,16 +27277,14 @@ func (c *Checker) getTypeFromConditionalTypeNode(node *ast.Node) *Type { isDistributive: checkType.flags&TypeFlagsTypeParameter != 0, inferTypeParameters: c.getInferTypeParameters(node), outerTypeParameters: outerTypeParameters, - instantiations: nil, alias: alias, } - links.resolvedType = c.getConditionalType(root, nil /*mapper*/, false /*forConstraint*/, nil) + links.resolvedType.set(c, c.getConditionalType(root, nil /*mapper*/, false /*forConstraint*/, nil)) if outerTypeParameters != nil { - root.instantiations = make(map[CacheHashKey]*Type) - root.instantiations[getConditionalTypeKey(outerTypeParameters, nil /*alias*/, false /*forConstraint*/)] = links.resolvedType + root.instantiations.intern(getConditionalTypeKey(outerTypeParameters, nil /*alias*/, false /*forConstraint*/), links.resolvedType.cached(c)) } } - return links.resolvedType + return links.resolvedType.cached(c) } func (c *Checker) getConditionalType(root *ConditionalRoot, mapper *TypeMapper, forConstraint bool, alias *TypeAlias) *Type { @@ -25666,7 +27298,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) @@ -25839,11 +27471,13 @@ func (c *Checker) getPermissiveInstantiation(t *Type) *Type { return t } key := CachedTypeKey{kind: CachedTypeKindPermissiveInstantiation, typeId: t.id} - if cached := c.cachedTypes[key]; cached != nil { + if cached, _ := c.cachedTypes.cached(c, key); cached != nil { return cached } + c.cachedTypes.begin(c, key) result := c.instantiateType(t, c.permissiveMapper) - c.cachedTypes[key] = result + c.cachedTypes.set(c, key, result) + c.endMemo() return result } @@ -25852,32 +27486,34 @@ func (c *Checker) getRestrictiveInstantiation(t *Type) *Type { return t } key := CachedTypeKey{kind: CachedTypeKindRestrictiveInstantiation, typeId: t.id} - if cached := c.cachedTypes[key]; cached != nil { + if cached, _ := c.cachedTypes.cached(c, key); cached != nil { return cached } + c.cachedTypes.begin(c, key) result := c.instantiateType(t, c.restrictiveMapper) - c.cachedTypes[key] = result - // We set the following so we don't attempt to set the restrictive instance of a restrictive instance - // which is redundant - we'll produce new type identities, but all type params have already been mapped. - // This also gives us a way to detect restrictive instances upon comparisons and _disable_ the "distributeive constraint" - // assignability check for them, which is distinctly unsafe, as once you have a restrctive instance, all the type parameters - // are constrained to `unknown` and produce tons of false positives/negatives! - c.cachedTypes[CachedTypeKey{kind: CachedTypeKindRestrictiveInstantiation, typeId: result.id}] = result + c.cachedTypes.set(c, key, result) + c.endMemo() return result } +// isRestrictiveTypeParameter reports whether t is the restrictive form of a +// type parameter; see getRestrictiveTypeParameter. +func isRestrictiveTypeParameter(t *Type) bool { + return t.flags&TypeFlagsTypeParameter != 0 && t.AsTypeParameter().origin != nil && t.AsTypeParameter().origin.flags&TypeFlagsTypeParameter != 0 +} + func (c *Checker) getRestrictiveTypeParameter(t *Type) *Type { if c.isRestrictivelyUnconstrained(t) { return t } key := CachedTypeKey{kind: CachedTypeKindRestrictiveTypeParameter, typeId: t.id} - if cached := c.cachedTypes[key]; cached != nil { + if cached, _ := c.cachedTypes.cached(c, key); cached != nil { return cached } result := c.newTypeParameter(t.symbol) - result.AsTypeParameter().constraint = c.noConstraintType + result.AsTypeParameter().constraint.intern(c.noConstraintType) result.AsTypeParameter().origin = t - c.cachedTypes[key] = result + c.cachedTypes.intern(key, result) return result } @@ -25887,11 +27523,13 @@ func (c *Checker) getRestrictiveTypeParameter(t *Type) *Type { // constraint of an infer type parameter would make depend on what was asked // first. func (c *Checker) isRestrictivelyUnconstrained(t *Type) bool { + if isRestrictiveTypeParameter(t) { + return true + } if t.symbol != nil && core.Some(t.symbol.Declarations(), ast.IsTypeParameterDeclaration) { return isUnconstrainedTypeParameter(t) } - constraint := t.AsTypeParameter().constraint - return constraint == nil || constraint == c.noConstraintType + return c.getConstraintOfTypeParameter(t) == nil } func (c *Checker) restrictiveMapperWorker(t *Type) *Type { @@ -25910,57 +27548,53 @@ func (c *Checker) permissiveMapperWorker(t *Type) *Type { func (c *Checker) getTrueTypeFromConditionalType(t *Type) *Type { d := t.AsConditionalType() - if d.resolvedTrueType == nil { - d.resolvedTrueType = c.instantiateType(c.getTypeFromTypeNode(d.root.node.TrueType), d.mapper) - } - return d.resolvedTrueType + return c.memoCompute(&d.resolvedTrueType, func() *Type { + return c.instantiateType(c.getTypeFromTypeNode(d.root.node.TrueType), d.mapper) + }) } func (c *Checker) getFalseTypeFromConditionalType(t *Type) *Type { d := t.AsConditionalType() - if d.resolvedFalseType == nil { - d.resolvedFalseType = c.instantiateType(c.getTypeFromTypeNode(d.root.node.FalseType), d.mapper) - } - return d.resolvedFalseType + return c.memoCompute(&d.resolvedFalseType, func() *Type { + return c.instantiateType(c.getTypeFromTypeNode(d.root.node.FalseType), d.mapper) + }) } func (c *Checker) getInferredTrueTypeFromConditionalType(t *Type) *Type { d := t.AsConditionalType() - if d.resolvedInferredTrueType == nil { + return c.memoCompute(&d.resolvedInferredTrueType, func() *Type { if d.combinedMapper != nil { - d.resolvedInferredTrueType = c.instantiateType(c.getTypeFromTypeNode(d.root.node.TrueType), d.combinedMapper) - } else { - d.resolvedInferredTrueType = c.getTrueTypeFromConditionalType(t) + return c.instantiateType(c.getTypeFromTypeNode(d.root.node.TrueType), d.combinedMapper) } - } - return d.resolvedInferredTrueType + return c.getTrueTypeFromConditionalType(t) + }) } func (c *Checker) getTypeFromInferTypeNode(node *ast.Node) *Type { links := c.typeNodeLinks.Get(node) - if links.resolvedType == nil { - links.resolvedType = c.getDeclaredTypeOfTypeParameter(c.getSymbolOfDeclaration(node.AsInferTypeNode().TypeParameter)) + if links.resolvedType.cached(c) == nil { + links.resolvedType.set(c, c.getDeclaredTypeOfTypeParameter(c.getSymbolOfDeclaration(node.AsInferTypeNode().TypeParameter))) } - return links.resolvedType + return links.resolvedType.cached(c) } func (c *Checker) getTypeFromImportTypeNode(node *ast.Node) *Type { links := c.typeNodeLinks.Get(node) - if links.resolvedType == nil { + if links.resolvedType.cached(c) == nil { n := node.AsImportTypeNode() if !ast.IsLiteralImportTypeNode(node) { c.error(n.Argument, diagnostics.String_literal_expected) - c.symbolNodeLinks.Get(node).resolvedSymbol = c.unknownSymbol - links.resolvedType = c.errorType - return links.resolvedType + c.symbolNodeLinks.Get(node).resolvedSymbol.set(c, c.unknownSymbol) + links.resolvedType.set(c, c.errorType) + return links.resolvedType.cached(c) } targetMeaning := core.IfElse(n.IsTypeOf, ast.SymbolFlagsValue, ast.SymbolFlagsType) // TODO: Future work: support unions/generics/whatever via a deferred import-type innerModuleSymbol := c.resolveExternalModuleName(node, n.Argument.AsLiteralTypeNode().Literal, false /*ignoreErrors*/, c.getTypeFromImportAttributes(ast.GetImportAttributes(node))) if innerModuleSymbol == nil { - c.symbolNodeLinks.Get(node).resolvedSymbol = c.unknownSymbol - links.resolvedType = c.errorType - return links.resolvedType + c.symbolNodeLinks.Get(node).resolvedSymbol.set(c, c.unknownSymbol) + links.resolvedType.set(c, c.errorType) + return links.resolvedType.cached(c) } moduleSymbol := c.resolveExternalModuleSymbol(innerModuleSymbol, false /*dontResolveAlias*/) if !ast.NodeIsMissing(n.Qualifier) { @@ -25995,28 +27629,28 @@ func (c *Checker) getTypeFromImportTypeNode(node *ast.Node) *Type { next := core.OrElse(symbolFromModule, symbolFromVariable) if next == nil { c.error(current, diagnostics.Namespace_0_has_no_exported_member_1, c.getFullyQualifiedName(currentNamespace, nil), scanner.DeclarationNameToString(current)) - links.resolvedType = c.errorType - return links.resolvedType + links.resolvedType.set(c, c.errorType) + return links.resolvedType.cached(c) } - c.symbolNodeLinks.Get(current).resolvedSymbol = next - c.symbolNodeLinks.Get(current.Parent).resolvedSymbol = next + c.symbolNodeLinks.Get(current).resolvedSymbol.set(c, next) + c.symbolNodeLinks.Get(current.Parent).resolvedSymbol.set(c, next) currentNamespace = next } - links.resolvedType = c.resolveImportSymbolType(node, currentNamespace, targetMeaning) + links.resolvedType.set(c, c.resolveImportSymbolType(node, currentNamespace, targetMeaning)) } else { if c.getSymbolFlags(moduleSymbol)&targetMeaning != 0 { - links.resolvedType = c.resolveImportSymbolType(node, moduleSymbol, targetMeaning) + links.resolvedType.set(c, c.resolveImportSymbolType(node, moduleSymbol, targetMeaning)) } else { message := core.IfElse(targetMeaning == ast.SymbolFlagsValue, diagnostics.Module_0_does_not_refer_to_a_value_but_is_used_as_a_value_here, diagnostics.Module_0_does_not_refer_to_a_type_but_is_used_as_a_type_here_Did_you_mean_typeof_import_0) c.error(node, message, n.Argument.AsLiteralTypeNode().Literal.Text()) - c.symbolNodeLinks.Get(node).resolvedSymbol = c.unknownSymbol - links.resolvedType = c.errorType + c.symbolNodeLinks.Get(node).resolvedSymbol.set(c, c.unknownSymbol) + links.resolvedType.set(c, c.errorType) } } } - return links.resolvedType + return links.resolvedType.cached(c) } func (c *Checker) getIdentifierChain(node *ast.Node) []*ast.Node { @@ -26028,7 +27662,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) @@ -26052,18 +27686,22 @@ func (c *Checker) getGlobalStrictFunctionType(name string) *Type { } func (c *Checker) getGlobalImportMetaExpressionType() *Type { - if c.deferredGlobalImportMetaExpressionType == nil { - // Create a synthetic type `ImportMetaExpression { meta: MetaProperty }` - symbol := c.newSymbol(ast.SymbolFlagsNone, "ImportMetaExpression") - importMetaType := c.getGlobalImportMetaType() - metaPropertySymbol := c.newSymbolEx(ast.SymbolFlagsProperty, "meta", ast.CheckFlagsReadonly) - metaPropertySymbol.SetParent(symbol) - c.valueSymbolLinks.Get(metaPropertySymbol).resolvedType = importMetaType - members := createSymbolTable([]*ast.Symbol{metaPropertySymbol}) - symbol.SetMembers(members, &c.symbolExtraArena) - c.deferredGlobalImportMetaExpressionType = c.newAnonymousType(symbol, members, nil, nil, nil) + if t := c.deferredGlobalImportMetaExpressionType.cached(c); t != nil { + return t } - return c.deferredGlobalImportMetaExpressionType + c.deferredGlobalImportMetaExpressionType.begin(c) + // Create a synthetic type `ImportMetaExpression { meta: MetaProperty }` + symbol := c.newSymbol(ast.SymbolFlagsNone, "ImportMetaExpression") + importMetaType := c.getGlobalImportMetaType() + metaPropertySymbol := c.newSymbolEx(ast.SymbolFlagsProperty, "meta", ast.CheckFlagsReadonly) + metaPropertySymbol.SetParent(symbol) + c.valueSymbolLinks.Get(metaPropertySymbol).resolvedType.intern(importMetaType) + members := createSymbolTable([]*ast.Symbol{metaPropertySymbol}) + symbol.SetMembers(members, &c.symbolExtraArena) + t := c.newAnonymousType(symbol, members, nil, nil, nil) + c.deferredGlobalImportMetaExpressionType.set(c, t) + c.endMemo() + return t } func (c *Checker) createIterableType(iteratedType *Type) *Type { @@ -26129,10 +27767,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 } @@ -26161,7 +27799,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) } @@ -26170,28 +27808,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 @@ -26255,17 +27892,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 @@ -26311,10 +27951,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 { @@ -26381,7 +28019,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) } @@ -26486,14 +28124,14 @@ func (c *Checker) tryCreateTypeReference(target *Type, typeArguments []*Type) *T func (c *Checker) createTypeReference(target *Type, typeArguments []*Type) *Type { id := getTypeListKey(typeArguments) intf := target.AsInterfaceType() - if t, ok := intf.instantiations[id]; ok { + if t, ok := intf.instantiations.cached(c, id); ok { return t } t := c.newObjectType(ObjectFlagsReference|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 } @@ -26517,12 +28155,18 @@ func (c *Checker) cloneTypeReference(source *Type) *Type { t := c.newObjectType(ObjectFlagsReference, source.symbol) t.objectFlags = source.objectFlags &^ ObjectFlagsMembersResolved t.AsTypeReference().target = source.AsTypeReference().target - t.AsTypeReference().resolvedTypeArguments = source.AsTypeReference().resolvedTypeArguments + t.AsTypeReference().resolvedTypeArguments.intern(c.getTypeArguments(source)) return t } +// setStructuredTypeMembers sets the members of a type being created, which +// are then resolved. func (c *Checker) setStructuredTypeMembers(t *Type, members ast.SymbolTable, callSignatures []*Signature, constructSignatures []*Signature, indexInfos []*IndexInfo) { t.objectFlags |= ObjectFlagsMembersResolved + c.setStructuredTypeData(t, members, callSignatures, constructSignatures, indexInfos) +} + +func (c *Checker) setStructuredTypeData(t *Type, members ast.SymbolTable, callSignatures []*Signature, constructSignatures []*Signature, indexInfos []*IndexInfo) { data := t.AsStructuredType() data.members = members data.properties = c.getNamedMembers(members) @@ -26621,6 +28265,12 @@ func (c *Checker) newConditionalType(root *ConditionalRoot, mapper *TypeMapper, data.extendsType = c.instantiateType(root.extendsType, mapper) data.mapper = mapper data.combinedMapper = combinedMapper + // A restrictive instantiation maps the outer type parameters to their + // restrictive forms, which leave the distributive constraint meaningless; + // see getConstraintOfDistributiveConditionalType. + if mapper != nil { + data.restrictive = core.Some(root.outerTypeParameters, func(p *Type) bool { return isRestrictiveTypeParameter(mapper.Map(p)) }) + } return c.newType(TypeFlagsConditional, ObjectFlagsNone, data.AsType(), typeKindConditional) } @@ -26640,10 +28290,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 } @@ -26690,10 +28340,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 } @@ -26707,19 +28357,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 } @@ -26756,11 +28406,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 } @@ -26768,11 +28418,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 } @@ -26863,11 +28513,13 @@ func (c *Checker) getBaseTypeOfEnumLikeType(t *Type) *Type { func (c *Checker) getBaseTypeOfLiteralTypeUnion(t *Type) *Type { key := CachedTypeKey{kind: CachedTypeKindLiteralUnionBaseType, typeId: t.id} - if cached, ok := c.cachedTypes[key]; ok { + if cached, ok := c.cachedTypes.cached(c, key); ok { return cached } + c.cachedTypes.begin(c, key) result := c.mapType(t, c.getBaseTypeOfLiteralType) - c.cachedTypes[key] = result + c.cachedTypes.set(c, key, result) + c.endMemo() return result } @@ -27037,10 +28689,12 @@ func (c *Checker) getUnionTypeEx(types []*Type, unionReduction UnionReduction, a id1, id2 = id2, id1 } key := UnionOfUnionKey{id1: id1, id2: id2, r: unionReduction, a: getAliasKey(alias)} - t := c.unionOfUnionTypes[key] + t, _ := c.unionOfUnionTypes.cached(c, key) if t == nil { + c.unionOfUnionTypes.begin(c, key) t = c.getUnionTypeWorker(types, unionReduction, alias, nil /*origin*/) - c.unionOfUnionTypes[key] = t + c.unionOfUnionTypes.set(c, key, t) + c.endMemo() } return t } @@ -27141,7 +28795,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 @@ -27149,13 +28803,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) { @@ -27336,9 +28990,10 @@ func (c *Checker) removeSubtypes(types []*Type, hasObjectTypes bool) []*Type { return types } key := getTypeListKey(types) - if cached := c.subtypeReductionCache[key]; cached != nil { + if cached, _ := c.subtypeReductionCache.cached(c, key); cached != nil { return cached } + c.subtypeReductionCache.begin(c, key) // We assume that redundant primitive types have already been removed from the types array and that there // are no any and unknown types in the array. Thus, the only possible supertypes for primitive types are empty // object types, and if none of those are present we can exclude primitive types from the subtype check. @@ -27392,7 +29047,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 } } @@ -27417,7 +29073,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 } @@ -27564,8 +29221,9 @@ func (c *Checker) getIntersectionTypeEx(types []*Type, flags IntersectionFlags, } } key := getIntersectionKey(typeSet, flags, alias) - result := c.intersectionTypes[key] + result, _ := c.intersectionTypes.cached(c, key) if result == nil { + c.intersectionTypes.begin(c, key) if includes&TypeFlagsUnion != 0 { var reduced bool typeSet, reduced = c.intersectUnionsOfPrimitiveTypes(typeSet) @@ -27601,6 +29259,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) @@ -27616,7 +29275,8 @@ func (c *Checker) getIntersectionTypeEx(types []*Type, flags IntersectionFlags, } else { 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 } @@ -27630,12 +29290,12 @@ func (c *Checker) getIntersectionTypeWithContent(objectFlags ObjectFlags, typeSe b.writeUint32(uint32(objectFlags)) b.writeAlias(alias) key := b.hash() - if existing := c.intersectionContentTypes[key]; existing != nil { + if existing, _ := c.intersectionContentTypes.get(key); existing != nil { return existing } result := c.newIntersectionType(objectFlags, typeSet) result.alias = alias - c.intersectionContentTypes[key] = result + c.intersectionContentTypes.intern(key, result) return result } @@ -28072,7 +29732,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 @@ -28137,9 +29797,10 @@ func (c *Checker) getExtractStringType(t *Type) *Type { func (c *Checker) getLiteralTypeFromProperties(t *Type, include TypeFlags, includeOrigin bool) *Type { key := PropertiesTypesKey{typeId: t.id, include: include, includeOrigin: includeOrigin} - if cached, ok := c.propertiesTypes[key]; ok { + if cached, ok := c.propertiesTypes.cached(c, key); ok { return cached } + c.propertiesTypes.begin(c, key) var origin *Type if includeOrigin && t.objectFlags&(ObjectFlagsClassOrInterface|ObjectFlagsReference) != 0 || t.alias != nil { origin = c.newIndexType(t, IndexFlagsNone) @@ -28160,7 +29821,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 } @@ -28221,30 +29883,37 @@ func isInvalidComputedPropertyName(node *ast.Node) bool { } func (c *Checker) checkComputedPropertyName(node *ast.Node) *Type { + c.typeNodeLinks.Get(node).resolvedType.begin(c) + result := c.checkComputedPropertyNameUncached(node) + c.endMemo() + return result +} + +func (c *Checker) checkComputedPropertyNameUncached(node *ast.Node) *Type { links := c.typeNodeLinks.Get(node) - if links.resolvedType == nil { + if links.resolvedType.cached(c) == nil { if isInvalidComputedPropertyName(node) { - links.resolvedType = c.errorType - return links.resolvedType + links.resolvedType.set(c, c.errorType) + return links.resolvedType.cached(c) } - if !c.pushTypeResolution(node, TypeSystemPropertyNameComputedPropertyName) { + if !c.pushTypeResolution(node, TypeSystemPropertyNameComputedPropertyName, &links.resolvedType.memoHeader) { return c.errorType } t := c.checkExpression(node.Expression()) c.popTypeResolution() - if links.resolvedType != nil { - return links.resolvedType + if links.resolvedType.cached(c) != nil { + return links.resolvedType.cached(c) } - links.resolvedType = t + links.resolvedType.set(c, t) // This will allow types number, string, symbol or any. It will also allow enums, the unknown // type, and any union of these types (like string | number). - if links.resolvedType.flags&TypeFlagsNullable != 0 || - !c.isTypeAssignableToKind(links.resolvedType, TypeFlagsStringLike|TypeFlagsNumberLike|TypeFlagsESSymbolLike) && - !c.isTypeAssignableTo(links.resolvedType, c.stringNumberSymbolType) { + if links.resolvedType.cached(c).flags&TypeFlagsNullable != 0 || + !c.isTypeAssignableToKind(links.resolvedType.cached(c), TypeFlagsStringLike|TypeFlagsNumberLike|TypeFlagsESSymbolLike) && + !c.isTypeAssignableTo(links.resolvedType.cached(c), c.stringNumberSymbolType) { c.error(node, diagnostics.A_computed_property_name_must_be_of_type_string_number_symbol_or_any) } } - return links.resolvedType + return links.resolvedType.cached(c) } func (c *Checker) isNoInferType(t *Type) bool { @@ -28283,11 +29952,11 @@ func (c *Checker) getIndexTypeForGenericType(t *Type, indexFlags IndexFlags) *Ty kind: core.IfElse(indexFlags&IndexFlagsStringsOnly != 0, CachedTypeKindStringIndexType, CachedTypeKindIndexType), typeId: t.id, } - if indexType := c.cachedTypes[key]; indexType != nil { + if indexType, _ := c.cachedTypes.cached(c, key); indexType != nil { return indexType } indexType := c.newIndexType(t, indexFlags&IndexFlagsStringsOnly) - c.cachedTypes[key] = indexType + c.cachedTypes.intern(key, indexType) return indexType } @@ -28388,11 +30057,11 @@ func (c *Checker) getIndexedAccessTypeOrUndefined(objectType *Type, indexType *T // Defer the operation by creating an indexed access type. persistentAccessFlags := accessFlags & AccessFlagsPersistent key := getIndexedAccessKey(objectType, indexType, persistentAccessFlags, alias) - t := c.indexedAccessTypes[key] + t, _ := c.indexedAccessTypes.get(key) if t == nil { t = c.newIndexedAccessType(objectType, indexType, persistentAccessFlags) t.alias = alias - c.indexedAccessTypes[key] = t + c.indexedAccessTypes.intern(key, t) } return t } @@ -28465,7 +30134,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 @@ -28564,7 +30233,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)) @@ -28845,11 +30514,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 } @@ -28896,68 +30565,33 @@ type baseConstraintWalk struct { } func (c *Checker) getResolvedBaseConstraint(t *Type, stack []RecursionId) *Type { - constrained := t.AsConstrainedType() - if constrained == nil { - return t - } - if constrained.resolvedBaseConstraint != nil { + if constrained := t.AsConstrainedType(); constrained != nil && constrained.resolvedBaseConstraint.peek() != nil { + // A resolved base constraint is only read. if len(stack) != 0 { depth := int32(len(stack)) + int32(t.baseConstraintHeight) if depth >= baseConstraintFreeDepth { - constraint, _, _ := c.resolveBaseConstraint(t, stack, TypeSystemPropertyNameBaseConstraintInWalk) + constraint, _, _ := c.resolveBaseConstraint(t, stack, TypeSystemPropertyNameBaseConstraintInWalk, nil) return constraint } c.baseConstraintWalk.depth = max(c.baseConstraintWalk.depth, depth) } - return constrained.resolvedBaseConstraint + return constrained.resolvedBaseConstraint.cached(c) } saveWalk := c.baseConstraintWalk if len(stack) == 0 { c.baseConstraintWalk = baseConstraintWalk{} } - constraint, height, gaveUp := c.resolveBaseConstraint(t, stack, TypeSystemPropertyNameResolvedBaseConstraint) + c.beginMemo(memoKeyOf(t, memoBaseConstraint)) + result := c.getResolvedBaseConstraintUncached(t, stack) + c.endMemo() if len(stack) == 0 { c.baseConstraintWalk = saveWalk } - if gaveUp && len(stack) != 0 { - // Depends on the walk it was computed in. - return constraint - } - if constrained.resolvedBaseConstraint == nil { - t.baseConstraintHeight = uint8(min(height, math.MaxUint8)) - constrained.resolvedBaseConstraint = constraint - } - return constraint -} - -// resolveBaseConstraint computes the base constraint of t inside the walk -// with stack as the resolution of propertyName, and returns it with the depth -// its own walk reached and whether its own walk gave up. -func (c *Checker) resolveBaseConstraint(t *Type, stack []RecursionId, propertyName TypeSystemPropertyName) (*Type, int32, bool) { - if !c.pushTypeResolution(t, propertyName) { - return c.circularConstraintType, 0, false - } - constraint, height, gaveUp := c.walkBaseConstraint(t, stack) - if !c.popTypeResolution() { - if t.flags&TypeFlagsTypeParameter != 0 { - errorNode := c.getConstraintDeclaration(t) - if errorNode != nil { - diagnostic := c.error(errorNode, diagnostics.Type_parameter_0_has_a_circular_constraint, c.TypeToString(t)) - if c.currentNode != nil && !isNodeDescendantOf(errorNode, c.currentNode) && !isNodeDescendantOf(c.currentNode, errorNode) { - diagnostic.AddRelatedInfo(NewDiagnosticForNode(c.currentNode, diagnostics.Circularity_originates_in_type_at_this_location)) - } - } - } - constraint = c.circularConstraintType - } - if constraint == nil { - constraint = c.noConstraintType - } - return constraint, height, gaveUp + return result } func (c *Checker) isBaseConstraintInProgress(t *Type) bool { - return c.findResolutionCycleStartIndex(t, TypeSystemPropertyNameResolvedBaseConstraint) >= 0 || c.findResolutionCycleStartIndex(t, TypeSystemPropertyNameBaseConstraintInWalk) >= 0 + return c.isResolutionInProgress(t, TypeSystemPropertyNameResolvedBaseConstraint) || c.isResolutionInProgress(t, TypeSystemPropertyNameBaseConstraintInWalk) } // walkBaseConstraint computes the base constraint of t inside the walk with @@ -28984,6 +30618,59 @@ func (c *Checker) walkBaseConstraint(t *Type, stack []RecursionId) (*Type, int32 return constraint, walk.depth - int32(len(stack)), walk.gaveUp } +func (c *Checker) getResolvedBaseConstraintUncached(t *Type, stack []RecursionId) *Type { + constrained := t.AsConstrainedType() + if constrained == nil { + return t + } + if constrained.resolvedBaseConstraint.cached(c) != nil { + return constrained.resolvedBaseConstraint.cached(c) + } + constraint, height, gaveUp := c.resolveBaseConstraint(t, stack, TypeSystemPropertyNameResolvedBaseConstraint, &constrained.resolvedBaseConstraint.memoHeader) + if gaveUp && len(stack) != 0 { + // Depends on the walk it was computed in. + return constraint + } + if constrained.resolvedBaseConstraint.cached(c) == nil { + t.baseConstraintHeight = uint8(min(height, math.MaxUint8)) + constrained.resolvedBaseConstraint.set(c, constraint) + } + return constraint +} + +// resolveBaseConstraint computes the base constraint of t inside the walk +// with stack as the resolution of propertyName, and returns it with the depth +// its own walk reached and whether its own walk gave up. +func (c *Checker) resolveBaseConstraint(t *Type, stack []RecursionId, propertyName TypeSystemPropertyName, memo *memoHeader) (*Type, int32, bool) { + if !c.pushTypeResolution(t, propertyName, memo) { + return c.circularConstraintType, 0, false + } + constraint, height, gaveUp := c.walkBaseConstraint(t, stack) + if !c.popTypeResolution() { + if t.flags&TypeFlagsTypeParameter != 0 { + errorNode := c.getConstraintDeclaration(t) + if errorNode != nil { + 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. + c.reportAtCurrentNodeOnce(func(c *Checker, node *ast.Node) { + diagnostic := c.error(errorNode, diagnostics.Type_parameter_0_has_a_circular_constraint, typeString) + if node != nil && !isNodeDescendantOf(errorNode, node) && !isNodeDescendantOf(node, errorNode) { + diagnostic.AddRelatedInfo(NewDiagnosticForNode(node, diagnostics.Circularity_originates_in_type_at_this_location)) + } + }) + } + } + constraint = c.circularConstraintType + } + if constraint == nil { + constraint = c.noConstraintType + } + return constraint, height, gaveUp +} + func (c *Checker) computeBaseConstraint(t *Type, stack []RecursionId) *Type { switch { case t.flags&TypeFlagsTypeParameter != 0: @@ -29057,12 +30744,12 @@ func (c *Checker) computeBaseConstraint(t *Type, stack []RecursionId) *Type { } return c.getNextBaseConstraint(c.getIndexedAccessTypeOrUndefined(baseObjectType, baseIndexType, t.AsIndexedAccessType().accessFlags, nil, nil), stack) case t.flags&TypeFlagsConditional != 0: - if c.conditionalConstraintDepth >= 100 { + if c.depthLimitReached(&c.conditionalConstraintDepth, 100) { return nil } - c.conditionalConstraintDepth++ + c.enterDepthLimit(&c.conditionalConstraintDepth) constraint := c.getConstraintFromConditionalType(t) - c.conditionalConstraintDepth-- + c.exitDepthLimit(&c.conditionalConstraintDepth) return c.getNextBaseConstraint(constraint, stack) case t.flags&TypeFlagsSubstitution != 0: return c.getNextBaseConstraint(c.getSubstitutionIntersection(t), stack) @@ -29223,7 +30910,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 { @@ -29243,9 +30930,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) } @@ -29299,14 +30986,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 } @@ -29421,16 +31110,24 @@ func (c *Checker) getSimplifiedIndexType(t *Type) *Type { // the target of an assignment. func (c *Checker) getSimplifiedIndexedAccessType(t *Type, writing bool) *Type { key := CachedTypeKey{kind: core.IfElse(writing, CachedTypeKindIndexedAccessForWriting, CachedTypeKindIndexedAccessForReading), typeId: t.id} - if cached := c.cachedTypes[key]; cached != nil { - return core.IfElse(cached == c.circularConstraintType, t, cached) + if cached, _ := c.cachedTypes.cached(c, key); cached != nil { + return cached } - c.cachedTypes[key] = t + propertyName := core.IfElse(writing, TypeSystemPropertyNameSimplifiedForWriting, TypeSystemPropertyNameSimplifiedForReading) + if c.isResolvingAnywhere(t, propertyName) { + // Resolve circular references to t itself while simplifying. + return t + } + c.cachedTypes.begin(c, key) + c.beginTypeResolution(t, propertyName, nil) result := c.getSimplifiedIndexedAccessTypeWorker(t, writing) if result != t { // If the simplification is a union type that includes t, remove t from the type. result = c.removeType(result, t) - c.cachedTypes[key] = result } + c.cachedTypes.set(c, key, result) + c.popTypeResolution() + c.endMemo() return result } @@ -29512,11 +31209,13 @@ func (c *Checker) distributeIndexOverObjectType(objectType *Type, indexType *Typ func (c *Checker) getSimplifiedConditionalType(t *Type, writing bool) *Type { key := CachedTypeKey{kind: core.IfElse(writing, CachedTypeKindSimplifiedConditionalTypeForWriting, CachedTypeKindSimplifiedConditionalTypeForReading), typeId: t.id} - if cached, ok := c.cachedTypes[key]; ok { + if cached, ok := c.cachedTypes.cached(c, key); ok { return cached } + c.cachedTypes.begin(c, key) result := c.getSimplifiedConditionalTypeWorker(t, writing) - c.cachedTypes[key] = result + c.cachedTypes.set(c, key, result) + c.endMemo() return result } @@ -29606,10 +31305,17 @@ func (c *Checker) getSingleBaseForNonAugmentingSubtype(t *Type) *Type { return nil } key := CachedTypeKey{kind: CachedTypeKindEquivalentBaseType, typeId: t.id} - if t.objectFlags&ObjectFlagsIdenticalBaseTypeCalculated != 0 { - return c.cachedTypes[key] + if cached, ok := c.cachedTypes.cached(c, key); ok { + return cached } - t.objectFlags |= ObjectFlagsIdenticalBaseTypeCalculated + c.cachedTypes.begin(c, key) + result := c.getSingleBaseForNonAugmentingSubtypeUncached(t) + c.cachedTypes.set(c, key, result) + c.endMemo() + return result +} + +func (c *Checker) getSingleBaseForNonAugmentingSubtypeUncached(t *Type) *Type { target := t.Target() if target.objectFlags&ObjectFlagsClass != 0 { baseTypeNode := getBaseTypeNodeOfClass(target) @@ -29637,36 +31343,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 { @@ -29678,9 +31380,10 @@ func (c *Checker) getRegularTypeOfObjectLiteral(t *Type) *Type { return t } key := CachedTypeKey{kind: CachedTypeKindRegularObjectLiteral, typeId: t.id} - if cached := c.cachedTypes[key]; cached != nil { + if cached, _ := c.cachedTypes.cached(c, key); cached != nil { return cached } + c.cachedTypes.begin(c, key) resolved := c.resolveStructuredTypeMembers(t) members := c.transformTypeOfMembers(t, c.getRegularTypeOfObjectLiteral) create := func() *Type { @@ -29695,7 +31398,8 @@ func (c *Checker) getRegularTypeOfObjectLiteral(t *Type) *Type { } else { regular = create() } - c.cachedTypes[key] = regular + c.cachedTypes.set(c, key, regular) + c.endMemo() return regular } @@ -30107,6 +31811,48 @@ 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 { + // Checking the helpers computes, so it waits for the end of the check + // in progress, outside the computations requesting them, whether + // checking or a query requested them. + c.addDeferredDiagnostic(func(c *Checker) { c.checkExternalEmitHelpersAt(sourceFile, location, helpers) }) + return + } + links.externalHelperRequests = append(links.externalHelperRequests, externalHelperRequest{location, helpers}) +} + +type externalHelperRequest struct { + location *ast.Node + helpers ExternalEmitHelpers +} + +// checkExternalHelperRequests checks the helpers requested by checking +// sourceFile. Errors are reported once per file, at the first location +// requesting a helper in the file, rather than the first location checked, +// since the order in which checking requests helpers depends on what was +// computed before. +func (c *Checker) checkExternalHelperRequests(sourceFile *ast.SourceFile) { + links := c.sourceFileLinks.Get(sourceFile) + requests := links.externalHelperRequests + links.externalHelperRequests = nil + slices.SortStableFunc(requests, func(a, b externalHelperRequest) int { + return cmp.Or( + cmp.Compare(a.location.Pos(), b.location.Pos()), + cmp.Compare(b.location.End(), a.location.End()), + cmp.Compare(a.location.Kind, b.location.Kind), + ) + }) + for _, r := range requests { + c.checkExternalEmitHelpersAt(sourceFile, r.location, r.helpers) + } +} + +func (c *Checker) checkExternalEmitHelpersAt(sourceFile *ast.SourceFile, location *ast.Node, helpers ExternalEmitHelpers) { helpersModule := c.resolveHelpersModule(sourceFile, location) if helpersModule == c.unknownSymbol { return @@ -30352,8 +32098,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 { @@ -30465,13 +32226,29 @@ func (c *Checker) getPromisedTypeOfPromiseEx(t *Type, errorNode *ast.Node, thisT return nil } key := CachedTypeKey{kind: CachedTypeKindPromisedTypeOfPromise, typeId: t.id} - if cached := c.cachedTypes[key]; cached != nil { + if cached, _ := c.cachedTypes.cached(c, key); cached != nil { return cached } + if errorNode != nil { + // Errors belong to errorNode; see getIterationTypesOfIterable. Only + // a missing result reports any, so a result is shared all the same. + if result := c.getPromisedTypeOfPromiseEx(t, nil /*errorNode*/, thisTypeForErrorOut); result != nil { + return result + } + return c.getPromisedTypeOfPromiseWorker(t, errorNode, thisTypeForErrorOut) + } + c.cachedTypes.begin(c, key) + defer c.endMemo() + result := c.getPromisedTypeOfPromiseWorker(t, nil /*errorNode*/, thisTypeForErrorOut) + if result != nil { + c.cachedTypes.set(c, key, result) + } + return result +} + +func (c *Checker) getPromisedTypeOfPromiseWorker(t *Type, errorNode *ast.Node, thisTypeForErrorOut **Type) *Type { if c.isReferenceToType(t, c.getGlobalPromiseType()) { - result := c.getTypeArguments(t)[0] - c.cachedTypes[key] = result - return result + return c.getTypeArguments(t)[0] } // primitives with a `{ then() }` won't be unwrapped/adopted. if c.allTypesAssignableToKind(c.getBaseConstraintOrType(t), TypeFlagsPrimitive|TypeFlagsNever) { @@ -30523,9 +32300,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 { @@ -30732,7 +32507,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 @@ -30751,10 +32526,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 } @@ -30824,10 +32599,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 } @@ -31017,8 +32792,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): @@ -31028,7 +32802,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) @@ -31222,6 +32996,13 @@ func (c *Checker) getContextualReturnType(functionDecl *ast.Node, contextFlags C // Otherwise, if the containing function is contextually typed by a function type with exactly one call signature // and that call signature is non-generic, return statements are contextually typed by the return type of the signature signature := c.getContextualSignatureForFunctionLikeDeclaration(functionDecl) + // A function whose own signature is its contextual signature cannot + // contextually type its returns while their type is being inferred, even + // when that started before the resolution of an enclosing call, which + // hides it from isResolvingReturnTypeOfSignature. + if signature != nil && signature.declaration == functionDecl && c.resolvingAnywhereIndex(signature, TypeSystemPropertyNameResolvedReturnType) >= 0 { + signature = nil + } if signature != nil && !c.isResolvingReturnTypeOfSignature(signature) { returnType := c.getReturnTypeOfSignature(signature) functionFlags := ast.GetFunctionFlags(functionDecl) @@ -31331,11 +33112,20 @@ func (c *Checker) getContextualTypeForArgumentAtIndex(callTarget *ast.Node, argI } } // If we're already in the process of resolving the given signature, don't resolve again as - // that could cause infinite recursion. Instead, return anySignature. + // that could cause infinite recursion. Instead, use what the resolution has resolved so far: + // the signature a resolution of the call re-entering it resolved, or anySignature. var signature *Signature - if c.signatureLinks.Get(callTarget).resolvedSignature == c.resolvingSignature { - signature = c.resolvingSignature - } else { + if links := c.signatureLinks.Get(callTarget); c.isSignatureResolutionVisible(links) { + signature = links.resolvedSignature.inProgress(c) + } + if signature == c.resolvingSignature { + // The marker is the incomplete result of the call, so what is + // derived from it, such as implicit any errors for the parameters of + // a callback, is dropped if it is discarded. + if i := c.resolvingAnywhereIndex(callTarget, TypeSystemPropertyNameCallResolution); i >= 0 { + c.markReadIncomplete(i) + } + } else if signature == nil { signature = c.getResolvedSignature(callTarget, nil, CheckModeNormal) } if ast.IsJsxOpeningLikeElement(callTarget) && argIndex == 0 { @@ -31378,7 +33168,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 @@ -31712,15 +33502,16 @@ func (c *Checker) getDecoratorCallSignature(decorator *ast.Node) *Signature { func (c *Checker) getLegacyDecoratorCallSignature(decorator *ast.Node) *Signature { node := decorator.Parent links := c.signatureLinks.Get(node) - if links.decoratorSignature == nil { - links.decoratorSignature = c.anySignature + if links.decoratorSignature.cached(c) == nil { + links.decoratorSignature.begin(c) + links.decoratorSignature.set(c, c.anySignature) switch node.Kind { case ast.KindClassDeclaration, ast.KindClassExpression: // For a class decorator, the `target` is the type of the class (e.g. the // "static" or "constructor" side of the class). targetType := c.getTypeOfSymbol(c.getSymbolOfDeclaration(node)) targetParam := c.newParameter("target", targetType) - links.decoratorSignature = c.newCallSignature(nil, nil, []*ast.Symbol{targetParam}, c.getUnionType([]*Type{targetType, c.voidType})) + links.decoratorSignature.set(c, c.newCallSignature(nil, nil, []*ast.Symbol{targetParam}, c.getUnionType([]*Type{targetType, c.voidType}))) case ast.KindParameter: if !ast.IsConstructorDeclaration(node.Parent) && !(ast.IsMethodDeclaration(node.Parent) || ast.IsSetAccessorDeclaration(node.Parent) && ast.IsClassLike(node.Parent.Parent)) { break @@ -31745,7 +33536,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 @@ -31764,16 +33555,17 @@ func (c *Checker) getLegacyDecoratorCallSignature(decorator *ast.Node) *Signatur if hasPropDesc { descriptorType := c.newTypedPropertyDescriptorType(c.getTypeOfNode(node)) descriptorParam := c.newParameter("descriptor", descriptorType) - links.decoratorSignature = c.newCallSignature(nil, nil, []*ast.Symbol{targetParam, keyParam, descriptorParam}, c.getUnionType([]*Type{returnType, c.voidType})) + links.decoratorSignature.set(c, c.newCallSignature(nil, nil, []*ast.Symbol{targetParam, keyParam, descriptorParam}, c.getUnionType([]*Type{returnType, c.voidType}))) } else { - links.decoratorSignature = c.newCallSignature(nil, nil, []*ast.Symbol{targetParam, keyParam}, c.getUnionType([]*Type{returnType, c.voidType})) + links.decoratorSignature.set(c, c.newCallSignature(nil, nil, []*ast.Symbol{targetParam, keyParam}, c.getUnionType([]*Type{returnType, c.voidType}))) } } + c.endMemo() } - if links.decoratorSignature == c.anySignature { + if links.decoratorSignature.cached(c) == c.anySignature { return nil } - return links.decoratorSignature + return links.decoratorSignature.cached(c) } func (c *Checker) getESDecoratorCallSignature(decorator *ast.Node) *Signature { @@ -31859,15 +33651,16 @@ func (c *Checker) getESDecoratorCallSignature(decorator *ast.Node) *Signature { // `undefined` then the "output type" is the "input type"). node := decorator.Parent links := c.signatureLinks.Get(node) - if links.decoratorSignature == nil { - links.decoratorSignature = c.anySignature + if links.decoratorSignature.cached(c) == nil { + links.decoratorSignature.begin(c) + links.decoratorSignature.set(c, c.anySignature) switch node.Kind { case ast.KindClassDeclaration, ast.KindClassExpression: // Class decorators have a `context` of `ClassDecoratorContext`, where the `Class` type // argument will be the "final type" of the class after all decorators are applied. targetType := c.getTypeOfSymbol(c.getSymbolOfDeclaration(node)) contextType := c.newClassDecoratorContextType(targetType) - links.decoratorSignature = c.newESDecoratorCallSignature(targetType, contextType, targetType) + links.decoratorSignature.set(c, c.newESDecoratorCallSignature(targetType, contextType, targetType)) case ast.KindMethodDeclaration, ast.KindGetAccessor, ast.KindSetAccessor: if !ast.IsClassLike(node.Parent) { break @@ -31908,7 +33701,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 @@ -31945,13 +33738,14 @@ func (c *Checker) getESDecoratorCallSignature(decorator *ast.Node) *Signature { returnType = c.newClassFieldDecoratorInitializerMutatorType(thisType, valueType) } contextType := c.newClassMemberDecoratorContextTypeForNode(node, thisType, valueType) - links.decoratorSignature = c.newESDecoratorCallSignature(targetType, contextType, returnType) + links.decoratorSignature.set(c, c.newESDecoratorCallSignature(targetType, contextType, returnType)) } + c.endMemo() } - if links.decoratorSignature == c.anySignature { + if links.decoratorSignature.cached(c) == c.anySignature { return nil } - return links.decoratorSignature + return links.decoratorSignature.cached(c) } func (c *Checker) newClassDecoratorContextType(classType *Type) *Type { @@ -31987,7 +33781,7 @@ func (c *Checker) getClassMemberDecoratorContextOverrideType(nameType *Type, isP core.IfElse(isStatic, CachedTypeKindDecoratorContextStatic, CachedTypeKindDecoratorContext), ) key := CachedTypeKey{kind: kind, typeId: nameType.id} - if overrideType := c.cachedTypes[key]; overrideType != nil { + if overrideType, _ := c.cachedTypes.cached(c, key); overrideType != nil { return overrideType } members := ast.NewSymbolTable() @@ -31995,7 +33789,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 } @@ -32161,7 +33955,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) @@ -32212,8 +34006,7 @@ func (c *Checker) getTypeFromIndexInfosOfContextualType(t *Type, name string, na func (c *Checker) isCircularMappedProperty(symbol *ast.Symbol) bool { if symbol.CheckFlags()&ast.CheckFlagsMapped != 0 { - links := c.valueSymbolLinks.Get(symbol) - return links.resolvedType == nil && c.findResolutionCycleStartIndex(symbol, TypeSystemPropertyNameType) >= 0 + return c.isResolutionInProgress(symbol, TypeSystemPropertyNameType) } return false } @@ -32304,9 +34097,10 @@ func (d *ObjectLiteralDiscriminator) matches(index int, t *Type) bool { func (c *Checker) discriminateContextualTypeByObjectMembers(node *ast.Node, contextualType *Type) *Type { key := DiscriminatedContextualTypeKey{nodeId: ast.GetNodeId(node), typeId: contextualType.id} - if discriminated := c.discriminatedContextualTypes[key]; discriminated != nil { + if discriminated, _ := c.discriminatedContextualTypes.cached(c, key); discriminated != nil { return discriminated } + c.discriminatedContextualTypes.begin(c, key) discriminated := c.getMatchingUnionConstituentForObjectLiteral(contextualType, node) if discriminated == nil { discriminantProperties := core.Filter(node.Properties(), func(p *ast.Node) bool { @@ -32328,7 +34122,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 } @@ -32694,7 +34489,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 { @@ -32827,32 +34622,53 @@ func (c *Checker) getAwaitedTypeNoAliasEx(t *Type, errorNode *ast.Node, diagnost } // If we've already cached an awaited type, return a possible `Awaited` for it. key := CachedTypeKey{kind: CachedTypeKindAwaitedType, typeId: t.id} - if awaitedType := c.cachedTypes[key]; awaitedType != nil { + if awaitedType, _ := c.cachedTypes.cached(c, key); awaitedType != nil { return awaitedType } + if errorNode != nil { + // Errors belong to errorNode; see getIterationTypesOfIterable. Only a + // result computing which reports nothing is cached, so it is shared + // all the same. + if c.getAwaitedTypeNoAliasEx(t, nil /*errorNode*/, nil /*diagnosticMessage*/) != nil { + if awaitedType, _ := c.cachedTypes.cached(c, key); awaitedType != nil { + return awaitedType + } + } + return c.getAwaitedTypeNoAliasWorker(t, errorNode, diagnosticMessage, args...) + } + c.cachedTypes.begin(c, key) + defer c.endMemo() + errors := c.awaitedTypeErrors + awaitedType := c.getAwaitedTypeNoAliasWorker(t, nil /*errorNode*/, nil /*diagnosticMessage*/) + if awaitedType != nil && c.awaitedTypeErrors == errors { + c.cachedTypes.set(c, key, awaitedType) + } + return awaitedType +} + +func (c *Checker) getAwaitedTypeNoAliasWorker(t *Type, errorNode *ast.Node, diagnosticMessage *diagnostics.Message, args ...any) *Type { // For a union, get a union of the awaited types of each constituent. if t.flags&TypeFlagsUnion != 0 { - if slices.Contains(c.awaitedTypeStack, t) { + if c.isAwaitingType(t) { + c.awaitedTypeErrors++ if errorNode != nil { c.error(errorNode, diagnostics.Type_is_referenced_directly_or_indirectly_in_the_fulfillment_callback_of_its_own_then_method) } return nil } - c.awaitedTypeStack = append(c.awaitedTypeStack, t) + c.pushAwaitingType(t) mapped := c.mapType(t, func(t *Type) *Type { return c.getAwaitedTypeNoAliasEx(t, errorNode, diagnosticMessage, args...) }) - c.awaitedTypeStack = c.awaitedTypeStack[:len(c.awaitedTypeStack)-1] - c.cachedTypes[key] = mapped + c.popTypeResolution() return mapped } // If `type` is generic and should be wrapped in `Awaited`, return it. if c.isAwaitedTypeNeeded(t) { - c.cachedTypes[key] = t return t } var thisTypeForError *Type promisedType := c.getPromisedTypeOfPromiseEx(t, nil /*errorNode*/, &thisTypeForError) if promisedType != nil { - if t == promisedType || slices.Contains(c.awaitedTypeStack, promisedType) { + if t == promisedType || c.isAwaitingType(promisedType) { // Verify that we don't have a bad actor in the form of a promise whose // promised type is the same as the promise type, or a mutually recursive // promise. If so, we return undefined as we cannot guess the shape. If this @@ -32886,6 +34702,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) } @@ -32893,13 +34710,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. @@ -32918,6 +34731,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 { @@ -32927,10 +34741,21 @@ func (c *Checker) getAwaitedTypeNoAliasEx(t *Type, errorNode *ast.Node, diagnost } return nil } - c.cachedTypes[key] = t return t } +// pushAwaitingType records that the awaited type of t is being computed, until +// the matching popTypeResolution. +func (c *Checker) pushAwaitingType(t *Type) { + c.beginTypeResolution(t, TypeSystemPropertyNameAwaitedType, nil) +} + +// isAwaitingType reports whether the awaited type of t is being computed; +// see isResolvingAnywhere. +func (c *Checker) isAwaitingType(t *Type) bool { + return c.isResolvingAnywhere(t, TypeSystemPropertyNameAwaitedType) +} + func (c *Checker) isAwaitedTypeInstantiation(t *Type) bool { if t.flags&TypeFlagsConditional != 0 { awaitedSymbol := c.getGlobalAwaitedSymbolOrNil() @@ -33190,7 +35015,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 @@ -33224,7 +35049,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: @@ -33357,8 +35182,7 @@ func (c *Checker) getSymbolOfNameOrPropertyAccessExpression(name *ast.Node) *ast if ast.IsEntityName(name) { possibleImportNode := isImportTypeQualifierPart(name) if possibleImportNode != nil { - c.getTypeFromTypeNode(possibleImportNode) - sym := c.getResolvedSymbolOrNil(name) + sym := c.getSymbolOfTypeNodePart(possibleImportNode, name) return core.IfElse(sym == c.unknownSymbol, nil, sym) } } @@ -33422,27 +35246,23 @@ func (c *Checker) getSymbolOfNameOrPropertyAccessExpression(name *ast.Node) *ast } else if ast.IsPrivateIdentifier(name) { return c.getSymbolForPrivateIdentifierExpression(name) } else if ast.IsPropertyAccessExpression(name) || ast.IsQualifiedName(name) { - links := c.symbolNodeLinks.Get(name) - if links.resolvedSymbol != nil { - return links.resolvedSymbol - } - if ast.IsPropertyAccessExpression(name) { - c.checkPropertyAccessExpression(name, CheckModeNormal, false /*writeOnly*/) - if links.resolvedSymbol == nil && !ast.IsPrivateIdentifier(name.Name()) { - // 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()), - ) - } - } else { - c.checkQualifiedName(name, CheckModeNormal) + // The symbol is read back from links after checking, before a query + // finishing would discard it. + query, ok := c.enterQuery() + defer c.exitQuery(query, ok) + symbol := c.getSymbolOfExpression(name) + if symbol == nil && ast.IsPropertyAccessExpression(name) && !ast.IsPrivateIdentifier(name.Name()) { + // Not cached in links, where checking would observe it as the + // property the access resolved to. + return c.getApplicableIndexSymbol( + c.checkExpressionCached(name.Expression()), + c.getLiteralTypeFromPropertyName(name.Name()), + ) } - if links.resolvedSymbol == nil && isJSDoc && ast.IsQualifiedName(name) { + if symbol == nil && isJSDoc && ast.IsQualifiedName(name) { return c.resolveJSDocMemberName(name) } - return links.resolvedSymbol + return symbol } } else if ast.IsEntityName(name) && isTypeReferenceIdentifier(name) { meaning := core.IfElse(name.Parent.Kind == ast.KindTypeReference, ast.SymbolFlagsType, ast.SymbolFlagsNamespace) @@ -33659,7 +35479,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 } } @@ -33680,9 +35500,10 @@ func (c *Checker) containsArgumentsReference(node *ast.Node) bool { return false } - if containsArguments, ok := c.cachedArgumentsReferenced[node]; ok { + if containsArguments, ok := c.cachedArgumentsReferenced.cached(c, node); ok { return containsArguments } + c.cachedArgumentsReferenced.begin(c, node) var visit func(node *ast.Node) bool visit = func(node *ast.Node) bool { @@ -33708,7 +35529,8 @@ func (c *Checker) containsArgumentsReference(node *ast.Node) bool { } containsArguments := visit(node.Body()) - c.cachedArgumentsReferenced[node] = containsArguments + c.cachedArgumentsReferenced.set(c, node, containsArguments) + c.endMemo() return containsArguments } diff --git a/tsc/internal/checker/checker_test.go b/tsc/internal/checker/checker_test.go index f5b766607c5f7..e3a40fe50771e 100644 --- a/tsc/internal/checker/checker_test.go +++ b/tsc/internal/checker/checker_test.go @@ -2,7 +2,11 @@ package checker_test import ( "fmt" + goast "go/ast" + "go/parser" + "go/token" "path/filepath" + "slices" "strings" "testing" @@ -182,6 +186,47 @@ func BenchmarkCheckFreshProgram(b *testing.B) { } } +func TestQueriesDoNotMoveErrorsAtCurrentNode(t *testing.T) { + t.Parallel() + + // Asking for the symbol of t.x computes T<"x"> at no node, reporting + // an excessive depth there. Asking for the type of tx then reuses it at + // t.x, so checking reports the error at t.x and not at tx. + content := `type T = { + x: T[K]; + y: number; +}; + +declare let t: T<"x">; +let tx = t.x; +` + diagnostics := func(query bool) []string { + fs := bundled.WrapFS(vfstest.FromMap(map[string]string{ + "/foo.ts": content, + "/tsconfig.json": `{"files": ["foo.ts"]}`, + }, tspath.CaseInsensitive)) + host := compiler.NewCompilerHost(fs, bundled.LibPath(), nil, nil, nil) + parsed, errors := tsoptions.GetParsedCommandLineOfConfigFile("/tsconfig.json", &core.CompilerOptions{}, nil, tsoptions.NewDefaultParseConfigHost(fs), nil) + assert.Equal(t, len(errors), 0) + p, err := compiler.NewProgram(t.Context(), compiler.ProgramOptions{Config: parsed, Host: host}) + assert.NilError(t, err) + file := p.GetSourceFile("/foo.ts") + if query { + c, done := p.GetTypeCheckerForFile(t.Context(), file) + decl := file.Statements.Nodes[2].AsVariableStatement().DeclarationList.AsVariableDeclarationList().Declarations.Nodes[0] + c.GetSymbolAtLocation(decl.Initializer().Name()) + c.GetTypeAtLocation(decl.Name()) + done() + } + var result []string + for _, d := range p.GetSemanticDiagnostics(t.Context(), file) { + result = append(result, fmt.Sprintf("%d: TS%d", d.Pos(), d.Code())) + } + return result + } + assert.DeepEqual(t, diagnostics(true), diagnostics(false)) +} + func TestTypeAllocationAcrossCheckerGrowth(t *testing.T) { t.Parallel() var content strings.Builder @@ -214,3 +259,476 @@ 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", "RelationCacheSizes"} + +var unmemoizedCacheFields = map[string]string{ + "valueSymbolExtra.nameType": unmemoizedCreated, + "valueSymbolExtra.containingType": unmemoizedCreated, + "valueSymbolExtra.instantiatedFrom": unmemoizedCreated, + "TypeAlias.symbol": unmemoizedCreated, + "TypeAlias.typeArguments": unmemoizedCreated, + "Type.flags": unmemoizedCreated, + "Type.objectFlags": unmemoizedEntityFlags, + "Type.id": unmemoizedCounter, + "Type.kind": unmemoizedCreated, + "Type.generation": unmemoizedDerived, + "Type.baseConstraintHeight": "Set with the resolved base constraint whose walk it describes; see \"Base constraint walks\"", + "Type.symbol": unmemoizedCreated, + "Type.alias": unmemoizedCreated, + "Type.checker": unmemoizedImmutable, + "IntrinsicType.intrinsicName": unmemoizedCreated, + "LiteralType.value": unmemoizedCreated, + "LiteralType.freshType": unmemoizedInterned, + "LiteralType.regularType": unmemoizedCreated, + "UniqueESSymbolType.name": unmemoizedCreated, + "StructuredType.members": unmemoizedFlagMemo, + "StructuredType.properties": unmemoizedFlagMemo, + "StructuredType.extra": unmemoizedFlagMemo, + "structuredTypeExtra.signatures": unmemoizedFlagMemo, + "structuredTypeExtra.callSignatureCount": unmemoizedFlagMemo, + "structuredTypeExtra.indexInfos": unmemoizedFlagMemo, + "structuredTypeExtra.objectTypeWithoutAbstractConstructSignatures": unmemoizedInterned, + "ObjectType.target": unmemoizedCreated, + "ObjectType.mapper": unmemoizedCreated, + "TypeReference.node": unmemoizedCreated, + "TypeReference.lazy": unmemoizedFlagMemo, + "LazyState.layout": unmemoizedCreated, + "LazyState.mapper": unmemoizedCreated, + "LazyState.baseTypes": unmemoizedCreated, + "LazyState.propertiesResolved": unmemoizedFlagMemo, + "MemberLayout.id": unmemoizedCounter, + "MemberLayout.baseIndices": unmemoizedCreated, + "MemberLayout.members": unmemoizedCreated, + "MemberLayout.layoutProperties": unmemoizedDerived, + "InterfaceType.allTypeParameters": unmemoizedCreated, + "InterfaceType.outerTypeParameterCount": unmemoizedCreated, + "InterfaceType.thisType": unmemoizedCreated, + "InterfaceType.baseTypesResolved": unmemoizedFlagMemo, + "InterfaceType.declaredMembersResolved": unmemoizedFlagMemo, + "InterfaceType.declaredMembers": unmemoizedFlagMemo, + "InterfaceType.declaredCallSignatures": unmemoizedFlagMemo, + "InterfaceType.declaredConstructSignatures": unmemoizedFlagMemo, + "InterfaceType.declaredIndexInfos": unmemoizedFlagMemo, + "TupleType.elementInfos": unmemoizedCreated, + "TupleType.minLength": unmemoizedCreated, + "TupleType.fixedLength": unmemoizedCreated, + "TupleType.combinedFlags": unmemoizedCreated, + "TupleType.readonly": unmemoizedCreated, + "InstantiationExpressionType.node": unmemoizedCreated, + "MappedType.declaration": unmemoizedCreated, + "ReverseMappedType.source": unmemoizedCreated, + "ReverseMappedType.mappedType": unmemoizedCreated, + "ReverseMappedType.constraintType": unmemoizedCreated, + "EvolvingArrayType.elementType": unmemoizedCreated, + "UnionOrIntersectionType.types": unmemoizedCreated, + "UnionType.regularType": unmemoizedInterned, + "UnionType.origin": unmemoizedCreated, + "UnionType.constituentMap": unmemoizedGuarded, + "TypeParameter.target": unmemoizedCreated, + "TypeParameter.mapper": unmemoizedCreated, + "TypeParameter.isThisType": unmemoizedCreated, + "TypeParameter.isDistributed": unmemoizedCreated, + "TypeParameter.distributedType": unmemoizedInterned, + "TypeParameter.origin": unmemoizedCreated, + "IndexType.target": unmemoizedCreated, + "IndexType.indexFlags": unmemoizedCreated, + "IndexedAccessType.objectType": unmemoizedCreated, + "IndexedAccessType.indexType": unmemoizedCreated, + "IndexedAccessType.accessFlags": unmemoizedCreated, + "TemplateLiteralType.texts": unmemoizedCreated, + "TemplateLiteralType.types": unmemoizedCreated, + "StringMappingType.target": unmemoizedCreated, + "SubstitutionType.baseType": unmemoizedCreated, + "SubstitutionType.constraint": unmemoizedCreated, + "ConditionalRoot.node": unmemoizedCreated, + "ConditionalRoot.checkType": unmemoizedCreated, + "ConditionalRoot.extendsType": unmemoizedCreated, + "ConditionalRoot.isDistributive": unmemoizedCreated, + "ConditionalRoot.inferTypeParameters": unmemoizedCreated, + "ConditionalRoot.outerTypeParameters": unmemoizedCreated, + "ConditionalRoot.alias": unmemoizedCreated, + "ConditionalType.restrictive": unmemoizedCreated, + "ConditionalType.root": unmemoizedCreated, + "ConditionalType.checkType": unmemoizedCreated, + "ConditionalType.extendsType": unmemoizedCreated, + "ConditionalType.mapper": unmemoizedCreated, + "ConditionalType.combinedMapper": unmemoizedCreated, + "Signature.id": unmemoizedCreated, + "Signature.flags": unmemoizedEntityFlags, + "Signature.minArgumentCount": unmemoizedCreated, + "Signature.declaration": unmemoizedCreated, + "Signature.parameters": unmemoizedCreated, + "Signature.target": unmemoizedCreated, + "Signature.mapper": unmemoizedCreated, + "Signature.extra": unmemoizedCreated, + "signatureExtra.typeParameters": unmemoizedCreated, + "signatureExtra.thisParameter": unmemoizedCreated, + "signatureExtra.resolvedTypePredicate": unmemoizedFlagMemo, + "signatureExtra.isolatedSignatureType": unmemoizedInterned, + "signatureExtra.composite": unmemoizedCreated, + "CompositeSignature.isUnion": unmemoizedCreated, + "CompositeSignature.signatures": unmemoizedCreated, + "TypePredicate.kind": unmemoizedCreated, + "TypePredicate.parameterIndex": unmemoizedCreated, + "TypePredicate.parameterName": unmemoizedCreated, + "TypePredicate.t": unmemoizedCreated, + "IndexInfo.keyType": unmemoizedCreated, + "IndexInfo.valueType": unmemoizedCreated, + "IndexInfo.isReadonly": unmemoizedCreated, + "IndexInfo.declaration": unmemoizedCreated, + "IndexInfo.indexSymbol": unmemoizedInterned, + "IndexInfo.components": unmemoizedCreated, + "memoStore.root": unmemoizedImmutable, + "memoStore.id": unmemoizedImmutable, + "memoStore.program": unmemoizedImmutable, + "memoStore.compilerOptions": unmemoizedImmutable, + "memoStore.files": unmemoizedImmutable, + "memoStore.fileIndexMap": unmemoizedImmutable, + "memoStore.languageVersion": unmemoizedImmutable, + "memoStore.moduleKind": unmemoizedImmutable, + "memoStore.moduleResolutionKind": unmemoizedImmutable, + "memoStore.legacyDecorators": unmemoizedImmutable, + "memoStore.emitStandardClassFields": unmemoizedImmutable, + "memoStore.strictNullChecks": unmemoizedImmutable, + "memoStore.strictFunctionTypes": unmemoizedImmutable, + "memoStore.strictBindCallApply": unmemoizedImmutable, + "memoStore.strictPropertyInitialization": unmemoizedImmutable, + "memoStore.strictBuiltinIteratorReturn": unmemoizedImmutable, + "memoStore.noImplicitAny": unmemoizedImmutable, + "memoStore.noImplicitThis": unmemoizedImmutable, + "memoStore.useUnknownInCatchVariables": unmemoizedImmutable, + "memoStore.exactOptionalPropertyTypes": unmemoizedImmutable, + "memoStore.canCollectSymbolAliasAccessibilityData": unmemoizedImmutable, + "memoStore.arrayVariances": unmemoizedImmutable, + "memoStore.globals": unmemoizedImmutable, + "memoStore.undefinedSymbol": unmemoizedImmutable, + "memoStore.argumentsSymbol": unmemoizedImmutable, + "memoStore.requireSymbol": unmemoizedImmutable, + "memoStore.unknownSymbol": unmemoizedImmutable, + "memoStore.globalThisSymbol": unmemoizedImmutable, + "memoStore.mergedSymbols": unmemoizedImmutable, + "memoStore.mergesFrozen": unmemoizedImmutable, + "memoStore.anyType": unmemoizedImmutable, + "memoStore.autoType": unmemoizedImmutable, + "memoStore.wildcardType": unmemoizedImmutable, + "memoStore.blockedStringType": unmemoizedImmutable, + "memoStore.errorType": unmemoizedImmutable, + "memoStore.unresolvedType": unmemoizedImmutable, + "memoStore.nonInferrableAnyType": unmemoizedImmutable, + "memoStore.intrinsicMarkerType": unmemoizedImmutable, + "memoStore.unknownType": unmemoizedImmutable, + "memoStore.undefinedType": unmemoizedImmutable, + "memoStore.undefinedWideningType": unmemoizedImmutable, + "memoStore.missingType": unmemoizedImmutable, + "memoStore.undefinedOrMissingType": unmemoizedImmutable, + "memoStore.optionalType": unmemoizedImmutable, + "memoStore.nullType": unmemoizedImmutable, + "memoStore.nullWideningType": unmemoizedImmutable, + "memoStore.stringType": unmemoizedImmutable, + "memoStore.numberType": unmemoizedImmutable, + "memoStore.bigintType": unmemoizedImmutable, + "memoStore.regularFalseType": unmemoizedImmutable, + "memoStore.falseType": unmemoizedImmutable, + "memoStore.regularTrueType": unmemoizedImmutable, + "memoStore.trueType": unmemoizedImmutable, + "memoStore.booleanType": unmemoizedImmutable, + "memoStore.esSymbolType": unmemoizedImmutable, + "memoStore.voidType": unmemoizedImmutable, + "memoStore.neverType": unmemoizedImmutable, + "memoStore.silentNeverType": unmemoizedImmutable, + "memoStore.implicitNeverType": unmemoizedImmutable, + "memoStore.unreachableNeverType": unmemoizedImmutable, + "memoStore.nonPrimitiveType": unmemoizedImmutable, + "memoStore.stringOrNumberType": unmemoizedImmutable, + "memoStore.stringNumberSymbolType": unmemoizedImmutable, + "memoStore.numberOrBigIntType": unmemoizedImmutable, + "memoStore.templateConstraintType": unmemoizedImmutable, + "memoStore.numericStringType": unmemoizedImmutable, + "memoStore.uniqueLiteralType": unmemoizedImmutable, + "memoStore.emptyObjectType": unmemoizedImmutable, + "memoStore.emptyJsxObjectType": unmemoizedImmutable, + "memoStore.emptyFreshJsxObjectType": unmemoizedImmutable, + "memoStore.emptyTypeLiteralType": unmemoizedImmutable, + "memoStore.unknownEmptyObjectType": unmemoizedImmutable, + "memoStore.unknownUnionType": unmemoizedImmutable, + "memoStore.emptyGenericType": unmemoizedImmutable, + "memoStore.anyFunctionType": unmemoizedImmutable, + "memoStore.noConstraintType": unmemoizedImmutable, + "memoStore.circularConstraintType": unmemoizedImmutable, + "memoStore.resolvingDefaultType": unmemoizedImmutable, + "memoStore.markerSuperType": unmemoizedImmutable, + "memoStore.markerSubType": unmemoizedImmutable, + "memoStore.markerOtherType": unmemoizedImmutable, + "memoStore.markerSuperTypeForCheck": unmemoizedImmutable, + "memoStore.markerSubTypeForCheck": unmemoizedImmutable, + "memoStore.noTypePredicate": unmemoizedImmutable, + "memoStore.anySignature": unmemoizedImmutable, + "memoStore.unknownSignature": unmemoizedImmutable, + "memoStore.resolvingSignature": unmemoizedImmutable, + "memoStore.globalIDs": unmemoizedImmutable, + "memoStore.silentNeverSignature": unmemoizedImmutable, + "memoStore.enumNumberIndexInfo": unmemoizedImmutable, + "memoStore.anyBaseTypeIndexInfo": unmemoizedImmutable, + "memoStore.patternAmbientModules": unmemoizedImmutable, + "memoStore.patternAmbientModuleAugmentations": unmemoizedImmutable, + "memoStore.patternAmbientModuleAugmentationTargets": unmemoizedImmutable, + "memoStore.globalObjectType": unmemoizedImmutable, + "memoStore.globalFunctionType": unmemoizedImmutable, + "memoStore.globalCallableFunctionType": unmemoizedImmutable, + "memoStore.globalNewableFunctionType": unmemoizedImmutable, + "memoStore.globalArrayType": unmemoizedImmutable, + "memoStore.globalReadonlyArrayType": unmemoizedImmutable, + "memoStore.globalStringType": unmemoizedImmutable, + "memoStore.globalNumberType": unmemoizedImmutable, + "memoStore.globalBooleanType": unmemoizedImmutable, + "memoStore.globalRegExpType": unmemoizedImmutable, + "memoStore.globalThisType": unmemoizedImmutable, + "memoStore.anyArrayType": unmemoizedImmutable, + "memoStore.autoArrayType": unmemoizedImmutable, + "memoStore.anyReadonlyArrayType": unmemoizedImmutable, + "memoStore.emptyStringType": unmemoizedImmutable, + "memoStore.zeroType": unmemoizedImmutable, + "memoStore.zeroBigIntType": unmemoizedImmutable, + "memoStore.typeofType": unmemoizedImmutable, + "memoStore.subtypeRelation": unmemoizedImmutable, + "memoStore.strictSubtypeRelation": unmemoizedImmutable, + "memoStore.assignableRelation": unmemoizedImmutable, + "memoStore.comparableRelation": unmemoizedImmutable, + "memoStore.identityRelation": unmemoizedImmutable, + "memoStore.nodeLinks": unmemoizedContainer, + "memoStore.signatureLinks": unmemoizedContainer, + "memoStore.symbolNodeLinks": unmemoizedContainer, + "memoStore.typeNodeLinks": unmemoizedContainer, + "memoStore.enumMemberLinks": unmemoizedContainer, + "memoStore.arrayLiteralLinks": unmemoizedContainer, + "memoStore.switchStatementLinks": unmemoizedContainer, + "memoStore.jsxElementLinks": unmemoizedContainer, + "memoStore.computedNameLinks": unmemoizedContainer, + "memoStore.symbolReferenceLinks": unmemoizedContainer, + "memoStore.valueSymbolLinks": unmemoizedContainer, + "memoStore.mappedSymbolLinks": unmemoizedContainer, + "memoStore.deferredSymbolLinks": unmemoizedContainer, + "memoStore.aliasSymbolLinks": unmemoizedContainer, + "memoStore.moduleSymbolLinks": unmemoizedContainer, + "memoStore.lateBoundLinks": unmemoizedContainer, + "memoStore.exportTypeLinks": unmemoizedContainer, + "memoStore.membersAndExportsLinks": unmemoizedContainer, + "memoStore.typeAliasLinks": unmemoizedContainer, + "memoStore.declaredTypeLinks": unmemoizedContainer, + "memoStore.spreadLinks": unmemoizedContainer, + "memoStore.varianceLinks": unmemoizedContainer, + "memoStore.ReverseMappedSymbolLinks": unmemoizedContainer, + "memoStore.markedAssignmentSymbolLinks": unmemoizedContainer, + "memoStore.sourceFileLinks": unmemoizedContainer, + "memoStore.emitResolverLinks": unmemoizedContainer, + "EmitResolverLinks.jsxLinks": unmemoizedContainer, + "EmitResolverLinks.declarationLinks": unmemoizedContainer, + "EmitResolverLinks.declarationFileLinks": unmemoizedContainer, + "memoStore.TypeCount": unmemoizedCounter, + "memoStore.memberLayoutCount": unmemoizedCounter, + "memoStore.SymbolCount": unmemoizedCounter, + "memoStore.SignatureCount": unmemoizedCounter, + "memoStore.TotalInstantiationCount": unmemoizedCounter, + "memoStore.nanType": unmemoizedInterned, + "memoStore.parentLateBindableKinds": unmemoizedSyntax, + "memoStore.packagesMap": unmemoizedProgram, + "memoStore.ambientModulesOnce": unmemoizedProgram, + "memoStore.ambientModules": unmemoizedProgram, + "memoStore.memoStates": unmemoizedMemoState, + "memoStore.memoPendingCount": unmemoizedMemoState, + "memoStore.memoErrorStates": unmemoizedMemoState, + "memoStore.stateFilter": unmemoizedMemoState, + "memoStore.errorFilter": unmemoizedMemoState, + "memoStore.mu": unmemoizedMemoState, + "memoStore.diagnostics": unmemoizedChecking, + "memoStore.suggestionDiagnostics": unmemoizedChecking, + "memoStore.nonExistentPropertyNodes": unmemoizedChecking, + "memoStore.deferredDiagnosticCallbacks": unmemoizedChecking, + "SymbolReferenceLinks.referenceKinds": unmemoizedChecking, + "AliasSymbolLinks.referenced": unmemoizedMark, + "AliasSymbolLinks.referenceChecked": unmemoizedChecking, + "SourceFileLinks.typeChecked": unmemoizedChecking, + "SourceFileLinks.unusedChecked": unmemoizedChecking, + "SourceFileLinks.deferredNodes": unmemoizedChecking, + "SourceFileLinks.identifierCheckNodes": unmemoizedChecking, + "SourceFileLinks.renamedBindingElements": unmemoizedSyntax, + "ValueSymbolLinks.target": unmemoizedCreated, + "ValueSymbolLinks.mapper": unmemoizedCreated, + "ValueSymbolLinks.extra": unmemoizedCreated, + "MappedSymbolLinks.keyType": unmemoizedCreated, + "MappedSymbolLinks.syntheticOrigin": unmemoizedCreated, + "DeferredSymbolLinks.parent": unmemoizedCreated, + "DeferredSymbolLinks.constituents": unmemoizedCreated, + "DeferredSymbolLinks.writeConstituents": unmemoizedCreated, + "ReverseMappedSymbolLinks.propertyType": unmemoizedCreated, + "ReverseMappedSymbolLinks.mappedType": unmemoizedCreated, + "ReverseMappedSymbolLinks.constraintType": unmemoizedCreated, + "ExportTypeLinks.target": unmemoizedCreated, + "ExportTypeLinks.originatingImport": unmemoizedCreated, + "SpreadLinks.leftSpread": unmemoizedCreated, + "SpreadLinks.rightSpread": unmemoizedCreated, + "JsxElementLinks.firstJSXTagInFile": unmemoizedSyntax, + "memoStore._jsxNamespace": unmemoizedSyntax, + "memoStore._jsxFactoryEntity": unmemoizedSyntax, + "SwitchStatementLinks.witnessesComputed": unmemoizedSyntax, + "SwitchStatementLinks.witnesses": unmemoizedSyntax, + "ArrayLiteralLinks.indicesComputed": unmemoizedSyntax, + "ArrayLiteralLinks.firstSpreadIndex": unmemoizedSyntax, + "ArrayLiteralLinks.lastSpreadIndex": unmemoizedSyntax, + "NodeLinks.declarationRequiresScopeChange": unmemoizedSyntax, + "SourceFileLinks.localJsxNamespace": unmemoizedSyntax, + "SourceFileLinks.localJsxFragmentNamespace": unmemoizedSyntax, + "SourceFileLinks.localJsxFactory": unmemoizedSyntax, + "SourceFileLinks.localJsxFragmentFactory": unmemoizedSyntax, + "JsxElementLinks.jsxFlags": unmemoizedFlagMemo, + "JsxElementLinks.jsxImplicitImportContainer": unmemoizedFlagMemo, + "flowLoopCacheEntry.t": unmemoizedLoopFixpoint, + "flowLoopCacheEntry.tooDeep": unmemoizedLoopFixpoint, + "instantiationExpressionEntry.t": unmemoizedFlagMemo, + "ModuleSymbolLinks.resolvedExports": unmemoizedFlagMemo, + "ModuleSymbolLinks.typeOnlyExportStarMap": unmemoizedFlagMemo, + "LateBoundLinks.lateSymbol": unmemoizedGuarded, + "TypeAliasLinks.typeParameters": unmemoizedGuarded, + "MarkedAssignmentSymbolLinks.lastAssignmentPos": unmemoizedGuarded, + "MarkedAssignmentSymbolLinks.hasDefiniteAssignment": unmemoizedGuarded, + "EnumMemberLinks.value": unmemoizedGuarded, + "JSXLinks.importRef": unmemoizedEmit, + "DeclarationLinks.madeVisible": unmemoizedEmit, + "DeclarationLinks.ruleKnown": unmemoizedSyntax, + "DeclarationLinks.ruleVisible": unmemoizedSyntax, + "DeclarationLinks.ruleInheritsFrom": unmemoizedSyntax, + "DeclarationFileLinks.aliasesMarked": unmemoizedEmit, + "NodeBuilderLinks.serializedTypes": unmemoizedNodeBuilder, + "NodeBuilderLinks.fakeScopeForSignatureDeclaration": unmemoizedNodeBuilder, + "NodeBuilderSymbolLinks.specifierCache": unmemoizedNodeBuilder, + "SourceFileLinks.externalHelpersModule": unmemoizedChecking, + "SourceFileLinks.requestedExternalEmitHelpers": unmemoizedChecking, + "SourceFileLinks.externalHelperRequests": unmemoizedChecking, + "AliasSymbolLinks.typeOnlyDeclaration": unmemoizedGuarded, + "NodeLinks.flags": unmemoizedNodeFlags, +} diff --git a/tsc/internal/checker/emitresolver.go b/tsc/internal/checker/emitresolver.go index 0e2938dbe8d1b..48a8932e93c25 100644 --- a/tsc/internal/checker/emitresolver.go +++ b/tsc/internal/checker/emitresolver.go @@ -406,11 +406,12 @@ func (r *EmitResolver) IsReferencedAliasDeclaration(node *ast.Node) bool { if aliasLinks.referenced { return true } - target := aliasLinks.aliasTarget - if target != nil && node.ModifierFlags()&ast.ModifierFlagsExport != 0 && - c.getSymbolFlags(target)&ast.SymbolFlagsValue != 0 && - (c.compilerOptions.ShouldPreserveConstEnums() || !isConstEnumOrConstEnumOnlyModule(target)) { - return true + if node.ModifierFlags()&ast.ModifierFlagsExport != 0 { + target := c.resolveAlias(symbol) + if target != c.unknownSymbol && c.getSymbolFlags(target)&ast.SymbolFlagsValue != 0 && + (c.compilerOptions.ShouldPreserveConstEnums() || !isConstEnumOrConstEnumOnlyModule(target)) { + return true + } } } } @@ -510,6 +511,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 { @@ -540,7 +547,7 @@ func (r *EmitResolver) getReferenceResolver() binder.ReferenceResolver { if r.referenceResolver == nil { r.referenceResolver = binder.NewReferenceResolver(r.checker.compilerOptions, binder.ReferenceResolverHooks{ ResolveName: r.checker.resolveName, - GetResolvedSymbol: r.checker.getResolvedSymbolOrNil, + GetResolvedSymbol: r.checker.getSymbolOfReferenceForEmit, GetMergedSymbol: r.checker.getMergedSymbol, GetParentOfSymbol: r.checker.getParentOfSymbol, GetSymbolOfDeclaration: r.checker.getSymbolOfDeclaration, diff --git a/tsc/internal/checker/exports.go b/tsc/internal/checker/exports.go index 26c6e8180454d..c23017e907c3f 100644 --- a/tsc/internal/checker/exports.go +++ b/tsc/internal/checker/exports.go @@ -469,3 +469,19 @@ func (c *Checker) CompareSymbols(s1, s2 *ast.Symbol) int { func IsDistributedTypeParameter(t *Type) bool { return t.flags&TypeFlagsTypeParameter != 0 && t.AsTypeParameter().isDistributed } + +func (c *Checker) GetTypeParameterOfMappedType(t *Type) *Type { + return c.getTypeParameterFromMappedType(t) +} + +func (c *Checker) GetConstraintTypeOfMappedType(t *Type) *Type { + return c.getConstraintTypeFromMappedType(t) +} + +func (c *Checker) GetNameTypeOfMappedType(t *Type) *Type { + return c.getNameTypeFromMappedType(t) +} + +func (c *Checker) GetTemplateTypeOfMappedType(t *Type) *Type { + return c.getTemplateTypeFromMappedType(t) +} diff --git a/tsc/internal/checker/flow.go b/tsc/internal/checker/flow.go index 7dd6c4d3d9c4e..cea7b709d9754 100644 --- a/tsc/internal/checker/flow.go +++ b/tsc/internal/checker/flow.go @@ -95,6 +95,11 @@ func (c *Checker) getFlowTypeOfReferenceEx(reference *ast.Node, declaredType *Ty f.sharedFlowStart = len(c.sharedFlows) c.flowInvocationCount++ evolvedType := c.getTypeAtFlowNode(f, flowNode).t + if f.limitHits != 0 { + // Give up on the whole reference, so its type does not depend on how + // deep the walk got before giving up. + evolvedType = c.errorType + } c.sharedFlows = c.sharedFlows[:f.sharedFlowStart] c.putFlowState(f) // When the reference is 'x' in an 'x.length', 'x.push(value)', 'x.unshift(value)' or x[n] = value' operation, @@ -124,10 +129,79 @@ const ( ) func (c *Checker) getTypeAtFlowNode(f *FlowState, flow *ast.FlowNode) FlowType { + // A walk that is too deep from a node is also too deep from it with less + // depth left, so remember the failure to avoid repeating it for every + // reference after the first. Loops being analyzed and reduce labels make + // walks depend on more than the node and reference, so such walks are not + // remembered. + if len(c.flowDepthFailures) != 0 && c.isRememberedFlowDepthFailure(f, flow) { + return FlowType{t: c.errorType} + } + hits := f.limitHits + t := c.getTypeAtFlowNodeWorker(f, flow) + if f.limitHits != hits { + c.rememberFlowDepthFailure(f, flow) + } + return t +} + +// isRememberedFlowDepthFailure reports whether a walk from flow is known to +// be too deep for the depth left, reporting the failure if so. +// +//go:noinline +func (c *Checker) isRememberedFlowDepthFailure(f *FlowState, flow *ast.FlowNode) bool { + if len(c.flowLoopStack) != 0 || len(f.reduceLabels) != 0 || !c.hasFlowReferenceKey(f) { + return false + } + if b, ok := c.flowDepthFailures[FlowLoopKey{flowNode: flow, refKey: f.refKey}]; ok && maxFlowDepth-f.depth <= b { + f.limitHits++ + c.reportFlowControlError(f.reference) + return true + } + return false +} + +// rememberFlowDepthFailure remembers that a walk from flow was too deep for +// the depth left. +// +//go:noinline +func (c *Checker) rememberFlowDepthFailure(f *FlowState, flow *ast.FlowNode) { + if len(c.flowLoopStack) != 0 || len(f.reduceLabels) != 0 || !c.hasFlowReferenceKey(f) { + return + } + budget := maxFlowDepth - f.depth + key := FlowLoopKey{flowNode: flow, refKey: f.refKey} + if b, ok := c.flowDepthFailures[key]; !ok || b < budget { + if c.flowDepthFailures == nil { + c.flowDepthFailures = make(map[FlowLoopKey]int) + } + if c.logResults() { + // The walk may have depended on results a cycle in progress + // discards. + c.logRestore(func() { + if ok { + c.flowDepthFailures[key] = b + } else { + delete(c.flowDepthFailures, key) + } + }) + } + c.flowDepthFailures[key] = budget + } +} + +func (c *Checker) hasFlowReferenceKey(f *FlowState) bool { + if f.refKey.IsZero() { + f.refKey = c.getFlowReferenceKey(f) + } + return f.refKey != nonDottedNameCacheKey +} + +func (c *Checker) getTypeAtFlowNodeWorker(f *FlowState, flow *ast.FlowNode) FlowType { if f.depth == maxFlowDepth || f.depthBase+f.depth == maxFlowTotalDepth { // We have made 2000 recursive invocations. To avoid overflowing the call stack we report an error // and 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. + // 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}) } @@ -393,14 +467,14 @@ func (c *Checker) narrowType(f *FlowState, t *Type, expr *ast.Node, assumeTrue b case ast.KindIdentifier: // When narrowing a reference to a const variable, non-assigned parameter, or readonly property, we inline // up to five levels of aliased conditional expressions that are themselves declared as const variables. - if !c.isMatchingReference(f.reference, expr) && c.inlineLevel < 5 { + if !c.isMatchingReference(f.reference, expr) { symbol := c.getResolvedSymbol(expr) if c.isConstantVariable(symbol) { declaration := symbol.ValueDeclaration() - if declaration != nil && ast.IsVariableDeclaration(declaration) && declaration.Type() == nil && declaration.Initializer() != nil && c.isConstantReference(f.reference) { - c.inlineLevel++ + if declaration != nil && ast.IsVariableDeclaration(declaration) && declaration.Type() == nil && declaration.Initializer() != nil && c.isConstantReference(f.reference) && !c.depthLimitReached(&c.inlineLevel, 5) { + c.enterDepthLimit(&c.inlineLevel) result := c.narrowType(f, t, declaration.Initializer(), assumeTrue) - c.inlineLevel-- + c.exitDepthLimit(&c.inlineLevel) return result } } @@ -858,11 +932,13 @@ func (c *Checker) getNarrowedType(t *Type, candidate *Type, assumeTrue bool, che return c.getNarrowedTypeWorker(t, candidate, assumeTrue, checkDerived) } key := NarrowedTypeKey{t, candidate, assumeTrue, checkDerived} - if narrowedType, ok := c.narrowedTypes[key]; ok { + if narrowedType, ok := c.narrowedTypes.cached(c, key); ok { return narrowedType } + c.narrowedTypes.begin(c, key) narrowedType := c.getNarrowedTypeWorker(t, candidate, assumeTrue, checkDerived) - c.narrowedTypes[key] = narrowedType + c.narrowedTypes.set(c, key, narrowedType) + c.endMemo() return narrowedType } @@ -1341,15 +1417,23 @@ func (c *Checker) getTypeAtFlowLoopLabel(f *FlowState, flow *ast.FlowNode) FlowT return FlowType{t: f.declaredType} } key := FlowLoopKey{flowNode: flow, refKey: f.refKey} + entry, _ := c.flowLoopCache.get(key) + if entry == nil { + entry = &flowLoopCacheEntry{} + c.flowLoopCache.intern(key, entry) + } // If we have previously computed the control flow type for the reference at // this flow loop junction, return the cached type. - if cached := c.flowLoopCache[key]; cached.t != nil { - if cached.tooDeep { + if entry.t != nil { + c.observeFlagMemo(memoKeyOf(entry, memoFlowLoopType)) + if entry.tooDeep { // Analyzing the loop again would give up again. + f.limitHits++ c.reportFlowControlError(f.reference) } - return FlowType{t: cached.t} + return FlowType{t: entry.t} } + c.beginMemo(memoKeyOf(entry, memoFlowLoopType)) // The result is cached for every reference with this key, so the analysis // neither uses the depth left to this reference nor the nodes this // reference already visited, and the nodes it visits are not reused @@ -1358,22 +1442,21 @@ func (c *Checker) getTypeAtFlowLoopLabel(f *FlowState, flow *ast.FlowNode) FlowT f.depthBase += f.depth f.depth = 0 f.sharedFlowStart = len(c.sharedFlows) - result := c.getTypeAtFlowLoopLabelUncached(f, flow, key) + result := c.getTypeAtFlowLoopLabelUncached(f, flow, key, entry) c.sharedFlows = c.sharedFlows[:f.sharedFlowStart] f.depth, f.depthBase, f.sharedFlowStart = depth, depthBase, sharedFlowStart - if cached := c.flowLoopCache[key]; cached.t != nil { - if f.limitHits != hits { - cached.tooDeep = true - c.flowLoopCache[key] = cached - } else if cached.tooDeep { - // Another reference completed the analysis meanwhile. - c.reportFlowControlError(f.reference) - } + if f.limitHits != hits { + entry.tooDeep = entry.t != nil + } else if entry.tooDeep { + // Another reference completed the analysis meanwhile. + f.limitHits++ + c.reportFlowControlError(f.reference) } + c.endMemo() return result } -func (c *Checker) getTypeAtFlowLoopLabelUncached(f *FlowState, flow *ast.FlowNode, key FlowLoopKey) FlowType { +func (c *Checker) getTypeAtFlowLoopLabelUncached(f *FlowState, flow *ast.FlowNode, key FlowLoopKey, entry *flowLoopCacheEntry) FlowType { // If this flow loop junction and reference are already being processed, return // the union of the types computed for each branch so far, marked as incomplete. // It is possible to see an empty array in cases where loops are nested and the @@ -1418,8 +1501,8 @@ func (c *Checker) getTypeAtFlowLoopLabelUncached(f *FlowState, flow *ast.FlowNod // 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.t != nil { - return FlowType{t: cached.t} + if entry.t != nil { + return FlowType{t: entry.t} } } antecedentTypes = core.AppendIfUnique(antecedentTypes, flowType.t) @@ -1442,7 +1525,10 @@ func (c *Checker) getTypeAtFlowLoopLabelUncached(f *FlowState, flow *ast.FlowNod if firstAntecedentType.incomplete { return c.newFlowType(result, true /*incomplete*/) } - c.flowLoopCache[key] = flowLoopCacheEntry{t: 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} } @@ -1553,11 +1639,11 @@ func getCandidateVariableDeclarationInitializer(node *ast.Node) *ast.Node { // and never escape the getFlowTypeOfReference function. func (c *Checker) getEvolvingArrayType(elementType *Type) *Type { key := CachedTypeKey{kind: CachedTypeKindEvolvingArrayType, typeId: elementType.id} - result := c.cachedTypes[key] + result, _ := c.cachedTypes.cached(c, key) if result == nil { result = c.newObjectType(ObjectFlagsEvolvingArray, nil) result.AsEvolvingArrayType().elementType = elementType - c.cachedTypes[key] = result + c.cachedTypes.intern(key, result) } return result } @@ -1616,10 +1702,7 @@ func (c *Checker) finalizeEvolvingArrayType(t *Type) *Type { } func (c *Checker) getFinalArrayType(t *EvolvingArrayType) *Type { - if t.finalArrayType == nil { - t.finalArrayType = c.createFinalArrayType(t.elementType) - } - return t.finalArrayType + return c.memoCompute(&t.finalArrayType, func() *Type { return c.createFinalArrayType(t.elementType) }) } func (c *Checker) createFinalArrayType(elementType *Type) *Type { @@ -1880,7 +1963,7 @@ func (c *Checker) isConstantReference(node *ast.Node) bool { case ast.KindPropertyAccessExpression, ast.KindElementAccessExpression: // The resolvedSymbol property is initialized by checkPropertyAccess or checkElementAccess before we get here. if c.isConstantReference(node.Expression()) { - symbol := c.getResolvedSymbolOrNil(node) + symbol := c.symbolOfCheckedExpression(node) if symbol != nil { return c.isReadonlySymbol(symbol) } @@ -1989,18 +2072,21 @@ func isCoercibleUnderDoubleEquals(source *Type, target *Type) bool { func (c *Checker) isExhaustiveSwitchStatement(node *ast.Node) bool { links := c.switchStatementLinks.Get(node) - if links.exhaustiveState == ExhaustiveStateUnknown { + switch links.exhaustiveState.cached(c) { + case ExhaustiveStateUnknown: + links.exhaustiveState.begin(c) // Indicate resolution is in process - links.exhaustiveState = ExhaustiveStateComputing + links.exhaustiveState.set(c, ExhaustiveStateComputing) isExhaustive := c.computeExhaustiveSwitchStatement(node) - if links.exhaustiveState == ExhaustiveStateComputing { - links.exhaustiveState = core.IfElse(isExhaustive, ExhaustiveStateTrue, ExhaustiveStateFalse) + if links.exhaustiveState.cached(c) == ExhaustiveStateComputing { + links.exhaustiveState.set(c, core.IfElse(isExhaustive, ExhaustiveStateTrue, ExhaustiveStateFalse)) } - } else if links.exhaustiveState == ExhaustiveStateComputing { + c.endMemo() + case ExhaustiveStateComputing: // Resolve circularity to false - links.exhaustiveState = ExhaustiveStateFalse + links.exhaustiveState.set(c, ExhaustiveStateFalse) } - return links.exhaustiveState == ExhaustiveStateTrue + return links.exhaustiveState.cached(c) == ExhaustiveStateTrue } func (c *Checker) computeExhaustiveSwitchStatement(node *ast.Node) bool { @@ -2082,16 +2168,17 @@ func (c *Checker) getNotEqualFactsFromTypeofSwitch(start int, end int, witnesses func (c *Checker) getSwitchClauseTypes(node *ast.Node) []*Type { links := c.switchStatementLinks.Get(node) - if !links.switchTypesComputed { + if links.switchTypes.cached(c) == nil { + links.switchTypes.begin(c) clauses := node.AsSwitchStatement().CaseBlock.AsCaseBlock().Clauses.Nodes types := make([]*Type, len(clauses)) for i, clause := range clauses { types[i] = c.getTypeOfSwitchClause(clause) } - links.switchTypes = types - links.switchTypesComputed = true + links.switchTypes.set(c, types) + c.endMemo() } - return links.switchTypes + return links.switchTypes.cached(c) } func (c *Checker) getTypeOfSwitchClause(clause *ast.Node) *Type { @@ -2103,8 +2190,9 @@ func (c *Checker) getTypeOfSwitchClause(clause *ast.Node) *Type { func (c *Checker) getEffectsSignature(node *ast.Node) *Signature { links := c.signatureLinks.Get(node) - signature := links.effectsSignature + signature := links.effectsSignature.cached(c) if signature == nil { + links.effectsSignature.begin(c) // A call expression parented by an expression statement is a potential assertion. Other call // expressions are potential type predicate function calls. In order to avoid triggering // circularities in control flow analysis, we use getTypeOfDottedName when resolving the call @@ -2136,7 +2224,8 @@ func (c *Checker) getEffectsSignature(node *ast.Node) *Signature { if !(signature != nil && c.hasTypePredicateOrNeverReturnType(signature)) { signature = c.unknownSignature } - links.effectsSignature = signature + links.effectsSignature.set(c, signature) + c.endMemo() } if signature == c.unknownSignature { return nil @@ -2211,10 +2300,11 @@ func (c *Checker) getTypeOfDottedName(node *ast.Node, diagnostic *ast.Diagnostic func (c *Checker) getExplicitTypeOfSymbol(symbol *ast.Symbol, diagnostic *ast.Diagnostic) *Type { symbol = c.resolveSymbol(symbol) - if !c.resolvingExplicitTypeOfSymbol.AddIfAbsent(symbol) { + if c.isResolvingAnywhere(symbol, TypeSystemPropertyNameExplicitType) { return nil } - defer c.resolvingExplicitTypeOfSymbol.Delete(symbol) + c.beginTypeResolution(symbol, TypeSystemPropertyNameExplicitType, nil) + defer c.popTypeResolution() if symbol.Flags()&(ast.SymbolFlagsFunction|ast.SymbolFlagsMethod|ast.SymbolFlagsClass|ast.SymbolFlagsValueModule) != 0 { return c.getTypeOfSymbol(symbol) } @@ -2314,16 +2404,13 @@ func (c *Checker) getInitialTypeOfVariableDeclaration(node *ast.Node) *Type { return c.errorType } +// getTypeOfInitializer returns the type of an initializer for flow analysis. +// It is the type of the expression where it is, cached apart from the type +// checking caches for it, which flow analysis would otherwise compute first: +// the cycles through the initializer would then be entered there rather than +// from the declaration. Within the analysis of a loop, it reflects the types of +// the references in progress in the loop. func (c *Checker) getTypeOfInitializer(node *ast.Node) *Type { - // Return the cached type if one is available. If the type of the variable was inferred - // from its initializer, we'll already have cached the type. Otherwise we compute it now - // without caching such that transient types are reflected. - if c.typeNodeLinks.Has(node) { - t := c.typeNodeLinks.Get(node).resolvedType - if t != nil { - return t - } - } return c.getTypeOfExpression(node) } @@ -2461,10 +2548,12 @@ func (c *Checker) getAssignmentReducedType(declaredType *Type, assignedType *Typ return assignedType } key := AssignmentReducedKey{id1: declaredType.id, id2: assignedType.id} - result := c.assignmentReducedTypes[key] + result, _ := c.assignmentReducedTypes.cached(c, key) if result == nil { + c.assignmentReducedTypes.begin(c, key) result = c.getAssignmentReducedTypeWorker(declaredType, assignedType) - c.assignmentReducedTypes[key] = result + c.assignmentReducedTypes.set(c, key, result) + c.endMemo() } return result } @@ -2571,24 +2660,30 @@ func (c *Checker) isReachableFlowNode(flow *ast.FlowNode) bool { f := c.getFlowState() result := c.isReachableFlowNodeWorker(f, flow, false /*noCacheCheck*/) c.putFlowState(f) - c.lastFlowNode = flow - c.lastFlowNodeReachable = result + // The last result is reused without accounting for reading it, so it is + // only kept where nothing computed since could be discarded. + if !c.logResults() { + c.lastFlowNode = flow + c.lastFlowNodeReachable = result + } return result } func (c *Checker) isReachableFlowNodeWorker(f *FlowState, flow *ast.FlowNode, noCacheCheck bool) bool { for { - if flow == c.lastFlowNode { + if flow == c.lastFlowNode && !c.observing() { return c.lastFlowNodeReachable } flags := flow.Flags if flags&ast.FlowFlagsShared != 0 { if !noCacheCheck && len(f.reduceLabels) == 0 { - if reachable, ok := c.flowNodeReachable[flow]; ok { + if reachable, ok := c.flowNodeReachable.cached(c, flow); ok { return reachable } + c.flowNodeReachable.begin(c, flow) reachable := c.isReachableFlowNodeWorker(f, flow, true /*noCacheCheck*/) - c.flowNodeReachable[flow] = reachable + c.flowNodeReachable.set(c, flow, reachable) + c.endMemo() return reachable } noCacheCheck = false @@ -2670,11 +2765,13 @@ func (c *Checker) isPostSuperFlowNodeWorker(f *FlowState, flow *ast.FlowNode, no flags := flow.Flags if flags&ast.FlowFlagsShared != 0 { if !noCacheCheck { - if postSuper, ok := c.flowNodePostSuper[flow]; ok { + if postSuper, ok := c.flowNodePostSuper.cached(c, flow); ok { return postSuper } + c.flowNodePostSuper.begin(c, flow) postSuper := c.isPostSuperFlowNodeWorker(f, flow, true /*noCacheCheck*/) - c.flowNodePostSuper[flow] = postSuper + c.flowNodePostSuper.set(c, flow, postSuper) + c.endMemo() return postSuper } noCacheCheck = false @@ -2729,24 +2826,16 @@ func (c *Checker) isPastLastAssignment(symbol *ast.Symbol, location *ast.Node) b return lastAssignmentPos == 0 || location != nil && int(lastAssignmentPos) < location.Pos() } +// ensureAssignmentsMarked marks the assignments within the function or file +// declaring symbol. func (c *Checker) ensureAssignmentsMarked(symbol *ast.Symbol) { parent := ast.FindAncestor(symbol.ValueDeclaration(), ast.IsFunctionOrSourceFile) if parent == nil { return } - links := c.nodeLinks.Get(parent) - if links.flags&NodeCheckFlagsAssignmentsMarked == 0 { - links.flags |= NodeCheckFlagsAssignmentsMarked - if !c.hasParentWithAssignmentsMarked(parent) { - c.markNodeAssignments(parent) - } - } -} - -func (c *Checker) hasParentWithAssignmentsMarked(node *ast.Node) bool { - return ast.FindAncestor(node.Parent, func(node *ast.Node) bool { - return ast.IsFunctionOrSourceFile(node) && c.nodeLinks.Get(node).flags&NodeCheckFlagsAssignmentsMarked != 0 - }) != nil + c.assignmentsMarked.once(c, parent, func() { + c.markNodeAssignments(parent) + }) } // For all assignments within the given root node, record the last assignment source position for all diff --git a/tsc/internal/checker/grammarchecks.go b/tsc/internal/checker/grammarchecks.go index 7282241c8bcee..5ef5fd7775ff6 100644 --- a/tsc/internal/checker/grammarchecks.go +++ b/tsc/internal/checker/grammarchecks.go @@ -2026,24 +2026,21 @@ func (c *Checker) checkGrammarSourceFile(node *ast.SourceFile) bool { func (c *Checker) checkGrammarStatementInAmbientContext(node *ast.Node) bool { if node.Flags&ast.NodeFlagsAmbient != 0 { - // Find containing block which is either Block, ModuleBlock, SourceFile - links := c.nodeLinks.Get(node) - if !links.hasReportedStatementInAmbientContext && (ast.IsFunctionLike(node.Parent) || ast.IsAccessor(node.Parent)) { - links.hasReportedStatementInAmbientContext = c.grammarErrorOnFirstToken(node, diagnostics.An_implementation_cannot_be_declared_in_ambient_contexts) - return links.hasReportedStatementInAmbientContext + if ast.IsFunctionLike(node.Parent) || ast.IsAccessor(node.Parent) { + return c.grammarErrorOnFirstToken(node, diagnostics.An_implementation_cannot_be_declared_in_ambient_contexts) } // We are either parented by another statement, or some sort of block. - // If we're in a block, we only want to really report an error once - // to prevent noisiness. So use a bit on the block to indicate if - // this has already been reported, and don't report if it has. - // + // If we're in a block, only its first statement not allowed in an + // ambient context reports an error, to prevent noisiness, unless the + // block is the body of a function, which reports itself. if node.Parent.Kind == ast.KindBlock || node.Parent.Kind == ast.KindModuleBlock || node.Parent.Kind == ast.KindSourceFile { - links := c.nodeLinks.Get(node.Parent) - // Check if the containing block ever report this error - if !links.hasReportedStatementInAmbientContext { - links.hasReportedStatementInAmbientContext = c.grammarErrorOnFirstToken(node, diagnostics.Statements_are_not_allowed_in_ambient_contexts) - return links.hasReportedStatementInAmbientContext + block := node.Parent + if block.Kind == ast.KindBlock && (ast.IsFunctionLike(block.Parent) || ast.IsAccessor(block.Parent)) { + return false + } + if core.Find(block.Statements(), isStatementNotAllowedInAmbientContext) == node { + return c.grammarErrorOnFirstToken(node, diagnostics.Statements_are_not_allowed_in_ambient_contexts) } } else { // We must be parented by a statement. If so, there's no need @@ -2054,6 +2051,23 @@ func (c *Checker) checkGrammarStatementInAmbientContext(node *ast.Node) bool { return false } +// isStatementNotAllowedInAmbientContext reports whether the check of node +// reports it with checkGrammarStatementInAmbientContext. +func isStatementNotAllowedInAmbientContext(node *ast.Node) bool { + if node.Flags&ast.NodeFlagsAmbient == 0 { + return false + } + switch node.Kind { + case ast.KindBlock, ast.KindEmptyStatement, ast.KindDebuggerStatement, ast.KindExpressionStatement, + ast.KindIfStatement, ast.KindDoStatement, ast.KindWhileStatement, ast.KindForStatement, + ast.KindForInStatement, ast.KindForOfStatement, ast.KindBreakStatement, ast.KindContinueStatement, + ast.KindReturnStatement, ast.KindWithStatement, ast.KindSwitchStatement, ast.KindLabeledStatement, + ast.KindThrowStatement, ast.KindTryStatement: + return true + } + return false +} + func (c *Checker) checkGrammarNumericLiteral(node *ast.NumericLiteral) { nodeText := scanner.GetTextOfNode(node.AsNode()) diff --git a/tsc/internal/checker/inference.go b/tsc/internal/checker/inference.go index 8b0cc87aedef4..0dfcaa5a849d6 100644 --- a/tsc/internal/checker/inference.go +++ b/tsc/internal/checker/inference.go @@ -399,7 +399,7 @@ func (c *Checker) inferFromMatchingTypes(n *InferenceState, sources []*Type, tar // when inferring from string[] | string[][] to T[] | T[][], the inference of string we make from // relating string[][] to T[][] is of higher quality than the inference of string[] we make relating // string[][] to T[]. - slices.SortFunc(matchedTargets, compareTypesAndDepth) + slices.SortFunc(matchedTargets, c.compareTypesAndDepth) for _, t := range matchedTargets { for _, s := range matchedSources { if matches(c, s, t) { @@ -418,9 +418,9 @@ func (c *Checker) inferFromMatchingTypes(n *InferenceState, sources []*Type, tar } // Compare two types first by depth and then by the regular type ordering. -func compareTypesAndDepth(t1, t2 *Type) int { - d1 := getTypeDepth(t1, 3) - d2 := getTypeDepth(t2, 3) +func (c *Checker) compareTypesAndDepth(t1, t2 *Type) int { + d1 := c.getTypeDepth(t1, 3) + d2 := c.getTypeDepth(t2, 3) if d1 != d2 { return d2 - d1 // Largest depth sorts first } @@ -431,27 +431,27 @@ func compareTypesAndDepth(t1, t2 *Type) int { // and type references, the depth is one plus the largest type argument depth. For union and // intersection types, the depth is the largest constituent type depth. For all other types, // the depth is zero. The maximum depth limits infinite recursion of circular types. -func getTypeDepth(t *Type, maxDepth int) int { +func (c *Checker) getTypeDepth(t *Type, maxDepth int) int { if maxDepth != 0 { if t.alias != nil && len(t.alias.typeArguments) != 0 { - return getTypeListDepth(t.alias.typeArguments, maxDepth-1) + 1 + return c.getTypeListDepth(t.alias.typeArguments, maxDepth-1) + 1 } if t.objectFlags&ObjectFlagsReference != 0 { - if typeArguments := t.checker.getTypeArguments(t); len(typeArguments) != 0 { - return getTypeListDepth(typeArguments, maxDepth-1) + 1 + if typeArguments := c.getTypeArguments(t); len(typeArguments) != 0 { + return c.getTypeListDepth(typeArguments, maxDepth-1) + 1 } } if t.flags&TypeFlagsUnionOrIntersection != 0 { - return getTypeListDepth(t.Types(), maxDepth) + return c.getTypeListDepth(t.Types(), maxDepth) } } return 0 } -func getTypeListDepth(types []*Type, maxDepth int) int { +func (c *Checker) getTypeListDepth(types []*Type, maxDepth int) int { depth := 0 for _, t := range types { - depth = max(depth, getTypeDepth(t, maxDepth)) + depth = max(depth, c.getTypeDepth(t, maxDepth)) } return depth } @@ -984,7 +984,7 @@ func (c *Checker) inferToMappedType(n *InferenceState, source *Type, target *Typ if constraintType.flags&TypeFlagsTypeParameter != 0 { // We're inferring from some source type S to a mapped type { [P in K]: X }, where K is a type // parameter. First infer from 'keyof S' to K. - c.inferWithPriority(n, c.getIndexTypeEx(source, core.IfElse(c.patternForType[source] != nil, IndexFlagsNoIndexSignatures, IndexFlagsNone)), constraintType, InferencePriorityMappedTypeConstraint) + c.inferWithPriority(n, c.getIndexTypeEx(source, core.IfElse(c.patternForType.has(source), IndexFlagsNoIndexSignatures, IndexFlagsNone)), constraintType, InferencePriorityMappedTypeConstraint) // If K is constrained to a type C, also infer to C. Thus, for a mapped type { [P in K]: X }, // where K extends keyof T, we make the same inferences as for a homomorphic mapped type // { [P in keyof T]: X }. This enables us to make meaningful inferences when the target is a @@ -1014,11 +1014,13 @@ func (c *Checker) inferToMappedType(n *InferenceState, source *Type, target *Typ // variable T[P] (i.e. we treat the type T[P] as the type variable we're inferring for). func (c *Checker) inferTypeForHomomorphicMappedType(source *Type, target *Type, constraint *Type) *Type { key := ReverseMappedTypeKey{sourceId: source.id, targetId: target.id, constraintId: constraint.id} - if cached := c.reverseHomomorphicMappedCache[key]; cached != nil { + if cached, _ := c.reverseHomomorphicMappedCache.cached(c, key); cached != nil { return cached } + c.reverseHomomorphicMappedCache.begin(c, key) t := c.createReverseMappedType(source, target, constraint) - c.reverseHomomorphicMappedCache[key] = t + c.reverseHomomorphicMappedCache.set(c, key, t) + c.endMemo() return t } @@ -1076,9 +1078,13 @@ func (c *Checker) isPartiallyInferableType(t *Type) bool { func (c *Checker) inferReverseMappedType(source *Type, target *Type, constraint *Type) *Type { key := ReverseMappedTypeKey{sourceId: source.id, targetId: target.id, constraintId: constraint.id} - if cached, ok := c.reverseMappedCache[key]; ok { + if cached, ok := c.reverseMappedCache.cached(c, key); ok { return core.OrElse(cached, c.unknownType) } + c.reverseMappedCache.begin(c, key) + if len(c.reverseMappedSourceStack) == 0 { + c.reverseMappedStart = int32(len(c.resolutions) - 1) + } c.reverseMappedSourceStack = append(c.reverseMappedSourceStack, source) c.reverseMappedTargetStack = append(c.reverseMappedTargetStack, target) saveExpandingFlags := c.reverseExpandingFlags @@ -1091,11 +1097,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.cached(c) == nil { reverseLinks := c.ReverseMappedSymbolLinks.Get(symbol) - links.resolvedType = core.OrElse(c.inferReverseMappedType(reverseLinks.propertyType, reverseLinks.mappedType, reverseLinks.constraintType), c.unknownType) + links.resolvedType.set(c, core.OrElse(c.inferReverseMappedType(reverseLinks.propertyType, reverseLinks.mappedType, reverseLinks.constraintType), c.unknownType)) } - return links.resolvedType + return links.resolvedType.cached(c) } // If the original mapped type had an intersection constraint we extract its components, @@ -1250,7 +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..b8c37cdd49d98 100644 --- a/tsc/internal/checker/jsx.go +++ b/tsc/internal/checker/jsx.go @@ -32,11 +32,11 @@ const ( ) type JsxElementLinks struct { - jsxFlags JsxFlags // Flags for the JSX element - resolvedJsxElementAttributesType *Type // Resolved element attributes type of a JSX opening-like element - jsxNamespace *ast.Symbol // Resolved JSX namespace symbol for this node - jsxImplicitImportContainer *ast.Symbol // Resolved module symbol the implicit JSX import of this file should refer to - firstJSXTagInFile *ast.Node // The first JSX tag in the file + jsxFlags JsxFlags // Flags for the JSX element + resolvedJsxElementAttributesType memo[*Type] // Resolved element attributes type of a JSX opening-like element + jsxNamespace memo[*ast.Symbol] // Resolved JSX namespace symbol for this node + jsxImplicitImportContainer *ast.Symbol // Resolved module symbol the implicit JSX import of this file should refer to + firstJSXTagInFile *ast.Node // The first JSX tag in the file } var JsxNames = struct { @@ -265,9 +265,10 @@ func (c *Checker) getContextualTypeForChildJsxExpression(node *ast.Node, child * func (c *Checker) discriminateContextualTypeByJSXAttributes(node *ast.Node, contextualType *Type) *Type { key := DiscriminatedContextualTypeKey{nodeId: ast.GetNodeId(node), typeId: contextualType.id} - if discriminated := c.discriminatedContextualTypes[key]; discriminated != nil { + if discriminated, _ := c.discriminatedContextualTypes.cached(c, key); discriminated != nil { return discriminated } + c.discriminatedContextualTypes.begin(c, key) jsxChildrenPropertyName := c.getJsxElementChildrenPropertyName(c.getJsxNamespaceAt(node)) discriminantProperties := core.Filter(node.Properties(), func(p *ast.Node) bool { symbol := p.Symbol() @@ -289,7 +290,8 @@ func (c *Checker) discriminateContextualTypeByJSXAttributes(node *ast.Node, cont }) discriminator := &ObjectLiteralDiscriminator{c: c, props: discriminantProperties, members: discriminantMembers} discriminated := c.discriminateTypeByDiscriminableItems(contextualType, discriminator) - c.discriminatedContextualTypes[key] = discriminated + c.discriminatedContextualTypes.set(c, key, discriminated) + c.endMemo() return discriminated } @@ -500,15 +502,22 @@ func (c *Checker) getSuggestedSymbolForNonexistentJSXAttribute(name string, cont func (c *Checker) getJSXFragmentType(node *ast.Node) *Type { // An opening fragment is required in order for `getJsxNamespace` to give the fragment factory links := c.sourceFileLinks.Get(ast.GetSourceFileOfNode(node)) - if links.jsxFragmentType != nil { - return links.jsxFragmentType + if t := links.jsxFragmentType.cached(c); t != nil { + return t } + links.jsxFragmentType.begin(c) + t := c.getJSXFragmentTypeUncached(node) + links.jsxFragmentType.set(c, t) + c.endMemo() + return t +} + +func (c *Checker) getJSXFragmentTypeUncached(node *ast.Node) *Type { jsxFragmentFactoryName := c.getJsxNamespace(node) // #38720/60122, allow null as jsxFragmentFactory shouldResolveFactoryReference := (c.compilerOptions.Jsx == core.JsxEmitReact || c.compilerOptions.JsxFragmentFactory != "") && jsxFragmentFactoryName != "null" if !shouldResolveFactoryReference { - links.jsxFragmentType = c.anyType - return links.jsxFragmentType + return c.anyType } jsxFactorySymbol := c.getJsxNamespaceContainerForImplicitImport(node) if jsxFactorySymbol == nil { @@ -520,12 +529,10 @@ func (c *Checker) getJSXFragmentType(node *ast.Node) *Type { jsxFactorySymbol = c.resolveName(node, jsxFragmentFactoryName, flags, diagnostics.Using_JSX_fragments_requires_fragment_factory_0_to_be_in_scope_but_it_could_not_be_found, true /*isUse*/, false /*excludeGlobals*/) } if jsxFactorySymbol == nil { - links.jsxFragmentType = c.errorType - return links.jsxFragmentType + return c.errorType } if jsxFactorySymbol.Name() == ReactNames.Fragment { - links.jsxFragmentType = c.getTypeOfSymbol(jsxFactorySymbol) - return links.jsxFragmentType + return c.getTypeOfSymbol(jsxFactorySymbol) } resolvedAlias := jsxFactorySymbol if jsxFactorySymbol.Flags()&ast.SymbolFlagsAlias != 0 { @@ -535,11 +542,9 @@ func (c *Checker) getJSXFragmentType(node *ast.Node) *Type { reactExports := c.getExportsOfSymbol(resolvedAlias) typeSymbol := c.getSymbol(reactExports, ReactNames.Fragment, ast.SymbolFlagsBlockScopedVariable) if typeSymbol != nil { - links.jsxFragmentType = c.getTypeOfSymbol(typeSymbol) - } else { - links.jsxFragmentType = c.errorType + return c.getTypeOfSymbol(typeSymbol) } - return links.jsxFragmentType + return c.errorType } func (c *Checker) resolveJsxOpeningLikeElement(node *ast.Node, candidatesOutArray *[]*Signature, checkMode CheckMode) *Signature { @@ -748,7 +753,7 @@ func (c *Checker) createJsxAttributesTypeFromAttributesProperty(openingLikeEleme attributeSymbol.SetValueDeclaration(member.ValueDeclaration()) } links := c.valueSymbolLinks.Get(attributeSymbol) - links.resolvedType = exprType + links.resolvedType.setIdentity(c, exprType) links.target = member attributesTable.Set(attributeSymbol.Name(), attributeSymbol) if allAttributesTable != nil { @@ -836,11 +841,11 @@ func (c *Checker) createJsxAttributesTypeFromAttributesProperty(openingLikeEleme links := c.valueSymbolLinks.Get(childrenPropSymbol) switch { case len(childTypes) == 1: - links.resolvedType = childTypes[0] + links.resolvedType.setIdentity(c, childTypes[0]) case childrenContextualType != nil && someType(childrenContextualType, c.isTupleLikeType): - links.resolvedType = c.createTupleType(childTypes) + links.resolvedType.setIdentity(c, c.createTupleType(childTypes)) default: - links.resolvedType = c.createArrayType(c.getUnionType(childTypes)) + links.resolvedType.setIdentity(c, c.createArrayType(c.getUnionType(childTypes))) } // Fake up a property declaration for the children childrenPropSymbol.SetValueDeclaration(c.factory.NewPropertySignatureDeclaration(nil, c.factory.NewIdentifier(jsxChildrenPropertyName), nil /*postfixToken*/, nil /*type*/, nil /*initializer*/)) @@ -1178,7 +1183,7 @@ func (c *Checker) createSignatureForJSXIntrinsic(node *ast.Node, result *Type) * // returnNode := typeSymbol && c.nodeBuilder.symbolToEntityName(typeSymbol, ast.SymbolFlagsType, node) // declaration := factory.createFunctionTypeNode(nil, []ParameterDeclaration{factory.createParameterDeclaration(nil, nil /*dotDotDotToken*/, "props", nil /*questionToken*/, c.nodeBuilder.typeToTypeNode(result, node))}, ifElse(returnNode != nil, factory.createTypeReferenceNode(returnNode, nil /*typeArguments*/), factory.createKeywordTypeNode(ast.KindAnyKeyword))) parameterSymbol := c.newSymbol(ast.SymbolFlagsFunctionScopedVariable, "props") - c.valueSymbolLinks.Get(parameterSymbol).resolvedType = result + c.valueSymbolLinks.Get(parameterSymbol).resolvedType.setIdentity(c, result) return c.newSignature(SignatureFlagsNone, nil, nil, nil, []*ast.Symbol{parameterSymbol}, elementType, nil, 1) } @@ -1188,23 +1193,31 @@ func (c *Checker) createSignatureForJSXIntrinsic(node *ast.Node, result *Type) * func (c *Checker) getIntrinsicAttributesTypeFromJsxOpeningLikeElement(node *ast.Node) *Type { debug.Assert(isJsxIntrinsicTagName(node.TagName())) links := c.jsxElementLinks.Get(node) - if links.resolvedJsxElementAttributesType != nil { - return links.resolvedJsxElementAttributesType + if t := links.resolvedJsxElementAttributesType.cached(c); t != nil { + return t } + links.resolvedJsxElementAttributesType.begin(c) + result := c.getIntrinsicAttributesTypeFromJsxOpeningLikeElementUncached(node, links) + c.endMemo() + return result +} + +func (c *Checker) getIntrinsicAttributesTypeFromJsxOpeningLikeElementUncached(node *ast.Node, links *JsxElementLinks) *Type { + if t := links.resolvedJsxElementAttributesType.cached(c); t != nil { + return t + } + result := c.errorType symbol := c.getIntrinsicTagSymbol(node) if links.jsxFlags&JsxFlagsIntrinsicNamedElement != 0 { - links.resolvedJsxElementAttributesType = core.OrElse(c.getTypeOfSymbol(symbol), c.errorType) - return links.resolvedJsxElementAttributesType - } - if links.jsxFlags&JsxFlagsIntrinsicIndexedElement != 0 { + result = core.OrElse(c.getTypeOfSymbol(symbol), c.errorType) + } else if links.jsxFlags&JsxFlagsIntrinsicIndexedElement != 0 { indexInfo := c.getApplicableIndexInfoForName(c.getJsxType(JsxNames.IntrinsicElements, node), node.TagName().Text()) if indexInfo != nil { - links.resolvedJsxElementAttributesType = indexInfo.valueType - return links.resolvedJsxElementAttributesType + result = indexInfo.valueType } } - links.resolvedJsxElementAttributesType = c.errorType - return links.resolvedJsxElementAttributesType + links.resolvedJsxElementAttributesType.set(c, result) + return result } // Looks up an intrinsic tag name and returns a symbol that either points to an intrinsic @@ -1212,9 +1225,22 @@ func (c *Checker) getIntrinsicAttributesTypeFromJsxOpeningLikeElement(node *ast. // string index signature (in which case nodeLinks.jsxFlags will be IntrinsicIndexedElement). // May also return unknownSymbol if both of these lookups fail. func (c *Checker) getIntrinsicTagSymbol(node *ast.Node) *ast.Symbol { + c.symbolNodeLinks.Get(node).resolvedSymbol.begin(c) + result := c.getIntrinsicTagSymbolUncached(node) + c.endMemo() + return result +} + +// setIntrinsicJsxFlag records how the intrinsic tag symbol of node was found, +// as part of resolving that symbol. +func (c *Checker) setIntrinsicJsxFlag(node *ast.Node, links *SymbolNodeLinks, flag JsxFlags) { + setFlagMemoBits(c, links.resolvedSymbol.key(), &c.jsxElementLinks.Get(node).jsxFlags, JsxFlagsIntrinsicNamedElement|JsxFlagsIntrinsicIndexedElement, flag) +} + +func (c *Checker) getIntrinsicTagSymbolUncached(node *ast.Node) *ast.Symbol { links := c.symbolNodeLinks.Get(node) - if links.resolvedSymbol != nil { - return links.resolvedSymbol + if links.resolvedSymbol.cached(c) != nil { + return links.resolvedSymbol.cached(c) } intrinsicElementsType := c.getJsxType(JsxNames.IntrinsicElements, node) if !c.isErrorType(intrinsicElementsType) { @@ -1226,32 +1252,32 @@ func (c *Checker) getIntrinsicTagSymbol(node *ast.Node) *ast.Symbol { propName := tagName.Text() intrinsicProp := c.getPropertyOfType(intrinsicElementsType, propName) if intrinsicProp != nil { - c.jsxElementLinks.Get(node).jsxFlags |= JsxFlagsIntrinsicNamedElement - links.resolvedSymbol = intrinsicProp - return links.resolvedSymbol + c.setIntrinsicJsxFlag(node, links, JsxFlagsIntrinsicNamedElement) + links.resolvedSymbol.set(c, intrinsicProp) + return links.resolvedSymbol.cached(c) } // Intrinsic string indexer case indexSymbol := c.getApplicableIndexSymbol(intrinsicElementsType, c.getStringLiteralType(propName)) if indexSymbol != nil { - c.jsxElementLinks.Get(node).jsxFlags |= JsxFlagsIntrinsicIndexedElement - links.resolvedSymbol = indexSymbol - return links.resolvedSymbol + c.setIntrinsicJsxFlag(node, links, JsxFlagsIntrinsicIndexedElement) + links.resolvedSymbol.set(c, indexSymbol) + return links.resolvedSymbol.cached(c) } if c.getTypeOfPropertyOrIndexSignatureOfType(intrinsicElementsType, propName) != nil { - c.jsxElementLinks.Get(node).jsxFlags |= JsxFlagsIntrinsicIndexedElement - links.resolvedSymbol = intrinsicElementsType.symbol - return links.resolvedSymbol + c.setIntrinsicJsxFlag(node, links, JsxFlagsIntrinsicIndexedElement) + links.resolvedSymbol.set(c, intrinsicElementsType.symbol) + return links.resolvedSymbol.cached(c) } // Wasn't found c.error(node, diagnostics.Property_0_does_not_exist_on_type_1, tagName.Text(), "JSX."+JsxNames.IntrinsicElements) - links.resolvedSymbol = c.unknownSymbol - return links.resolvedSymbol + links.resolvedSymbol.set(c, c.unknownSymbol) + return links.resolvedSymbol.cached(c) } if c.noImplicitAny { c.error(node, diagnostics.JSX_element_implicitly_has_type_any_because_no_interface_JSX_0_exists, JsxNames.IntrinsicElements) } - links.resolvedSymbol = c.unknownSymbol - return links.resolvedSymbol + links.resolvedSymbol.set(c, c.unknownSymbol) + return links.resolvedSymbol.cached(c) } func (c *Checker) getJsxStatelessElementTypeAt(location *ast.Node) *Type { @@ -1302,14 +1328,28 @@ func (c *Checker) getJsxType(name string, location *ast.Node) *Type { } func (c *Checker) getJsxNamespaceAt(location *ast.Node) *ast.Symbol { - var links *JsxElementLinks - if location != nil { - links = c.jsxElementLinks.Get(location) + if location == nil { + return c.getJsxNamespaceAtUncached(location, nil) } - if links != nil && links.jsxNamespace != nil && links.jsxNamespace != c.unknownSymbol { - return links.jsxNamespace + links := c.jsxElementLinks.Get(location) + if s := links.jsxNamespace.cached(c); s != nil && s != c.unknownSymbol { + return s } - if links == nil || links.jsxNamespace != c.unknownSymbol { + links.jsxNamespace.begin(c) + result := c.getJsxNamespaceAtUncached(location, links) + c.endMemo() + return result +} + +func (c *Checker) getJsxNamespaceAtUncached(location *ast.Node, links *JsxElementLinks) *ast.Symbol { + var cached *ast.Symbol + if links != nil { + cached = links.jsxNamespace.cached(c) + if cached != nil && cached != c.unknownSymbol { + return cached + } + } + if cached != c.unknownSymbol { resolvedNamespace := c.getJsxNamespaceContainerForImplicitImport(location) if resolvedNamespace == nil || resolvedNamespace == c.unknownSymbol { namespaceName := c.getJsxNamespace(location) @@ -1319,13 +1359,13 @@ func (c *Checker) getJsxNamespaceAt(location *ast.Node) *ast.Symbol { candidate := c.resolveSymbol(c.getSymbol(c.getExportsOfSymbol(c.resolveSymbol(resolvedNamespace)), JsxNames.JSX, ast.SymbolFlagsNamespace)) if candidate != nil && candidate != c.unknownSymbol { if links != nil { - links.jsxNamespace = candidate + links.jsxNamespace.set(c, candidate) } return candidate } } if links != nil { - links.jsxNamespace = c.unknownSymbol + links.jsxNamespace.set(c, c.unknownSymbol) } } // JSX global fallback @@ -1450,8 +1490,16 @@ func (c *Checker) getJsxNamespaceContainerForImplicitImport(location *ast.Node) file := ast.GetSourceFileOfNode(location) links := c.jsxElementLinks.Get(file.AsNode()) if links.jsxImplicitImportContainer != nil { + c.observeFlagMemo(memoKeyOf(links, memoJsxImplicitImportContainer)) return core.IfElse(links.jsxImplicitImportContainer == c.unknownSymbol, nil, links.jsxImplicitImportContainer) } + c.beginMemo(memoKeyOf(links, memoJsxImplicitImportContainer)) + result := c.getJsxNamespaceContainerForImplicitImportUncached(file, links) + c.endMemo() + return result +} + +func (c *Checker) getJsxNamespaceContainerForImplicitImportUncached(file *ast.SourceFile, links *JsxElementLinks) *ast.Symbol { canonicalErrorTag := links.firstJSXTagInFile if canonicalErrorTag == nil { var visit ast.Visitor @@ -1479,7 +1527,7 @@ func (c *Checker) getJsxNamespaceContainerForImplicitImport(location *ast.Node) if mod != nil && mod != c.unknownSymbol { result = c.getMergedSymbol(c.resolveSymbol(mod)) } - links.jsxImplicitImportContainer = core.OrElse(result, c.unknownSymbol) + c.setFlagMemoValue(memoKeyOf(links, memoJsxImplicitImportContainer), &links.jsxImplicitImportContainer, core.OrElse(result, c.unknownSymbol)) return result } diff --git a/tsc/internal/checker/links.go b/tsc/internal/checker/links.go index c21981cae9d80..e7a92438685bf 100644 --- a/tsc/internal/checker/links.go +++ b/tsc/internal/checker/links.go @@ -31,8 +31,13 @@ func (s *nodeLinkStore[V]) Has(node *ast.Node) bool { return s.TryGet(node) != nil } +// TryGet returns the links of node, or nil if it has none. A node without +// an id has no links, and looking it up does not give it one. func (s *nodeLinkStore[V]) TryGet(node *ast.Node) *V { - id := uint64(s.gen.GetNodeId(node)) + id := uint64(ast.PeekNodeId(node)) + if id == 0 { + return nil + } if id >= ast.BlockIdOffset && id < ast.BlockIdOffset+maxPageLinkCount { return s.pages.TryGet(id - ast.BlockIdOffset) } @@ -57,8 +62,13 @@ func (s *symbolLinkStore[V]) Has(symbol *ast.Symbol) bool { return s.TryGet(symbol) != nil } +// TryGet returns the links of symbol, or nil if it has none. A symbol +// without an id has no links, and looking it up does not give it one. func (s *symbolLinkStore[V]) TryGet(symbol *ast.Symbol) *V { - id := uint64(s.gen.GetSymbolId(symbol)) + id := uint64(ast.PeekSymbolId(symbol)) + if id == 0 { + return nil + } if id >= ast.BlockIdOffset && id < ast.BlockIdOffset+maxPageLinkCount { return s.pages.TryGet(id - ast.BlockIdOffset) } diff --git a/tsc/internal/checker/memo.go b/tsc/internal/checker/memo.go new file mode 100644 index 0000000000000..fcce77d3177e1 --- /dev/null +++ b/tsc/internal/checker/memo.go @@ -0,0 +1,2160 @@ +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 + 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 + // Re-entry observes the partial result the computation has published so + // far, or computes the result again if it publishes none. Results + // derived from it may differ depending on which computation starts + // first. Like re-entering a circular computation, it reads an incomplete + // result; see markReadIncomplete. + reentryPartial +) + +// reenter accounts for re-entering the computation in progress at index i +// of resolutions, as r says. +func (c *Checker) reenter(i int, r reentry) { + if r == reentryCircular { + c.markCircular(i) + } + if r != reentryResolution { + c.markReadIncomplete(i) + } +} + +// memoReentry says what re-entering means for each kind of computation. +var memoReentry = [memoFieldCount]reentry{ + // memoCompute keeps the result that a re-entrant computation cached, + // and many cells publish an in-progress marker for re-entry to read. + memoCell: reentryPartial, + // Many kinds of types make members available before they are complete. + memoStructuredMembers: reentryPartial, + // Circular defaults are reported at the default first in program order. + memoTypeParameterDefault: reentryResolution, + // Contextual parameter typing resolves a cycle through the enclosing call. + // Its type resolution ends once the parameters are assigned. + memoContextualParameters: reentryResolution, +} + +// memoKey identifies a memoized result: the address of the entity owning the +// cache slot (an *ast.Node, *ast.Symbol, *Type, or *Signature) shifted left by +// eight bits, plus the memoField of the slot. Packing into an integer keeps map +// operations on the fast path. Entities live as long as the program or the +// checker store, so an address cannot be reused while its keys exist. +type memoKey uint64 + +func (k memoKey) field() memoField { + return memoField(k) +} + +func memoKeyOf[T any](entity *T, field memoField) memoKey { + // SAFETY: Only the address is kept, as an identity; it is never turned back + // into a pointer. + return memoKey(uint64(uintptr(unsafe.Pointer(entity)))<<8 | uint64(field)) +} + +type memoEffects struct { + effects []func(c *Checker) + deps []*memoEffects + parent *memoEffects // Resolution d was most recently added to; avoids duplicate deps + entry *ast.Node // Current node when the computation started, if entered + rare *memoEffectsRare + entered bool // Whether this is the resolution of a computation, not just a set of deps + // Whether the result was discarded at the end of a cycle, so that its + // own effects are not replayed; see effectsToDrop. + dropped bool +} + +// memoEffectsRare holds the parts of memoEffects that few computations have, +// kept apart since the effects of every computation in a program can be +// retained at once. +type memoEffectsRare struct { + 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) +} + +// cached returns the cached result, accounting for the effects of computing it. +func (m *memo[T]) cached(c *Checker) T { + if c.observing() { + c.observeCell(&m.memoHeader) + } + return m.memoValue +} + +// set caches a result. When set outside the result's own computation (for +// example, the types of binding elements assigned while resolving the type of +// their declaration), the result depends on the computation setting it. +func (m *memo[T]) set(c *Checker, v T) { + if c.logResults() { + m.logDiscard(c) + } + m.memoValue = v + if !c.checking { + c.attachCell(&m.memoHeader) + } +} + +// setAfterMarker is set for a result replacing the marker its computation put +// in place when it began. A marker put in place before a cycle began was not +// logged, so discarding the result would restore it; a restored marker that +// stale reports as no longer in progress is cleared instead. Stale is given x +// rather than capturing it so that nothing is allocated unless the set is +// logged. +func setAfterMarker[T comparable, X any](c *Checker, m *memo[T], v T, x X, stale func(*Checker, X, T) bool) { + n := len(c.discardLog) + m.set(c, v) + if len(c.discardLog) > n { + restore := c.discardLog[n].restore + c.discardLog[n].restore = func() { + restore() + if stale(c, x, m.memoValue) { + var zero T + m.memoValue = zero + } + } + } +} + +// setIfChanged is set for a result that every computation needing it sets +// again, such as the symbol a property access resolves to. Setting the value +// it already has comes from the same computation, whose effects are already +// retained, so it is only set when it changes. +func setIfChanged[T comparable](c *Checker, m *memo[T], v T) { + if m.memoValue != v { + m.set(c, v) + } +} + +// setIdentity is set for a result that defines the identity of what it +// caches, such as a declared type, or that is part of an entity being +// created, such as the type of a synthetic property. It is never discarded at +// the end of a cycle: discarding an identity would let a second, distinct +// result exist, and an entity can outlive the cycle in caches that are kept +// while having no way to compute its parts again. +func (m *memo[T]) setIdentity(c *Checker, v T) { + m.memoValue = v + if !c.checking { + c.attachCell(&m.memoHeader) + } +} + +// A memoReported is a memo whose result can have errors to replay; see +// setReported. Reading it accounts for them even when nothing else must be +// accounted for. +type memoReported[T comparable] struct { + memo[T] +} + +func (m *memoReported[T]) cached(c *Checker) T { + if c.observing() || c.memoErrorStates != 0 { + c.observeCell(&m.memoHeader) + } + return m.memoValue +} + +// setReported is setIdentity for a result whose computation collected errors +// reported at the current node, as returned by endCurrentNodeErrors. Every +// node reusing the result reports them again, as it would had it computed the +// result itself. If computing the result elsewhere may not report them (see +// endCurrentNodeErrors), it is instead discarded with other results cached +// for the current node. +func (m *memoReported[T]) setReported(c *Checker, v T, r currentNodeErrors) { + if r.cyclic { + if c.logResults() { + m.logDiscard(c) + } + r.list = nil + } + m.setIdentity(c, v) + if r.list != nil || c.memoErrorStates != 0 && c.peekMemoState(m.key()) != nil { + if r.list != nil { + i := errorFilterIndex(m.key()) + c.errorFilter[i/64] |= 1 << (i % 64) + } + c.memoState(m.key()).setErrors(c, r.list) + } +} + +//go:noinline +func (m *memo[T]) logDiscard(c *Checker) { + old := m.memoValue + c.logMemoDiscard(&m.memoHeader, m.key(), func() { + m.memoValue = old + }) +} + +// inProgress returns the result of a computation in progress, which a +// computation re-entering it may have cached before it finishes. +func (m *memo[T]) inProgress(c *Checker) T { + _, ok := c.resolving.get(m.key()) + debug.Assert(ok, "the computation of the result is not in progress") + return m.cached(c) +} + +// peek returns the cached result without accounting for effects. It is only +// for a result whose computation is in progress, where reading it does not +// observe it. +func (m *memo[T]) peek() T { + return m.memoValue +} + +// swap replaces the cached result without accounting for effects. It is +// only for speculative computations that restore the previous result after. +func (m *memo[T]) swap(v T) T { + old := m.memoValue + m.memoValue = v + return old +} + +// intern sets the result of a cell whose owner is being created. Nothing can +// observe the owner before its creator returns it, so the result needs no +// dependency of its own. +func (m *memo[T]) intern(v T) { + m.memoValue = v +} + +// begin starts the computation of the result; see beginMemo. +func (m *memo[T]) begin(c *Checker) { + c.beginMemo(m.key()) +} + +// memoCompute returns the result cached in m, computing it in a computation +// of its own if there is none. A result cached while computing it, by a +// computation that re-entered it, is kept. +func (c *Checker) memoCompute[T comparable](m *memo[T], compute func() T) T { + var zero T + if v := m.cached(c); v != zero { + return v + } + m.begin(c) + v := compute() + if cur := m.peek(); cur != zero { + v = cur + } else { + m.set(c, v) + } + c.endMemo() + return v +} + +// internMap is a map of results each constructed from the inputs in its key +// alone, without consulting any cached result, so caching or reusing one has +// no effects to account for. +type internMap[K comparable, V any] struct { + _ memoNoCopy + entries map[K]V +} + +func (m *internMap[K, V]) get(k K) (V, bool) { + v, ok := m.entries[k] + return v, ok +} + +func (m *internMap[K, V]) has(k K) bool { + _, ok := m.entries[k] + return ok +} + +func (m *internMap[K, V]) intern(k K, v V) { + if m.entries == nil { + m.entries = make(map[K]V) + } + m.entries[k] = v +} + +func (m *internMap[K, V]) isEmpty() bool { + return len(m.entries) == 0 +} + +func (m *internMap[K, V]) values() iter.Seq[V] { + return maps.Values(m.entries) +} + +// memoMap is a map of cached results, each accounted for like a memo. The +// entries are only accessible through methods. Memo state is kept per entry +// in a side map allocated on first use by a query. +// +// Most maps never need anything but their entries, and many are embedded in +// types, so everything else lives in a side table allocated on first use. +// +// An entry should be computed between enter and endMemo, so that reusing it +// replays the effects of computing that entry alone. An entry set outside its +// own computation depends on the whole enclosing computation instead. +type memoMap[K comparable, V any] struct { + _ memoNoCopy + memoEntries map[K]V + side *memoMapSide[K] + // The number of writes to memoEntries, with which a caller can tell + // that an entry it read is still current without reading it again. + writes uint32 +} + +type memoMapSide[K comparable] struct { + memoStates map[K]*memoState + 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 stateKeyFilter + hasErrors bool // Whether an entry ever had reports; see setReported + reentry reentry // What re-entering an entry means; see memoReentry +} + +func (m *memoMap[K, V]) sideTable() *memoMapSide[K] { + if m.side == nil { + m.side = &memoMapSide[K]{} + } + return m.side +} + +// setReentry sets what re-entering an entry of the map means, which is +// reentryCircular by default. +func (m *memoMap[K, V]) setReentry(r reentry) { + m.sideTable().reentry = r +} + +// setKeyBits makes the map filter the keys that may have a memo state with +// keyBits; see memoMapSide. +func (m *memoMap[K, V]) setKeyBits(keyBits func(K) uint64) { + m.sideTable().keyBits = keyBits +} + +// 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 +} + +// stateOf returns the memo state of the entry for k, or nil. +func (m *memoMap[K, V]) stateOf(k K) *memoState { + s := m.side + if s == nil || s.memoStates == nil { + return nil + } + if s.keyBits != nil && !s.stateKeys.mayContain(s.keyBits(k)) { + return nil + } + return s.memoStates[k] +} + +// cached returns the cached result for k, accounting for the effects of +// computing it. +func (m *memoMap[K, V]) cached(c *Checker, k K) (V, bool) { + if m.side != nil && (c.observing() || m.side.hasErrors) { + m.observe(c, k) + } + v, ok := m.memoEntries[k] + return v, ok +} + +// observe is the out of line part of get, keeping get cheap enough to inline. +// +//go:noinline +func (m *memoMap[K, V]) observe(c *Checker, k K) { + if m.side.memoStates == nil && len(m.side.resolvingKeys) == 0 { + return + } + if c.checking && c.memoPendingCount == 0 && !m.side.hasErrors { + // Only reports are replayed; see observeMemo. + return + } + // A computation in progress may not have a memo state yet; see + // resolutionState. + if state := m.stateOf(k); c.observeState(state) || state == nil && !c.checking { + c.memoCycle(m.resolvingIndex(c, k)) + } +} + +// hasCached reports whether a result is cached for k; see get. +func (m *memoMap[K, V]) hasCached(c *Checker, k K) bool { + _, ok := m.cached(c, k) + return ok +} + +// isEmpty reports whether no result is cached, without observing any. +func (m *memoMap[K, V]) isEmpty() bool { + return len(m.memoEntries) == 0 +} + +// values iterates the cached results without observing them, for +// inspection outside of checking. +func (m *memoMap[K, V]) values() iter.Seq[V] { + return maps.Values(m.memoEntries) +} + +// set caches the result for k; see memo.set. +func (m *memoMap[K, V]) set(c *Checker, k K, v V) { + if c.logResults() { + m.logDiscard(c, k) + } + m.setIdentity(c, k, v) +} + +//go:noinline +func (m *memoMap[K, V]) logDiscard(c *Checker, k K) { + old, ok := m.memoEntries[k] + c.logResultDiscard(c.memoTop != 0 && m.isOwnResolution(c, k), nil, func() { + m.writes++ + if ok { + m.memoEntries[k] = old + } else { + delete(m.memoEntries, k) + } + }) +} + +// setReported is setIdentity for an entry; see memo.setReported. +func (m *memoMap[K, V]) setReported(c *Checker, k K, v V, r currentNodeErrors) { + if r.cyclic { + if c.logResults() { + m.logDiscard(c, k) + } + r.list = nil + } + m.setIdentity(c, k, v) + if r.list != nil || c.memoErrorStates != 0 && m.stateOf(k) != nil { + if r.list != nil { + m.sideTable().hasErrors = true + } + m.state(k).setErrors(c, r.list) + } +} + +// setIdentity is set for a result that defines the identity of what it +// caches; see memo.setIdentity. +func (m *memoMap[K, V]) setIdentity(c *Checker, k K, v V) { + if m.memoEntries == nil { + m.memoEntries = make(map[K]V) + } + m.memoEntries[k] = v + m.writes++ + m.attach(c, k) +} + +// attach is memoAttach for the entry for k. +func (m *memoMap[K, V]) attach(c *Checker, k K) { + if c.memoTop == 0 || c.checking { + return + } + if f := &c.resolutions[c.memoTop-1]; f.source == memoStateSource(m) && m.side.resolvingKeys[f.index] == k { + return + } + c.attachState(m.state(k)) +} + +// intern caches a result constructed from the inputs in k alone, without +// consulting any cached result, so computing it has no effects to account for. +func (m *memoMap[K, V]) intern(k K, v V) { + if m.memoEntries == nil { + m.memoEntries = make(map[K]V) + } + m.memoEntries[k] = v + m.writes++ +} + +// compute computes and caches the result for k in a computation of its own. +func (m *memoMap[K, V]) compute(c *Checker, k K, fn func() V) V { + m.begin(c, k) + v := fn() + m.set(c, k, v) + c.endMemo() + return v +} + +// begin starts the computation of the result for k; see beginMemo. +func (m *memoMap[K, V]) begin(c *Checker, k K) { + side := m.sideTable() + outer := 0 + if len(side.resolvingKeys) != 0 { + outer = m.resolvingIndex(c, k) + } + if outer != 0 { + c.reenter(outer-1, side.reentry) + } + 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) + } + state = &memoState{} + s.memoStates[k] = state + if s.keyBits != nil { + s.stateKeys.add(s.keyBits(k), s.memoStates, s.keyBits) + } + } + return state +} + +// memoSet tracks computations that run at most once per key, such as checks +// whose only results are diagnostics. Each run is a computation of its own, so +// skipping a key that already ran accounts for the effects of that run. +type memoSet[K comparable] struct { + m memoMap[K, struct{}] +} + +// hasCached reports whether k hasCached run; see memoMap.get. +func (s *memoSet[K]) hasCached(c *Checker, k K) bool { + return s.m.hasCached(c, k) +} + +// once runs fn unless k has run already. k is marked before fn runs, so fn +// does not run again if it re-enters. +func (s *memoSet[K]) once(c *Checker, k K, fn func()) { + if s.m.hasCached(c, k) { + return + } + s.m.begin(c, k) + s.m.set(c, k, struct{}{}) + fn() + c.endMemo() +} + +// memoActive reports whether reading a cached result must account for its +// effects: false in a check with nothing pending. +func (c *Checker) memoActive() bool { + return !c.checking || c.memoPendingCount|c.memoErrorStates != 0 +} + +// observing reports whether reading a cached result that cannot have errors +// to replay must account for its effects: memoActive, except for results +// with errors, which only memoReported and memoMap cache. It is kept in a +// field for the many reads that check it. +func (c *Checker) observing() bool { + return c.observingMemos +} + +// syncObserving updates observingMemos after a change to what it depends +// on: the checking flag or the counts it reads. The counts are shared with other checkers using the same +// store, but those only run while this one is not checking, and it syncs on +// starting to check. +func (c *Checker) syncObserving() { + c.observingMemos = !c.checking || c.memoPendingCount != 0 +} + +// readsWithoutMemo reports whether a memoized computation identified by key, +// whose result is cached, can read it without beginning the memo: when no +// memo is active, the memo records and replays nothing, and the computation +// only reads, unless it re-enters itself in progress, with the result +// published before it is complete. +func (c *Checker) readsWithoutMemo(key memoKey) bool { + if c.observing() { + return false + } + _, resolving := c.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. + debug.Assert(c.queryRoot == 0, "nested query") + c.queryRoot = n + 1 + c.querySave = c.enterCurrentNode(c.currentNode) + } + c.memoTop = n + 1 +} + +// stopEffects stops recording the effects of the current resolution, +// returning it if it recorded them. +func (c *Checker) stopEffects() *resolution { + n := len(c.resolutions) - 1 + if c.queryRoot == n && c.currentNodeResolution == n+1 { + n-- + c.exitCurrentNode(c.querySave) + c.queryRoot = 0 + } + f := &c.resolutions[n] + if !f.memo { + return nil + } + c.memoTop = int(f.prevMemo) + return f +} + +func (c *Checker) memoState(key memoKey) *memoState { + state := c.memoStates[key] + if state == nil { + if c.memoStates == nil { + c.memoStates = make(map[memoKey]*memoState) + } + state = &memoState{} + c.memoStates[key] = state + c.stateFilter.add(memoKeyBits(key), c.memoStates, memoKeyBits) + } + return state +} + +// stateKeyFilter is a filter of the keys of a map of memo states, given by +// well-mixed bits of each key, sized to the number of states so that it stays +// in cache: few results have a memo state. +type stateKeyFilter struct { + words []uint64 + shift uint8 // 64 - log2 of the number of bits +} + +// Bits per state below which the filter grows, keeping false positives +// to a few percent. +const stateFilterBitsPerState = 16 + +func memoKeyBits(key memoKey) uint64 { + return uint64(key) * 0x9E3779B97F4A7C15 +} + +func (f *stateKeyFilter) mayContain(h uint64) bool { + if f.words == nil { + return false + } + i := h >> f.shift + return f.words[i/64]&(1<<(i%64)) != 0 +} + +// add adds the key with bits h, which states has just been given a state +// for. +func (f *stateKeyFilter) add[K comparable](h uint64, states map[K]*memoState, keyBits func(K) uint64) { + if n := 64 * len(f.words); n < stateFilterBitsPerState*len(states) { + n = max(2*n, 1<<15) + f.words = make([]uint64, n/64) + f.shift = uint8(65 - bits.Len(uint(n))) + for k := range states { + f.set(keyBits(k)) + } + return + } + f.set(h) +} + +func (f *stateKeyFilter) set(h uint64) { + i := h >> f.shift + f.words[i/64] |= 1 << (i % 64) +} + +const errorFilterBits = 12 + +type errorKeyFilter [1 << errorFilterBits / 64]uint64 + +func errorFilterIndex(key memoKey) uint64 { + return 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(memoKeyBits(key)) { + return nil + } + return c.memoStates[key] +} + +// memoAttach makes the result identified by key depend on the innermost +// computation in progress, unless that computation is the result's own. +func (c *Checker) memoAttach(key memoKey) { + if c.memoTop == 0 || c.checking { + return + } + if f := &c.resolutions[c.memoTop-1]; f.source == nil && f.key == key { + return + } + 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), c.logResults()) +} + +// linkState makes the result in state depend on the effects f of the +// computation that cached it, logging the change in the discard log if log. +func (c *Checker) linkState(state *memoState, f *memoEffects, log bool) { + if log { + c.logPendingDiscard(state) + } + switch { + case state.pending == nil: + // Replaying f is replaying a set of deps holding only f. + state.pending = f + c.memoPendingCount++ + c.syncObserving() + if c.recordingFromCheck { + c.flushBuf = append(c.flushBuf, state) + } + case state.pending == f: + // Already depends on f. + case state.pending.entered: + // The effects of a computation are shared with whatever else + // depends on it, so they cannot gain a dependency of the result. + deps := &memoEffects{} + deps.addDep(state.pending) + deps.addDep(f) + state.pending = deps + default: + state.pending.addDep(f) + } +} + +// observeCell and attachCell are observeMemo and memoAttach for a memo at +// address p. They are kept out of line so that memo reads and writes are +// cheap enough to inline. +// +//go:noinline +func (c *Checker) observeCell(h *memoHeader) { + c.observeMemo(h.key()) +} + +//go:noinline +func (c *Checker) attachCell(h *memoHeader) { + c.memoAttach(h.key()) +} + +// observeMemo accounts for reading a memoized result without computing it. +func (c *Checker) observeMemo(key memoKey) { + if !c.memoActive() { + return + } + if c.checking && c.memoPendingCount == 0 { + // Only reports are replayed, which few results have, so a filter + // small enough to stay in cache rules out most. + if i := errorFilterIndex(key); c.errorFilter[i/64]&(1<<(i%64)) == 0 { + return + } + } + // A computation in progress may not have a memo state yet; see + // resolutionState. + if state := c.peekMemoState(key); c.observeState(state) || state == nil && !c.checking && c.resolving.count != 0 { + c.memoCycle(c.resolvingIndex(key)) + } +} + +// observeState is observeMemo for the memo state of a result, if it has one. +// It reports whether the result is read in a query, in which case reading a +// computation in progress is left to the caller; see memoCycle. +func (c *Checker) observeState(state *memoState) bool { + if state == nil { + return false + } + if state.errors != nil { + c.replayCurrentNodeErrors(*state.errors) + } + if c.checking { + c.replayPending(state) + return false + } + if state.pending != nil { + c.observePending(state.pending) + } + return true +} + +// observePending adds the effects of a reused result to the enclosing +// computation. Those of a computation started at no node are located where +// it is reused, so if that is not where the enclosing computation started, +// the node is kept with them; replay would otherwise locate them wherever the +// enclosing computation is reused. +func (c *Checker) observePending(pending *memoEffects) { + parent := c.currentMemoEffects() + if parent == nil { + return + } + if c.currentNode != nil && c.currentNode != parent.entry && (!pending.entered || pending.entry == nil) { + pending = &memoEffects{deps: []*memoEffects{pending}, entry: c.currentNode, entered: true} + } + parent.addDep(pending) +} + +// A currentNodeError is an error reported at the current node; see +// reportAtCurrentNode. Replaying it reports the same *currentNodeError, so +// that reports collected more than once can be told apart from distinct ones. +type currentNodeError struct { + report func(c *Checker, node *ast.Node) +} + +type currentNodeErrorsMark struct { + errors int + cyclic bool +} + +// currentNodeErrors are the errors a computation reported at the current +// node. +type currentNodeErrors struct { + list []*currentNodeError + cyclic bool // Whether the computation observed a cycle, so computing it elsewhere may not report them +} + +// startCurrentNodeErrors starts collecting the errors a computation reports +// at the current node, to be passed to endCurrentNodeErrors when it finishes. +func (c *Checker) startCurrentNodeErrors() currentNodeErrorsMark { + c.currentNodeErrorCollectors++ + mark := currentNodeErrorsMark{len(c.currentNodeErrors), c.currentNodeErrorsCyclic} + c.currentNodeErrorsCyclic = false + return mark +} + +// endCurrentNodeErrors returns the errors reported at the current node since +// mark. +func (c *Checker) endCurrentNodeErrors(mark currentNodeErrorsMark) currentNodeErrors { + var r currentNodeErrors + for _, report := range c.currentNodeErrors[mark.errors:] { + // Reusing a result more than once reports its errors each time. + if !slices.Contains(r.list, report) { + r.list = append(r.list, report) + } + } + // Which errors a cycle reports depends on where it is entered, so they + // are only reported where the result is computed. + r.cyclic = r.list != nil && c.currentNodeErrorsCyclic + c.currentNodeErrorsCyclic = c.currentNodeErrorsCyclic || mark.cyclic + c.currentNodeErrorCollectors-- + if c.currentNodeErrorCollectors == 0 { + clear(c.currentNodeErrors) + c.currentNodeErrors = c.currentNodeErrors[:0] + c.currentNodeErrorsCyclic = false + } + return r +} + +func (s *memoState) setErrors(c *Checker, reports []*currentNodeError) { + switch { + case s.errors == nil && reports != nil: + c.memoErrorStates++ + c.syncObserving() + case s.errors != nil && reports == nil: + c.memoErrorStates-- + c.syncObserving() + } + if reports == nil { + s.errors = nil + } else { + s.errors = &reports + } +} + +// replayCurrentNodeErrors reports at the current node the errors that +// computing a reused result reported at the node it was computed for. +// +//go:noinline +func (c *Checker) replayCurrentNodeErrors(reports []*currentNodeError) { + for _, r := range reports { + c.reportNode(r) + } +} + +func (c *Checker) replayPending(state *memoState) { + if state != nil && state.pending != nil { + 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)) + } + c.dropResolution(n) + return + } + if f := c.stopEffects(); f != nil && f.effects != nil { + c.retainEffects(c.resolutionState(f), f.effects) + } + c.endResolution() +} + +// markReadIncomplete marks the computations in progress above the one at +// index i, which is re-entered, as reading its incomplete result: either the +// in-progress marker of a circular computation or the part of a partial +// result published so far. What they compute from here on may be derived +// from it; see logResultDiscard. +func (c *Checker) markReadIncomplete(i int) { + for j := i + 1; j < len(c.resolutions); j++ { + c.resolutions[j].readIncomplete = true + } +} + +// 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.recordingFromCheck { + c.retainEffects(c.resolutionState(res), f) + } +} + +// resolutionState returns the memo state of the result a memo resolution +// computes, creating it on first use, since most computations have no +// effects to retain. +func (c *Checker) resolutionState(f *resolution) *memoState { + if f.result == nil { + switch { + case f.source != nil: + f.result = f.source.stateAt(int(f.index)) + case f.key != 0: + f.result = c.memoState(f.key) + default: + // The computation caches no result; see forgetResult. + f.result = &memoState{} + } + } + return f.result +} + +// peekResolutionState is resolutionState without creating the memo state, +// returning nil if the result has none yet. +func (c *Checker) peekResolutionState(f *resolution) *memoState { + if f.result == nil { + switch { + case f.source != nil: + f.result = f.source.peekStateAt(int(f.index)) + case f.key != 0: + f.result = c.peekMemoState(f.key) + } + } + return f.result +} + +// retainEffects retains the effects of a computation that just finished for +// replay by later reuse of its result, and adds them to the enclosing +// computation. +func (c *Checker) retainEffects(state *memoState, f *memoEffects) { + if state.pending != nil && len(f.effects) == 0 && state.pending.covers(f.deps) { + // Computing the result again, typically to return it from a cache + // that the computation reads, observed only what computing it + // before did. Retaining that again would grow the effects of the + // result each time. + if parent := c.currentMemoEffects(); parent != nil { + parent.addDep(state.pending) + } + return + } + if state.pending == nil && len(f.effects) == 0 && f.rare == nil && len(f.deps) == 1 && f.deps[0].entered && f.deps[0].entry == f.entry { + // The computation only observed one result computed at the same + // node, whose effects replay the same way without it. + f = f.deps[0] + } + if c.logEffects() { + c.logPendingDiscard(state) + } + if state.pending != nil { + f.addDep(state.pending) + } else { + c.memoPendingCount++ + c.syncObserving() + if c.recordingFromCheck { + c.flushBuf = append(c.flushBuf, state) + } + } + state.pending = f + if parent := c.currentMemoEffects(); parent != nil { + parent.addDep(f) + } +} + +func (c *Checker) replayMemo(f *memoEffects) { + c.replayEffects(f, nil, false) +} + +// replayEffects replays the effects of f and its dependencies. Effects +// located at the current node that a computation started with (see +// reportAtCurrentNode) are located at the node the reuse happens at instead, +// as they would be had the computation happened there, unless the computation +// started at a different node than the computation replaying it, which then +// fixes its location. Replaying f empties it, so that revisiting it through +// other dependencies replays nothing. +func (c *Checker) replayEffects(f *memoEffects, outerEntry *ast.Node, outerEntered bool) { + effects, deps := f.effects, f.deps + f.effects, f.deps, f.rare = nil, nil, nil + saveCurrentNode := c.currentNode + if f.entered { + // A computation that started at no node can be located anywhere, + // like one started at the node it is reused at. + if outerEntered && f.entry != outerEntry && f.entry != nil { + c.currentNode = f.entry + } + outerEntry, outerEntered = f.entry, true + } + if !f.dropped { + for _, e := range effects { + e(c) + } + } + for _, d := range deps { + c.replayEffects(d, outerEntry, outerEntered) + } + c.currentNode = saveCurrentNode +} + +// atMemoStartNode reports whether the current node is the one the innermost +// computation in progress started with. +func (c *Checker) atMemoStartNode() bool { + n := c.memoTop - 1 + return n >= 0 && c.resolutions[n].entry == c.currentNode +} + +func (c *Checker) currentMemoEffects() *memoEffects { + if c.memoTop == 0 { + return nil + } + return c.memoEffectsAt(c.memoTop - 1) +} + +// recordEffect records a side effect produced by a query against the +// innermost memoized computation, if any. Callers must only call this when +// !c.checking, and must not apply the effect themselves. +func (c *Checker) recordEffect(effect func(c *Checker)) { + if f := c.currentMemoEffects(); f != nil { + f.effects = append(f.effects, effect) + } +} + +// 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 && !f.dropped { + 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) }) + } +} + +// 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, if +// any, a query from here on, because a cycle or a discard mark begins, after which +// results and their effects may be discarded. Effects are then recorded with +// the results computed and with every result observing them, and are replayed +// when the outermost computation finishes (see endQueryFromCheck), so that +// those of discarded results apply only if a result that is kept observed +// them. The computations in progress applied their earlier effects already, +// which is right since they are kept: a cycle discards only what is computed +// after it is found, and a mark only what is computed after it is taken. +func (c *Checker) recordFromCheck() { + if !c.checking || c.memoTop == 0 { + return + } + debug.Assert(!c.recordingFromCheck, "recording from a check already recording") + i := c.memoTop - 1 + for c.resolutions[i].prevMemo != 0 { + i = int(c.resolutions[i].prevMemo) - 1 + } + c.resolutions[i].fromCheck = true + c.checking = false + c.syncObserving() + c.flushBuf = c.flushBuf[:0] + c.recordingFromCheck = true +} + +// endQueryFromCheck ends the query begun by recordFromCheck, replaying +// the effects of everything it computed in the check. +func (c *Checker) endQueryFromCheck() { + if !c.recordingFromCheck { + // The query already ended; see resumeChecking. + return + } + states := c.flushBuf + c.recordingFromCheck = false + c.checking = true + c.syncObserving() + defer clear(states) + c.replayFlushed(states) +} + +func (c *Checker) replayFlushed(states []*memoState) { + for _, state := range states { + if state.pending != nil { + f := state.pending + state.pending = nil + c.memoPendingCount-- + c.syncObserving() + c.replayEffects(f, c.currentNode, true) + } + } +} + +// resumeChecking ends the query begun by recordFromCheck as soon as nothing +// computed since can be discarded: no cycle is in progress and no effects +// mark is held. Recording until the outermost computation finishes would be +// equivalent, but makes every read until then account for effects. What the +// query recorded applies now, as it would have in the check, including what +// the computations in progress recorded, which continue as in a check. +func (c *Checker) resumeChecking() { + if c.checking || !c.recordingFromCheck || c.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.recordingFromCheck = false + c.checking = true + c.syncObserving() + c.replayFlushed(states) + clear(states) + loc := c.currentNode + for _, i := range slices.Backward(chain) { + r := &c.resolutions[i] + if f := r.effects; f != nil { + r.effects = nil + c.currentNode = loc + c.replayEffects(f, loc, true) + } + if r.entry != nil { + loc = r.entry + } + } + c.currentNode = saveCurrentNode + clear(chain) + c.resumeBuf = chain[:0] +} + +// withChecking runs fn in a check. +func (c *Checker) withChecking(fn func()) { + // Checking starts only from top-level requests, so any resolution left at + // this point was never exited and would absorb unrelated effects. + debug.Assert(c.memoTop == 0, "memo resolution leaked") + saveChecking := c.checking + c.checking = true + c.syncObserving() + fn() + c.checking = saveChecking + c.syncObserving() +} + +// memoCycle is called when a computation observes another computation that is +// still in progress, whose resolution is at index depth-1. Every computation +// started since then produced its result from the incomplete state of that +// computation, so reusing any of them must also replay the effects of the +// whole cycle (for example, its circularity error). +func (c *Checker) memoCycle(depth int) { + if depth == 0 || !c.resolutions[depth-1].memo { + // The outer computation does not record effects. + return + } + var outer *memoEffects + // A computation that depends on a cycle head depends on every computation + // in progress above the head, as their effects become part of the head's. + // So walk down from the top, stopping at a computation an earlier reentry + // already made depend on outer or a head below it: the computations below + // it were in progress then too, so they depend on that head as well. + // Without this, every reentry of a cycle would walk, and grow, the whole + // stack. + head := depth - 1 + for i := len(c.resolutions) - 1; i >= depth; i-- { + if !c.resolutions[i].memo { + continue + } + if outer == nil { + // Typically, the computation reads its own result, and no + // computation in between depends on it. + outer = c.memoEffectsAt(depth - 1) + } + f := c.memoEffectsAt(i) + if f == outer || outer.parent == f { + continue + } + if h := f.cycleHead(); h >= 0 && h <= head { + break + } + if i < c.effectsMarkDepth-1 { + // The resolution is in progress below the mark, so discarding to + // the mark must also discard this dependency. + c.logDepsDiscard(f) + } + rare := f.rareFields() + rare.cycles = append(rare.cycles, memoCycleDep{dep: int32(len(f.deps)), head: int32(head)}) + f.deps = append(f.deps, outer) + outer.parent = f + } +} + +// A memoCycleDep is a dependency memoCycle added on a cycle head. +type memoCycleDep struct { + dep int32 // Index in deps + head int32 // Index of the head's resolution +} + +// cycleHead returns the index of the resolution of the lowest cycle head that +// memoCycle made f depend on, or -1. +func (f *memoEffects) cycleHead() int { + if f.rare == nil || len(f.rare.cycles) == 0 { + return -1 + } + return int(f.rare.cycles[len(f.rare.cycles)-1].head) +} + +// logDepsDiscard logs the dependencies of a computation in progress below the +// innermost effects mark, which are about to grow, so discardSince can +// restore them. +// +//go:noinline +func (c *Checker) logDepsDiscard(f *memoEffects) { + n := len(f.deps) + c.discardLog = append(c.discardLog, discardEntry{effects: true, restore: func() { + if len(f.deps) > n { + f.truncateDeps(n) + } + }}) +} + +func (c *Checker) memoEffectsAt(i int) *memoEffects { + f := c.resolutions[i].effects + if f == nil { + f = &memoEffects{entry: c.resolutions[i].entry, entered: true} + c.resolutions[i].effects = f + c.attachDeferred(i, f) + } + return f +} + +// attachDeferred attaches the results the memo resolution at index i cached +// before it had effects f; see attachState. A result cached before an effects +// mark or a cycle is attached as if it had been attached then, so the discard +// log does not log it. +// +//go:noinline +func (c *Checker) attachDeferred(i int, f *memoEffects) { + start := int(c.resolutions[i].attachStart) + end := len(c.deferredAttach) + for j := i + 1; j < len(c.resolutions); j++ { + if c.resolutions[j].memo { + end = int(c.resolutions[j].attachStart) + break + } + } + if start == end { + return + } + for k := start; k < end; k++ { + if state := c.deferredAttach[k]; state != nil { + c.deferredAttach[k] = nil + c.linkState(state, f, c.logResults()) + } + } +} + +// Cycles +// +// A cached result must be the result of computing it from scratch, so that +// it does not depend on which computation happened to request it first. A +// computation that observes another computation still in progress (a +// circularity) sees a provisional state, so results cached from the moment +// the cycle is detected until the outermost computation of the cycle (its +// head) finishes may differ from computing them from scratch. Those results +// are discarded when the head finishes, and are recomputed when next +// requested. The computations that were in progress when the cycle was +// detected (its participants) are kept: each of them reaches the cycle when +// computed from scratch too, so each result is the fallback for a circularity +// whichever participant is computed first. +// +// Type comparisons are the exception: a comparison that reaches itself +// assumes it holds rather than being a circularity, since relations are +// coinductive. The Relater tracks those assumptions itself (see +// recursiveTypeRelatedTo), and caches only results that hold whatever they +// assumed. Each comparison is still a resolution, so circularities through +// other computations it needs are handled as above, discarding the relation +// results cached during them. A comparison that needs another relater, as in +// variance measurement, does not see the assumptions of the outer one, so it +// compares from scratch, as it would if run first. + +// Discard log +// +// Some computations run provisionally, and may have to be discarded as if +// they had never run: those in a cycle (see above), and those a computation +// that retries from a mark runs before retrying (see markDiscard). While any +// of them is in progress, what they cache is logged in the discard log, from +// which each discards to the position where it started. The discard log is +// cleared once nothing in progress can discard. + +type discardEntry struct { + memo *memoHeader // The memo restored, or nil + drop *memoEffects // Effects to drop when discarded; see logResultDiscard + restore func() + effects bool // Restores the effects of a result rather than the result +} + +// logResultDiscard appends a result restore entry to the discard log. If own, +// the innermost computation in progress computes the result, and if it read +// the incomplete result of a computation in progress (see markReadIncomplete) +// without reporting an error located at the current node, discarding the +// result also drops the computation's own effects: they may be derived from +// the incomplete result, so they would report errors that computing from +// complete results does not, while the results it reused are still replayed. +func (c *Checker) logResultDiscard(own bool, memo *memoHeader, restore func()) { + var drop *memoEffects + if own { + if f := &c.resolutions[c.memoTop-1]; f.readIncomplete && !f.reportsAtCurrentNode { + drop = f.effects + } + } + c.discardLog = append(c.discardLog, discardEntry{memo: memo, drop: drop, restore: restore}) +} + +func (c *Checker) logMemoDiscard(memo *memoHeader, key memoKey, restore func()) { + c.logResultDiscard(c.memoTop != 0 && c.resolutions[c.memoTop-1].source == nil && c.resolutions[c.memoTop-1].key == key, memo, restore) +} + +// logResults reports whether caching a result must be logged in the discard +// log. +func (c *Checker) logResults() bool { + return c.circularityStart != 0 || c.varianceCycleRoot != 0 +} + +// 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 := range c.varianceStack { + c.varianceStack[i].discardLog = min(c.varianceStack[i].discardLog, start) + } + for i := len(c.discardLog) - 1; i >= start; i-- { + if d := c.discardLog[i].drop; d != nil { + d.dropped = true + } + c.discardLog[i].restore() + } + clear(c.discardLog[start:]) + c.discardLog = c.discardLog[:start] +} + +// trimDiscardLog clears the discard log if nothing in progress can discard. +// While a variance measurement is measured again from the canonical entry of +// its circularity, the measurements in progress are hidden, but may still be +// discarded once it finishes, so the part of the log logged for them before +// it began is kept; see getVariancesWorker. +func (c *Checker) trimDiscardLog() { + if !c.logEffects() && len(c.discardLog) > c.discardLogFloor { + for i := range c.varianceStack { + c.varianceStack[i].discardLog = min(c.varianceStack[i].discardLog, c.discardLogFloor) + } + clear(c.discardLog[c.discardLogFloor:]) + c.discardLog = c.discardLog[:c.discardLogFloor] + } +} + +// A flag memo is a cached result held outside a memo, so that it costs no +// space of its own: bits of a flags word shared with other results, or a +// field of storage allocated only when needed. It is accounted for like a +// memo under a key naming its entity and field. Readers finding it cached +// call observeFlagMemo; it is computed between beginMemo and endMemo for the +// key, and cached with setFlagMemoBits or setFlagMemoValue, or with +// setFlagMemo after logging how to discard it with logMemoDiscard. + +// observeFlagMemo accounts for reading the flag memo identified by key. +func (c *Checker) observeFlagMemo(key memoKey) { + if c.observing() { + c.observeMemo(key) + } +} + +// setFlagMemo accounts for caching the result of the flag memo identified by +// key, as memo.set does. +func (c *Checker) setFlagMemo(key memoKey) { + if !c.checking { + c.memoAttach(key) + } +} + +// logRestore logs how to discard part of a result, or state derived from +// results, in the discard log; the caller checks logResults so that the +// closure is only allocated when needed. +// +//go:noinline +func (c *Checker) logRestore(restore func()) { + c.discardLog = append(c.discardLog, discardEntry{restore: restore}) +} + +// objectFlagsKnown reports whether the flag memo of t whose result is cached +// once computed is set can be read without objectFlagsCell, which callers +// check first since objectFlagsCell is too large to inline. +func (c *Checker) objectFlagsKnown(t *Type, computed ObjectFlags) bool { + return t.objectFlags&computed != 0 && !c.observingMemos +} + +// objectFlagsCell returns the flags under value of t, a flag memo whose +// result is cached once the computed flag is set, computing them in a +// computation of their own if needed. With inProgress, the computed flag is +// set while computing, so that a computation re-entering it finds no flags. +func (c *Checker) objectFlagsCell(t *Type, field memoField, computed ObjectFlags, value ObjectFlags, inProgress bool, compute func() ObjectFlags) ObjectFlags { + key := memoKeyOf(t, field) + if t.objectFlags&computed != 0 { + c.observeMemo(key) + return t.objectFlags & value + } + c.beginMemo(key) + if inProgress { + setFlagMemoBits(c, key, &t.objectFlags, computed|value, computed) + } + result := compute() & value + if inProgress || t.objectFlags&computed == 0 { + setFlagMemoBits(c, key, &t.objectFlags, computed|value, computed|result) + } else { + result = t.objectFlags & value + } + c.endMemo() + return result +} + +// setFlagMemoBits caches the bits of *p under mask as the result of the flag +// memo identified by key. +func setFlagMemoBits[T ~uint32](c *Checker, key memoKey, p *T, mask T, bits T) { + if c.logResults() { + old := *p & mask + c.logMemoDiscard(nil, key, func() { *p = *p&^mask | old }) + } + *p = *p&^mask | bits&mask + c.setFlagMemo(key) +} + +// setFlagMemoValue caches v in *p as the result of the flag memo identified +// by key. +func (c *Checker) setFlagMemoValue[T any](key memoKey, p *T, v T) { + if c.logResults() { + old := *p + c.logMemoDiscard(nil, key, func() { *p = old }) + } + *p = v + c.setFlagMemo(key) +} + +// endCircularity discards the results cached since the outermost cycle in +// progress was detected, except those of its participants. +func (c *Checker) endCircularity() { + mark := min(c.circularityMark, len(c.discardLog)) + c.circularityStart = 0 + c.innerCycles = c.innerCycles[:0] + c.discardCycle(mark, false) + c.cycleParticipants = nil + c.trimDiscardLog() + c.resumeChecking() +} + +// discardCycle discards the results logged since mark, except those of the +// participants of the cycle in progress. If retain, the entries not undone +// stay in the log, as the outer cycle may still discard them. +func (c *Checker) discardCycle(mark int, retain bool) { + undo := c.discardLog[mark:] + participants := c.cycleParticipants + keep := make(map[*memoHeader]struct{}, len(participants)) + for _, p := range participants { + if p != nil { + keep[p] = struct{}{} + } + } + n := mark + for i := len(undo) - 1; i >= 0; i-- { + u := undo[i] + if u.effects { + // A result recomputed after the cycle also replays the effects + // of the computation discarded here. + continue + } + if _, ok := keep[u.memo]; ok && u.memo != nil { + continue + } + if u.drop != nil { + u.drop.dropped = true + } + u.restore() + undo[i] = discardEntry{} + } + if retain { + for _, u := range undo { + if u.restore != nil { + c.discardLog[n] = u + n++ + } + } + } + clear(c.discardLog[n:]) + c.discardLog = c.discardLog[:n] +} + +// extendCircularity makes the resolution at index head-1 part of the cycle in +// progress, starting one if there is none. A cycle whose head is inside the +// one in progress is an inner cycle: what is computed from its head while it +// is incomplete is discarded when it finishes, as for the outermost, rather +// than read by the rest of the outer cycle. +func (c *Checker) extendCircularity(head int) { + c.recordFromCheck() + switch { + case c.circularityStart == 0: + c.circularityMark = len(c.discardLog) + c.circularityStart = head + case head < c.circularityStart: + c.addInnerCycle(c.circularityStart, c.circularityMark) + c.circularityStart = head + case head > c.circularityStart: + c.addInnerCycle(head, len(c.discardLog)) + } +} + +type innerCycle struct { + head int // As Checker.circularityStart + mark int // Length of the discard log when detected +} + +func (c *Checker) addInnerCycle(head int, mark int) { + for _, ic := range c.innerCycles { + if ic.head == head { + return + } + } + c.innerCycles = append(c.innerCycles, innerCycle{head, mark}) +} + +// dropResolution removes the resolution at index n, the top of the stack, and +// ends the cycles it was the head of. +func (c *Checker) dropResolution(n int) { + c.resolutions[n] = resolution{} + c.resolutions = c.resolutions[:n] + c.endCyclesAt(n) +} + +// endCyclesAt ends the cycles whose head is the resolution at index n, which +// just finished. +func (c *Checker) endCyclesAt(n int) { + if c.circularityStart > n { + c.endCircularity() + } else if len(c.innerCycles) != 0 { + c.endInnerCycles(n) + } +} + +// endInnerCycles ends the inner cycles whose head is the resolution at index +// n, which just finished. +func (c *Checker) endInnerCycles(n int) { + for i, ic := range slices.Backward(c.innerCycles) { + if ic.head > n { + c.innerCycles = slices.Delete(c.innerCycles, i, i+1) + c.discardCycle(min(ic.mark, len(c.discardLog)), true) + } + } +} + +// A discardMark is a position in the computation in progress to which it can +// discard, so that it can run again from the same state, as if what it +// computed since had never run. From markDiscard to releaseDiscardMark, the +// discard log logs all that may have to be discarded. +type discardMark struct { + discardPoint + effectsMarkDepth int // Checker.effectsMarkDepth to restore on release + + // The effects recorded so far by the innermost computation in progress, + // which must have a memo resolution. + recording *memoEffects + effects int + deps int + resolutionIndex int +} + +func (c *Checker) markDiscard() discardMark { + c.recordFromCheck() + n := c.memoTop - 1 + f := c.memoEffectsAt(n) + m := discardMark{ + discardPoint: c.discardPoint(), + effectsMarkDepth: c.effectsMarkDepth, + recording: f, + effects: len(f.effects), + deps: len(f.deps), + resolutionIndex: n, + } + c.effectsMarkDepth = n + 1 + return m +} + +// discardSince discards the results cached since m, with the effects of +// computing them, restoring the cycle in progress then, and discards the +// effects recorded by the computation in progress. +func (c *Checker) discardSince(m discardMark) { + c.discardTo(m.discardPoint) + debug.Assert(c.memoTop-1 == m.resolutionIndex && c.resolutions[m.resolutionIndex].effects == m.recording, "effects discarded outside their computation") + m.recording.truncate(m.effects, m.deps) +} + +// A discardPoint is a position in the computation in progress to which what +// it caches since can be discarded. +type discardPoint struct { + discardLog int + participants int + circularityStart int +} + +func (c *Checker) discardPoint() discardPoint { + return discardPoint{discardLog: len(c.discardLog), participants: len(c.cycleParticipants), circularityStart: c.circularityStart} +} + +// discardTo discards the results cached since p, with the effects of +// computing them, restoring the cycle in progress then. +func (c *Checker) discardTo(p discardPoint) { + c.discardLogSince(p.discardLog) + c.cycleParticipants = c.cycleParticipants[:min(p.participants, len(c.cycleParticipants))] + c.circularityStart = p.circularityStart +} + +// truncate discards the effects recorded in f since it had the given numbers +// of effects and dependencies. +func (f *memoEffects) truncate(effects int, deps int) { + clear(f.effects[effects:]) + f.effects = f.effects[:effects] + f.truncateDeps(deps) +} + +// releaseDiscardMark ends the period during which the computation in progress +// can discard to m. +func (c *Checker) releaseDiscardMark(m discardMark) { + c.effectsMarkDepth = m.effectsMarkDepth + c.trimDiscardLog() + c.resumeChecking() +} + +func (f *memoEffects) truncateDeps(n int) { + for _, d := range f.deps[n:] { + if d.parent == f { + d.parent = nil + } + } + clear(f.deps[n:]) + f.deps = f.deps[:n] + if rare := f.rare; rare != nil { + for len(rare.cycles) != 0 && int(rare.cycles[len(rare.cycles)-1].dep) >= n { + rare.cycles = rare.cycles[:len(rare.cycles)-1] + } + } +} + +// logPendingDiscard logs the effects of the result in the memo state, which +// are about to change, so discardSince can restore them. +// +//go:noinline +func (c *Checker) logPendingDiscard(state *memoState) { + old := state.pending + n := 0 + if old != nil { + n = len(old.deps) + } + c.discardLog = append(c.discardLog, discardEntry{effects: true, restore: func() { + switch { + case old == nil && state.pending != nil: + c.memoPendingCount-- + c.syncObserving() + case old != nil && state.pending == nil: + c.memoPendingCount++ + c.syncObserving() + } + state.pending = old + // Only a set of deps (see linkState) gains deps through its state. + if old != nil && !old.entered && len(old.deps) > n { + old.truncateDeps(n) + } + }}) +} + +// Instantiation limits +// +// Instantiation stops with an error when nested too deeply or after too +// many instantiations, as the instantiation is then very likely infinite. +// For the result not to depend on what was cached before, each memoized +// computation (including each cached comparison of two types) measures +// depth from where it started, whether or not it reports errors, and a +// reused result adds no depth. Chains that start a new memoized computation +// at every level are only stopped by a 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 +} + +// A Relation caches the results of comparisons. +type Relation struct { + results memoMap[CacheHashKey, RelationComparisonResult] +} + +func (r *Relation) size() int { + return len(r.results.memoEntries) +} + +func (r *Relation) cached(c *Checker, key CacheHashKey) RelationComparisonResult { + result, _ := r.results.cached(c, key) + return result +} + +func (r *Relation) set(c *Checker, key CacheHashKey, result RelationComparisonResult) { + r.results.set(c, key, result) +} + +// begin starts the comparison computing the result for key. +func (r *Relation) begin(c *Checker, key CacheHashKey) { + r.results.begin(c, key) +} diff --git a/tsc/internal/checker/memopeek_test.go b/tsc/internal/checker/memopeek_test.go new file mode 100644 index 0000000000000..ba773d7232d51 --- /dev/null +++ b/tsc/internal/checker/memopeek_test.go @@ -0,0 +1,383 @@ +package checker_test + +import ( + goast "go/ast" + "go/parser" + "go/printer" + "go/token" + "path/filepath" + "strings" + "testing" + + "gotest.tools/v3/assert" +) + +// memoComputeCalls are the calls only the computation of a result makes on +// its memo: a function making one computes the results of that memo. +var memoComputeCalls = map[string]bool{ + "begin": true, "set": true, "setIdentity": true, "setReported": true, + "swap": true, "intern": true, "compute": true, "once": true, + "setAfterMarker": true, "setIfChanged": true, +} + +// memoReads are the calls reading what a memo holds. +var memoReads = map[string]bool{"cached": true, "hasCached": true, "peek": true} + +// memoHelpers are methods standing for a call on a memo whose storage is +// allocated only when needed: each names the memo field and whether the +// method reads it or computes it. +var memoHelpers = map[string]struct { + field string + reads bool +}{ + "cachedWriteType": {"writeType", true}, + "setWriteType": {"writeType", false}, + "setNewWriteType": {"writeType", false}, + "cachedOuterTypeParameters": {"outerTypeParameters", true}, +} + +// Whether a memo holds a result yet depends on what was computed first, so +// only the computation of a result reads it from its memo: its getter, which +// reuses it, and the computation itself. Everything else asks the getter. A +// memo a computation fills in as a side output of another has no getter of +// its own; it is read by the one accessor listed in memoAccessors, which runs +// the computation producing it first. +func TestOnlyComputationsReadMemos(t *testing.T) { + t.Parallel() + fset := token.NewFileSet() + files, err := filepath.Glob("*.go") + assert.NilError(t, err) + text := func(e goast.Expr) string { + var b strings.Builder + printer.Fprint(&b, fset, e) + return b.String() + } + field := func(memo string) string { + return memo[strings.LastIndexByte(memo, '.')+1:] + } + for _, name := range files { + // Memos and the resolutions computing them are implemented in + // memo.go and resolutions.go, which find computations in progress. + // Tracing reports what has been computed without computing more, + // and its output is not the checker's. + if name == "memo.go" || name == "resolutions.go" || name == "tracer.go" || strings.HasSuffix(name, "_test.go") { + continue + } + file, err := parser.ParseFile(fset, name, nil, parser.SkipObjectResolution) + assert.NilError(t, err) + for _, decl := range file.Decls { + fn, isFunc := decl.(*goast.FuncDecl) + if !isFunc || fn.Body == nil { + continue + } + if _, ok := memoHelpers[fn.Name.Name]; ok && fn.Recv != nil { + continue + } + computes := make(map[string]bool) + computesAny := false + goast.Inspect(fn.Body, func(n goast.Node) bool { + call, ok := n.(*goast.CallExpr) + if !ok { + return true + } + switch f := call.Fun.(type) { + case *goast.SelectorExpr: + if memoComputeCalls[f.Sel.Name] { + computes[text(f.X)] = true + } + if h, ok := memoHelpers[f.Sel.Name]; ok && !h.reads { + computes[text(f.X)+"."+h.field] = true + } + // Computations keyed by entity and field begin by key. + if f.Sel.Name == "beginMemo" || f.Sel.Name == "memoCompute" || f.Sel.Name == "objectFlagsCell" { + computesAny = true + } + case *goast.Ident, *goast.IndexExpr: + callee := text(call.Fun) + if i := strings.IndexByte(callee, '['); i >= 0 { + callee = callee[:i] + } + if memoComputeCalls[callee] && len(call.Args) > 1 { + if u, ok := call.Args[1].(*goast.UnaryExpr); ok { + computes[text(u.X)] = true + } + } + } + return true + }) + goast.Inspect(fn.Body, func(n goast.Node) bool { + call, ok := n.(*goast.CallExpr) + if !ok { + return true + } + sel, ok := call.Fun.(*goast.SelectorExpr) + if !ok { + return true + } + var memo string + if h, ok := memoHelpers[sel.Sel.Name]; ok && h.reads { + memo = text(sel.X) + "." + h.field + } else if memoReads[sel.Sel.Name] { + memo = text(sel.X) + } else { + return true + } + if computes[memo] || computesAny || memoAccessors[field(memo)][fn.Name.Name] { + return true + } + t.Errorf("%s: %s reads %s, whose results it does not compute", fset.Position(call.Pos()), fn.Name.Name, memo) + return true + }) + } + } +} + +// memoAccessors lists, for each memo filled in as a side output of another +// computation, the accessors reading it, which run that computation first or +// are called by it once it has; and for each memo holding a part an entity's +// creator supplies, the accessor reading that part. +var memoAccessors = map[string]map[string]bool{ + "resolvedTypeArguments": {"typeArgumentsOfCreation": true}, + "writeType": {"writeTypeOfCreation": true}, + "resolvedType": {"typeOfCreation": true}, + "constraint": {"constraintOfCreation": true}, + "containsError": {"mappedTypeContainsError": true}, + "resolvedSymbol": { + "getSymbolOfExpression": true, "symbolOfCheckedExpression": true, + "getSymbolOfTypeNodePart": true, + }, + "lateMergedSymbols": {"getLateMergedSymbol": true, "combineSymbolTables": true}, + "relation": {"cachedRelation": true}, + // Inferring the return type of a contextually typed function resolves + // it without its memo, so whether it is in progress cannot be asked of + // the memo. + "resolvedReturnType": {"isResolvingReturnTypeOfSignature": true}, +} + +// A result an entity's creator sets is part of the entity, which can outlive +// the computation creating it in caches, with no way to compute the result +// again. So the creator sets it with setIdentity or intern, which are kept, +// and not with set, which a discarded computation discards. +func TestCreatorsKeepThePartsTheySet(t *testing.T) { + t.Parallel() + fset := token.NewFileSet() + files, err := filepath.Glob("*.go") + assert.NilError(t, err) + text := func(e goast.Expr) string { + var b strings.Builder + printer.Fprint(&b, fset, e) + return b.String() + } + for _, name := range files { + if strings.HasSuffix(name, "_test.go") { + continue + } + file, err := parser.ParseFile(fset, name, nil, parser.SkipObjectResolution) + assert.NilError(t, err) + for _, decl := range file.Decls { + fn, isFunc := decl.(*goast.FuncDecl) + if !isFunc || fn.Body == nil { + continue + } + // The entities the function creates, and the links of those. + created := make(map[string]bool) + goast.Inspect(fn.Body, func(n goast.Node) bool { + assign, ok := n.(*goast.AssignStmt) + if !ok || len(assign.Lhs) != 1 || len(assign.Rhs) != 1 { + return true + } + call, ok := assign.Rhs[0].(*goast.CallExpr) + if !ok { + return true + } + sel, ok := call.Fun.(*goast.SelectorExpr) + if !ok { + return true + } + isNew := strings.HasPrefix(sel.Sel.Name, "new") && text(sel.X) == "c" + isLinks := sel.Sel.Name == "Get" && strings.HasSuffix(text(sel.X), "Links") && len(call.Args) == 1 && created[text(call.Args[0])] + if isNew || isLinks { + created[text(assign.Lhs[0])] = true + } + return true + }) + goast.Inspect(fn.Body, func(n goast.Node) bool { + call, ok := n.(*goast.CallExpr) + if !ok { + return true + } + sel, ok := call.Fun.(*goast.SelectorExpr) + if !ok || sel.Sel.Name != "set" && sel.Sel.Name != "setWriteType" { + return true + } + // The memo is reached from a created entity or its links. + for e := sel.X; e != nil; { + switch x := e.(type) { + case *goast.SelectorExpr: + e = x.X + case *goast.CallExpr: + if s, ok := x.Fun.(*goast.SelectorExpr); ok && s.Sel.Name == "Get" && len(x.Args) == 1 && created[text(x.Args[0])] { + t.Errorf("%s: %s sets part of %s, which it creates, with %s", fset.Position(call.Pos()), fn.Name.Name, text(x.Args[0]), sel.Sel.Name) + return true + } + e = x.Fun + case *goast.Ident: + if created[x.Name] { + t.Errorf("%s: %s sets part of %s, which it creates, with %s", fset.Position(call.Pos()), fn.Name.Name, x.Name, sel.Sel.Name) + } + e = nil + default: + e = nil + } + } + return true + }) + } + } +} + +// appliedCalls are the checker methods an effect may call when it is +// applied: those adding what was computed where the effect was recorded. +var appliedCalls = map[string]bool{ + "error": true, "addErrorOrSuggestion": true, "Add": true, "Has": true, "Get": true, + "IsTrue": true, +} + +// A query records the effects of a computation, and reports located at the +// node checking it, to apply them once checking reaches its result; checking +// applies them as they happen, inside the computation. So an effect, and a +// report, only applies what was computed where it was recorded: computing +// more when applied, such as printing a type, would run inside the +// computation in a check but after it in a query, and could find +// computations in progress in one and not in the other. +func TestDeferredEffectsOnlyApply(t *testing.T) { + t.Parallel() + fset := token.NewFileSet() + files, err := filepath.Glob("*.go") + assert.NilError(t, err) + text := func(e goast.Expr) string { + var b strings.Builder + printer.Fprint(&b, fset, e) + return b.String() + } + funcs := make(map[string]*goast.FuncDecl) + var parsed []*goast.File + for _, name := range files { + if strings.HasSuffix(name, "_test.go") { + continue + } + file, err := parser.ParseFile(fset, name, nil, parser.SkipObjectResolution) + assert.NilError(t, err) + parsed = append(parsed, file) + for _, decl := range file.Decls { + if fn, ok := decl.(*goast.FuncDecl); ok && fn.Recv != nil && fn.Body != nil { + funcs[fn.Name.Name] = fn + } + } + } + // check reports the calls in body of checker methods not adding what + // was computed. A method recording an effect that calls the method + // again applies the rest of its body. + var check func(owner *goast.FuncDecl, body goast.Node, where token.Pos) + check = func(owner *goast.FuncDecl, body goast.Node, where token.Pos) { + goast.Inspect(body, func(n goast.Node) bool { + call, ok := n.(*goast.CallExpr) + if !ok { + return true + } + sel, ok := call.Fun.(*goast.SelectorExpr) + if !ok { + return true + } + root := sel.X + for { + if s, ok := root.(*goast.SelectorExpr); ok { + root = s.X + } else { + break + } + } + if id, ok := root.(*goast.Ident); !ok || id.Name != "c" { + return true + } + // A deferred diagnostic is produced when the check ends, outside + // the computations in progress, in a check and in a query alike. + if sel.Sel.Name == "addDeferredDiagnostic" { + return false + } + if appliedCalls[sel.Sel.Name] { + return true + } + if sel.Sel.Name == owner.Name.Name && text(sel.X) == "c" { + for _, stmt := range owner.Body.List { + if !recordsEffect(stmt) { + check(owner, stmt, where) + } + } + return true + } + t.Errorf("%s: an effect recorded by %s calls %s when applied", fset.Position(where), owner.Name.Name, text(call.Fun)) + return true + }) + } + for _, file := range parsed { + for _, decl := range file.Decls { + fn, isFunc := decl.(*goast.FuncDecl) + if !isFunc || fn.Body == nil { + continue + } + // Closures the function assigns to names. + closures := make(map[string]*goast.FuncLit) + goast.Inspect(fn.Body, func(n goast.Node) bool { + if assign, ok := n.(*goast.AssignStmt); ok && len(assign.Lhs) == 1 && len(assign.Rhs) == 1 { + if lit, ok := assign.Rhs[0].(*goast.FuncLit); ok { + closures[text(assign.Lhs[0])] = lit + } + } + return true + }) + goast.Inspect(fn.Body, func(n goast.Node) bool { + call, ok := n.(*goast.CallExpr) + if !ok || len(call.Args) == 0 { + return true + } + sel, ok := call.Fun.(*goast.SelectorExpr) + if !ok || text(sel.X) != "c" || !deferringCalls[sel.Sel.Name] { + return true + } + var lit *goast.FuncLit + switch arg := call.Args[len(call.Args)-1].(type) { + case *goast.FuncLit: + lit = arg + case *goast.Ident: + lit = closures[arg.Name] + } + if lit != nil { + check(fn, lit.Body, call.Pos()) + } + return true + }) + } + } +} + +// deferringCalls are the checker methods taking an effect, or a report, +// that a query applies later than checking does. +var deferringCalls = map[string]bool{ + "recordEffect": true, "recordMark": true, "reportAtCurrentNode": true, "reportAtCurrentNodeOnce": true, +} + +// recordsEffect reports whether stmt is the part of a method recording an +// effect that records it. +func recordsEffect(stmt goast.Stmt) bool { + found := false + goast.Inspect(stmt, func(n goast.Node) bool { + if call, ok := n.(*goast.CallExpr); ok { + if sel, ok := call.Fun.(*goast.SelectorExpr); ok && deferringCalls[sel.Sel.Name] { + found = true + } + } + return !found + }) + return found +} diff --git a/tsc/internal/checker/nodebuilder_hover.go b/tsc/internal/checker/nodebuilder_hover.go index b49ac981fbd41..9abe67c6b1ed4 100644 --- a/tsc/internal/checker/nodebuilder_hover.go +++ b/tsc/internal/checker/nodebuilder_hover.go @@ -263,7 +263,7 @@ func (b *NodeBuilderImpl) expandInterfaceDecl(symbol *ast.Symbol) *ast.Node { members = append(members, b.signatureToSignatureDeclarationHelper(sig, ast.KindCallSignature, nil)) } // Properties, filtering inherited - filteredProps := b.filterInheritedProperties(interfaceType, baseTypes, resolved.getProperties()) + filteredProps := b.filterInheritedProperties(interfaceType, baseTypes, resolved.getProperties(b.ch)) members = b.serializePropertiesWithTruncation(filteredProps, members) // Heritage clauses diff --git a/tsc/internal/checker/nodebuilderimpl.go b/tsc/internal/checker/nodebuilderimpl.go index dcbdb8c0cd9fb..a8ddb707d9342 100644 --- a/tsc/internal/checker/nodebuilderimpl.go +++ b/tsc/internal/checker/nodebuilderimpl.go @@ -544,13 +544,7 @@ func (b *NodeBuilderImpl) tryGetResolvedSymbolFromTypeNode(node *ast.Node) *ast. if node == nil || node.Parent == nil { return nil } - b.ch.getTypeFromTypeNode(node) - // call to ensure symbol is resolved - links := b.ch.symbolNodeLinks.TryGet(node) - if links == nil { - return nil - } - return links.resolvedSymbol + return b.ch.getSymbolOfTypeNode(node) } func (b *NodeBuilderImpl) existingTypeNodeIsNotReferenceOrIsReferenceWithCompatibleTypeArgumentCount(existing *ast.TypeNode, t *Type) bool { @@ -607,7 +601,7 @@ func (b *NodeBuilderImpl) getResolvedTypeWithoutAbstractConstructSignatures(t *S t.extra.objectTypeWithoutAbstractConstructSignatures = t.AsType() return t.AsType() } - typeCopy := b.ch.newAnonymousType(t.symbol, t.getMembers(), t.CallSignatures(), core.IfElse(len(constructSignatures) > 0, constructSignatures, []*Signature{}), t.getIndexInfos()) + typeCopy := b.ch.newAnonymousType(t.symbol, t.getMembers(b.ch), t.CallSignatures(), core.IfElse(len(constructSignatures) > 0, constructSignatures, []*Signature{}), t.getIndexInfos()) t.extra.objectTypeWithoutAbstractConstructSignatures = typeCopy typeCopy.AsStructuredType().ensureExtra().objectTypeWithoutAbstractConstructSignatures = typeCopy return typeCopy @@ -2097,9 +2091,9 @@ func (c *Checker) getExpandedParameters(sig *Signature, skipUnionExpanding bool) symbol := c.newSymbolEx(ast.SymbolFlagsFunctionScopedVariable, name, checkFlags) links := c.valueSymbolLinks.Get(symbol) if flags&ElementFlagsRest != 0 { - links.resolvedType = c.createArrayType(t) + links.resolvedType.setIdentity(c, c.createArrayType(t)) } else { - links.resolvedType = t + links.resolvedType.setIdentity(c, t) } return symbol }) @@ -2625,6 +2619,16 @@ func (b *NodeBuilderImpl) getPropertyNameNodeForSymbolFromNameType(symbol *ast.S return nil } +// approximateNameLength returns the length of a property name, without the +// symbol ID a late-bound name ends with, which depends on when the symbol was +// created and so would make truncation depend on the order of checking. +func approximateNameLength(name string) int { + if isLateBoundName(name) { + return strings.LastIndexByte(name, '@') + } + return len(name) +} + func (b *NodeBuilderImpl) addPropertyToElementList(propertySymbol *ast.Symbol, typeElements []*ast.TypeElement) []*ast.TypeElement { propertyIsReverseMapped := propertySymbol.CheckFlags()&ast.CheckFlagsReverseMapped != 0 var propertyType *Type @@ -2661,7 +2665,7 @@ func (b *NodeBuilderImpl) addPropertyToElementList(propertySymbol *ast.Symbol, t } propertyName := b.getPropertyNameNodeForSymbol(propertySymbol, saveEnclosingDeclaration) b.ctx.enclosingDeclaration = saveEnclosingDeclaration - b.ctx.approximateLength += len(ast.SymbolName(propertySymbol)) + 1 + b.ctx.approximateLength += approximateNameLength(ast.SymbolName(propertySymbol)) + 1 if propertySymbol.Flags()&ast.SymbolFlagsAccessor != 0 { writeType := b.ch.getWriteTypeOfSymbol(propertySymbol) @@ -2703,7 +2707,7 @@ func (b *NodeBuilderImpl) addPropertyToElementList(propertySymbol *ast.Symbol, t typeElements = append(typeElements, fakeGetterDeclaration) setterParam := b.ch.newSymbol(ast.SymbolFlagsFunctionScopedVariable, "arg") - b.ch.valueSymbolLinks.Get(setterParam).resolvedType = writeType + b.ch.valueSymbolLinks.Get(setterParam).resolvedType.set(b.ch, writeType) fakeSetterSignature := b.ch.newSignature(SignatureFlagsNone, nil, nil, nil, []*ast.Symbol{setterParam}, b.ch.voidType, nil, 0) fakeSetterDeclaration := b.signatureToSignatureDeclarationHelper(fakeSetterSignature, ast.KindSetAccessor, &SignatureToSignatureDeclarationOptions{ name: propertyName, @@ -2792,7 +2796,7 @@ func (b *NodeBuilderImpl) createTypeNodesFromResolvedType(resolvedType *Structur typeElements = slices.Concat(typeElements, b.indexInfoToObjectComputedNamesOrSignatureDeclaration(info, typeNode)) } - properties := resolvedType.getProperties() + properties := resolvedType.getProperties(b.ch) if len(properties) == 0 { return b.f.NewNodeList(typeElements) } @@ -2834,14 +2838,14 @@ func (b *NodeBuilderImpl) createTypeNodesFromResolvedType(resolvedType *Structur } func (b *NodeBuilderImpl) createTypeNodeFromObjectType(t *Type) *ast.TypeNode { - if b.ch.isGenericMappedType(t) || (t.objectFlags&ObjectFlagsMapped != 0 && t.AsMappedType().containsError) { + if b.ch.isGenericMappedType(t) || (t.objectFlags&ObjectFlagsMapped != 0 && b.ch.mappedTypeContainsError(t)) { return b.createMappedTypeNodeFromType(t) } resolved := b.ch.resolveStructuredTypeMembers(t) callSigs := resolved.CallSignatures() ctorSigs := resolved.ConstructSignatures() - if len(resolved.getProperties()) == 0 && len(resolved.getIndexInfos()) == 0 { + if len(resolved.getProperties(b.ch)) == 0 && len(resolved.getIndexInfos()) == 0 { if len(callSigs) == 0 && len(ctorSigs) == 0 { b.ctx.approximateLength += 2 result := b.f.NewTypeLiteralNode(b.f.NewNodeList([]*ast.Node{})) @@ -2870,9 +2874,9 @@ func (b *NodeBuilderImpl) createTypeNodeFromObjectType(t *Type) *ast.TypeNode { return b.ch.getOrCreateTypeFromSignature(s) }) // count the number of type elements excluding abstract constructors - typeElementCount := len(callSigs) + (len(ctorSigs) - len(abstractSignatures)) + len(resolved.getIndexInfos()) + core.IfElse(b.ctx.flags&nodebuilder.FlagsWriteClassExpressionAsTypeLiteral != 0, core.CountWhere(resolved.getProperties(), func(p *ast.Symbol) bool { + typeElementCount := len(callSigs) + (len(ctorSigs) - len(abstractSignatures)) + len(resolved.getIndexInfos()) + core.IfElse(b.ctx.flags&nodebuilder.FlagsWriteClassExpressionAsTypeLiteral != 0, core.CountWhere(resolved.getProperties(b.ch), func(p *ast.Symbol) bool { return p.Flags()&ast.SymbolFlagsPrototype == 0 - }), len(resolved.getProperties())) + }), len(resolved.getProperties(b.ch))) // don't include an empty object literal if there were no other static-side // properties to write, i.e. `abstract class C { }` becomes `abstract new () => {}` // and not `(abstract new () => {}) & {}` diff --git a/tsc/internal/checker/printer.go b/tsc/internal/checker/printer.go index b84c967883d88..c06d16d173323 100644 --- a/tsc/internal/checker/printer.go +++ b/tsc/internal/checker/printer.go @@ -60,7 +60,7 @@ func (c *Checker) typeToStringEx(t *Type, enclosingDeclaration *ast.Node, flags // Serialization of types can lead to (lazy) resolution of members, which can cause diagnostics that again require // serialization of types. This can potentially result in infinite recursion and stack overflows. To prevent that, // after a certain number of recursive invocations the function simply returns "?". - if c.serializationLevel >= maxSerializationLevel { + if c.depthLimitReached(&c.serializationLevel, maxSerializationLevel) { return "?" } newLine := "" @@ -80,9 +80,9 @@ func (c *Checker) typeToStringEx(t *Type, enclosingDeclaration *ast.Node, flags defer func() { nodeBuilder.verbosity = oldVerbosity }() - c.serializationLevel++ + c.enterDepthLimit(&c.serializationLevel) typeNode := nodeBuilder.TypeToTypeNode(t, enclosingDeclaration, combinedFlags, nodebuilder.InternalFlagsNone, nil) - c.serializationLevel-- + c.exitDepthLimit(&c.serializationLevel) if typeNode == nil { panic("should always get typenode") } diff --git a/tsc/internal/checker/relater.go b/tsc/internal/checker/relater.go index 6b038a9c464fd..8d9bf4a25f657 100644 --- a/tsc/internal/checker/relater.go +++ b/tsc/internal/checker/relater.go @@ -72,8 +72,11 @@ const ( RelationComparisonResultReportsUnmeasurable RelationComparisonResult = 1 << 3 RelationComparisonResultReportsUnreliable RelationComparisonResult = 1 << 4 RelationComparisonResultComplexityOverflow RelationComparisonResult = 1 << 5 - RelationComparisonResultReportsMask = RelationComparisonResultReportsUnmeasurable | RelationComparisonResultReportsUnreliable - RelationComparisonResultOverflow = RelationComparisonResultComplexityOverflow + // The comparison observed incomplete variances; see getRecursiveVariances. + // Only reported, never cached. + RelationComparisonResultReportsIncomplete RelationComparisonResult = 1 << 6 + RelationComparisonResultReportsMask = RelationComparisonResultReportsUnmeasurable | RelationComparisonResultReportsUnreliable + RelationComparisonResultOverflow = RelationComparisonResultComplexityOverflow ) type DiagnosticAndArguments struct { @@ -97,23 +100,13 @@ func asRecursionId[T *ast.Node | *ast.Symbol | *Type](value T) RecursionId { return RecursionId{value: value} } -type Relation struct { - results map[CacheHashKey]RelationComparisonResult -} - -func (r *Relation) get(key CacheHashKey) RelationComparisonResult { - return r.results[key] -} - -func (r *Relation) set(key CacheHashKey, result RelationComparisonResult) { - if r.results == nil { - r.results = make(map[CacheHashKey]RelationComparisonResult) - } - r.results[key] = result -} +// relationCountLimit is the number of results a single comparison may add to +// a relation before it is considered too complex. +const relationCountLimit = 16_000_000 / 8 -func (r *Relation) size() int { - return len(r.results) +// relationKeyBits returns well-mixed bits of a relation key, which is a hash. +func relationKeyBits(k CacheHashKey) uint64 { + return k.Lo } func (c *Checker) isTypeIdenticalTo(source *Type, target *Type) bool { @@ -168,6 +161,25 @@ func (c *Checker) areTypesComparable(type1 *Type, type2 *Type) bool { return c.isTypeComparableTo(type1, type2) || c.isTypeComparableTo(type2, type1) } +// reuseRelation returns the result of a comparison cached as entry, if it can +// be reused, accounting for what the comparison reported about the reliability +// of the variances it used, as computing it would. +func (c *Checker) reuseRelation(entry RelationComparisonResult) (related bool, ok bool) { + if entry == RelationComparisonResultNone || entry&RelationComparisonResultOverflow != 0 { + return false, false + } + c.reliabilityFlags |= entry & (RelationComparisonResultReportsUnmeasurable | RelationComparisonResultReportsUnreliable) + return entry&RelationComparisonResultSucceeded != 0, true +} + +// cachedRelation returns the result cached for the comparison id, and whether +// it is related, if it can be reused; see reuseRelation. +func (c *Checker) cachedRelation(relation *Relation, id CacheHashKey) (entry RelationComparisonResult, related bool, ok bool) { + entry = relation.cached(c, id) + related, ok = c.reuseRelation(entry) + return entry, related, ok +} + func (c *Checker) isTypeRelatedTo(source *Type, target *Type, relation *Relation) bool { if isFreshLiteralType(source) { source = source.AsLiteralType().regularType @@ -192,12 +204,14 @@ func (c *Checker) isTypeRelatedTo(source *Type, target *Type, relation *Relation } } if source.flags&TypeFlagsObject != 0 && target.flags&TypeFlagsObject != 0 { - id, _ := getRelationKey(source, target, IntersectionStateNone, relation == c.identityRelation, false) - related := relation.get(id) - if related != RelationComparisonResultNone { - c.reliabilityFlags |= related & (RelationComparisonResultReportsUnmeasurable | RelationComparisonResultReportsUnreliable) - return related&RelationComparisonResultSucceeded != 0 + id, constrained := c.getRelationKey(source, target, IntersectionStateNone, relation == c.identityRelation, false) + // An overflow is reported by each comparison that reaches it, so it + // is left to checkTypeRelatedTo. + related, result, ok := c.cachedRelation(relation, id) + if ok { + return result } + return c.checkTypeRelatedToWithKey(source, target, relation, nil /*errorNode*/, nil, nil, true, id, constrained, related) } if source.flags&TypeFlagsStructuredOrInstantiable != 0 || target.flags&TypeFlagsStructuredOrInstantiable != 0 { return c.checkTypeRelatedTo(source, target, relation, nil /*errorNode*/) @@ -291,9 +305,22 @@ func (c *Checker) isEnumTypeRelatedTo(source *ast.Symbol, target *ast.Symbol, er return false } key := EnumRelationKey{sourceId: ast.GetSymbolId(sourceSymbol), targetId: ast.GetSymbolId(targetSymbol)} - if entry := c.enumRelation[key]; entry != RelationComparisonResultNone && !(entry&RelationComparisonResultFailed != 0 && errorReporter != nil) { - return entry&RelationComparisonResultSucceeded != 0 - } + entry, _ := c.enumRelation.cached(c, key) + if entry != RelationComparisonResultNone { + if entry&RelationComparisonResultFailed == 0 || errorReporter == nil { + return entry&RelationComparisonResultSucceeded != 0 + } + // Recompute a cached failure only to elaborate it. + return c.isEnumTypeRelatedToUncached(sourceSymbol, targetSymbol, errorReporter) + } + c.enumRelation.begin(c, key) + related := c.isEnumTypeRelatedToUncached(sourceSymbol, targetSymbol, errorReporter) + c.enumRelation.set(c, key, core.IfElse(related, RelationComparisonResultSucceeded, RelationComparisonResultFailed)) + c.endMemo() + return related +} + +func (c *Checker) isEnumTypeRelatedToUncached(sourceSymbol *ast.Symbol, targetSymbol *ast.Symbol, errorReporter ErrorReporter) bool { targetEnumType := c.getTypeOfSymbol(targetSymbol) for _, sourceProperty := range c.getPropertiesOfType(c.getTypeOfSymbol(sourceSymbol)) { if sourceProperty.Flags()&ast.SymbolFlagsEnumMember != 0 { @@ -302,7 +329,6 @@ func (c *Checker) isEnumTypeRelatedTo(source *ast.Symbol, target *ast.Symbol, er if errorReporter != nil { errorReporter(diagnostics.Property_0_is_missing_in_type_1, c.symbolToString(sourceProperty), c.TypeToStringEx(c.getDeclaredTypeOfSymbol(targetSymbol), nil /*enclosingDeclaration*/, TypeFormatFlagsUseFullyQualifiedType, nil)) } - c.enumRelation[key] = RelationComparisonResultFailed return false } sourceValue := c.getEnumMemberValue(ast.GetDeclarationOfKind(sourceProperty, ast.KindEnumMember)).Value @@ -313,7 +339,6 @@ func (c *Checker) isEnumTypeRelatedTo(source *ast.Symbol, target *ast.Symbol, er if errorReporter != nil { errorReporter(diagnostics.Each_declaration_of_0_1_differs_in_its_value_where_2_was_expected_but_3_was_given, c.symbolToString(targetSymbol), c.symbolToString(targetProperty), c.valueToString(targetValue), c.valueToString(sourceValue)) } - c.enumRelation[key] = RelationComparisonResultFailed return false } // At this point we know that at least one of the values is 'undefined'. @@ -329,13 +354,11 @@ func (c *Checker) isEnumTypeRelatedTo(source *ast.Symbol, target *ast.Symbol, er knownStringValue := core.OrElse(sourceValue, targetValue) errorReporter(diagnostics.One_value_of_0_1_is_the_string_2_and_the_other_is_assumed_to_be_an_unknown_numeric_value, c.symbolToString(targetSymbol), c.symbolToString(targetProperty), c.valueToString(knownStringValue)) } - c.enumRelation[key] = RelationComparisonResultFailed return false } } } } - c.enumRelation[key] = RelationComparisonResultSucceeded return true } @@ -365,23 +388,66 @@ func (c *Checker) checkTypeRelatedToEx( errorNode *ast.Node, headMessage *diagnostics.Message, diagnosticOutput *[]*ast.Diagnostic, +) bool { + return c.checkTypeRelatedToWithKey(source, target, relation, errorNode, headMessage, diagnosticOutput, false, CacheHashKey{}, false, RelationComparisonResultNone) +} + +// checkTypeRelatedToWithKey is checkTypeRelatedToEx given, if hasKey, the +// relation key of source and target, as returned by getRelationKey, and the +// result cached under it. +func (c *Checker) checkTypeRelatedToWithKey( + source *Type, + target *Type, + relation *Relation, + errorNode *ast.Node, + headMessage *diagnostics.Message, + diagnosticOutput *[]*ast.Diagnostic, + hasKey bool, + id CacheHashKey, + constrained bool, + entry RelationComparisonResult, ) bool { r := c.getRelater() r.relation = relation r.errorNode = errorNode - r.relationCount = (16_000_000 - relation.size()) / 8 - result := r.isRelatedToEx(source, target, RecursionFlagsBoth, errorNode != nil /*reportErrors*/, headMessage, IntersectionStateNone) + // The budget does not depend on how many results are cached, so that whether + // a comparison overflows does not depend on what was compared before it. + r.relationCount = relationCountLimit + r.topSource, r.topTarget = source, target + if hasKey { + r.topKey, r.topConstrained, r.topHasKey = id, constrained, true + r.topEntry, r.topEntryWrites, r.topEntryRead = entry, relation.results.writes, true + } + var result Ternary + if entry&RelationComparisonResultOverflow != 0 { + // The comparison overflowed before, and would again. + r.overflow = true + } else { + saveIncomplete := c.reliabilityFlags & RelationComparisonResultReportsIncomplete + c.reliabilityFlags &^= RelationComparisonResultReportsIncomplete + result = r.isRelatedToEx(source, target, RecursionFlagsBoth, errorNode != nil /*reportErrors*/, headMessage, IntersectionStateNone) + c.reliabilityFlags = c.reliabilityFlags&^RelationComparisonResultReportsIncomplete | saveIncomplete + if r.topBegun { + if r.overflow { + // Record this relation as having failed such that we don't attempt the overflowing operation again. + relation.set(c, r.topKey, RelationComparisonResultFailed|RelationComparisonResultComplexityOverflow) + } + c.endMemo() + } + } if r.overflow { - // Record this relation as having failed such that we don't attempt the overflowing operation again. - id, _ := getRelationKey(source, target, IntersectionStateNone, relation == c.identityRelation, false /*ignoreConstraints*/) - relation.set(id, RelationComparisonResultFailed|RelationComparisonResultComplexityOverflow) if tr := c.tracer; tr != nil { tr.Instant(tracing.PhaseCheckTypes, "checkTypeRelatedTo_DepthLimit", map[string]any{"sourceId": source.id, "targetId": target.id, "depth": len(r.sourceStack), "targetDepth": len(r.targetStack)}) } - if errorNode == nil { - errorNode = c.currentNode + message, sourceString, targetString := diagnostics.Excessive_complexity_comparing_types_0_and_1, c.TypeToString(source), c.TypeToString(target) + switch { + case errorNode != nil: + c.reportDiagnostic(NewDiagnosticForNode(errorNode, message, sourceString, targetString), diagnosticOutput) + case diagnosticOutput != nil: + c.reportDiagnostic(NewDiagnosticForNode(c.currentNode, message, sourceString, targetString), diagnosticOutput) + default: + c.errorAtCurrentNode(message, sourceString, targetString) } - c.reportDiagnostic(NewDiagnosticForNode(errorNode, diagnostics.Excessive_complexity_comparing_types_0_and_1, c.TypeToString(source), c.TypeToString(target)), diagnosticOutput) } else if r.errorChain != nil { // Check if we should issue an extra diagnostic to produce a quickfix for a slightly incorrect import statement if headMessage != nil && errorNode != nil && result == TernaryFalse && source.symbol != nil && c.exportTypeLinks.Has(source.symbol) { @@ -768,7 +834,7 @@ func isExcessPropertyCheckTarget(t *Type) bool { // structurally equal to at least maxDepth levels, but unequal at some level beyond that. func (c *Checker) isDeeplyNestedType(t *Type, stack []*Type, maxDepth int) bool { if len(stack) >= maxDepth { - target := getRecursionIdentityTarget(t) + target := c.getRecursionIdentityTarget(t) if target.flags&TypeFlagsIntersection != 0 { for _, t := range target.Types() { if c.isDeeplyNestedType(t, stack, maxDepth) { @@ -819,7 +885,7 @@ func (c *Checker) typeGeneration(t *Type) int { switch { case t.flags&TypeFlagsObject != 0: if t.objectFlags&ObjectFlagsReference != 0 && t.AsTypeReference().node == nil { - generation = c.typesGeneration(t.AsTypeReference().resolvedTypeArguments) + generation = c.typesGeneration(t.AsTypeReference().typeArgumentsOfCreation()) } else if m := t.AsObjectType().mapper; m != nil { generation = c.mapperGeneration(m) } else if t.symbol != nil && t.symbol.Flags()&ast.SymbolFlagsObjectLiteral != 0 { @@ -829,7 +895,7 @@ func (c *Checker) typeGeneration(t *Type) int { 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; propType != nil { + if propType := c.peekTypeOfObjectLiteralMember(prop); propType != nil { generation = max(generation, c.typeGeneration(propType)+1) } } @@ -898,7 +964,7 @@ func (c *Checker) deeplyNestedStart(t *Type, stack []*Type, maxDepth int) int { } func (c *Checker) hasMatchingRecursionIdentity(t *Type, identity RecursionId) bool { - target := getRecursionIdentityTarget(t) + target := c.getRecursionIdentityTarget(t) if target.flags&TypeFlagsIntersection != 0 { for _, t := range target.Types() { if c.hasMatchingRecursionIdentity(t, identity) { @@ -911,7 +977,7 @@ func (c *Checker) hasMatchingRecursionIdentity(t *Type, identity RecursionId) bo } func (c *Checker) getRecursionIdentity(t *Type) RecursionId { - return c.getRecursionIdentityFromTarget(getRecursionIdentityTarget(t)) + return c.getRecursionIdentityFromTarget(c.getRecursionIdentityTarget(t)) } // Get the recursion identity target type from a type. Recursively (a) obtain the target object type of an @@ -920,15 +986,15 @@ func (c *Checker) 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 @@ -1190,18 +1256,35 @@ func (c *Checker) isDiscriminantProperty(t *Type, name string) bool { if t != nil && t.flags&TypeFlagsUnion != 0 { prop := c.getUnionOrIntersectionProperty(t, name, false /*skipObjectFunctionPropertyAugment*/) if prop != nil && prop.CheckFlags()&ast.CheckFlagsSyntheticProperty != 0 { - if prop.CheckFlags()&ast.CheckFlagsIsDiscriminantComputed == 0 { - prop.SetCheckFlags(prop.CheckFlags() | ast.CheckFlagsIsDiscriminantComputed) - if prop.CheckFlags()&ast.CheckFlagsNonUniformAndLiteral == ast.CheckFlagsNonUniformAndLiteral && !c.isGenericType(c.getTypeOfSymbol(prop)) { - prop.SetCheckFlags(prop.CheckFlags() | ast.CheckFlagsIsDiscriminant) - } + key := memoKeyOf(prop, memoDiscriminant) + if prop.CheckFlags()&ast.CheckFlagsIsDiscriminantComputed != 0 { + c.observeFlagMemo(key) + return prop.CheckFlags()&ast.CheckFlagsIsDiscriminant != 0 + } + c.beginMemo(key) + c.setDiscriminantFlags(prop, ast.CheckFlagsIsDiscriminantComputed) + if prop.CheckFlags()&ast.CheckFlagsNonUniformAndLiteral == ast.CheckFlagsNonUniformAndLiteral && !c.isGenericType(c.getTypeOfSymbol(prop)) { + c.setDiscriminantFlags(prop, ast.CheckFlagsIsDiscriminantComputed|ast.CheckFlagsIsDiscriminant) } + c.endMemo() return prop.CheckFlags()&ast.CheckFlagsIsDiscriminant != 0 } } return false } +// setDiscriminantFlags caches whether the synthetic property prop is a +// discriminant, a flag memo. +func (c *Checker) setDiscriminantFlags(prop *ast.Symbol, flags ast.CheckFlags) { + const mask = ast.CheckFlagsIsDiscriminantComputed | ast.CheckFlagsIsDiscriminant + if c.logResults() { + old := prop.CheckFlags() & mask + c.logMemoDiscard(nil, memoKeyOf(prop, memoDiscriminant), func() { prop.SetCheckFlags(prop.CheckFlags()&^mask | old) }) + } + prop.SetCheckFlags(prop.CheckFlags()&^mask | flags) + c.setFlagMemo(memoKeyOf(prop, memoDiscriminant)) +} + func (c *Checker) getMatchingUnionConstituentForType(unionType *Type, t *Type) *Type { keyPropertyName := c.getKeyPropertyName(unionType) if keyPropertyName == "" { @@ -1219,13 +1302,15 @@ func (c *Checker) getMatchingUnionConstituentForType(unionType *Type, t *Type) * // an empty string if no such discriminant property exists. func (c *Checker) getKeyPropertyName(t *Type) string { u := t.AsUnionType() - if u.keyPropertyName == "" { - u.keyPropertyName, u.constituentMap = c.computeKeyPropertyNameAndMap(t) - } - if u.keyPropertyName == ast.InternalSymbolNameMissing { + name := c.memoCompute(&u.keyPropertyName, func() string { + var name string + name, u.constituentMap = c.computeKeyPropertyNameAndMap(t) + return name + }) + if name == ast.InternalSymbolNameMissing { return "" } - return u.keyPropertyName + return name } // Given a union type for which getKeyPropertyName returned a non-empty string, return the constituent @@ -1432,7 +1517,7 @@ func (c *Checker) getVariances(t *Type) []VarianceFlags { } func (c *Checker) getAliasVariances(symbol *ast.Symbol) []VarianceFlags { - return c.getVariancesWorker(symbol, c.typeAliasLinks.Get(symbol).typeParameters) + return c.getVariancesWorker(symbol, c.getTypeParametersOfTypeAlias(symbol)) } // Return an array containing the variance of each type parameter. The variance is effectively @@ -1442,114 +1527,220 @@ func (c *Checker) getAliasVariances(symbol *ast.Symbol) []VarianceFlags { // returns an empty slice when invoked recursively for the given generic type. func (c *Checker) getVariancesWorker(symbol *ast.Symbol, typeParameters []*Type) []VarianceFlags { links := c.varianceLinks.Get(symbol) - if links.variances == nil { - var traceArgs map[string]any - if tr := c.tracer; tr != nil { - traceArgs = map[string]any{"arity": len(typeParameters), "id": c.getDeclaredTypeOfSymbol(symbol).id} - popFn := tr.Push(tracing.PhaseCheckTypes, "getVariancesWorker", traceArgs, true) - defer func() { - formatted := make([]string, len(links.variances)) - for i, v := range links.variances { - formatted[i] = v.String() - } - traceArgs["variances"] = formatted - popFn() - }() - } - stackIndex := c.getVarianceStackIndex(symbol) - if stackIndex < 0 { - saveResolutionStart := c.resolutionStart - if len(c.varianceStack) == 0 { - c.resolutionStart = len(c.typeResolutions) - } - c.varianceStack = append(c.varianceStack, VarianceStackEntry{symbol, typeParameters}) - variances := make([]VarianceFlags, len(typeParameters)) - for i, tp := range typeParameters { - modifiers := c.getTypeParameterModifiers(tp) - var variance VarianceFlags - switch { - case modifiers&ast.ModifierFlagsOut != 0: - if modifiers&ast.ModifierFlagsIn != 0 { - variance = VarianceFlagsInvariant - } else { - variance = VarianceFlagsCovariant - } - case modifiers&ast.ModifierFlagsIn != 0: - variance = VarianceFlagsContravariant - default: - saveReliabilityFlags := c.reliabilityFlags - c.reliabilityFlags = 0 - // We first compare instantiations where the type parameter is replaced with - // marker types that have a known subtype relationship. From this we can infer - // invariance, covariance, contravariance or bivariance. - typeWithSuper := c.createMarkerType(symbol, tp, c.markerSuperType) - typeWithSub := c.createMarkerType(symbol, tp, c.markerSubType) - variance = core.IfElse(c.isTypeAssignableTo(typeWithSub, typeWithSuper), VarianceFlagsCovariant, 0) | - core.IfElse(c.isTypeAssignableTo(typeWithSuper, typeWithSub), VarianceFlagsContravariant, 0) - // If the instantiations appear to be related bivariantly it may be because the - // type parameter is independent (i.e. it isn't witnessed anywhere in the generic - // type). To determine this we compare instantiations where the type parameter is - // replaced with marker types that are known to be unrelated. - if variance == VarianceFlagsBivariant && c.isTypeAssignableTo(c.createMarkerType(symbol, tp, c.markerOtherType), typeWithSuper) { - variance = VarianceFlagsIndependent - } - if c.reliabilityFlags&RelationComparisonResultReportsUnmeasurable != 0 { - variance |= VarianceFlagsUnmeasurable - } - if c.reliabilityFlags&RelationComparisonResultReportsUnreliable != 0 { - variance |= VarianceFlagsUnreliable - } - c.reliabilityFlags = saveReliabilityFlags - } - // If variance computation was restarted due to a circularity we may have already - // computed variances for this generic type. If so, we exit early. - if len(links.variances) != 0 { - break - } - variances[i] = variance - } - // Store the results unless a restarted computation has already stored them. - if len(links.variances) == 0 { - links.variances = variances - } - c.varianceStack = c.varianceStack[:len(c.varianceStack)-1] - if len(c.varianceStack) == 0 { - c.resolutionStart = saveResolutionStart - } - } else { - // We've detected a circularity. Since we may compute different variances depending on where - // we enter a circularity, we find the generic type with the "smallest" symbol in the circular - // region of the variance stack and restart the computation from there if necessary. This - // ensures stable results for circular generic types. - minIndex := stackIndex - for i := stackIndex + 1; i < len(c.varianceStack); i++ { - if c.compareSymbols(c.varianceStack[i].symbol, c.varianceStack[minIndex].symbol) < 0 { - minIndex = i - } - } - if minIndex > stackIndex { - saveVarianceStack := c.varianceStack - c.varianceStack = nil - c.getVariancesWorker(saveVarianceStack[minIndex].symbol, saveVarianceStack[minIndex].typeParameters) - c.varianceStack = saveVarianceStack + if variances := links.variances.cached(c); variances != nil { + return variances + } + if stackIndex := c.getVarianceStackIndex(symbol); stackIndex >= 0 { + return c.getRecursiveVariances(stackIndex) + } + var traceArgs map[string]any + if tr := c.tracer; tr != nil { + traceArgs = map[string]any{"arity": len(typeParameters), "id": c.getDeclaredTypeOfSymbol(symbol).id} + popFn := tr.Push(tracing.PhaseCheckTypes, "getVariancesWorker", traceArgs, true) + defer func() { + variances := links.variances.cached(c) + formatted := make([]string, len(variances)) + for i, v := range variances { + formatted[i] = v.String() + } + traceArgs["variances"] = formatted + popFn() + }() + } + links.variances.begin(c) + saveResolutionStart := c.resolutionStart + if len(c.varianceStack) == 0 { + c.resolutionStart = len(c.resolutions) + } + index := len(c.varianceStack) + c.varianceStack = append(c.varianceStack, VarianceStackEntry{symbol: symbol, resolution: len(c.resolutions), low: index, min: symbol, minTypeParameters: typeParameters, discardPoint: c.discardPoint(), provisionalStart: len(c.varianceProvisional)}) + c.beginTypeResolution(symbol, TypeSystemPropertyNameVariances, &links.variances.memoHeader) + variances := c.measureVariances(symbol, typeParameters, links) + e := c.varianceStack[index] + if index == 0 { + // A superseded measurement found a smaller type in its circularity, + // from which it is measured again below. + debug.Assert(!c.varianceSuperseded || e.min != symbol && !c.isYieldingTo(e.min, TypeSystemPropertyNameVariances), "superseded variance measurement not measured again") + c.varianceSuperseded = false + } + if e.low == index && e.min != symbol && !c.isYieldingTo(e.min, TypeSystemPropertyNameVariances) { + // The measurement entered a circularity, of which this type is the + // first entered, at a type other than the canonical entry. What it + // measured depends on where the circularity was entered, so it is + // discarded, and the circularity measured again from the canonical + // entry, as if that type had been measured first, with nothing in + // progress visible. That measures this type as it reaches it. + c.discardVariancesSince(e) + saveVarianceStack, saveCycleRoot, saveProvisional, saveFloor := c.varianceStack, c.varianceCycleRoot, c.varianceProvisional, c.discardLogFloor + c.varianceStack, c.varianceCycleRoot, c.varianceProvisional, c.discardLogFloor = nil, 0, nil, len(c.discardLog) + c.beginCycleYield(e.min, TypeSystemPropertyNameVariances, -1, len(c.resolutions)) + c.getVariancesWorker(e.min, e.minTypeParameters) + c.endCycleYield() + c.varianceStack, c.varianceCycleRoot, c.varianceProvisional, c.discardLogFloor = saveVarianceStack, saveCycleRoot, saveProvisional, saveFloor + variances = links.variances.cached(c) + if len(variances) == 0 { + c.varianceStack[index].remeasuring = true + variances = c.measureVariances(symbol, typeParameters, links) + } + } else if restarted := links.variances.cached(c); len(restarted) != 0 { + // A measurement from the canonical entry of a circularity measured + // this type while its own measurement was in progress, hidden. + variances = restarted + } + links.variances.set(c, variances) + if c.varianceCycleRoot == index+1 { + c.varianceCycleRoot = 0 + c.trimDiscardLog() + c.resumeChecking() + } + c.varianceStack = c.varianceStack[:index] + if index != 0 && e.low < index { + // This type is in a circularity with the measurement that reached it, + // so its variances depend on those of a measurement in progress, and + // are as much a guess as those until it finishes. + c.varianceProvisional = append(c.varianceProvisional, symbol) + parent := &c.varianceStack[index-1] + parent.low = min(parent.low, e.low) + if c.compareSymbols(e.min, parent.min) < 0 { + parent.min, parent.minTypeParameters = e.min, e.minTypeParameters + } + } else { + clear(c.varianceProvisional[e.provisionalStart:]) + c.varianceProvisional = c.varianceProvisional[:e.provisionalStart] + } + c.popTypeResolution() + if len(c.varianceStack) == 0 { + c.resolutionStart = saveResolutionStart + } + c.endMemo() + return variances +} + +// getRecursiveVariances handles a measurement needing the variances of the type at the given +// index of the variance stack, whose measurement is in progress. Occurrences of type parameters +// nested in such recursive references are not measured: the variances are an empty slice, which +// comparisons treat as unknown. Since the variances measured then depend on where the +// circularity was entered, each circularity (a strongly connected component of types whose +// measurements need each other's variances) is measured from a canonical entry, the type with +// the "smallest" symbol, as if that type had been measured first: the measurement of the type +// at which it was entered finds the canonical entry once it finishes (see getVariancesWorker). +func (c *Checker) getRecursiveVariances(stackIndex int) []VarianceFlags { + top := &c.varianceStack[len(c.varianceStack)-1] + top.low = min(top.low, stackIndex) + // The variances are incomplete. Only comparisons and inferences read + // variances, and a comparison observing them is not cached. What else + // is computed from them is kept if the measurement is not discarded: + // the outermost measurement hides what is below it, so what is computed + // inside it is the same whatever led to it, and computing any of it + // first from scratch reaches the measurement and computes it again + // inside, the same way. What is cached from now on until the + // measurement re-entered finishes is logged, so that it can be discarded + // if the measurement is. + if c.varianceCycleRoot == 0 { + c.recordFromCheck() + c.varianceCycleRoot = stackIndex + 1 + } else { + c.varianceCycleRoot = min(c.varianceCycleRoot, stackIndex+1) + } + bottom := &c.varianceStack[0] + c.reliabilityFlags |= RelationComparisonResultReportsIncomplete + if stackIndex == 0 && !c.varianceSuperseded && !c.varianceStack[0].remeasuring { + // The circularity includes the measurement at the bottom of the stack, + // so that is where it was entered. If it has a smaller type, what the + // measurement measures is discarded once it finishes, so it stops + // measuring now (see Relater.recursiveTypeRelatedTo). + for _, f := range c.varianceStack[1:] { + if c.compareSymbols(f.min, bottom.symbol) < 0 && !c.isYieldingTo(f.min, TypeSystemPropertyNameVariances) { + c.varianceSuperseded = true + break } - // Store an empty slice to mark that we can't compute variances for this type. We treat type - // parameters as co-variant in this case. - if len(links.variances) == 0 { - links.variances = []VarianceFlags{} + } + } + return []VarianceFlags{} +} + +// discardVariancesSince discards the results cached since e began, and all +// the effects the measurement recorded. +func (c *Checker) discardVariancesSince(e VarianceStackEntry) { + clear(c.varianceProvisional[e.provisionalStart:]) + c.varianceProvisional = c.varianceProvisional[:e.provisionalStart] + c.discardTo(e.discardPoint) + if f := c.resolutions[e.resolution-1].effects; f != nil { + f.truncate(0, 0) + } +} + +func (c *Checker) measureVariances(symbol *ast.Symbol, typeParameters []*Type, links *VarianceLinks) []VarianceFlags { + variances := make([]VarianceFlags, len(typeParameters)) + for i, tp := range typeParameters { + modifiers := c.getTypeParameterModifiers(tp) + var variance VarianceFlags + switch { + case modifiers&ast.ModifierFlagsOut != 0: + if modifiers&ast.ModifierFlagsIn != 0 { + variance = VarianceFlagsInvariant + } else { + variance = VarianceFlagsCovariant } + case modifiers&ast.ModifierFlagsIn != 0: + variance = VarianceFlagsContravariant + default: + saveReliabilityFlags := c.reliabilityFlags + c.reliabilityFlags = 0 + // We first compare instantiations where the type parameter is replaced with + // marker types that have a known subtype relationship. From this we can infer + // invariance, covariance, contravariance or bivariance. + typeWithSuper := c.createMarkerType(symbol, tp, c.markerSuperType) + typeWithSub := c.createMarkerType(symbol, tp, c.markerSubType) + variance = core.IfElse(c.isTypeAssignableTo(typeWithSub, typeWithSuper), VarianceFlagsCovariant, 0) | + core.IfElse(c.isTypeAssignableTo(typeWithSuper, typeWithSub), VarianceFlagsContravariant, 0) + // If the instantiations appear to be related bivariantly it may be because the + // type parameter is independent (i.e. it isn't witnessed anywhere in the generic + // type). To determine this we compare instantiations where the type parameter is + // replaced with marker types that are known to be unrelated. + if variance == VarianceFlagsBivariant && c.isTypeAssignableTo(c.createMarkerType(symbol, tp, c.markerOtherType), typeWithSuper) { + variance = VarianceFlagsIndependent + } + if c.reliabilityFlags&RelationComparisonResultReportsUnmeasurable != 0 { + variance |= VarianceFlagsUnmeasurable + } + if c.reliabilityFlags&RelationComparisonResultReportsUnreliable != 0 { + variance |= VarianceFlagsUnreliable + } + c.reliabilityFlags = saveReliabilityFlags + } + // If variance computation was restarted due to a circularity we may have already + // computed variances for this generic type. If so, we exit early. + if len(links.variances.inProgress(c)) != 0 { + break } + variances[i] = variance } - return links.variances + return variances } +// isGuessedVariance reports whether the variances of symbol are a guess: +// those of a measurement in progress, or measured in a circularity with one. +func (c *Checker) isGuessedVariance(symbol *ast.Symbol) bool { + return c.getVarianceStackIndex(symbol) >= 0 || slices.Contains(c.varianceProvisional, symbol) +} + +// getVarianceStackIndex returns the index in the variance stack of the +// measurement of the variances of symbol in progress, or -1. A measurement +// hidden by a cycle yield is not in progress. func (c *Checker) getVarianceStackIndex(symbol *ast.Symbol) int { - for i, entry := range c.varianceStack { - if entry.symbol == symbol { - return i - } + if len(c.varianceStack) == 0 { + return -1 } - return -1 + r := c.resolvingIndex(c.varianceLinks.Get(symbol).variances.key()) + if r == 0 { + return -1 + } + i, found := slices.BinarySearchFunc(c.varianceStack, r, func(e VarianceStackEntry, r int) int { return e.resolution - r }) + if !found { + return -1 + } + return i } func (c *Checker) createMarkerType(symbol *ast.Symbol, source *Type, target *Type) *Type { @@ -1560,16 +1751,67 @@ func (c *Checker) createMarkerType(symbol *ast.Symbol, source *Type, target *Typ } var result *Type if symbol.Flags()&ast.SymbolFlagsTypeAlias != 0 { - result = c.getTypeAliasInstantiation(symbol, c.instantiateTypes(c.typeAliasLinks.Get(symbol).typeParameters, mapper), nil) + result = c.getTypeAliasInstantiation(symbol, c.instantiateTypes(c.getTypeParametersOfTypeAlias(symbol), mapper), nil) } else { result = c.createTypeReference(t, c.instantiateTypes(t.AsInterfaceType().TypeParameters(), mapper)) } - c.markerTypes.Add(result) return result } +// isMarkerType reports whether t is a marker type of the innermost variance +// computation or variance annotation check in progress: an instantiation of +// the generic type or type alias being measured with one of its type +// parameters replaced by a variance marker. Instantiations of other types with +// markers, such as those nested in the type being measured, are not marker +// types, whether or not their own variances have been measured before. Nor +// are those of measurements further down the variance stack: a reference to +// them must get their variances, so that the circularity is found and +// measured from its canonical entry (see getRecursiveVariances). func (c *Checker) isMarkerType(t *Type) bool { - return c.markerTypes.Has(t) + if len(c.varianceStack) == 0 && c.varianceTypeParameter == nil { + return false + } + if t.alias != nil && t.alias.symbol.Flags()&ast.SymbolFlagsTypeAlias != 0 && + c.isMarkerInstantiation(t.alias.symbol, c.typeAliasLinks.Get(t.alias.symbol).typeParameters, t.alias.typeArguments) { + return true + } + if t.objectFlags&ObjectFlagsReference != 0 && t.AsTypeReference().node == nil { + target := t.Target() + if target != nil && target != t && target.objectFlags&ObjectFlagsClassOrInterface != 0 { + return c.isMarkerInstantiation(target.symbol, target.AsInterfaceType().TypeParameters(), t.AsTypeReference().typeArgumentsOfCreation()) + } + } + return false +} + +func (c *Checker) isMarkerInstantiation(symbol *ast.Symbol, typeParameters []*Type, typeArguments []*Type) bool { + if len(typeParameters) == 0 || len(typeParameters) != len(typeArguments) { + return false + } + replaced := -1 + for i, tp := range typeParameters { + if typeArguments[i] == tp { + continue + } + if replaced >= 0 || !c.isVarianceMarker(typeArguments[i]) { + return false + } + replaced = i + } + if replaced < 0 { + return false + } + switch typeArguments[replaced] { + case c.markerSuperTypeForCheck, c.markerSubTypeForCheck: + return typeParameters[replaced] == c.varianceTypeParameter + default: + return len(c.varianceStack) != 0 && c.varianceStack[len(c.varianceStack)-1].symbol == symbol + } +} + +func (c *Checker) isVarianceMarker(t *Type) bool { + return t == c.markerSuperType || t == c.markerSubType || t == c.markerOtherType || + t == c.markerSuperTypeForCheck || t == c.markerSubTypeForCheck } func (c *Checker) getTypeParameterModifiers(tp *Type) ast.ModifierFlags { @@ -1848,9 +2090,23 @@ func (c *Checker) getMinArgumentCount(signature *Signature) int { } func (c *Checker) getMinArgumentCountEx(signature *Signature, flags MinArgumentCountFlags) int { + voidIsNonOptional := flags & MinArgumentCountFlagsVoidIsNonOptional + if voidIsNonOptional != 0 { + return c.getMinArgumentCountUncached(signature, flags) + } + if count := signature.resolvedMinArgumentCount.cached(c); count != -1 { + return int(count) + } + signature.resolvedMinArgumentCount.begin(c) + result := c.getMinArgumentCountUncached(signature, flags) + c.endMemo() + return result +} + +func (c *Checker) getMinArgumentCountUncached(signature *Signature, flags MinArgumentCountFlags) int { strongArityForUntypedJS := flags & MinArgumentCountFlagsStrongArityForUntypedJS voidIsNonOptional := flags & MinArgumentCountFlagsVoidIsNonOptional - if voidIsNonOptional != 0 || signature.resolvedMinArgumentCount == -1 { + { minArgumentCount := -1 if signatureHasRestParameter(signature) { restType := c.getTypeOfSymbol(signature.parameters[len(signature.parameters)-1]) @@ -1883,9 +2139,9 @@ func (c *Checker) getMinArgumentCountEx(signature *Signature, flags MinArgumentC } minArgumentCount = i } - signature.resolvedMinArgumentCount = int32(minArgumentCount) + signature.resolvedMinArgumentCount.set(c, int32(minArgumentCount)) + return minArgumentCount } - return int(signature.resolvedMinArgumentCount) } func (c *Checker) hasEffectiveRestParameter(signature *Signature) bool { @@ -2156,6 +2412,22 @@ func (c *Checker) getTupleElementLabelFromBindingElement(node *ast.Node, index i } func (c *Checker) getTypePredicateOfSignature(sig *Signature) *TypePredicate { + key := memoKeyOf(sig, memoTypePredicate) + if sig.getResolvedTypePredicate(c) != nil { + c.observeFlagMemo(key) + } else { + c.beginMemo(key) + c.resolveTypePredicateOfSignature(sig) + c.endMemo() + } + predicate := sig.getResolvedTypePredicate(c) + if predicate == c.noTypePredicate { + return nil + } + return predicate +} + +func (c *Checker) resolveTypePredicateOfSignature(sig *Signature) { if sig.getResolvedTypePredicate(c) == nil { switch { case sig.target != nil: @@ -2173,7 +2445,7 @@ func (c *Checker) getTypePredicateOfSignature(sig *Signature) *TypePredicate { if ast.IsTypePredicateNode(typeNode) { sig.setResolvedTypePredicate(c, c.createTypePredicateFromTypePredicateNode(typeNode, sig)) } - case ast.IsFunctionLikeDeclaration(sig.declaration) && (sig.resolvedReturnType == nil || sig.resolvedReturnType.flags&TypeFlagsBoolean != 0) && c.getParameterCount(sig) > 0: + case ast.IsFunctionLikeDeclaration(sig.declaration) && c.getParameterCount(sig) > 0: sig.setResolvedTypePredicate(c, c.noTypePredicate) // avoid infinite loop sig.setResolvedTypePredicate(c, c.getTypePredicateFromBody(sig.declaration)) } @@ -2183,11 +2455,6 @@ func (c *Checker) getTypePredicateOfSignature(sig *Signature) *TypePredicate { sig.setResolvedTypePredicate(c, c.noTypePredicate) } } - predicate := sig.getResolvedTypePredicate(c) - if predicate == c.noTypePredicate { - return nil - } - return predicate } func (c *Checker) getUnionOrIntersectionTypePredicate(signatures []*Signature, isUnion bool) *TypePredicate { @@ -2256,7 +2523,7 @@ 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 + return signature.resolvedReturnType.cached(c) == nil && c.isResolutionInProgress(signature, TypeSystemPropertyNameResolvedReturnType) } func (c *Checker) findMatchingSignatures(signatureLists [][]*Signature, signature *Signature, listIndex int) []*Signature { @@ -2698,8 +2965,18 @@ type Relater struct { // them by key. maybeKeys []maybeKey maybeKeysSet map[CacheHashKey]int - sourceStack []*Type - targetStack []*Type + // 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 @@ -2732,6 +3009,37 @@ type maybeKey struct { truncated bool } +// beginTop makes the outermost comparison a computation of its own, so that +// reusing any result it caches accounts for the effects of the whole +// comparison. Errors are reported after it, since they belong to the caller +// rather than the result. Only recursiveTypeRelatedTo caches results, so the +// comparison begins on its first call there, and most comparisons, which +// finish before, need neither the computation nor the relation key. What the +// comparison did before then cannot affect a result it caches other than +// through the types it compares. beginTop returns false if the comparison +// overflowed before, and would again. +func (r *Relater) beginTop() bool { + r.topBegun = true + c := r.c + if !r.topHasKey { + r.topKey, r.topConstrained = c.getRelationKey(r.topSource, r.topTarget, IntersectionStateNone, r.relation == c.identityRelation, false /*ignoreConstraints*/) + r.topHasKey = true + } + // A comparison made before now may have cached a result for the key, + // unless nothing was cached since the caller read it. + if !r.topEntryRead || r.topEntryWrites != r.relation.results.writes { + r.topEntry = r.relation.cached(c, r.topKey) + } + r.topEntryValid = true + if r.topEntry&RelationComparisonResultOverflow != 0 { + r.topBegun = false + r.overflow = true + return false + } + r.relation.begin(c, r.topKey) + return true +} + func (c *Checker) getRelater() *Relater { r := c.freeRelater if r == nil { @@ -2742,17 +3050,25 @@ func (c *Checker) getRelater() *Relater { } func (c *Checker) putRelater(r *Relater) { - clear(r.maybeKeysSet) - *r = Relater{ - c: c, - maybeKeys: r.maybeKeys[:0], - maybeKeysSet: r.maybeKeysSet, - sourceStack: r.sourceStack[:0], - targetStack: r.targetStack[:0], - sourceDepths: r.sourceDepths[:0], - targetDepths: r.targetDepths[:0], - next: c.freeRelater, - } + if len(r.maybeKeysSet) != 0 { + clear(r.maybeKeysSet) + } + // Reset field by field, which is cheaper than assigning a whole Relater. + r.relation = nil + r.errorNode = nil + r.errorChain = nil + r.relatedInfo = nil + r.maybeKeys = r.maybeKeys[:0] + r.sourceStack, r.targetStack = r.sourceStack[:0], r.targetStack[:0] + r.sourceDepths, r.targetDepths = r.sourceDepths[:0], r.targetDepths[:0] + r.depth, r.low, r.truncated = 0, 0, false + r.topSource, r.topTarget = nil, nil + r.topKey, r.topConstrained = CacheHashKey{}, false + r.topEntry, r.topEntryValid, r.topHasKey, r.topBegun, r.topEntryRead = RelationComparisonResultNone, false, false, false, false + r.expandingFlags, r.expandingSourceDepth, r.expandingTargetDepth = ExpandingFlagsNone, 0, 0 + r.overflow = false + r.relationCount = 0 + r.next = c.freeRelater c.freeRelater = r } @@ -2976,7 +3292,7 @@ func (c *Checker) getTypeOfPropertyInType(t *Type, name string) *Type { t = c.getApparentType(t) var prop *ast.Symbol if t.flags&TypeFlagsUnionOrIntersection != 0 { - prop = c.getPropertyOfUnionOrIntersectionType(t, name, false) + prop = c.getPropertyOfType(t, name) } else { prop = c.getPropertyOfObjectType(t, name) } @@ -3254,19 +3570,48 @@ func (r *Relater) recursiveTypeRelatedTo(source *Type, target *Type, reportError // important to have well-defined behavior even in cases that shouldn't normally occur. return TernaryFalse } - id, constrained := getRelationKey(source, target, intersectionState, r.relation == r.c.identityRelation, false /*ignoreConstraints*/) - if entry := r.relation.get(id); entry != RelationComparisonResultNone { - if reportErrors && entry&RelationComparisonResultFailed != 0 && entry&RelationComparisonResultOverflow == 0 { + if r.c.varianceSuperseded && r.c.isMarkerType(r.topSource) { + // The measurement at the bottom of the variance stack is discarded + // once it finishes (see getRecursiveVariances), so the comparisons + // measuring variances stop here, as if reading its incomplete + // variances. Other comparisons go on: what is computed from their + // results may be kept. + r.c.reliabilityFlags |= RelationComparisonResultReportsIncomplete + return TernaryFalse + } + if !r.topBegun && !r.beginTop() { + return TernaryFalse + } + var id CacheHashKey + var constrained bool + var entry RelationComparisonResult + if source == r.topSource && target == r.topTarget && intersectionState == IntersectionStateNone { + id, constrained = r.topKey, r.topConstrained + // The comparison read the cached result on starting, and nothing + // caches one for it before its first visit to its own pair. + if r.topEntryValid { + r.topEntryValid = false + entry = r.topEntry + } else { + entry = r.relation.cached(r.c, id) + } + } else { + id, constrained = r.c.getRelationKey(source, target, intersectionState, r.relation == r.c.identityRelation, false /*ignoreConstraints*/) + entry = r.relation.cached(r.c, id) + } + if entry != RelationComparisonResultNone { + if entry&RelationComparisonResultOverflow != 0 { + // Computing the comparison overflowed, so computing this one, + // which needs it, overflows too. + r.overflow = true + return TernaryFalse + } + if reportErrors && entry&RelationComparisonResultFailed != 0 { // We are elaborating errors and the cached result is a failure not due to a comparison overflow, // so we will do the comparison again to generate an error message. + } else if related, _ := r.c.reuseRelation(entry); related { + return TernaryTrue } else { - r.c.reliabilityFlags |= entry & (RelationComparisonResultReportsUnmeasurable | RelationComparisonResultReportsUnreliable) - if reportErrors && entry&RelationComparisonResultOverflow != 0 { - r.reportError(diagnostics.Excessive_complexity_comparing_types_0_and_1, r.c.TypeToString(source), r.c.TypeToString(target)) - } - if entry&RelationComparisonResultSucceeded != 0 { - return TernaryTrue - } return TernaryFalse } } @@ -3282,13 +3627,13 @@ func (r *Relater) recursiveTypeRelatedTo(source *Type, target *Type, reportError // 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*/) + 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(broadestEquivalentId); entry&RelationComparisonResultSucceeded != 0 { + if entry := r.relation.cached(r.c, broadestEquivalentId); entry&RelationComparisonResultSucceeded != 0 { r.c.reliabilityFlags |= entry & (RelationComparisonResultReportsUnmeasurable | RelationComparisonResultReportsUnreliable) return TernaryTrue } @@ -3351,9 +3696,15 @@ func (r *Relater) recursiveTypeRelatedTo(source *Type, target *Type, reportError if tr := r.c.tracer; tr != nil { defer tr.Push(tracing.PhaseCheckTypes, "structuredTypeRelatedTo", map[string]any{"sourceId": source.id, "targetId": target.id}, false)() } + // The result is cached, so instantiations it needs count against + // the depth limit from here, not from wherever it is first compared + // (see "Instantiation limits" in memo.go). + r.c.beginResolution(nil, 0) result = r.structuredTypeRelatedTo(source, target, reportErrors, intersectionState) + r.c.endResolution() } - propagatingVarianceFlags := r.c.reliabilityFlags + propagatingVarianceFlags := r.c.reliabilityFlags & RelationComparisonResultReportsMask + incomplete := r.c.reliabilityFlags&RelationComparisonResultReportsIncomplete != 0 r.c.reliabilityFlags |= saveReliabilityFlags if recursionFlags&RecursionFlagsSource != 0 { r.sourceStack = r.sourceStack[:len(r.sourceStack)-1] @@ -3368,10 +3719,27 @@ func (r *Relater) recursiveTypeRelatedTo(source *Type, target *Type, reportError low, truncated := r.low, r.truncated r.low, r.truncated = saveLow, saveTruncated switch { + case r.overflow: + // The comparison was cut short, so its result and those of the + // comparisons that completed assuming it are not what computing them + // from scratch would give. Only the overflow is cached. + r.resetMaybeStack(maybeStart, propagatingVarianceFlags, false) + result = TernaryFalse + case incomplete && low >= depth: + // The result observed incomplete variances, so it is not what + // comparing from scratch would give (see getRecursiveVariances). + r.resetMaybeStack(maybeStart, propagatingVarianceFlags, false) + if result == TernaryMaybe { + result = TernaryTrue + } + case incomplete: + // As above, once the outermost comparison this one assumed completes. + r.low = min(r.low, low) + r.truncated = r.truncated || truncated case result == TernaryFalse: // A false result goes straight into global cache (when something is false under // assumptions it will also be false without assumptions) - r.relation.set(id, RelationComparisonResultFailed|propagatingVarianceFlags) + r.relation.set(r.c, id, RelationComparisonResultFailed|propagatingVarianceFlags) r.relationCount-- r.resetMaybeStack(maybeStart, propagatingVarianceFlags, false) case low >= depth: @@ -3384,7 +3752,7 @@ func (r *Relater) recursiveTypeRelatedTo(source *Type, target *Type, reportError r.resetMaybeStack(maybeStart, propagatingVarianceFlags, false) case truncated: r.resetMaybeStack(maybeStart, propagatingVarianceFlags, false) - r.relation.set(id, RelationComparisonResultSucceeded|propagatingVarianceFlags) + r.relation.set(r.c, id, RelationComparisonResultSucceeded|propagatingVarianceFlags) r.relationCount-- default: r.resetMaybeStack(maybeStart, propagatingVarianceFlags, true) @@ -3433,7 +3801,7 @@ func (r *Relater) resetMaybeStack(maybeStart int, propagatingVarianceFlags Relat key := r.maybeKeys[i].key delete(r.maybeKeysSet, key) if markAllAsSucceeded { - r.relation.set(key, RelationComparisonResultSucceeded|propagatingVarianceFlags) + r.relation.set(r.c, key, RelationComparisonResultSucceeded|propagatingVarianceFlags) r.relationCount-- } } @@ -3526,10 +3894,24 @@ func (r *Relater) structuredTypeRelatedToWorker(source *Type, target *Type, repo var varianceCheckFailed bool var originalErrorChain *ErrorChain saveErrorState := r.getErrorState() - relateVariances := func(sourceTypeArguments []*Type, targetTypeArguments []*Type, variances []VarianceFlags, intersectionState IntersectionState) (Ternary, bool) { + relateVariances := func(sourceTypeArguments []*Type, targetTypeArguments []*Type, variances []VarianceFlags, guessed bool, intersectionState IntersectionState) (Ternary, bool) { if result = r.typeArgumentsRelatedTo(sourceTypeArguments, targetTypeArguments, variances, reportErrors, intersectionState); result != TernaryFalse { return result, true } + if guessed { + // The variances are a guess for a generic type whose variances are being + // measured, or were measured in a circularity with a measurement still in + // progress (see isGuessedVariance). There is no structural fallback for + // them, so that a stricter guess never makes a comparison succeed, and the + // measurement depends on the guess monotonically. The measurement still + // learns that it observed unreliable or unmeasurable variances. + for i, v := range variances { + if v&VarianceFlagsUnmeasurable != 0 && i < len(sourceTypeArguments) { + r.c.instantiateType(sourceTypeArguments[i], r.c.reportUnmeasurableMapper) + } + } + return TernaryFalse, true + } if core.Some(variances, func(v VarianceFlags) bool { return v&VarianceFlagsAllowsStructuralFallback != 0 }) { // If some type parameter was `Unmeasurable` or `Unreliable`, and we couldn't pass by assuming it was identical, then we // have to allow a structural fallback check @@ -3663,7 +4045,7 @@ func (r *Relater) structuredTypeRelatedToWorker(source *Type, target *Type, repo nodeIsInJsFile := ast.IsInJSFile(source.alias.symbol.ValueDeclaration()) sourceTypes := r.c.fillMissingTypeArguments(source.alias.typeArguments, params, minParams, nodeIsInJsFile) targetTypes := r.c.fillMissingTypeArguments(target.alias.typeArguments, params, minParams, nodeIsInJsFile) - varianceResult, ok := relateVariances(sourceTypes, targetTypes, variances, intersectionState) + varianceResult, ok := relateVariances(sourceTypes, targetTypes, variances, r.c.isGuessedVariance(source.alias.symbol), intersectionState) if ok { return varianceResult } @@ -4093,13 +4475,10 @@ func (r *Relater) structuredTypeRelatedToWorker(source *Type, target *Type, repo // type references (which are intended by be compared structurally). Obtain the variance // information for the type parameters and relate the type arguments accordingly. variances := r.c.getVariances(source.Target()) - // We return Ternary.Maybe for a recursive invocation of getVariances (signaled by emptyArray). This - // effectively means we measure variance only from type parameter occurrences that aren't nested in - // recursive instantiations of the generic type. if len(variances) == 0 { return TernaryUnknown } - varianceResult, ok := relateVariances(r.c.getTypeArguments(source), r.c.getTypeArguments(target), variances, intersectionState) + varianceResult, ok := relateVariances(r.c.getTypeArguments(source), r.c.getTypeArguments(target), variances, r.c.isGuessedVariance(source.Target().symbol), intersectionState) if ok { return varianceResult } @@ -5005,7 +5384,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)) @@ -5033,7 +5412,7 @@ func (r *Relater) reportRelationError(message *diagnostics.Message, source *Type if targetFlags&TypeFlagsTypeParameter != 0 && target != r.c.markerSuperTypeForCheck && target != r.c.markerSubTypeForCheck { constraint := r.c.getBaseConstraintOfType(target) switch { - case IsDistributedTypeParameter(target) && r.c.isTypeAssignableTo(generalizedSource, target.AsTypeParameter().constraint): + case IsDistributedTypeParameter(target) && r.c.isTypeAssignableTo(generalizedSource, target.AsTypeParameter().constraintOfCreation()): r.reportError(diagnostics.X_0_is_only_assignable_to_the_non_distributed_1_but_1_has_been_distributed_here, generalizedSourceType, targetType) case constraint != nil && r.c.isTypeAssignableTo(generalizedSource, constraint): r.reportError(diagnostics.X_0_is_assignable_to_the_constraint_of_type_1_but_1_could_be_instantiated_with_a_different_subtype_of_constraint_2, generalizedSourceType, targetType, r.c.TypeToString(constraint)) diff --git a/tsc/internal/checker/resolutions.go b/tsc/internal/checker/resolutions.go new file mode 100644 index 0000000000000..a0b5e9449e2a2 --- /dev/null +++ b/tsc/internal/checker/resolutions.go @@ -0,0 +1,380 @@ +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 + resolving bool // The resolution is the one in Checker.resolving for key + fromCheck bool // The query began in a check; see recordFromCheck + // The computation read the incomplete result of a computation in + // progress, or was started by one that did; see effectsToDrop. + readIncomplete bool + // The computation reported an error located at the current node; see + // effectsToDrop. + reportsAtCurrentNode bool + // The structured members the outermost resolution of key computes are + // available before it completes; see resolveStructuredTypeMembersUncached. + membersPublished bool + prevMemo int32 // Checker.memoTop on entry + // Index in Checker.deferredAttach of the first result cached by the + // computation before it had effects; see attachState. + attachStart int32 + result *memoState // Memo state of the result computed + effects *memoEffects // Allocated on first use + entry *ast.Node // Current node when the computation started + // The symbol whose member table this memo computes, if any. Keeping it + // directly lets canonical cycle entry compare declarations without + // recovering a pointer from the packed memo key. + memberSymbol *ast.Symbol + + // A type resolution is a computation that re-entering detects as a cycle; + // see beginTypeResolution. Its other fields are those of the resolution + // below it, whose work it shares. + typeResolution TypeResolution + isTypeResolution bool + prevTypeResolution int32 // Checker.typeResolutionTop on entry +} + +// A memoStateSource creates the memo state of a computation in progress on +// demand, since few computations do work worth storing. +type memoStateSource interface { + stateAt(i int) *memoState + peekStateAt(i int) *memoState + popState(i int) +} + +func (c *Checker) initResolutions() { + c.resolutions = []resolution{{}} + c.syncObserving() +} + +// pushResolution pushes a resolution with every field zero and returns it. +// Popping a resolution zeroes it, so space reused above the stack needs no +// zeroing, and the caller sets only the fields it needs in place rather than +// copying in a whole resolution. +func (c *Checker) pushResolution() *resolution { + n := len(c.resolutions) + if n == 1 { + // An outermost computation, such as a query, counts its own + // instantiations; see "Instantiation limits" in memo.go. + c.instantiationCount = 0 + } + if n == cap(c.resolutions) { + c.resolutions = append(c.resolutions, resolution{}) + } else { + c.resolutions = c.resolutions[:n+1] + } + f := &c.resolutions[n] + // What a computation started by one that read an incomplete result + // computes may be derived from it too. + f.readIncomplete = n != 0 && c.resolutions[n-1].readIncomplete + return f +} + +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.dropResolution(n) + if fromCheck { + c.endQueryFromCheck() + } +} + +// forgetResult makes the current resolution compute no result, for a +// computation that did not cache its result. +func (c *Checker) forgetResult() { + f := c.currentResolution() + if f.source != nil { + f.source.popState(int(f.index)) + } + c.endResolving(f) + 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 memoReentry says for its kind. 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 { + c.reenter(int(i), memoReentry[key.field()]) + 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 + } +} + +func (c *Checker) findResolutionCycleStartIndex(target TypeSystemEntity, propertyName TypeSystemPropertyName) int { + for i := c.typeResolutionTop - 1; i >= c.resolutionStart; i = int(c.resolutions[i].prevTypeResolution) - 1 { + resolution := &c.resolutions[i].typeResolution + if c.typeResolutionHasProperty(resolution) { + // The result was set before its computation finished, which + // hides a cycle below it. Only then does the search depend on + // the result. + if c.memoActive() && c.findResolutionBelow(i, target, propertyName) { + if resolution.memo != nil { + c.observeCell(resolution.memo) + } + } + return -1 + } + if resolution.target == target && resolution.propertyName == propertyName { + return i + } + } + return -1 +} + +// findResolutionBelow reports whether a type resolution of target below the +// one at index i is in progress. +func (c *Checker) findResolutionBelow(i int, target TypeSystemEntity, propertyName TypeSystemPropertyName) bool { + for i = int(c.resolutions[i].prevTypeResolution) - 1; i >= c.resolutionStart; i = int(c.resolutions[i].prevTypeResolution) - 1 { + r := &c.resolutions[i].typeResolution + if r.target == target && r.propertyName == propertyName { + return true + } + } + return false +} + +// typeResolutionHasProperty reports whether a resolution on the stack already +// has a result. Its computation is in progress, so the result is read without +// observing it; see findResolutionCycleStartIndex. +func (c *Checker) typeResolutionHasProperty(r *TypeResolution) bool { + switch r.propertyName { + case TypeSystemPropertyNameType: + return c.valueSymbolLinks.Get(r.target.(*ast.Symbol)).resolvedType.peek() != nil + case TypeSystemPropertyNameDeclaredType: + return c.typeAliasLinks.Get(r.target.(*ast.Symbol)).declaredType.peek() != nil + case TypeSystemPropertyNameResolvedTypeArguments: + return r.target.(*Type).AsTypeReference().resolvedTypeArguments.peek() != nil + case TypeSystemPropertyNameResolvedBaseTypes: + return r.target.(*Type).AsInterfaceType().baseTypesResolved + case TypeSystemPropertyNameResolvedBaseConstructorType: + return r.target.(*Type).AsInterfaceType().resolvedBaseConstructorType.peek() != nil + case TypeSystemPropertyNameResolvedReturnType: + return r.target.(*Signature).resolvedReturnType.peek() != nil + case TypeSystemPropertyNameResolvedBaseConstraint: + return r.target.(*Type).AsConstrainedType().resolvedBaseConstraint.peek() != nil + case TypeSystemPropertyNameInitializerIsUndefined: + return c.nodeLinks.Get(r.target.(*ast.Node)).flags&NodeCheckFlagsInitializerIsUndefinedComputed != 0 + case TypeSystemPropertyNameWriteType: + extra := c.valueSymbolLinks.Get(r.target.(*ast.Symbol)).extra + return extra != nil && extra.writeType.peek() != nil + case TypeSystemPropertyNameAliasTarget: + return c.aliasSymbolLinks.Get(r.target.(*ast.Symbol)).aliasTarget.peek() != nil + case TypeSystemPropertyNameComputedPropertyName: + return c.typeNodeLinks.Get(r.target.(*ast.Node)).resolvedType.peek() != nil + case TypeSystemPropertyNameVariances: + return c.varianceLinks.Get(r.target.(*ast.Symbol)).variances.peek() != nil + default: + // Marked as checked or resolved on entry, so it is only on the stack + // while in progress. + return false + } +} diff --git a/tsc/internal/checker/services.go b/tsc/internal/checker/services.go index 6838a3b242aa1..8d45e1292699c 100644 --- a/tsc/internal/checker/services.go +++ b/tsc/internal/checker/services.go @@ -151,7 +151,7 @@ func (c *Checker) ForEachExportAndPropertyOfModule(moduleSymbol *ast.Symbol, cb if reducedType.flags&TypeFlagsStructuredType == 0 { return } - for name, symbol := range c.resolveStructuredTypeMembers(reducedType).getMembers().All() { + for name, symbol := range c.resolveStructuredTypeMembers(reducedType).getMembers(c).All() { if c.isNamedMember(symbol, name) { cb(symbol, name) } @@ -367,22 +367,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 } @@ -819,10 +816,7 @@ func (c *Checker) GetConstantValue(node *ast.Node) any { return c.getEnumMemberValue(node).Value } - if c.symbolNodeLinks.Get(node).resolvedSymbol == nil { - c.checkExpressionCached(node) // ensure cached resolved symbol is set - } - symbol := c.symbolNodeLinks.Get(node).resolvedSymbol + symbol := c.getSymbolOfExpression(node) if symbol == nil && ast.IsEntityNameExpression(node) { symbol = c.resolveEntityName( node, diff --git a/tsc/internal/checker/symbolaccessibility.go b/tsc/internal/checker/symbolaccessibility.go index 204062db49de0..13ad9921a6a4e 100644 --- a/tsc/internal/checker/symbolaccessibility.go +++ b/tsc/internal/checker/symbolaccessibility.go @@ -171,18 +171,37 @@ func (c *Checker) getAlternativeContainingModules(symbol *ast.Symbol, enclosingD return nil } containingFile := ast.GetSourceFileOfNode(enclosingDeclaration) - id := ast.GetNodeId(containingFile.AsNode()) - links := c.symbolContainerLinks.Get(symbol) - if links.extendedContainersByFile == nil { - links.extendedContainersByFile = make(map[ast.NodeId][]*ast.Symbol) + // Try to make an import using an import already in the enclosing file, if possible + if results := c.getImportedContainingModules(symbol, containingFile, enclosingDeclaration); len(results) > 0 { + return results } - existing, ok := links.extendedContainersByFile[id] - if ok && existing != nil { - return existing + // No results from files already being imported by this file - expand search (not location-specific, so cached) + if results, ok := c.extendedContainers.cached(c, symbol); ok { + return results + } + return c.extendedContainers.compute(c, symbol, func() []*ast.Symbol { + return c.getExternalModuleContainers(symbol) + }) +} + +type symbolFileKey struct { + symbol *ast.Symbol + file *ast.SourceFile +} + +// getImportedContainingModules returns the modules imported by a file that +// export a symbol. The result only depends on the file, as the module names +// are resolved relative to it. +func (c *Checker) getImportedContainingModules(symbol *ast.Symbol, containingFile *ast.SourceFile, enclosingDeclaration *ast.Node) []*ast.Symbol { + if len(containingFile.Imports()) == 0 { + return nil } - var results []*ast.Symbol - if len(containingFile.Imports()) > 0 { - // Try to make an import using an import already in the enclosing file, if possible + key := symbolFileKey{symbol, containingFile} + if results, ok := c.importedContainingModules.cached(c, key); ok { + return results + } + return c.importedContainingModules.compute(c, key, func() []*ast.Symbol { + var results []*ast.Symbol for _, importRef := range containingFile.Imports() { if ast.NodeIsSynthesized(importRef) { // Synthetic names can't be resolved by `resolveExternalModuleName` - they'll cause a debug assert if they error @@ -198,23 +217,11 @@ func (c *Checker) getAlternativeContainingModules(symbol *ast.Symbol, enclosingD } results = append(results, resolvedModule) } - if len(results) > 0 { - links.extendedContainersByFile[id] = results - return results - } - } - - if links.extendedContainers != nil { - return *links.extendedContainers - } - // No results from files already being imported by this file - expand search (not location-specific, so cached) - results = c.getExternalModuleContainers(symbol) - links.extendedContainers = &results - return results + return results + }) } type externalModuleContainerIndex struct { - complete bool containersByTarget map[*ast.Symbol][]*ast.Symbol moduleOrder map[*ast.Symbol]int } @@ -227,14 +234,11 @@ func (index *externalModuleContainerIndex) add(target *ast.Symbol, container *as } func (c *Checker) getExternalModuleContainers(symbol *ast.Symbol) []*ast.Symbol { - if c.externalModuleContainers == nil { - c.buildExternalModuleContainerIndex() - } - index := c.externalModuleContainers - if !index.complete { + if _, building := c.resolvingAnyIndex(c.externalModuleContainers.key()); building { // Re-entered from an alias resolved while building the index; answer this query without it. return c.scanExternalModuleContainers(symbol) } + index := c.getExternalModuleContainerIndex() containers := index.containersByTarget[c.getResolvedTarget(symbol)] parent := c.getParentOfSymbol(symbol) parentOrder, parentIsModule := index.moduleOrder[parent] @@ -250,12 +254,15 @@ func (c *Checker) getExternalModuleContainers(symbol *ast.Symbol) []*ast.Symbol return containers } -func (c *Checker) buildExternalModuleContainerIndex() { +func (c *Checker) getExternalModuleContainerIndex() *externalModuleContainerIndex { + if index := c.externalModuleContainers.cached(c); index != nil { + return index + } + c.externalModuleContainers.begin(c) index := &externalModuleContainerIndex{ containersByTarget: make(map[*ast.Symbol][]*ast.Symbol), moduleOrder: make(map[*ast.Symbol]int, len(c.program.SourceFiles())), } - c.externalModuleContainers = index for _, file := range c.program.SourceFiles() { if !ast.IsExternalModule(file) { continue @@ -269,7 +276,9 @@ func (c *Checker) buildExternalModuleContainerIndex() { index.add(c.getResolvedTarget(exportEquals), container) } } - index.complete = true + c.externalModuleContainers.set(c, index) + c.endMemo() + return index } func (c *Checker) scanExternalModuleContainers(symbol *ast.Symbol) []*ast.Symbol { @@ -373,8 +382,7 @@ func (c *Checker) getContainersOfSymbol(symbol *ast.Symbol, enclosingDeclaration } continue } - c.checkExpressionCached(d.Parent.AsBinaryExpression().Left.Expression()) - sym := c.symbolNodeLinks.Get(d.Parent.AsBinaryExpression().Left.Expression()).resolvedSymbol + sym := c.getSymbolOfExpression(d.Parent.AsBinaryExpression().Left.Expression()) if sym != nil && !slices.Contains(candidates, sym) { candidates = append(candidates, sym) } @@ -513,15 +521,11 @@ func (c *Checker) getAccessibleSymbolChainEx(ctx accessibleSymbolChainContext) [ firstRelevantLocation = node return true }) - links := c.symbolContainerLinks.Get(ctx.symbol) - linkKey := accessibleChainCacheKey{ctx.useOnlyExternalAliasing, firstRelevantLocation, ctx.meaning} - if links.accessibleChainCache == nil { - links.accessibleChainCache = make(map[accessibleChainCacheKey][]*ast.Symbol) - } - existing, ok := links.accessibleChainCache[linkKey] - if ok { + key := accessibleChainCacheKey{ctx.symbol, ctx.useOnlyExternalAliasing, firstRelevantLocation, ctx.meaning} + if existing, ok := c.accessibleChains.cached(c, key); ok { return existing } + c.accessibleChains.begin(c, key) var result []*ast.Symbol @@ -533,7 +537,8 @@ func (c *Checker) getAccessibleSymbolChainEx(ctx accessibleSymbolChainContext) [ } return false }) - links.accessibleChainCache[linkKey] = result + c.accessibleChains.set(c, key, result) + c.endMemo() return result } @@ -573,10 +578,8 @@ func (c *Checker) getSymbolTableAliases(symbols ast.SymbolTable, tableId symbolT // Cache globals and exports tables (which are large and revisited often). // Locals tables are small and per-scope, so they are filtered but not cached. if kind == stKindGlobals || kind == stKindExports || kind == stKindResolvedExports { - if c.symbolTableAliasCache != nil { - if aliases, ok := c.symbolTableAliasCache[tableId]; ok { - return aliases - } + if aliases, ok := c.symbolTableAliasCache.get(tableId); ok { + return aliases } } var aliases []*ast.Symbol @@ -586,10 +589,7 @@ func (c *Checker) getSymbolTableAliases(symbols ast.SymbolTable, tableId symbolT } } if kind == stKindGlobals || kind == stKindExports || kind == stKindResolvedExports { - if c.symbolTableAliasCache == nil { - c.symbolTableAliasCache = make(map[symbolTableID][]*ast.Symbol) - } - c.symbolTableAliasCache[tableId] = aliases + c.symbolTableAliasCache.intern(tableId, aliases) } return aliases } @@ -882,10 +882,8 @@ func (c *Checker) someSymbolTableInScope( // synthesized table lets someSymbolTableInScope expose them during accessibility checks. func (c *Checker) getClassExpressionNameTable(location *ast.Node) ast.SymbolTable { nodeId := ast.GetNodeId(location) - if c.classExpressionNameTables != nil { - if table, ok := c.classExpressionNameTables[nodeId]; ok { - return table - } + if table, ok := c.classExpressionNameTables.get(nodeId); ok { + return table } classSymbol := c.getSymbolOfDeclaration(location) nameText := location.AsClassExpression().Name().Text() @@ -893,10 +891,7 @@ func (c *Checker) getClassExpressionNameTable(location *ast.Node) ast.SymbolTabl return nil } table := ast.SymbolTableOf(nameText, classSymbol) - if c.classExpressionNameTables == nil { - c.classExpressionNameTables = make(map[ast.NodeId]ast.SymbolTable) - } - c.classExpressionNameTables[nodeId] = table + c.classExpressionNameTables.intern(nodeId, table) return table } diff --git a/tsc/internal/checker/tracer.go b/tsc/internal/checker/tracer.go index d514ef9fbd4da..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,7 +319,8 @@ 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 { diff --git a/tsc/internal/checker/types.go b/tsc/internal/checker/types.go index 6d1d9f26c6005..f9c3552ab38fd 100644 --- a/tsc/internal/checker/types.go +++ b/tsc/internal/checker/types.go @@ -9,6 +9,7 @@ import ( "github.com/microsoft/TypeScript/tsc/internal/ast" "github.com/microsoft/TypeScript/tsc/internal/collections" "github.com/microsoft/TypeScript/tsc/internal/core" + "github.com/microsoft/TypeScript/tsc/internal/debug" "github.com/microsoft/TypeScript/tsc/internal/evaluator" ) @@ -188,24 +189,39 @@ type SymbolReferenceLinks struct { // Links for value symbols type ValueSymbolLinks struct { - resolvedType *Type // Type of value symbol + resolvedType memo[*Type] // Type of value symbol target *ast.Symbol mapper *TypeMapper extra *valueSymbolExtra } type valueSymbolExtra struct { - writeType *Type + writeType memo[*Type] nameType *Type containingType *Type // Mapped type for mapped type property, containing union or intersection type for synthetic property instantiatedFrom *ast.Symbol // For an instantiation of an instantiated symbol, the symbol instantiated } -func (links *ValueSymbolLinks) getWriteType() *Type { +func (links *ValueSymbolLinks) cachedWriteType(c *Checker) *Type { if links.extra == nil { return nil } - return links.extra.writeType + return links.extra.writeType.cached(c) +} + +// typeOfCreation returns the type of a member its creator supplies, such as +// a member of an object literal or of the type implied by a binding pattern. +func (links *ValueSymbolLinks) typeOfCreation() *Type { + return links.resolvedType.peek() +} + +// writeTypeOfCreation returns the write type of a synthetic property, which +// its creator supplies. +func (links *ValueSymbolLinks) writeTypeOfCreation() *Type { + if links.extra == nil { + return nil + } + return links.extra.writeType.peek() } func (links *ValueSymbolLinks) getNameType() *Type { @@ -229,7 +245,19 @@ func (links *ValueSymbolLinks) setWriteType(c *Checker, typ *Type) { } links.extra = c.valueSymbolExtraArena.New() } - links.extra.writeType = typ + links.extra.writeType.set(c, typ) +} + +// setNewWriteType sets the write type of a symbol being created; see +// memo.setIdentity. +func (links *ValueSymbolLinks) setNewWriteType(c *Checker, typ *Type) { + if links.extra == nil { + if typ == nil { + return + } + links.extra = c.valueSymbolExtraArena.New() + } + links.extra.writeType.setIdentity(c, typ) } func (links *ValueSymbolLinks) setNameType(c *Checker, typ *Type) { @@ -287,10 +315,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 @@ -298,7 +327,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 { @@ -323,20 +351,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 @@ -351,11 +374,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 { @@ -385,7 +407,7 @@ type SpreadLinks struct { // Links for variances of type aliases and interface types type VarianceLinks struct { - variances []VarianceFlags + variances memo[[]VarianceFlags] } type VarianceFlags uint32 @@ -408,17 +430,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 ( @@ -439,14 +456,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 ) @@ -454,41 +468,43 @@ const ( // Common links type NodeLinks struct { - flags NodeCheckFlags // Set of flags specific to Node - declarationRequiresScopeChange core.Tristate // Set by `useOuterVariableScopeInParameter` in checker when downlevel emit would change the name resolution scope inside of a parameter. - hasReportedStatementInAmbientContext bool // Cache boolean if we report statements in ambient context + flags NodeCheckFlags // Set of flags specific to Node + declarationRequiresScopeChange core.Tristate // Set by `useOuterVariableScopeInParameter` in checker when downlevel emit would change the name resolution scope inside of a parameter. } type SymbolNodeLinks struct { - resolvedSymbol *ast.Symbol // Resolved symbol associated with node + resolvedSymbol memo[*ast.Symbol] // Resolved symbol associated with node } type TypeNodeLinks struct { - resolvedType *Type // Resolved type associated with node - outerTypeParameters *[]*Type // Outer type parameters of anonymous object type + resolvedType memo[*Type] // Resolved type associated with node + outerTypeParameters memo[*[]*Type] // Outer type parameters of anonymous object type } -func (links *TypeNodeLinks) getOuterTypeParameters() []*Type { - if links.outerTypeParameters == nil { - return nil +func (links *TypeNodeLinks) cachedOuterTypeParameters(c *Checker) []*Type { + if p := links.outerTypeParameters.cached(c); p != nil { + return *p } - return *links.outerTypeParameters + return nil } func (links *TypeNodeLinks) setOuterTypeParameters(c *Checker, types []*Type) { if types == nil { - links.outerTypeParameters = nil + links.outerTypeParameters.set(c, nil) return } - if links.outerTypeParameters == nil { - links.outerTypeParameters = c.outerTypeParameterListArena.New() - } - *links.outerTypeParameters = types + p := c.outerTypeParameterListArena.New() + *p = types + links.outerTypeParameters.set(c, p) } type ComputedNameNodeLinks struct { - hasName core.Tristate // If the node has a computable name - name string // Resolved name associated with the type of the node + name memo[computedName] // Resolved name associated with the type of the node +} + +type computedName struct { + name string + exists core.Tristate // If the node has a computable name; unknown until computed } // Links for enum members @@ -503,22 +519,24 @@ type SourceFileLinks struct { typeChecked bool unusedChecked bool externalHelpersModule *ast.Symbol + externalHelperRequests []externalHelperRequest requestedExternalEmitHelpers ExternalEmitHelpers deferredNodes collections.OrderedSet[*ast.Node] + renamedBindingElements collections.OrderedSet[*ast.Node] // Binding elements renamed in function types, which are errors unless used identifierCheckNodes []*ast.Node localJsxNamespace string localJsxFragmentNamespace string localJsxFactory *ast.EntityName localJsxFragmentFactory *ast.EntityName - jsxFragmentType *Type + jsxFragmentType memo[*Type] } // Signature specific links type SignatureLinks struct { - resolvedSignature *Signature // Cached signature of signature node or call expression - effectsSignature *Signature // Signature with possible control flow effects - decoratorSignature *Signature // Signature for decorator as if invoked by the runtime + resolvedSignature memo[*Signature] // Cached signature of signature node or call expression + effectsSignature memo[*Signature] // Signature with possible control flow effects + decoratorSignature memo[*Signature] // Signature for decorator as if invoked by the runtime } type TypeFlags uint32 @@ -732,8 +750,7 @@ const ( ObjectFlagsSingleSignatureType = 1 << 25 // A single signature type extracted from a potentially broader type ObjectFlagsIsClassInstanceClone = 1 << 26 // Type is a clone of a class instance type // Flags that require TypeFlags.Object and ObjectFlags.Reference - ObjectFlagsIdenticalBaseTypeCalculated = 1 << 27 // has had `getSingleBaseForNonAugmentingSubtype` invoked on it already - ObjectFlagsIdenticalBaseTypeExists = 1 << 28 // has a defined cachedEquivalentBaseType member + ObjectFlagsIdenticalBaseTypeExists = 1 << 28 // has a defined cachedEquivalentBaseType member // Flags that require TypeFlags.UnionOrIntersection or TypeFlags.Substitution ObjectFlagsIsGenericTypeComputed = 1 << 22 // IsGenericObjectType flag has been computed ObjectFlagsIsGenericObjectType = 1 << 23 // Union or intersection contains generic object type @@ -926,6 +943,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. @@ -1135,7 +1160,7 @@ type UniqueESSymbolType struct { type ConstrainedType struct { TypeBase - resolvedBaseConstraint *Type + resolvedBaseConstraint memo[*Type] } func (t *ConstrainedType) AsConstrainedType() *ConstrainedType { return t } @@ -1173,7 +1198,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) } @@ -1185,12 +1210,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) @@ -1200,7 +1225,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] @@ -1213,19 +1238,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 } @@ -1272,7 +1300,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. @@ -1310,9 +1338,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 } @@ -1322,7 +1350,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 } @@ -1342,6 +1370,13 @@ type MemberLayout struct { func (t *TypeReference) AsTypeReference() *TypeReference { return t } +// typeArgumentsOfCreation returns the type arguments of a reference that is +// not deferred, which its creator supplies. +func (t *TypeReference) typeArgumentsOfCreation() []*Type { + debug.Assert(t.node == nil, "deferred type references compute their type arguments") + return t.resolvedTypeArguments.peek() +} + // InterfaceType (when generic, serves as reference to instantiation of itself) type InterfaceType struct { @@ -1351,8 +1386,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 @@ -1442,24 +1477,13 @@ type InstantiationExpressionType struct { type MappedType struct { ObjectType declaration *ast.MappedTypeNode - typeParameter *Type - constraintType *Type - nameType *Type - templateType *Type - modifiersType *Type - resolvedApparentType *Type - containsError bool -} - -func (t *MappedType) TypeParameter() *Type { return t.typeParameter } -func (t *MappedType) ConstraintType() *Type { return t.constraintType } -func (t *MappedType) NameType() *Type { return t.nameType } -func (t *MappedType) TemplateType() *Type { return t.templateType } -func (t *MappedType) ResolveComponents(c *Checker, typ *Type) { - c.getTypeParameterFromMappedType(typ) - c.getConstraintTypeFromMappedType(typ) - c.getNameTypeFromMappedType(typ) - c.getTemplateTypeFromMappedType(typ) + typeParameter memo[*Type] + constraintType memo[*Type] + nameType memo[*Type] + templateType memo[*Type] + modifiersType memo[*Type] + resolvedApparentType memo[*Type] + containsError memo[bool] } // ReverseMappedType @@ -1476,7 +1500,7 @@ type ReverseMappedType struct { type EvolvingArrayType struct { ObjectType elementType *Type - finalArrayType *Type + finalArrayType memo[*Type] } // UnionOrIntersectionTypeData @@ -1484,9 +1508,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 } @@ -1499,10 +1523,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 } @@ -1510,26 +1534,31 @@ type UnionType struct { type IntersectionType struct { UnionOrIntersectionType - resolvedApparentType *Type - uniqueLiteralFilledInstantiation *Type // Instantiation with type parameters mapped to never type + resolvedApparentType memo[*Type] + uniqueLiteralFilledInstantiation memo[*Type] // Instantiation with type parameters mapped to never type } // TypeParameter type TypeParameter struct { ConstrainedType - constraint *Type + constraint memo[*Type] target *Type mapper *TypeMapper isThisType bool isDistributed bool - resolvedDefaultType *Type - distributedType *Type + resolvedDefaultType memo[*Type] + distributedType *Type // The distributed counterpart, or for a distributed type parameter, its original origin *Type // The type parameter a restrictive type parameter was made from, or the tuple target of a tuple element type parameter } func (t *TypeParameter) IsThisType() bool { return t.isThisType } +// constraintOfCreation returns the constraint of a type parameter whose +// creator supplies it, such as the this type of a tuple or a distributed type +// parameter. +func (t *TypeParameter) constraintOfCreation() *Type { return t.constraint.peek() } + // IndexFlags type IndexFlags uint32 @@ -1595,7 +1624,7 @@ type ConditionalRoot struct { isDistributive bool inferTypeParameters []*Type outerTypeParameters []*Type - instantiations map[CacheHashKey]*Type + instantiations memoMap[CacheHashKey, *Type] alias *TypeAlias } @@ -1604,13 +1633,14 @@ type ConditionalType struct { root *ConditionalRoot checkType *Type extendsType *Type - resolvedTrueType *Type - resolvedFalseType *Type - resolvedInferredTrueType *Type // The `trueType` instantiated with the `combinedMapper`, if present - resolvedDefaultConstraint *Type - resolvedConstraintOfDistributive *Type + resolvedTrueType memo[*Type] + resolvedFalseType memo[*Type] + resolvedInferredTrueType memo[*Type] // The `trueType` instantiated with the `combinedMapper`, if present + resolvedDefaultConstraint memo[*Type] + resolvedConstraintOfDistributive memo[*Type] mapper *TypeMapper combinedMapper *TypeMapper + restrictive bool // Whether the outer type parameters are mapped to restrictive forms } func (t *ConditionalType) CheckType() *Type { return t.checkType } @@ -1647,10 +1677,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 @@ -1693,7 +1723,20 @@ func (s *Signature) getResolvedTypePredicate(c *Checker) *TypePredicate { return s.extra.resolvedTypePredicate } +// setResolvedTypePredicate caches the type predicate of the signature, a flag +// memo; see initResolvedTypePredicate. func (s *Signature) setResolvedTypePredicate(c *Checker, predicate *TypePredicate) { + if c.logResults() { + old := s.getResolvedTypePredicate(c) + c.logMemoDiscard(nil, memoKeyOf(s, memoTypePredicate), func() { s.initResolvedTypePredicate(c, old) }) + } + s.initResolvedTypePredicate(c, predicate) + c.setFlagMemo(memoKeyOf(s, memoTypePredicate)) +} + +// initResolvedTypePredicate sets the type predicate of a signature being +// created. +func (s *Signature) initResolvedTypePredicate(c *Checker, predicate *TypePredicate) { s.flags &^= signatureFlagsNoTypePredicate if predicate != nil && predicate == c.noTypePredicate { s.flags |= signatureFlagsNoTypePredicate diff --git a/tsc/internal/checker/types_test.go b/tsc/internal/checker/types_test.go index 63b9a61ce0424..1b376f5e44e0b 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.cached(first).id, TypeId(i+1)) + assert.Equal(t, first.signatureLinks.Get(node).resolvedSignature.cached(first).id, SignatureId(i+1)) + assert.Equal(t, second.typeNodeLinks.Get(node).resolvedType.cached(second).id, TypeId(i+2)) + assert.Equal(t, second.signatureLinks.Get(node).resolvedSignature.cached(second).id, SignatureId(i+2)) } clone := nodes[0].Clone(f) assert.Assert(t, !first.typeNodeLinks.Has(clone)) @@ -85,7 +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,15 +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), - intersectionContentTypes: 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") @@ -307,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 { @@ -349,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) } @@ -367,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 { @@ -489,7 +492,7 @@ func TestCompactValueSymbolLinksLayout(t *testing.T) { assert.Equal(t, unsafe.Sizeof(valueSymbolExtra{}), 4*unsafe.Sizeof(uintptr(0))) c, types := newCompositeTestChecker() var links ValueSymbolLinks - assert.Assert(t, links.getWriteType() == nil) + assert.Assert(t, links.cachedWriteType(c) == nil) assert.Assert(t, links.getNameType() == nil) assert.Assert(t, links.getContainingType() == nil) links.setWriteType(c, nil) @@ -506,55 +509,15 @@ func TestCompactValueSymbolLinksLayout(t *testing.T) { other.setNameType(c, types[2]) } runtime.GC() - assert.Equal(t, links.getWriteType(), types[0]) + assert.Equal(t, links.cachedWriteType(c), types[0]) assert.Equal(t, links.getNameType(), types[1]) assert.Equal(t, links.getContainingType(), types[2]) links.setNameType(c, nil) assert.Assert(t, links.getNameType() == nil) - assert.Equal(t, links.getWriteType(), types[0]) + assert.Equal(t, links.cachedWriteType(c), types[0]) assert.Equal(t, links.getContainingType(), types[2]) } -func TestUnionIntersectionPropertyCacheSharing(t *testing.T) { - t.Parallel() - for _, intersection := range []bool{false, true} { - for _, augmentedFirst := range []bool{false, true} { - t.Run(strconv.FormatBool(intersection)+"/"+strconv.FormatBool(augmentedFirst), func(t *testing.T) { - t.Parallel() - c, _ := newCompositeTestChecker() - members := ast.NewSymbolTable() - for i := range 300 { - name := strconv.Itoa(i) - members.Set(name, c.newSymbol(ast.SymbolFlagsProperty, name)) - } - members.Set("", c.newSymbol(ast.SymbolFlagsProperty, "")) - object := c.newAnonymousType(nil, members, nil, nil, nil) - var typ *Type - if intersection { - typ = c.newIntersectionType(ObjectFlagsNone, []*Type{object, object}) - } else { - typ = c.newUnionType(ObjectFlagsNone, []*Type{object, object}) - } - data := typ.AsUnionOrIntersectionType() - for name, symbol := range members.All() { - assert.Equal(t, c.getUnionOrIntersectionProperty(typ, name, !augmentedFirst), symbol) - assert.Equal(t, c.getUnionOrIntersectionProperty(typ, name, augmentedFirst), symbol) - } - assert.Equal(t, data.propertyCacheWithoutFunctionPropertyAugment.Len(), members.Len()) - if !augmentedFirst { - assert.Assert(t, data.propertyCache == nil) - } - runtime.GC() - for name, symbol := range members.All() { - assert.Equal(t, c.getUnionOrIntersectionProperty(typ, name, true), symbol) - assert.Equal(t, c.getUnionOrIntersectionProperty(typ, name, false), symbol) - } - runtime.KeepAlive(c) - }) - } - } -} - func TestUnionIntersectionPropertyCacheModes(t *testing.T) { t.Parallel() for _, intersection := range []bool{false, true} { @@ -570,25 +533,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) }) @@ -650,30 +611,28 @@ func TestCompactTypeNodeLinksLayout(t *testing.T) { assert.Equal(t, unsafe.Sizeof(TypeNodeLinks{}), 2*unsafe.Sizeof(uintptr(0))) c, types := newCompositeTestChecker() var links TypeNodeLinks - links.resolvedType = types[0] - assert.Assert(t, links.getOuterTypeParameters() == nil) + links.resolvedType.intern(types[0]) + assert.Assert(t, links.cachedOuterTypeParameters(c) == nil) links.setOuterTypeParameters(c, nil) - assert.Assert(t, links.outerTypeParameters == nil) + assert.Assert(t, links.outerTypeParameters.memoValue == nil) links.setOuterTypeParameters(c, []*Type{}) - assert.Assert(t, links.getOuterTypeParameters() != nil) - assert.Equal(t, len(links.getOuterTypeParameters()), 0) - entry := links.outerTypeParameters + assert.Assert(t, links.cachedOuterTypeParameters(c) != nil) + assert.Equal(t, len(links.cachedOuterTypeParameters(c)), 0) list := slices.Clone(types) links.setOuterTypeParameters(c, list) - assert.Equal(t, links.outerTypeParameters, entry) - assert.Equal(t, links.getOuterTypeParameters()[0], types[0]) + assert.Equal(t, links.cachedOuterTypeParameters(c)[0], types[0]) list[0] = types[1] - assert.Equal(t, links.getOuterTypeParameters()[0], types[1]) + assert.Equal(t, links.cachedOuterTypeParameters(c)[0], types[1]) for range 1024 { var other TypeNodeLinks other.setOuterTypeParameters(c, types) } runtime.GC() - assert.Equal(t, links.getOuterTypeParameters()[0], types[1]) - assert.Equal(t, links.resolvedType, types[0]) + assert.Equal(t, links.cachedOuterTypeParameters(c)[0], types[1]) + assert.Equal(t, links.resolvedType.cached(c), types[0]) links.setOuterTypeParameters(c, nil) - assert.Assert(t, links.getOuterTypeParameters() == nil) - assert.Equal(t, links.resolvedType, types[0]) + assert.Assert(t, links.cachedOuterTypeParameters(c) == nil) + assert.Equal(t, links.resolvedType.cached(c), types[0]) runtime.KeepAlive(c) } @@ -694,7 +653,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) @@ -749,8 +708,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.cached(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 bdc55ba66c932..9cfb109e469fe 100644 --- a/tsc/internal/checker/utilities.go +++ b/tsc/internal/checker/utilities.go @@ -375,6 +375,15 @@ func (c *Checker) compareSymbolsWorker(s1, s2 *ast.Symbol) int { 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)) @@ -478,7 +487,7 @@ func CompareTypes(t1, t2 *Type) int { // Here we know we have references to instantiations of the same type because we have matching targets. if r1.node == nil && r2.node == nil { // Non-deferred type references with the same target are sorted by their type argument lists. - if c := compareTypeLists(t1.AsTypeReference().resolvedTypeArguments, t2.AsTypeReference().resolvedTypeArguments); c != 0 { + if c := compareTypeLists(r1.typeArgumentsOfCreation(), r2.typeArgumentsOfCreation()); c != 0 { return c } } else { @@ -663,8 +672,8 @@ func CompareTypes(t1, t2 *Type) int { } // Types implied by binding patterns are ordered by their patterns. if t1.flags&TypeFlagsObject != 0 { - p1 := t1.checker.patternForType[t1] - p2 := t2.checker.patternForType[t2] + p1, _ := t1.checker.patternForType.get(t1) + p2, _ := t2.checker.patternForType.get(t2) if c := t1.checker.compareNodes(p1, p2); c != 0 { return c } @@ -822,7 +831,7 @@ func compareObjectMembers(t1, t2 *Type, withTypes bool) int { // created. func (c *Checker) peekTypeOfObjectLiteralMember(s *ast.Symbol) *Type { if links := c.valueSymbolLinks.TryGet(s); links != nil { - return links.resolvedType + return links.typeOfCreation() } return nil } @@ -869,7 +878,7 @@ func compareTypeParameterOrigins(t1, t2 *Type) int { // Tuple this types have no symbol; their constraint is the tuple target, // initialized at creation. if t1.symbol == nil { - return CompareTypes(p1.constraint, p2.constraint) + return CompareTypes(p1.constraintOfCreation(), p2.constraintOfCreation()) } case typeParameterOriginDistributed: return CompareTypes(p1.distributedType, p2.distributedType) 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 8dbdc2623cc36..c7081ce8b6b44 100644 --- a/tsc/internal/testrunner/compiler_runner.go +++ b/tsc/internal/testrunner/compiler_runner.go @@ -167,21 +167,8 @@ func (r *CompilerBaselineRunner) runTest(t *testing.T, filename string) { } } -// When a program checks its files on several checkers, these tests can see different results depending on which -// checker answers a query first. -var concurrentSkippedTests = map[string]string{ - "checkOrderCircularDefaults.ts": "Circular default results depend on which checker resolves the cycle first.", - "checkOrderSpreadCycle.ts": "Spread cycle results depend on which checker resolves the cycle first.", - "checkOrderStableInstantiationErrors.ts": "Instantiation limit errors depend on which checker instantiates first.", -} - func (r *CompilerBaselineRunner) runSingleConfigTest(t *testing.T, testName string, test *compilerFileBasedTest, config *harnessutil.NamedTestConfiguration) { t.Parallel() - if !testutil.TestProgramIsSingleThreaded() { - if msg, ok := concurrentSkippedTests[tspath.GetBaseFileName(test.filename)]; ok { - t.Skipf("Skipping in concurrent mode: %s", msg) - } - } defer testutil.RecoverAndFail(t, "Panic on compiler test "+test.filename) payload := makeUnitsFromTest(test.content, test.filename) diff --git a/tsc/testdata/baselines/reference/compiler/bigintArbirtraryIdentifier(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/bigintArbirtraryIdentifier(checkorder=typesfirst).errors.txt index e70af53237c1f..5a959d4e04b62 100644 --- a/tsc/testdata/baselines/reference/compiler/bigintArbirtraryIdentifier(checkorder=typesfirst).errors.txt +++ b/tsc/testdata/baselines/reference/compiler/bigintArbirtraryIdentifier(checkorder=typesfirst).errors.txt @@ -6,7 +6,6 @@ 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,16): error TS2304: Cannot find name 'foo'. 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'. @@ -25,14 +24,12 @@ badImport2.ts(1,22): error TS2304: Cannot find name 'from'. import { "0n" as foo } from "./foo"; export { foo as "0n" }; -==== badImport.ts (6 errors) ==== +==== badImport.ts (5 errors) ==== import { 0n as foo } from "./foo"; ~~ !!! error TS1003: Identifier expected. ~~~~~~~~~ !!! error TS1141: String literal expected. - ~~~ -!!! error TS2304: Cannot find name 'foo'. ~ !!! error TS1128: Declaration or statement expected. ~~~~ diff --git a/tsc/testdata/baselines/reference/compiler/boundedRecursiveTypeInferredThroughClosure.errors.txt b/tsc/testdata/baselines/reference/compiler/boundedRecursiveTypeInferredThroughClosure.errors.txt deleted file mode 100644 index e537c857eb57a..0000000000000 --- a/tsc/testdata/baselines/reference/compiler/boundedRecursiveTypeInferredThroughClosure.errors.txt +++ /dev/null @@ -1,86 +0,0 @@ -boundedRecursiveTypeInferredThroughClosure.ts(79,12): error TS5115: Instantiations of the following types appear infinitely circular: 'InferData', 'UnpackKeyValue'. - - -==== boundedRecursiveTypeInferredThroughClosure.ts (1 errors) ==== - // The recursion of InferData and UnpackKeyValue is bounded by Next, so - // inferring it through a closure must not report it as infinite. - - type Prettify = { [K in keyof T]: T[K] } & {}; - type ExtractUndefined = { [K in keyof T]: undefined extends T[K] ? K : never }[keyof T]; - type ExtractDefined = { [K in keyof T]: undefined extends T[K] ? never : K }[keyof T]; - type Next = [1, 2, 3, 4, 5, 6]; - type JSONPrimitives = string | number | bigint | boolean | null | undefined; - type JSONValues = JSONPrimitives | CanBeSerialized; - type CanBeSerialized = { - toJSON(): T; - }; - type JSONDataTypes = JSONValues | JSONDataTypes[] | { - [key: string]: JSONDataTypes; - }; - type SerializeJSONObject = { - [K in ExtractDefined]: SerializeJSONTypes; - } & { - [K in ExtractUndefined]?: SerializeJSONTypes; - }; - interface ExtendedJSONTypes { - } - type NonAllowedJSTypes = Map | Set; - type ForcefullyAllowedTypes = { - [K in keyof ExtendedJSONTypes]: ExtendedJSONTypes[K]; - }[keyof ExtendedJSONTypes]; - type SerializeJSONOwnTypes = T extends JSONPrimitives ? T : T extends ForcefullyAllowedTypes ? T : T extends NonAllowedJSTypes ? never : T extends Array ? Array> : T extends object ? Prettify> : never; - type SerializeJSONTypes = T extends ForcefullyAllowedTypes ? T : T extends CanBeSerialized ? SerializeJSONOwnTypes : SerializeJSONOwnTypes; - interface ItemContract, MaxDepth extends Next[number], Variant extends string> { - $type: 'item'; - transformer: { - new (...args: any[]): Transformer; - }; - maxDepth: MaxDepth; - variant: Variant; - } - type UnpackKeyValue = [Value[0]] extends [never] ? SerializeJSONTypes : Value[0] extends ItemContract ? InferData | SerializeJSONTypes : SerializeJSONTypes; - type LimitDepth = [ - Value - ] extends [never] ? Key : Value extends ItemContract ? MaxDepth extends Depth ? never : Key : Key; - type UnpackOptionalValues = { - [O in { - [K in keyof Data]: [undefined] extends [Data[K]] ? LimitDepth[0], MaxDepth, Depth> : never; - }[keyof Data]]?: UnpackKeyValue, MaxDepth, Depth>; - }; - type UnpackRequiredValues = { - [O in { - [K in keyof Data]: [undefined] extends [Data[K]] ? never : LimitDepth[0], MaxDepth, Depth>; - }[keyof Data]]: UnpackKeyValue, MaxDepth, Depth>; - }; - type SplitItm = [ - Extract>, - Exclude> - ]; - type UnpackAsTopLevelItem = T extends ItemContract ? InferData : never; - type UnpackValues = Prettify & UnpackOptionalValues>; - type InferData = Transformer extends { - [K in Variant]: (...args: any[]) => unknown; - } ? UnpackValues>, MaxDepth, Depth> : never; - declare class Item, MaxDepth extends Next[number], Variant extends string> { - transformer: { new (...args: any[]): Transformer }; - maxDepth: MaxDepth; - variant: Variant; - $type: 'item'; - resolve(): Promise>; - } - type Ctor = { new (resource: any, ...rest: any[]): any }; - declare abstract class BaseTransformer { - static transform(this: Self, data: ConstructorParameters[0]): Item, 1, 'toObject'>; - constructor(resource: T); - } - class Size { - } - class SizeTransformer extends BaseTransformer { - toObject() { - } - } - declare function once(value: T): T; - once(() => SizeTransformer.transform(new Size())); - ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS5115: Instantiations of the following types appear infinitely circular: 'InferData', 'UnpackKeyValue'. - \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderAwaitedCycle(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/checkOrderAwaitedCycle(checkorder=default).errors.txt index fbdc7623ca157..126b9485926f5 100644 --- a/tsc/testdata/baselines/reference/compiler/checkOrderAwaitedCycle(checkorder=default).errors.txt +++ b/tsc/testdata/baselines/reference/compiler/checkOrderAwaitedCycle(checkorder=default).errors.txt @@ -1,6 +1,7 @@ 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) ==== @@ -15,10 +16,12 @@ b.ts(2,11): 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 (1 errors) ==== +==== 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).errors.txt b/tsc/testdata/baselines/reference/compiler/checkOrderAwaitedCycle(checkorder=reverse).errors.txt index 55a3e6d752ab1..126b9485926f5 100644 --- a/tsc/testdata/baselines/reference/compiler/checkOrderAwaitedCycle(checkorder=reverse).errors.txt +++ b/tsc/testdata/baselines/reference/compiler/checkOrderAwaitedCycle(checkorder=reverse).errors.txt @@ -1,9 +1,10 @@ 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 (1 errors) ==== +==== a.ts (2 errors) ==== type S = string | Promise; declare const s: S; declare const p: Promise; @@ -11,6 +12,8 @@ b.ts(2,23): error TS1062: Type is referenced directly or indirectly in the fulfi 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) ==== diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderAwaitedCycle(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/checkOrderAwaitedCycle(checkorder=typesfirst).errors.txt index 55a3e6d752ab1..126b9485926f5 100644 --- a/tsc/testdata/baselines/reference/compiler/checkOrderAwaitedCycle(checkorder=typesfirst).errors.txt +++ b/tsc/testdata/baselines/reference/compiler/checkOrderAwaitedCycle(checkorder=typesfirst).errors.txt @@ -1,9 +1,10 @@ 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 (1 errors) ==== +==== a.ts (2 errors) ==== type S = string | Promise; declare const s: S; declare const p: Promise; @@ -11,6 +12,8 @@ b.ts(2,23): error TS1062: Type is referenced directly or indirectly in the fulfi 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) ==== diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderCircularConstraint(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/checkOrderCircularConstraint(checkorder=default).errors.txt index 938f4b7bb63d2..9309ae4c7eb15 100644 --- a/tsc/testdata/baselines/reference/compiler/checkOrderCircularConstraint(checkorder=default).errors.txt +++ b/tsc/testdata/baselines/reference/compiler/checkOrderCircularConstraint(checkorder=default).errors.txt @@ -15,7 +15,6 @@ checkOrderCircularConstraint.ts(10,17): error TS2349: This expression is not cal class A { ~ !!! error TS2313: Type parameter 'T' has a circular constraint. -!!! related TS2751 checkOrderCircularConstraint.ts:7:17: Circularity originates in type at this location. foo() { var x!: T; var a = x.foo(); diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderCircularConstraint(checkorder=reverse).errors.txt b/tsc/testdata/baselines/reference/compiler/checkOrderCircularConstraint(checkorder=reverse).errors.txt index 938f4b7bb63d2..9309ae4c7eb15 100644 --- a/tsc/testdata/baselines/reference/compiler/checkOrderCircularConstraint(checkorder=reverse).errors.txt +++ b/tsc/testdata/baselines/reference/compiler/checkOrderCircularConstraint(checkorder=reverse).errors.txt @@ -15,7 +15,6 @@ checkOrderCircularConstraint.ts(10,17): error TS2349: This expression is not cal class A { ~ !!! error TS2313: Type parameter 'T' has a circular constraint. -!!! related TS2751 checkOrderCircularConstraint.ts:7:17: Circularity originates in type at this location. foo() { var x!: T; var a = x.foo(); diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderCircularConstraint(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/checkOrderCircularConstraint(checkorder=typesfirst).errors.txt index ef7991cfbe407..9309ae4c7eb15 100644 --- a/tsc/testdata/baselines/reference/compiler/checkOrderCircularConstraint(checkorder=typesfirst).errors.txt +++ b/tsc/testdata/baselines/reference/compiler/checkOrderCircularConstraint(checkorder=typesfirst).errors.txt @@ -15,7 +15,6 @@ checkOrderCircularConstraint.ts(10,17): error TS2349: This expression is not cal class A { ~ !!! error TS2313: Type parameter 'T' has a circular constraint. -!!! related TS2751 checkOrderCircularConstraint.ts:10:17: Circularity originates in type at this location. foo() { var x!: T; var a = x.foo(); diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderCircularDefaults(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/checkOrderCircularDefaults(checkorder=default).errors.txt index 5c28d3ee0a214..4dee4171e029f 100644 --- a/tsc/testdata/baselines/reference/compiler/checkOrderCircularDefaults(checkorder=default).errors.txt +++ b/tsc/testdata/baselines/reference/compiler/checkOrderCircularDefaults(checkorder=default).errors.txt @@ -1,15 +1,15 @@ -a.ts(2,24): error TS2716: Type parameter 'T' has a circular default. +b.ts(2,24): error TS2716: Type parameter 'U' has a circular default. -==== a.ts (1 errors) ==== +==== a.ts (0 errors) ==== import type { B } from "./b"; export interface A { a: T } - ~ -!!! error TS2716: Type parameter 'T' has a circular default. export declare const a: A; -==== b.ts (0 errors) ==== +==== 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).types b/tsc/testdata/baselines/reference/compiler/checkOrderCircularDefaults(checkorder=default).types index 145f91d78caf3..a88d998c374ec 100644 --- a/tsc/testdata/baselines/reference/compiler/checkOrderCircularDefaults(checkorder=default).types +++ b/tsc/testdata/baselines/reference/compiler/checkOrderCircularDefaults(checkorder=default).types @@ -8,7 +8,7 @@ export interface A { a: T } >a : T export declare const a: A; ->a : A +>a : A> === b.ts === import type { A } from "./a"; @@ -18,5 +18,5 @@ export interface B { b: U } >b : U export declare const b: B; ->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).types b/tsc/testdata/baselines/reference/compiler/checkOrderCircularDefaults(checkorder=isolated).types index 145f91d78caf3..a88d998c374ec 100644 --- a/tsc/testdata/baselines/reference/compiler/checkOrderCircularDefaults(checkorder=isolated).types +++ b/tsc/testdata/baselines/reference/compiler/checkOrderCircularDefaults(checkorder=isolated).types @@ -8,7 +8,7 @@ export interface A { a: T } >a : T export declare const a: A; ->a : A +>a : A> === b.ts === import type { A } from "./a"; @@ -18,5 +18,5 @@ export interface B { b: U } >b : U export declare const b: B; ->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 index 5c28d3ee0a214..4dee4171e029f 100644 --- a/tsc/testdata/baselines/reference/compiler/checkOrderCircularDefaults(checkorder=typesfirst).errors.txt +++ b/tsc/testdata/baselines/reference/compiler/checkOrderCircularDefaults(checkorder=typesfirst).errors.txt @@ -1,15 +1,15 @@ -a.ts(2,24): error TS2716: Type parameter 'T' has a circular default. +b.ts(2,24): error TS2716: Type parameter 'U' has a circular default. -==== a.ts (1 errors) ==== +==== a.ts (0 errors) ==== import type { B } from "./b"; export interface A { a: T } - ~ -!!! error TS2716: Type parameter 'T' has a circular default. export declare const a: A; -==== b.ts (0 errors) ==== +==== 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).types b/tsc/testdata/baselines/reference/compiler/checkOrderCircularDefaults(checkorder=typesfirst).types index 145f91d78caf3..a88d998c374ec 100644 --- a/tsc/testdata/baselines/reference/compiler/checkOrderCircularDefaults(checkorder=typesfirst).types +++ b/tsc/testdata/baselines/reference/compiler/checkOrderCircularDefaults(checkorder=typesfirst).types @@ -8,7 +8,7 @@ export interface A { a: T } >a : T export declare const a: A; ->a : A +>a : A> === b.ts === import type { A } from "./a"; @@ -18,5 +18,5 @@ export interface B { b: U } >b : U export declare const b: B; ->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 index 0570bff3e21f0..81bd46c132406 100644 --- a/tsc/testdata/baselines/reference/compiler/checkOrderEmitBeforeCheck(checkorder=default).errors.txt +++ b/tsc/testdata/baselines/reference/compiler/checkOrderEmitBeforeCheck(checkorder=default).errors.txt @@ -1,5 +1,5 @@ checkOrderEmitBeforeCheck.ts(9,5): error TS2502: '"each"' is referenced directly or indirectly in its own type annotation. -checkOrderEmitBeforeCheck.ts(15,1): error TS2615: Type of property '"each"' circularly references itself in mapped type '{ [P in keyof ListWidget]: undefined extends ListWidget[P] ? never : P; }'. +checkOrderEmitBeforeCheck.ts(9,13): error TS2615: Type of property '"each"' circularly references itself in mapped type '{ type: "type"; each: any; }'. ==== checkOrderEmitBeforeCheck.ts (2 errors) ==== @@ -14,12 +14,12 @@ checkOrderEmitBeforeCheck.ts(15,1): error TS2615: Type of property '"each"' circ "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; - ~ -!!! error TS2615: Type of property '"each"' circularly references itself in mapped type '{ [P in keyof ListWidget]: undefined extends ListWidget[P] ? never : P; }'. \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderEmitBeforeCheck(checkorder=isolated).errors.txt b/tsc/testdata/baselines/reference/compiler/checkOrderEmitBeforeCheck(checkorder=isolated).errors.txt index c220c7e1092af..81bd46c132406 100644 --- a/tsc/testdata/baselines/reference/compiler/checkOrderEmitBeforeCheck(checkorder=isolated).errors.txt +++ b/tsc/testdata/baselines/reference/compiler/checkOrderEmitBeforeCheck(checkorder=isolated).errors.txt @@ -1,5 +1,5 @@ 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 '{ [P in keyof ListWidget]: undefined extends ListWidget[P] ? never : P; }'. +checkOrderEmitBeforeCheck.ts(9,13): error TS2615: Type of property '"each"' circularly references itself in mapped type '{ type: "type"; each: any; }'. ==== checkOrderEmitBeforeCheck.ts (2 errors) ==== @@ -15,7 +15,7 @@ checkOrderEmitBeforeCheck.ts(9,13): error TS2615: Type of property '"each"' circ ~~~~~~ !!! 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 '{ [P in keyof ListWidget]: undefined extends ListWidget[P] ? never : P; }'. +!!! error TS2615: Type of property '"each"' circularly references itself in mapped type '{ type: "type"; each: any; }'. } type ListChild = Child diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=default).js b/tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=default).js index 433d0bfbb69b5..8d70e46a3bf67 100644 --- a/tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=default).js +++ b/tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=default).js @@ -57,7 +57,10 @@ module.exports = { v: { ...M } }; //// [xb.d.ts] declare const _exports: { - v: {}; + v: { + pa: {}; + ma: 1; + }; }; export = _exports; //// [mb.d.ts] @@ -65,10 +68,7 @@ export { v as pb } from "./xb"; export declare const mb = 1; //// [xa.d.ts] declare const _exports: { - v: { - pb: {}; - mb: 1; - }; + v: {}; }; export = _exports; //// [ma.d.ts] @@ -77,10 +77,7 @@ export declare const ma = 1; //// [ia.d.ts] declare const _exports: { v: { - pa: { - pb: {}; - mb: 1; - }; + pa: {}; ma: 1; }; }; diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=default).types index 216ad9304dfd7..b82d88007b600 100644 --- a/tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=default).types +++ b/tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=default).types @@ -7,19 +7,19 @@ const M = /** @type {any} */ (null); >(null) : any module.exports = { v: { ...M } }; ->module.exports = { v: { ...M } } : { 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; }; } ->{ v: { ...M } } : { v: { pa: { pb: {}; mb: 1; }; ma: 1; }; } ->v : { pa: { pb: {}; mb: 1; }; ma: 1; } ->{ ...M } : { pa: { pb: {}; mb: 1; }; ma: 1; } +>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 : { pb: {}; mb: 1; } ->pa : { pb: {}; mb: 1; } +>v : {} +>pa : {} export const ma = 1; >ma : 1 @@ -27,8 +27,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 @@ -41,13 +41,13 @@ const M = /** @type {any} */ (null); >(null) : any module.exports = { v: { ...M } }; ->module.exports = { v: { ...M } } : { v: { pb: {}; mb: 1; }; } ->module.exports : { v: { pb: {}; mb: 1; }; } ->module : { exports: { v: { pb: {}; mb: 1; }; }; } ->exports : { v: { pb: {}; mb: 1; }; } ->{ v: { ...M } } : { v: { pb: {}; mb: 1; }; } ->v : { pb: {}; mb: 1; } ->{ ...M } : { pb: {}; mb: 1; } +>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 === @@ -57,12 +57,12 @@ const M = /** @type {any} */ (null); >(null) : any module.exports = { v: { ...M } }; ->module.exports = { v: { ...M } } : { v: {}; } ->module.exports : { v: {}; } ->module : { exports: { v: {}; }; } ->exports : { v: {}; } ->{ v: { ...M } } : { v: {}; } ->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 index 8621be455c50d..8d70e46a3bf67 100644 --- a/tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=isolated).js +++ b/tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=isolated).js @@ -56,13 +56,20 @@ module.exports = { v: { ...M } }; //// [xb.d.ts] -declare const _exports: any; +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: any; +declare const _exports: { + v: {}; +}; export = _exports; //// [ma.d.ts] export { v as pa } from "./xa"; @@ -70,10 +77,7 @@ export declare const ma = 1; //// [ia.d.ts] declare const _exports: { v: { - pa: { - pb: {}; - mb: 1; - }; + pa: {}; ma: 1; }; }; diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=isolated).types b/tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=isolated).types index 216ad9304dfd7..b82d88007b600 100644 --- a/tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=isolated).types +++ b/tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=isolated).types @@ -7,19 +7,19 @@ const M = /** @type {any} */ (null); >(null) : any module.exports = { v: { ...M } }; ->module.exports = { v: { ...M } } : { 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; }; } ->{ v: { ...M } } : { v: { pa: { pb: {}; mb: 1; }; ma: 1; }; } ->v : { pa: { pb: {}; mb: 1; }; ma: 1; } ->{ ...M } : { pa: { pb: {}; mb: 1; }; ma: 1; } +>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 : { pb: {}; mb: 1; } ->pa : { pb: {}; mb: 1; } +>v : {} +>pa : {} export const ma = 1; >ma : 1 @@ -27,8 +27,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 @@ -41,13 +41,13 @@ const M = /** @type {any} */ (null); >(null) : any module.exports = { v: { ...M } }; ->module.exports = { v: { ...M } } : { v: { pb: {}; mb: 1; }; } ->module.exports : { v: { pb: {}; mb: 1; }; } ->module : { exports: { v: { pb: {}; mb: 1; }; }; } ->exports : { v: { pb: {}; mb: 1; }; } ->{ v: { ...M } } : { v: { pb: {}; mb: 1; }; } ->v : { pb: {}; mb: 1; } ->{ ...M } : { pb: {}; mb: 1; } +>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 === @@ -57,12 +57,12 @@ const M = /** @type {any} */ (null); >(null) : any module.exports = { v: { ...M } }; ->module.exports = { v: { ...M } } : { v: {}; } ->module.exports : { v: {}; } ->module : { exports: { v: {}; }; } ->exports : { v: {}; } ->{ v: { ...M } } : { v: {}; } ->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 index 433d0bfbb69b5..8d70e46a3bf67 100644 --- a/tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=reverse).js +++ b/tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=reverse).js @@ -57,7 +57,10 @@ module.exports = { v: { ...M } }; //// [xb.d.ts] declare const _exports: { - v: {}; + v: { + pa: {}; + ma: 1; + }; }; export = _exports; //// [mb.d.ts] @@ -65,10 +68,7 @@ export { v as pb } from "./xb"; export declare const mb = 1; //// [xa.d.ts] declare const _exports: { - v: { - pb: {}; - mb: 1; - }; + v: {}; }; export = _exports; //// [ma.d.ts] @@ -77,10 +77,7 @@ export declare const ma = 1; //// [ia.d.ts] declare const _exports: { v: { - pa: { - pb: {}; - mb: 1; - }; + pa: {}; ma: 1; }; }; diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=reverse).types b/tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=reverse).types index 216ad9304dfd7..b82d88007b600 100644 --- a/tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=reverse).types +++ b/tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=reverse).types @@ -7,19 +7,19 @@ const M = /** @type {any} */ (null); >(null) : any module.exports = { v: { ...M } }; ->module.exports = { v: { ...M } } : { 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; }; } ->{ v: { ...M } } : { v: { pa: { pb: {}; mb: 1; }; ma: 1; }; } ->v : { pa: { pb: {}; mb: 1; }; ma: 1; } ->{ ...M } : { pa: { pb: {}; mb: 1; }; ma: 1; } +>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 : { pb: {}; mb: 1; } ->pa : { pb: {}; mb: 1; } +>v : {} +>pa : {} export const ma = 1; >ma : 1 @@ -27,8 +27,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 @@ -41,13 +41,13 @@ const M = /** @type {any} */ (null); >(null) : any module.exports = { v: { ...M } }; ->module.exports = { v: { ...M } } : { v: { pb: {}; mb: 1; }; } ->module.exports : { v: { pb: {}; mb: 1; }; } ->module : { exports: { v: { pb: {}; mb: 1; }; }; } ->exports : { v: { pb: {}; mb: 1; }; } ->{ v: { ...M } } : { v: { pb: {}; mb: 1; }; } ->v : { pb: {}; mb: 1; } ->{ ...M } : { pb: {}; mb: 1; } +>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 === @@ -57,12 +57,12 @@ const M = /** @type {any} */ (null); >(null) : any module.exports = { v: { ...M } }; ->module.exports = { v: { ...M } } : { v: {}; } ->module.exports : { v: {}; } ->module : { exports: { v: {}; }; } ->exports : { v: {}; } ->{ v: { ...M } } : { v: {}; } ->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 index 433d0bfbb69b5..8d70e46a3bf67 100644 --- a/tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=typesfirst).js +++ b/tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=typesfirst).js @@ -57,7 +57,10 @@ module.exports = { v: { ...M } }; //// [xb.d.ts] declare const _exports: { - v: {}; + v: { + pa: {}; + ma: 1; + }; }; export = _exports; //// [mb.d.ts] @@ -65,10 +68,7 @@ export { v as pb } from "./xb"; export declare const mb = 1; //// [xa.d.ts] declare const _exports: { - v: { - pb: {}; - mb: 1; - }; + v: {}; }; export = _exports; //// [ma.d.ts] @@ -77,10 +77,7 @@ export declare const ma = 1; //// [ia.d.ts] declare const _exports: { v: { - pa: { - pb: {}; - mb: 1; - }; + pa: {}; ma: 1; }; }; diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=typesfirst).types index 216ad9304dfd7..b82d88007b600 100644 --- a/tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=typesfirst).types +++ b/tsc/testdata/baselines/reference/compiler/checkOrderSpreadCycle(checkorder=typesfirst).types @@ -7,19 +7,19 @@ const M = /** @type {any} */ (null); >(null) : any module.exports = { v: { ...M } }; ->module.exports = { v: { ...M } } : { 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; }; } ->{ v: { ...M } } : { v: { pa: { pb: {}; mb: 1; }; ma: 1; }; } ->v : { pa: { pb: {}; mb: 1; }; ma: 1; } ->{ ...M } : { pa: { pb: {}; mb: 1; }; ma: 1; } +>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 : { pb: {}; mb: 1; } ->pa : { pb: {}; mb: 1; } +>v : {} +>pa : {} export const ma = 1; >ma : 1 @@ -27,8 +27,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 @@ -41,13 +41,13 @@ const M = /** @type {any} */ (null); >(null) : any module.exports = { v: { ...M } }; ->module.exports = { v: { ...M } } : { v: { pb: {}; mb: 1; }; } ->module.exports : { v: { pb: {}; mb: 1; }; } ->module : { exports: { v: { pb: {}; mb: 1; }; }; } ->exports : { v: { pb: {}; mb: 1; }; } ->{ v: { ...M } } : { v: { pb: {}; mb: 1; }; } ->v : { pb: {}; mb: 1; } ->{ ...M } : { pb: {}; mb: 1; } +>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 === @@ -57,12 +57,12 @@ const M = /** @type {any} */ (null); >(null) : any module.exports = { v: { ...M } }; ->module.exports = { v: { ...M } } : { v: {}; } ->module.exports : { v: {}; } ->module : { exports: { v: {}; }; } ->exports : { v: {}; } ->{ v: { ...M } } : { v: {}; } ->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 index 735d4e676a17d..a547413430b10 100644 --- a/tsc/testdata/baselines/reference/compiler/checkOrderStableInstantiationErrors(checkorder=default).errors.txt +++ b/tsc/testdata/baselines/reference/compiler/checkOrderStableInstantiationErrors(checkorder=default).errors.txt @@ -1,4 +1,7 @@ +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) ==== @@ -9,15 +12,21 @@ a.ts(2,15): error TS2589: Type instantiation is excessively deep and possibly in export type Recur = N extends 0 ? S : Recur, `${S}_${S}`>; -==== a.ts (1 errors) ==== +==== 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 (0 errors) ==== +==== 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 { diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderStableInstantiationErrors(checkorder=reverse).errors.txt b/tsc/testdata/baselines/reference/compiler/checkOrderStableInstantiationErrors(checkorder=reverse).errors.txt index 6e370b78d30f9..a547413430b10 100644 --- a/tsc/testdata/baselines/reference/compiler/checkOrderStableInstantiationErrors(checkorder=reverse).errors.txt +++ b/tsc/testdata/baselines/reference/compiler/checkOrderStableInstantiationErrors(checkorder=reverse).errors.txt @@ -1,3 +1,6 @@ +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. @@ -9,13 +12,19 @@ b.ts(2,15): error TS2589: Type instantiation is excessively deep and possibly in export type Recur = N extends 0 ? S : Recur, `${S}_${S}`>; -==== a.ts (0 errors) ==== +==== 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 (1 errors) ==== +==== 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. diff --git a/tsc/testdata/baselines/reference/compiler/checkOrderStableInstantiationErrors(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/checkOrderStableInstantiationErrors(checkorder=typesfirst).errors.txt index 9b99a0b62969b..a547413430b10 100644 --- a/tsc/testdata/baselines/reference/compiler/checkOrderStableInstantiationErrors(checkorder=typesfirst).errors.txt +++ b/tsc/testdata/baselines/reference/compiler/checkOrderStableInstantiationErrors(checkorder=typesfirst).errors.txt @@ -1,7 +1,9 @@ -error TS2589: Type instantiation is excessively deep and possibly infinite. +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. -!!! 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 : @@ -10,13 +12,21 @@ error TS2589: Type instantiation is excessively deep and possibly infinite. export type Recur = N extends 0 ? S : Recur, `${S}_${S}`>; -==== a.ts (0 errors) ==== +==== 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 (0 errors) ==== +==== 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 { diff --git a/tsc/testdata/baselines/reference/compiler/circularAccessorAnnotations(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/circularAccessorAnnotations(checkorder=typesfirst).types index e6b4d1fca90ca..2b01358a33dca 100644 --- a/tsc/testdata/baselines/reference/compiler/circularAccessorAnnotations(checkorder=typesfirst).types +++ b/tsc/testdata/baselines/reference/compiler/circularAccessorAnnotations(checkorder=typesfirst).types @@ -2,23 +2,23 @@ === circularAccessorAnnotations.ts === declare const c1: { ->c1 : { readonly foo: any; } +>c1 : { readonly foo: typeof c1.foo; } get foo(): typeof c1.foo; >foo : any >c1.foo : any ->c1 : { readonly foo: any; } +>c1 : { readonly foo: typeof c1.foo; } >foo : any } declare const c2: { ->c2 : { foo: any; } +>c2 : { foo: typeof c2.foo; } set foo(value: typeof c2.foo); >foo : any >value : any >c2.foo : any ->c2 : { foo: any; } +>c2 : { foo: typeof c2.foo; } >foo : any } diff --git a/tsc/testdata/baselines/reference/compiler/circularIndexedPropertyInstantiation.errors.txt b/tsc/testdata/baselines/reference/compiler/circularIndexedPropertyInstantiation.errors.txt index 3322a7ea25b66..1d225438007a0 100644 --- a/tsc/testdata/baselines/reference/compiler/circularIndexedPropertyInstantiation.errors.txt +++ b/tsc/testdata/baselines/reference/compiler/circularIndexedPropertyInstantiation.errors.txt @@ -1,12 +1,15 @@ +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 (2 errors) ==== +==== 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", {}>; diff --git a/tsc/testdata/baselines/reference/compiler/circularInlineMappedGenericTupleTypeNoCrash(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/circularInlineMappedGenericTupleTypeNoCrash(checkorder=default).errors.txt index 8d568d19a5373..61ac052a41c80 100644 --- a/tsc/testdata/baselines/reference/compiler/circularInlineMappedGenericTupleTypeNoCrash(checkorder=default).errors.txt +++ b/tsc/testdata/baselines/reference/compiler/circularInlineMappedGenericTupleTypeNoCrash(checkorder=default).errors.txt @@ -1,7 +1,8 @@ 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 (1 errors) ==== +==== circularInlineMappedGenericTupleTypeNoCrash.ts (2 errors) ==== class Foo { public readonly elements: { [P in keyof Elements]: { bar: Elements[P] } }; @@ -14,6 +15,8 @@ circularInlineMappedGenericTupleTypeNoCrash.ts(11,12): error TS2589: Type instan 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. } } diff --git a/tsc/testdata/baselines/reference/compiler/circularInlineMappedGenericTupleTypeNoCrash(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/circularInlineMappedGenericTupleTypeNoCrash(checkorder=typesfirst).errors.txt index 8d568d19a5373..61ac052a41c80 100644 --- a/tsc/testdata/baselines/reference/compiler/circularInlineMappedGenericTupleTypeNoCrash(checkorder=typesfirst).errors.txt +++ b/tsc/testdata/baselines/reference/compiler/circularInlineMappedGenericTupleTypeNoCrash(checkorder=typesfirst).errors.txt @@ -1,7 +1,8 @@ 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 (1 errors) ==== +==== circularInlineMappedGenericTupleTypeNoCrash.ts (2 errors) ==== class Foo { public readonly elements: { [P in keyof Elements]: { bar: Elements[P] } }; @@ -14,6 +15,8 @@ circularInlineMappedGenericTupleTypeNoCrash.ts(11,12): error TS2589: Type instan 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. } } diff --git a/tsc/testdata/baselines/reference/compiler/circularReturnTypeSubtypeReductionOrder.errors.txt b/tsc/testdata/baselines/reference/compiler/circularReturnTypeSubtypeReductionOrder.errors.txt index f0b2f978c0228..b93093c154d7d 100644 --- a/tsc/testdata/baselines/reference/compiler/circularReturnTypeSubtypeReductionOrder.errors.txt +++ b/tsc/testdata/baselines/reference/compiler/circularReturnTypeSubtypeReductionOrder.errors.txt @@ -1,10 +1,12 @@ 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 '() => () => A | A' is not assignable to type 'A'. + 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 (1 errors) ==== +==== 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 @@ -19,11 +21,15 @@ expression.ts(10,7): error TS2322: Type 'typeof A' is not assignable to type 'ne !!! 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 '() => () => A | A' is not assignable to type 'A'. +!!! 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() { diff --git a/tsc/testdata/baselines/reference/compiler/circularReturnTypeSubtypeReductionOrder.types b/tsc/testdata/baselines/reference/compiler/circularReturnTypeSubtypeReductionOrder.types index 9088517456379..a44fd2123e1c2 100644 --- a/tsc/testdata/baselines/reference/compiler/circularReturnTypeSubtypeReductionOrder.types +++ b/tsc/testdata/baselines/reference/compiler/circularReturnTypeSubtypeReductionOrder.types @@ -20,7 +20,7 @@ const A: new () => A = class { >class { rebuild() { return flag ? this : new A(); } b() { return this.rebuild(); } c() { return this.rebuild; }} : typeof A rebuild() { ->rebuild : () => this | A +>rebuild : () => any return flag ? this : new A(); >flag ? this : new A() : this | A @@ -30,21 +30,21 @@ const A: new () => A = class { >A : new () => A } b() { ->b : () => this | A +>b : () => any return this.rebuild(); ->this.rebuild() : this | A ->this.rebuild : () => this | A +>this.rebuild() : any +>this.rebuild : () => any >this : this ->rebuild : () => this | A +>rebuild : () => any } c() { ->c : () => () => this | A +>c : () => () => any return this.rebuild; ->this.rebuild : () => this | A +>this.rebuild : () => any >this : this ->rebuild : () => this | A +>rebuild : () => any } }; export {}; @@ -61,23 +61,23 @@ class K { >K : K rebuild() { ->rebuild : () => this | B +>rebuild : () => B return flag ? this : new B(); ->flag ? this : new B() : this | B +>flag ? this : new B() : B >flag : boolean >this : this >new B() : B >B : new () => B } b() { ->b : () => this | B +>b : () => B return this.rebuild(); ->this.rebuild() : this | B ->this.rebuild : () => this | B +>this.rebuild() : B +>this.rebuild : () => B >this : this ->rebuild : () => this | B +>rebuild : () => B } } const B: new () => B = K; diff --git a/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallbackArgument(strict=false).errors.txt b/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallbackArgument(strict=false).errors.txt new file mode 100644 index 0000000000000..3c7a84d051ca9 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallbackArgument(strict=false).errors.txt @@ -0,0 +1,38 @@ +circularReturnTypeThroughCallbackArgument.ts(23,25): error TS2322: Type 'Promise' is not assignable to type 'Promise'. + Type 'Other | Result' is not assignable to type 'Result'. + Type 'Other' is not assignable to type 'Result'. + Index signature for type 'string' is missing in type 'Other'. + + +==== circularReturnTypeThroughCallbackArgument.ts (1 errors) ==== + 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)); + ~~~~~~~~ +!!! error TS2322: Type 'Promise' is not assignable to type 'Promise'. +!!! error TS2322: Type 'Other | Result' is not assignable to type 'Result'. +!!! error TS2322: Type 'Other' is not assignable to type 'Result'. +!!! error TS2322: Index signature for type 'string' is missing in type 'Other'. +!!! related TS6502 circularReturnTypeThroughCallbackArgument.ts:18:38: The expected type comes from the return type of this signature. + } + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallbackArgument(strict=false).types b/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallbackArgument(strict=false).types index fb9e85bf2b1d7..c3e8f0316281f 100644 --- a/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallbackArgument(strict=false).types +++ b/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallbackArgument(strict=false).types @@ -6,15 +6,15 @@ declare function fan(g: () => number): number; >g : () => number export function a(n: number) { ->a : (n: number) => any +>a : (n: number) => number >n : number return fan(() => a(n)); >fan(() => a(n)) : number >fan : (g: () => number) => number ->() => a(n) : () => any ->a(n) : any ->a : (n: number) => any +>() => a(n) : () => number +>a(n) : number +>a : (n: number) => number >n : number } @@ -25,7 +25,7 @@ declare function fanAll(g: () => Promise<{ ok: boolean }>): Promise<{ ok: boolea >ok : boolean export async function b(n: number) { ->b : (n: number) => any +>b : (n: number) => Promise<{ ok: boolean; }> >n : number if (n > 0) { @@ -36,9 +36,9 @@ export async function b(n: number) { 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 +>() => b(n - 1) : () => Promise<{ ok: boolean; }> +>b(n - 1) : Promise<{ ok: boolean; }> +>b : (n: number) => Promise<{ ok: boolean; }> >n - 1 : number >n : number >1 : 1 @@ -66,7 +66,7 @@ declare const other: Other; >other : Other export async function c(n: number) { ->c : (n: number) => any +>c : (n: number) => Promise >n : number if (n) return other; @@ -76,9 +76,9 @@ export async function c(n: number) { 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 +>() => c(n - 1) : () => Promise +>c(n - 1) : Promise +>c : (n: number) => Promise >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 index a10fc6bcbe59c..3c7a84d051ca9 100644 --- a/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallbackArgument(strict=true).errors.txt +++ b/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallbackArgument(strict=true).errors.txt @@ -1,31 +1,21 @@ -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(23,25): error TS2322: Type 'Promise' is not assignable to type 'Promise'. + Type 'Other | Result' is not assignable to type 'Result'. + Type 'Other' is not assignable to type 'Result'. + Index signature for type 'string' is missing in type 'Other'. -==== circularReturnTypeThroughCallbackArgument.ts (6 errors) ==== +==== circularReturnTypeThroughCallbackArgument.ts (1 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 }; } @@ -36,11 +26,13 @@ circularReturnTypeThroughCallbackArgument.ts(23,19): error TS7024: Function impl 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. + ~~~~~~~~ +!!! error TS2322: Type 'Promise' is not assignable to type 'Promise'. +!!! error TS2322: Type 'Other | Result' is not assignable to type 'Result'. +!!! error TS2322: Type 'Other' is not assignable to type 'Result'. +!!! error TS2322: Index signature for type 'string' is missing in type 'Other'. +!!! related TS6502 circularReturnTypeThroughCallbackArgument.ts:18:38: The expected type comes from the return type of this signature. } \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallbackArgument(strict=true).types b/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallbackArgument(strict=true).types index fb9e85bf2b1d7..c3e8f0316281f 100644 --- a/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallbackArgument(strict=true).types +++ b/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallbackArgument(strict=true).types @@ -6,15 +6,15 @@ declare function fan(g: () => number): number; >g : () => number export function a(n: number) { ->a : (n: number) => any +>a : (n: number) => number >n : number return fan(() => a(n)); >fan(() => a(n)) : number >fan : (g: () => number) => number ->() => a(n) : () => any ->a(n) : any ->a : (n: number) => any +>() => a(n) : () => number +>a(n) : number +>a : (n: number) => number >n : number } @@ -25,7 +25,7 @@ declare function fanAll(g: () => Promise<{ ok: boolean }>): Promise<{ ok: boolea >ok : boolean export async function b(n: number) { ->b : (n: number) => any +>b : (n: number) => Promise<{ ok: boolean; }> >n : number if (n > 0) { @@ -36,9 +36,9 @@ export async function b(n: number) { 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 +>() => b(n - 1) : () => Promise<{ ok: boolean; }> +>b(n - 1) : Promise<{ ok: boolean; }> +>b : (n: number) => Promise<{ ok: boolean; }> >n - 1 : number >n : number >1 : 1 @@ -66,7 +66,7 @@ declare const other: Other; >other : Other export async function c(n: number) { ->c : (n: number) => any +>c : (n: number) => Promise >n : number if (n) return other; @@ -76,9 +76,9 @@ export async function c(n: number) { 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 +>() => c(n - 1) : () => Promise +>c(n - 1) : Promise +>c : (n: number) => Promise >n - 1 : number >n : number >1 : 1 diff --git a/tsc/testdata/baselines/reference/compiler/circularScopeThunkReverseMapped(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/circularScopeThunkReverseMapped(checkorder=default).errors.txt new file mode 100644 index 0000000000000..495583f737e9e --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/circularScopeThunkReverseMapped(checkorder=default).errors.txt @@ -0,0 +1,40 @@ +circularScopeThunkReverseMapped.ts(12,14): error TS7022: '$' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. +circularScopeThunkReverseMapped.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. +circularScopeThunkReverseMapped.ts(14,41): error TS7006: Parameter 'n' implicitly has an 'any' type. +circularScopeThunkReverseMapped.ts(18,14): error TS7022: '$2' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. +circularScopeThunkReverseMapped.ts(20,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. + + +==== circularScopeThunkReverseMapped.ts (5 errors) ==== + 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({ + ~ +!!! error TS7022: '$' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. + a: type("string").pipe(function (s) { return s.length; }), + b: () => $.type("a").pipe(function (n) { return n === 0; }), + ~ +!!! 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. + ~ +!!! error TS7006: Parameter 'n' implicitly has an 'any' type. + }); + + // Entered from the function in the first property when queried in reverse + export const $2 = scope({ + ~~ +!!! error TS7022: '$2' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. + a: type("string").pipe(function (s) { return s.length; }), + b: () => $2.type("a").pipe((n: number) => n === 0), + ~ +!!! 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. + }); + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/circularScopeThunkReverseMapped(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/circularScopeThunkReverseMapped(checkorder=default).symbols index cefed83354abf..162296d91ea40 100644 --- a/tsc/testdata/baselines/reference/compiler/circularScopeThunkReverseMapped(checkorder=default).symbols +++ b/tsc/testdata/baselines/reference/compiler/circularScopeThunkReverseMapped(checkorder=default).symbols @@ -82,11 +82,7 @@ export const $ = scope({ 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)) @@ -109,11 +105,7 @@ export const $2 = scope({ 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 index 6edac2ffefa43..cd86ca9ddbbf9 100644 --- a/tsc/testdata/baselines/reference/compiler/circularScopeThunkReverseMapped(checkorder=default).types +++ b/tsc/testdata/baselines/reference/compiler/circularScopeThunkReverseMapped(checkorder=default).types @@ -27,10 +27,10 @@ declare function type(x: T): Type; >x : T export const $ = scope({ ->$ : Scope<{ readonly a: Type; readonly b: () => Type; }> ->scope({ a: type("string").pipe(function (s) { return s.length; }), b: () => $.type("a").pipe(function (n) { return n === 0; }),}) : Scope<{ readonly a: Type; readonly b: () => Type; }> +>$ : any +>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: () => any; }> >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; }), b: () => $.type("a").pipe(function (n) { return n === 0; }),} : { a: Type; b: () => any; } a: type("string").pipe(function (s) { return s.length; }), >a : Type @@ -47,30 +47,30 @@ export const $ = scope({ >length : number b: () => $.type("a").pipe(function (n) { return n === 0; }), ->b : () => Type ->() => $.type("a").pipe(function (n) { return n === 0; }) : () => Type ->$.type("a").pipe(function (n) { return n === 0; }) : Type ->$.type("a").pipe : (f: (x: number) => U) => Type ->$.type("a") : Type ->$.type : (k: k_1) => Resolve<{ readonly a: Type; readonly b: () => Type; }[k_1]> ->$ : Scope<{ readonly a: Type; readonly b: () => Type; }> ->type : (k: k_1) => Resolve<{ readonly a: Type; readonly b: () => Type; }[k_1]> +>b : () => any +>() => $.type("a").pipe(function (n) { return n === 0; }) : () => any +>$.type("a").pipe(function (n) { return n === 0; }) : any +>$.type("a").pipe : any +>$.type("a") : any +>$.type : any +>$ : any +>type : any >"a" : "a" ->pipe : (f: (x: number) => U) => Type ->function (n) { return n === 0; } : (n: number) => n is 0 ->n : number +>pipe : any +>function (n) { return n === 0; } : (n: any) => boolean +>n : any >n === 0 : boolean ->n : number +>n : any >0 : 0 }); // Entered from the function in the first property when queried in reverse export const $2 = scope({ ->$2 : Scope<{ readonly a: Type; readonly b: () => Type; }> ->scope({ a: type("string").pipe(function (s) { return s.length; }), b: () => $2.type("a").pipe((n: number) => n === 0),}) : Scope<{ readonly a: Type; readonly b: () => Type; }> +>$2 : any +>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: () => any; }> >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; }), b: () => $2.type("a").pipe((n: number) => n === 0),} : { a: Type; b: () => any; } a: type("string").pipe(function (s) { return s.length; }), >a : Type @@ -87,16 +87,16 @@ export const $2 = scope({ >length : number b: () => $2.type("a").pipe((n: number) => n === 0), ->b : () => Type ->() => $2.type("a").pipe((n: number) => n === 0) : () => Type ->$2.type("a").pipe((n: number) => n === 0) : Type ->$2.type("a").pipe : (f: (x: number) => U) => Type ->$2.type("a") : Type ->$2.type : (k: k_1) => Resolve<{ readonly a: Type; readonly b: () => Type; }[k_1]> ->$2 : Scope<{ readonly a: Type; readonly b: () => Type; }> ->type : (k: k_1) => Resolve<{ readonly a: Type; readonly b: () => Type; }[k_1]> +>b : () => any +>() => $2.type("a").pipe((n: number) => n === 0) : () => any +>$2.type("a").pipe((n: number) => n === 0) : any +>$2.type("a").pipe : any +>$2.type("a") : any +>$2.type : any +>$2 : any +>type : any >"a" : "a" ->pipe : (f: (x: number) => U) => Type +>pipe : any >(n: number) => n === 0 : (n: number) => n is 0 >n : number >n === 0 : boolean diff --git a/tsc/testdata/baselines/reference/compiler/circularScopeThunkReverseMapped(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/circularScopeThunkReverseMapped(checkorder=typesfirst).errors.txt new file mode 100644 index 0000000000000..495583f737e9e --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/circularScopeThunkReverseMapped(checkorder=typesfirst).errors.txt @@ -0,0 +1,40 @@ +circularScopeThunkReverseMapped.ts(12,14): error TS7022: '$' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. +circularScopeThunkReverseMapped.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. +circularScopeThunkReverseMapped.ts(14,41): error TS7006: Parameter 'n' implicitly has an 'any' type. +circularScopeThunkReverseMapped.ts(18,14): error TS7022: '$2' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. +circularScopeThunkReverseMapped.ts(20,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. + + +==== circularScopeThunkReverseMapped.ts (5 errors) ==== + 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({ + ~ +!!! error TS7022: '$' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. + a: type("string").pipe(function (s) { return s.length; }), + b: () => $.type("a").pipe(function (n) { return n === 0; }), + ~ +!!! 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. + ~ +!!! error TS7006: Parameter 'n' implicitly has an 'any' type. + }); + + // Entered from the function in the first property when queried in reverse + export const $2 = scope({ + ~~ +!!! error TS7022: '$2' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. + a: type("string").pipe(function (s) { return s.length; }), + b: () => $2.type("a").pipe((n: number) => n === 0), + ~ +!!! 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. + }); + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/circularScopeThunkReverseMapped(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/circularScopeThunkReverseMapped(checkorder=typesfirst).symbols index cefed83354abf..162296d91ea40 100644 --- a/tsc/testdata/baselines/reference/compiler/circularScopeThunkReverseMapped(checkorder=typesfirst).symbols +++ b/tsc/testdata/baselines/reference/compiler/circularScopeThunkReverseMapped(checkorder=typesfirst).symbols @@ -82,11 +82,7 @@ export const $ = scope({ 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)) @@ -109,11 +105,7 @@ export const $2 = scope({ 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 index 6edac2ffefa43..cd86ca9ddbbf9 100644 --- a/tsc/testdata/baselines/reference/compiler/circularScopeThunkReverseMapped(checkorder=typesfirst).types +++ b/tsc/testdata/baselines/reference/compiler/circularScopeThunkReverseMapped(checkorder=typesfirst).types @@ -27,10 +27,10 @@ declare function type(x: T): Type; >x : T export const $ = scope({ ->$ : Scope<{ readonly a: Type; readonly b: () => Type; }> ->scope({ a: type("string").pipe(function (s) { return s.length; }), b: () => $.type("a").pipe(function (n) { return n === 0; }),}) : Scope<{ readonly a: Type; readonly b: () => Type; }> +>$ : any +>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: () => any; }> >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; }), b: () => $.type("a").pipe(function (n) { return n === 0; }),} : { a: Type; b: () => any; } a: type("string").pipe(function (s) { return s.length; }), >a : Type @@ -47,30 +47,30 @@ export const $ = scope({ >length : number b: () => $.type("a").pipe(function (n) { return n === 0; }), ->b : () => Type ->() => $.type("a").pipe(function (n) { return n === 0; }) : () => Type ->$.type("a").pipe(function (n) { return n === 0; }) : Type ->$.type("a").pipe : (f: (x: number) => U) => Type ->$.type("a") : Type ->$.type : (k: k_1) => Resolve<{ readonly a: Type; readonly b: () => Type; }[k_1]> ->$ : Scope<{ readonly a: Type; readonly b: () => Type; }> ->type : (k: k_1) => Resolve<{ readonly a: Type; readonly b: () => Type; }[k_1]> +>b : () => any +>() => $.type("a").pipe(function (n) { return n === 0; }) : () => any +>$.type("a").pipe(function (n) { return n === 0; }) : any +>$.type("a").pipe : any +>$.type("a") : any +>$.type : any +>$ : any +>type : any >"a" : "a" ->pipe : (f: (x: number) => U) => Type ->function (n) { return n === 0; } : (n: number) => n is 0 ->n : number +>pipe : any +>function (n) { return n === 0; } : (n: any) => boolean +>n : any >n === 0 : boolean ->n : number +>n : any >0 : 0 }); // Entered from the function in the first property when queried in reverse export const $2 = scope({ ->$2 : Scope<{ readonly a: Type; readonly b: () => Type; }> ->scope({ a: type("string").pipe(function (s) { return s.length; }), b: () => $2.type("a").pipe((n: number) => n === 0),}) : Scope<{ readonly a: Type; readonly b: () => Type; }> +>$2 : any +>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: () => any; }> >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; }), b: () => $2.type("a").pipe((n: number) => n === 0),} : { a: Type; b: () => any; } a: type("string").pipe(function (s) { return s.length; }), >a : Type @@ -87,16 +87,16 @@ export const $2 = scope({ >length : number b: () => $2.type("a").pipe((n: number) => n === 0), ->b : () => Type ->() => $2.type("a").pipe((n: number) => n === 0) : () => Type ->$2.type("a").pipe((n: number) => n === 0) : Type ->$2.type("a").pipe : (f: (x: number) => U) => Type ->$2.type("a") : Type ->$2.type : (k: k_1) => Resolve<{ readonly a: Type; readonly b: () => Type; }[k_1]> ->$2 : Scope<{ readonly a: Type; readonly b: () => Type; }> ->type : (k: k_1) => Resolve<{ readonly a: Type; readonly b: () => Type; }[k_1]> +>b : () => any +>() => $2.type("a").pipe((n: number) => n === 0) : () => any +>$2.type("a").pipe((n: number) => n === 0) : any +>$2.type("a").pipe : any +>$2.type("a") : any +>$2.type : any +>$2 : any +>type : any >"a" : "a" ->pipe : (f: (x: number) => U) => Type +>pipe : any >(n: number) => n === 0 : (n: number) => n is 0 >n : number >n === 0 : boolean 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/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/contextualReturnTypeInSpreadArgument.js b/tsc/testdata/baselines/reference/compiler/contextualReturnTypeInSpreadArgument.js new file mode 100644 index 0000000000000..ca1d3b91449da --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/contextualReturnTypeInSpreadArgument.js @@ -0,0 +1,36 @@ +//// [tests/cases/compiler/contextualReturnTypeInSpreadArgument.ts] //// + +//// [contextualReturnTypeInSpreadArgument.ts] +enum Kind { A, B } + +interface ItemA { kind: Kind.A; name: string } +interface ItemB { kind: Kind.B; size: number } +type Item = ItemA | ItemB; + +declare function create(options: { items?: () => readonly Item[]; label: string }): void; + +function test(flag: boolean) { + create({ + label: "x", + ...(flag ? {} : { + items: () => [{ kind: Kind.A, name: "a" }], + }), + }); +} + + +//// [contextualReturnTypeInSpreadArgument.js] +"use strict"; +var Kind; +(function (Kind) { + Kind[Kind["A"] = 0] = "A"; + Kind[Kind["B"] = 1] = "B"; +})(Kind || (Kind = {})); +function test(flag) { + create({ + label: "x", + ...(flag ? {} : { + items: () => [{ kind: Kind.A, name: "a" }], + }), + }); +} diff --git a/tsc/testdata/baselines/reference/compiler/contextualReturnTypeInSpreadArgument.symbols b/tsc/testdata/baselines/reference/compiler/contextualReturnTypeInSpreadArgument.symbols new file mode 100644 index 0000000000000..0802a21d1a19b --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/contextualReturnTypeInSpreadArgument.symbols @@ -0,0 +1,59 @@ +//// [tests/cases/compiler/contextualReturnTypeInSpreadArgument.ts] //// + +=== contextualReturnTypeInSpreadArgument.ts === +enum Kind { A, B } +>Kind : Symbol(Kind, Decl(contextualReturnTypeInSpreadArgument.ts, 0, 0)) +>A : Symbol(Kind.A, Decl(contextualReturnTypeInSpreadArgument.ts, 0, 11)) +>B : Symbol(Kind.B, Decl(contextualReturnTypeInSpreadArgument.ts, 0, 14)) + +interface ItemA { kind: Kind.A; name: string } +>ItemA : Symbol(ItemA, Decl(contextualReturnTypeInSpreadArgument.ts, 0, 18)) +>kind : Symbol(ItemA.kind, Decl(contextualReturnTypeInSpreadArgument.ts, 2, 17)) +>Kind : Symbol(Kind, Decl(contextualReturnTypeInSpreadArgument.ts, 0, 0)) +>A : Symbol(Kind.A, Decl(contextualReturnTypeInSpreadArgument.ts, 0, 11)) +>name : Symbol(ItemA.name, Decl(contextualReturnTypeInSpreadArgument.ts, 2, 31)) + +interface ItemB { kind: Kind.B; size: number } +>ItemB : Symbol(ItemB, Decl(contextualReturnTypeInSpreadArgument.ts, 2, 46)) +>kind : Symbol(ItemB.kind, Decl(contextualReturnTypeInSpreadArgument.ts, 3, 17)) +>Kind : Symbol(Kind, Decl(contextualReturnTypeInSpreadArgument.ts, 0, 0)) +>B : Symbol(Kind.B, Decl(contextualReturnTypeInSpreadArgument.ts, 0, 14)) +>size : Symbol(ItemB.size, Decl(contextualReturnTypeInSpreadArgument.ts, 3, 31)) + +type Item = ItemA | ItemB; +>Item : Symbol(Item, Decl(contextualReturnTypeInSpreadArgument.ts, 3, 46)) +>ItemA : Symbol(ItemA, Decl(contextualReturnTypeInSpreadArgument.ts, 0, 18)) +>ItemB : Symbol(ItemB, Decl(contextualReturnTypeInSpreadArgument.ts, 2, 46)) + +declare function create(options: { items?: () => readonly Item[]; label: string }): void; +>create : Symbol(create, Decl(contextualReturnTypeInSpreadArgument.ts, 4, 26)) +>options : Symbol(options, Decl(contextualReturnTypeInSpreadArgument.ts, 6, 24)) +>items : Symbol(items, Decl(contextualReturnTypeInSpreadArgument.ts, 6, 34)) +>Item : Symbol(Item, Decl(contextualReturnTypeInSpreadArgument.ts, 3, 46)) +>label : Symbol(label, Decl(contextualReturnTypeInSpreadArgument.ts, 6, 65)) + +function test(flag: boolean) { +>test : Symbol(test, Decl(contextualReturnTypeInSpreadArgument.ts, 6, 89)) +>flag : Symbol(flag, Decl(contextualReturnTypeInSpreadArgument.ts, 8, 14)) + + create({ +>create : Symbol(create, Decl(contextualReturnTypeInSpreadArgument.ts, 4, 26)) + + label: "x", +>label : Symbol(label, Decl(contextualReturnTypeInSpreadArgument.ts, 9, 12)) + + ...(flag ? {} : { +>flag : Symbol(flag, Decl(contextualReturnTypeInSpreadArgument.ts, 8, 14)) + + items: () => [{ kind: Kind.A, name: "a" }], +>items : Symbol(items, Decl(contextualReturnTypeInSpreadArgument.ts, 11, 25)) +>kind : Symbol(kind, Decl(contextualReturnTypeInSpreadArgument.ts, 12, 27)) +>Kind.A : Symbol(Kind.A, Decl(contextualReturnTypeInSpreadArgument.ts, 0, 11)) +>Kind : Symbol(Kind, Decl(contextualReturnTypeInSpreadArgument.ts, 0, 0)) +>A : Symbol(Kind.A, Decl(contextualReturnTypeInSpreadArgument.ts, 0, 11)) +>name : Symbol(name, Decl(contextualReturnTypeInSpreadArgument.ts, 12, 41)) + + }), + }); +} + diff --git a/tsc/testdata/baselines/reference/compiler/contextualReturnTypeInSpreadArgument.types b/tsc/testdata/baselines/reference/compiler/contextualReturnTypeInSpreadArgument.types new file mode 100644 index 0000000000000..6c1780590bad8 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/contextualReturnTypeInSpreadArgument.types @@ -0,0 +1,63 @@ +//// [tests/cases/compiler/contextualReturnTypeInSpreadArgument.ts] //// + +=== contextualReturnTypeInSpreadArgument.ts === +enum Kind { A, B } +>Kind : Kind +>A : Kind.A +>B : Kind.B + +interface ItemA { kind: Kind.A; name: string } +>kind : Kind.A +>Kind : any +>name : string + +interface ItemB { kind: Kind.B; size: number } +>kind : Kind.B +>Kind : any +>size : number + +type Item = ItemA | ItemB; +>Item : Item + +declare function create(options: { items?: () => readonly Item[]; label: string }): void; +>create : (options: { items?: () => readonly Item[]; label: string; }) => void +>options : { items?: () => readonly Item[]; label: string; } +>items : (() => readonly Item[]) | undefined +>label : string + +function test(flag: boolean) { +>test : (flag: boolean) => void +>flag : boolean + + create({ +>create({ label: "x", ...(flag ? {} : { items: () => [{ kind: Kind.A, name: "a" }], }), }) : void +>create : (options: { items?: () => readonly Item[]; label: string; }) => void +>{ label: "x", ...(flag ? {} : { items: () => [{ kind: Kind.A, name: "a" }], }), } : { label: string; items?: (() => { kind: Kind.A; name: string; }[]) | undefined; } + + label: "x", +>label : string +>"x" : "x" + + ...(flag ? {} : { +>(flag ? {} : { items: () => [{ kind: Kind.A, name: "a" }], }) : {} | { items: () => { kind: Kind.A; name: string; }[]; } +>flag ? {} : { items: () => [{ kind: Kind.A, name: "a" }], } : {} | { items: () => { kind: Kind.A; name: string; }[]; } +>flag : boolean +>{} : {} +>{ items: () => [{ kind: Kind.A, name: "a" }], } : { items: () => { kind: Kind.A; name: string; }[]; } + + items: () => [{ kind: Kind.A, name: "a" }], +>items : () => { kind: Kind.A; name: string; }[] +>() => [{ kind: Kind.A, name: "a" }] : () => { kind: Kind.A; name: string; }[] +>[{ kind: Kind.A, name: "a" }] : { kind: Kind.A; name: string; }[] +>{ kind: Kind.A, name: "a" } : { kind: Kind.A; name: string; } +>kind : Kind.A +>Kind.A : Kind.A +>Kind : typeof Kind +>A : Kind.A +>name : string +>"a" : "a" + + }), + }); +} + diff --git a/tsc/testdata/baselines/reference/compiler/cycleYieldThroughVarianceCheckOrder(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/cycleYieldThroughVarianceCheckOrder(checkorder=default).errors.txt new file mode 100644 index 0000000000000..e4b5adb3ee604 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/cycleYieldThroughVarianceCheckOrder(checkorder=default).errors.txt @@ -0,0 +1,21 @@ +cycleYieldThroughVarianceCheckOrder.ts(6,5): error TS2502: 'p' is referenced directly or indirectly in its own type annotation. + + +==== cycleYieldThroughVarianceCheckOrder.ts (1 errors) ==== + // Resolving the base of E measures the variances of B, which needs the type + // of p, which needs the members of E. Whether p is circular must not depend + // on whether B is checked before the type of arg is queried. + + declare class B { + p: E["p"]; + ~ +!!! error TS2502: 'p' is referenced directly or indirectly in its own type annotation. + } + declare class E extends mix(Base) { + p: number; + } + declare function mix object>(x: T): T; + declare class Base { + constructor(arg?: InstanceType); + } + \ No newline at end of file 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/evolvingArrayReadInLoopCondition.errors.txt b/tsc/testdata/baselines/reference/compiler/evolvingArrayReadInLoopCondition.errors.txt deleted file mode 100644 index 74a594964208d..0000000000000 --- a/tsc/testdata/baselines/reference/compiler/evolvingArrayReadInLoopCondition.errors.txt +++ /dev/null @@ -1,23 +0,0 @@ -evolvingArrayReadInLoopCondition.ts(7,7): error TS7034: Variable 'seen' implicitly has type 'any[]' in some locations where its type cannot be determined. -evolvingArrayReadInLoopCondition.ts(9,10): error TS7005: Variable 'seen' implicitly has an 'any[]' type. - - -==== evolvingArrayReadInLoopCondition.ts (2 errors) ==== - // Narrowing by the condition needs the type of `seen` at the call, which - // depends on the analysis of the loop in progress for that same read. Once - // the loop is analyzed, `seen` is number[] there, so no error should say that - // its type cannot be determined. - - declare const x: number; - const seen = []; - ~~~~ -!!! error TS7034: Variable 'seen' implicitly has type 'any[]' in some locations where its type cannot be determined. - for (let i = 0; i < 3; i++) { - if (!seen.some(s => true)) { - ~~~~ -!!! error TS7005: Variable 'seen' implicitly has an 'any[]' type. - seen.push(x); - } - } - const result = seen; - \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/excessivelyLargeTupleSpread(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/excessivelyLargeTupleSpread(checkorder=typesfirst).errors.txt index 5bb90d57b8a95..6ec6fc6629d8a 100644 --- a/tsc/testdata/baselines/reference/compiler/excessivelyLargeTupleSpread(checkorder=typesfirst).errors.txt +++ b/tsc/testdata/baselines/reference/compiler/excessivelyLargeTupleSpread(checkorder=typesfirst).errors.txt @@ -1,15 +1,17 @@ -error TS2800: Expression produces a tuple type that is too large to represent. +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. -!!! error TS2800: Expression produces a tuple type that is too large to represent. -==== excessivelyLargeTupleSpread.ts (1 errors) ==== +==== 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]; @@ -26,6 +28,8 @@ excessivelyLargeTupleSpread.ts(38,13): error TS2800: Expression produces a tuple 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; diff --git a/tsc/testdata/baselines/reference/compiler/flowLoopTooDeepCheckOrder(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/flowLoopTooDeepCheckOrder(checkorder=default).types index b73df554b7234..1aa8a74fe18dd 100644 --- a/tsc/testdata/baselines/reference/compiler/flowLoopTooDeepCheckOrder(checkorder=default).types +++ b/tsc/testdata/baselines/reference/compiler/flowLoopTooDeepCheckOrder(checkorder=default).types @@ -3355,7 +3355,7 @@ if (isString(w)) { >w : any const narrowed = w; ->narrowed : string ->w : string +>narrowed : any +>w : any } diff --git a/tsc/testdata/baselines/reference/compiler/flowLoopTooDeepCheckOrder(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/flowLoopTooDeepCheckOrder(checkorder=typesfirst).types index b73df554b7234..1aa8a74fe18dd 100644 --- a/tsc/testdata/baselines/reference/compiler/flowLoopTooDeepCheckOrder(checkorder=typesfirst).types +++ b/tsc/testdata/baselines/reference/compiler/flowLoopTooDeepCheckOrder(checkorder=typesfirst).types @@ -3355,7 +3355,7 @@ if (isString(w)) { >w : any const narrowed = w; ->narrowed : string ->w : string +>narrowed : any +>w : any } diff --git a/tsc/testdata/baselines/reference/compiler/incorrectRecursiveMappedTypeConstraint.errors.txt b/tsc/testdata/baselines/reference/compiler/incorrectRecursiveMappedTypeConstraint.errors.txt index 41f682e455f8d..4fc215b0dd52d 100644 --- a/tsc/testdata/baselines/reference/compiler/incorrectRecursiveMappedTypeConstraint.errors.txt +++ b/tsc/testdata/baselines/reference/compiler/incorrectRecursiveMappedTypeConstraint.errors.txt @@ -8,10 +8,8 @@ incorrectRecursiveMappedTypeConstraint.ts(3,5): error TS2365: Operator '+=' cann function sum(n: number, v: T, k: K) { ~~~~~~~~~~~~~~~~~~~~ !!! error TS2313: Type parameter 'T' has a circular constraint. -!!! related TS2751 incorrectRecursiveMappedTypeConstraint.ts:3:10: Circularity originates in type at this location. ~ !!! error TS2313: Type parameter 'P' has a circular constraint. -!!! related TS2751 incorrectRecursiveMappedTypeConstraint.ts:3:10: Circularity originates in type at this location. n += v[k]; ~~~~~~~~~ !!! error TS2365: Operator '+=' cannot be applied to types 'number' and 'T[K]'. diff --git a/tsc/testdata/baselines/reference/compiler/indexSignatureWithIndexedAccessOfDerivedInterface.errors.txt b/tsc/testdata/baselines/reference/compiler/indexSignatureWithIndexedAccessOfDerivedInterface.errors.txt deleted file mode 100644 index b66f2e95879ca..0000000000000 --- a/tsc/testdata/baselines/reference/compiler/indexSignatureWithIndexedAccessOfDerivedInterface.errors.txt +++ /dev/null @@ -1,28 +0,0 @@ -indexSignatureWithIndexedAccessOfDerivedInterface.ts(9,11): error TS2430: Interface 'TokenNode' incorrectly extends interface 'BaseNode'. - Index signature for type 'string' is missing in type 'TokenNode'. - - -==== indexSignatureWithIndexedAccessOfDerivedInterface.ts (1 errors) ==== - // The type of data in TokenNode is assignable to its inherited index - // signature, which mentions it through an indexed access. - - interface BaseNode { - kind: string; - [key: string]: string | TokenNode["data"]; - } - - interface TokenNode extends BaseNode { - ~~~~~~~~~ -!!! error TS2430: Interface 'TokenNode' incorrectly extends interface 'BaseNode'. -!!! error TS2430: Index signature for type 'string' is missing in type 'TokenNode'. - kind: 'token'; - data: TokenData; - } - - interface TokenData { - offset: number; - width: number; - leading_width: number; - trailing_width: number; - } - \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/instantiationCountSharedCheckOrder(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/instantiationCountSharedCheckOrder(checkorder=typesfirst).errors.txt index 0dcf882bf475c..9da9a188af742 100644 --- a/tsc/testdata/baselines/reference/compiler/instantiationCountSharedCheckOrder(checkorder=typesfirst).errors.txt +++ b/tsc/testdata/baselines/reference/compiler/instantiationCountSharedCheckOrder(checkorder=typesfirst).errors.txt @@ -1,8 +1,7 @@ -error TS2589: Type instantiation is excessively deep and possibly infinite. +instantiationCountSharedCheckOrder.ts(10,12): error TS2589: Type instantiation is excessively deep and possibly infinite. -!!! error TS2589: Type instantiation is excessively deep and possibly infinite. -==== instantiationCountSharedCheckOrder.ts (0 errors) ==== +==== instantiationCountSharedCheckOrder.ts (1 errors) ==== // Instantiating Wide<[], "a"> fresh takes over five million instantiations, // which is too many. In program order Rest has already done all but about // two million of them. Whether All takes too many must not depend on which @@ -13,4 +12,6 @@ error TS2589: Type instantiation is excessively deep and possibly infinite. type Wide = N["length"] extends 6 ? [I, J] : { [J2 in K]: Wide<[...N, 0], I, J2> }[K]; type Rest = Wide<[0, 0], "a">; type All = Wide<[], "a">; + ~~~~~~~~~~~~~ +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/instantiationDepthSharedCheckOrder(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/instantiationDepthSharedCheckOrder(checkorder=typesfirst).errors.txt index 083ecdc701b69..848c226ea7dbd 100644 --- a/tsc/testdata/baselines/reference/compiler/instantiationDepthSharedCheckOrder(checkorder=typesfirst).errors.txt +++ b/tsc/testdata/baselines/reference/compiler/instantiationDepthSharedCheckOrder(checkorder=typesfirst).errors.txt @@ -1,8 +1,10 @@ -error TS5114: Instantiations of type 'Deep' appear infinitely circular. +instantiationDepthSharedCheckOrder.ts(7,15): error TS5114: Instantiations of type 'Deep' appear infinitely circular. +instantiationDepthSharedCheckOrder.ts(8,15): error TS5114: Instantiations of type 'Deep' appear infinitely circular. +instantiationDepthSharedCheckOrder.ts(9,15): error TS5114: Instantiations of type 'Deep' appear infinitely circular. +instantiationDepthSharedCheckOrder.ts(10,16): error TS5114: Instantiations of type 'Deep' appear infinitely circular. -!!! error TS5114: Instantiations of type 'Deep' appear infinitely circular. -==== instantiationDepthSharedCheckOrder.ts (0 errors) ==== +==== instantiationDepthSharedCheckOrder.ts (4 errors) ==== // Instantiating Deep<[]> fresh nests 100 instantiations of Deep, which is // too deep. In program order each declaration finds the rest of the chain // already instantiated by the one before it, so none of them nests more @@ -10,7 +12,15 @@ error TS5114: Instantiations of type 'Deep' appear infinitely circular. type Deep = N["length"] extends 100 ? never : Deep<[...N, 0]> | N["length"]; type Deep75 = Deep<[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]>; + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS5114: Instantiations of type 'Deep' appear infinitely circular. type Deep50 = Deep<[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]>; + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS5114: Instantiations of type 'Deep' appear infinitely circular. type Deep25 = Deep<[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]>; + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS5114: Instantiations of type 'Deep' appear infinitely circular. type DeepAll = Deep<[]>; + ~~~~~~~~ +!!! error TS5114: Instantiations of type 'Deep' appear infinitely circular. \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/instantiationStackLimitCheckOrder(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/instantiationStackLimitCheckOrder(checkorder=default).errors.txt index cda46ad3a724f..469631d6d5bdf 100644 --- a/tsc/testdata/baselines/reference/compiler/instantiationStackLimitCheckOrder(checkorder=default).errors.txt +++ b/tsc/testdata/baselines/reference/compiler/instantiationStackLimitCheckOrder(checkorder=default).errors.txt @@ -1,8 +1,9 @@ instantiationStackLimitCheckOrder.ts(6,48): error TS5114: Instantiations of type 'F' appear infinitely circular. +instantiationStackLimitCheckOrder.ts(7,10): error TS5114: Instantiations of type 'F' appear infinitely circular. instantiationStackLimitCheckOrder.ts(14,11): error TS5114: Instantiations of type 'FlatArray' appear infinitely circular. -==== instantiationStackLimitCheckOrder.ts (2 errors) ==== +==== instantiationStackLimitCheckOrder.ts (3 errors) ==== // F<[]> recurses forever, so instantiating it reaches the limit on the // instantiation stack, wherever it is first instantiated. The instantiations // in progress then fail as a whole, and none of them may be cached partly @@ -12,6 +13,8 @@ instantiationStackLimitCheckOrder.ts(14,11): error TS5114: Instantiations of typ ~~~~~~~~~~~~ !!! error TS5114: Instantiations of type 'F' appear infinitely circular. type X = F<[]>; + ~~~~~ +!!! error TS5114: Instantiations of type 'F' appear infinitely circular. // The element type of A[] is resolved whenever first needed, inside the // instantiation of the return type of flat or not. Reaching the limit while diff --git a/tsc/testdata/baselines/reference/compiler/instantiationStackLimitCheckOrder(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/instantiationStackLimitCheckOrder(checkorder=default).types index 8e3cbd6baf4b9..0731d655cd19a 100644 --- a/tsc/testdata/baselines/reference/compiler/instantiationStackLimitCheckOrder(checkorder=default).types +++ b/tsc/testdata/baselines/reference/compiler/instantiationStackLimitCheckOrder(checkorder=default).types @@ -10,7 +10,7 @@ type F = T extends [unknown?, ...infer R] ? [0, ...F] : []; >F : F type X = F<[]>; ->X : [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ...any[]] +>X : [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ...any[]] // The element type of A[] is resolved whenever first needed, inside the // instantiation of the return type of flat or not. Reaching the limit while diff --git a/tsc/testdata/baselines/reference/compiler/instantiationStackLimitCheckOrder(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/instantiationStackLimitCheckOrder(checkorder=typesfirst).errors.txt index aaa7aed71c5bf..469631d6d5bdf 100644 --- a/tsc/testdata/baselines/reference/compiler/instantiationStackLimitCheckOrder(checkorder=typesfirst).errors.txt +++ b/tsc/testdata/baselines/reference/compiler/instantiationStackLimitCheckOrder(checkorder=typesfirst).errors.txt @@ -1,16 +1,20 @@ -error TS5114: Instantiations of type 'F' appear infinitely circular. +instantiationStackLimitCheckOrder.ts(6,48): error TS5114: Instantiations of type 'F' appear infinitely circular. +instantiationStackLimitCheckOrder.ts(7,10): error TS5114: Instantiations of type 'F' appear infinitely circular. instantiationStackLimitCheckOrder.ts(14,11): error TS5114: Instantiations of type 'FlatArray' appear infinitely circular. -!!! error TS5114: Instantiations of type 'F' appear infinitely circular. -==== instantiationStackLimitCheckOrder.ts (1 errors) ==== +==== instantiationStackLimitCheckOrder.ts (3 errors) ==== // F<[]> recurses forever, so instantiating it reaches the limit on the // instantiation stack, wherever it is first instantiated. The instantiations // in progress then fail as a whole, and none of them may be cached partly // built for the other declaration to reuse. type F = T extends [unknown?, ...infer R] ? [0, ...F] : []; + ~~~~~~~~~~~~ +!!! error TS5114: Instantiations of type 'F' appear infinitely circular. type X = F<[]>; + ~~~~~ +!!! error TS5114: Instantiations of type 'F' appear infinitely circular. // The element type of A[] is resolved whenever first needed, inside the // instantiation of the return type of flat or not. Reaching the limit while diff --git a/tsc/testdata/baselines/reference/compiler/instantiationStackLimitCheckOrder(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/instantiationStackLimitCheckOrder(checkorder=typesfirst).types index 8e3cbd6baf4b9..0731d655cd19a 100644 --- a/tsc/testdata/baselines/reference/compiler/instantiationStackLimitCheckOrder(checkorder=typesfirst).types +++ b/tsc/testdata/baselines/reference/compiler/instantiationStackLimitCheckOrder(checkorder=typesfirst).types @@ -10,7 +10,7 @@ type F = T extends [unknown?, ...infer R] ? [0, ...F] : []; >F : F type X = F<[]>; ->X : [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ...any[]] +>X : [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ...any[]] // The element type of A[] is resolved whenever first needed, inside the // instantiation of the return type of flat or not. Reaching the limit while diff --git a/tsc/testdata/baselines/reference/compiler/intersectionBaseConstructorCycleCheckOrder(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/intersectionBaseConstructorCycleCheckOrder(checkorder=typesfirst).errors.txt index 96858d411691e..999b86cd14552 100644 --- a/tsc/testdata/baselines/reference/compiler/intersectionBaseConstructorCycleCheckOrder(checkorder=typesfirst).errors.txt +++ b/tsc/testdata/baselines/reference/compiler/intersectionBaseConstructorCycleCheckOrder(checkorder=typesfirst).errors.txt @@ -1,16 +1,13 @@ -intersectionBaseConstructorCycleCheckOrder.ts(5,24): error TS2502: 'x' is referenced directly or indirectly in its own type annotation. intersectionBaseConstructorCycleCheckOrder.ts(6,15): error TS2310: Type 'C' recursively references itself as a base type. intersectionBaseConstructorCycleCheckOrder.ts(6,15): error TS2506: 'C' is referenced directly or indirectly in its own base expression. -==== intersectionBaseConstructorCycleCheckOrder.ts (3 errors) ==== +==== intersectionBaseConstructorCycleCheckOrder.ts (2 errors) ==== // The type of x depends on the members of C, which depend on its base B, // whose members depend on the type of x. Whichever is resolved first, the // cycle must be resolved the same way. declare const B: (new (x: C["p"]) => {}) & (new () => {}); - ~~~~~~~~~ -!!! error TS2502: 'x' is referenced directly or indirectly in its own type annotation. declare class C extends B { p: number; } ~ !!! error TS2310: Type 'C' recursively references itself as a base type. diff --git a/tsc/testdata/baselines/reference/compiler/intersectionBaseConstructorCycleCheckOrder(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/intersectionBaseConstructorCycleCheckOrder(checkorder=typesfirst).types index 334afbb4eb4f5..3a18ead789620 100644 --- a/tsc/testdata/baselines/reference/compiler/intersectionBaseConstructorCycleCheckOrder(checkorder=typesfirst).types +++ b/tsc/testdata/baselines/reference/compiler/intersectionBaseConstructorCycleCheckOrder(checkorder=typesfirst).types @@ -7,7 +7,7 @@ declare const B: (new (x: C["p"]) => {}) & (new () => {}); >B : (new (x: C["p"]) => {}) & (new () => {}) ->x : any +>x : number declare class C extends B { p: number; } >C : C diff --git a/tsc/testdata/baselines/reference/compiler/jsExpandoIndexedAssignmentDiagnostic.errors.txt b/tsc/testdata/baselines/reference/compiler/jsExpandoIndexedAssignmentDiagnostic.errors.txt new file mode 100644 index 0000000000000..bafe2d1546822 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/jsExpandoIndexedAssignmentDiagnostic.errors.txt @@ -0,0 +1,19 @@ +file.js(4,11): error TS7022: 'pixel' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. +file.js(4,19): error TS7053: Element implicitly has an 'any' type because expression of type 'any' can't be used to index type '{ skip: any; }'. +file.js(5,24): error TS7053: Element implicitly has an 'any' type because expression of type 'any' can't be used to index type '{ skip: any; }'. + + +==== file.js (3 errors) ==== + /** @param {any} axis @param {any} value */ + function updateElements(axis, value) { + const properties = {}; + const pixel = properties[axis] = value; + ~~~~~ +!!! error TS7022: 'pixel' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. + ~~~~~~~~~~~~~~~~ +!!! error TS7053: Element implicitly has an 'any' type because expression of type 'any' can't be used to index type '{ skip: any; }'. + const otherPixel = properties[axis] = value; + ~~~~~~~~~~~~~~~~ +!!! error TS7053: Element implicitly has an 'any' type because expression of type 'any' can't be used to index type '{ skip: any; }'. + properties.skip = isNaN(pixel) || isNaN(otherPixel); + } \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/jsExpandoIndexedAssignmentDiagnostic.js b/tsc/testdata/baselines/reference/compiler/jsExpandoIndexedAssignmentDiagnostic.js new file mode 100644 index 0000000000000..d660e1f2146fc --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/jsExpandoIndexedAssignmentDiagnostic.js @@ -0,0 +1,20 @@ +//// [tests/cases/compiler/jsExpandoIndexedAssignmentDiagnostic.ts] //// + +//// [file.js] +/** @param {any} axis @param {any} value */ +function updateElements(axis, value) { + const properties = {}; + const pixel = properties[axis] = value; + const otherPixel = properties[axis] = value; + properties.skip = isNaN(pixel) || isNaN(otherPixel); +} + +//// [file.js] +"use strict"; +/** @param {any} axis @param {any} value */ +function updateElements(axis, value) { + const properties = {}; + const pixel = properties[axis] = value; + const otherPixel = properties[axis] = value; + properties.skip = isNaN(pixel) || isNaN(otherPixel); +} diff --git a/tsc/testdata/baselines/reference/compiler/jsExpandoIndexedAssignmentDiagnostic.symbols b/tsc/testdata/baselines/reference/compiler/jsExpandoIndexedAssignmentDiagnostic.symbols new file mode 100644 index 0000000000000..373963a684ab3 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/jsExpandoIndexedAssignmentDiagnostic.symbols @@ -0,0 +1,33 @@ +//// [tests/cases/compiler/jsExpandoIndexedAssignmentDiagnostic.ts] //// + +=== file.js === +/** @param {any} axis @param {any} value */ +function updateElements(axis, value) { +>updateElements : Symbol(updateElements, Decl(file.js, 0, 0)) +>axis : Symbol(axis, Decl(file.js, 1, 24)) +>value : Symbol(value, Decl(file.js, 1, 29)) + + const properties = {}; +>properties : Symbol(properties, Decl(file.js, 2, 9)) + + const pixel = properties[axis] = value; +>pixel : Symbol(pixel, Decl(file.js, 3, 9)) +>properties : Symbol(properties, Decl(file.js, 2, 9)) +>axis : Symbol(axis, Decl(file.js, 1, 24)) +>value : Symbol(value, Decl(file.js, 1, 29)) + + const otherPixel = properties[axis] = value; +>otherPixel : Symbol(otherPixel, Decl(file.js, 4, 9)) +>properties : Symbol(properties, Decl(file.js, 2, 9)) +>axis : Symbol(axis, Decl(file.js, 1, 24)) +>value : Symbol(value, Decl(file.js, 1, 29)) + + properties.skip = isNaN(pixel) || isNaN(otherPixel); +>properties.skip : Symbol(skip, Decl(file.js, 4, 48)) +>properties : Symbol(properties, Decl(file.js, 2, 9)) +>skip : Symbol(skip, Decl(file.js, 4, 48)) +>isNaN : Symbol(isNaN, Decl(lib.es5.d.ts, --, --)) +>pixel : Symbol(pixel, Decl(file.js, 3, 9)) +>isNaN : Symbol(isNaN, Decl(lib.es5.d.ts, --, --)) +>otherPixel : Symbol(otherPixel, Decl(file.js, 4, 9)) +} diff --git a/tsc/testdata/baselines/reference/compiler/jsExpandoIndexedAssignmentDiagnostic.types b/tsc/testdata/baselines/reference/compiler/jsExpandoIndexedAssignmentDiagnostic.types new file mode 100644 index 0000000000000..607a8ed056027 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/jsExpandoIndexedAssignmentDiagnostic.types @@ -0,0 +1,42 @@ +//// [tests/cases/compiler/jsExpandoIndexedAssignmentDiagnostic.ts] //// + +=== file.js === +/** @param {any} axis @param {any} value */ +function updateElements(axis, value) { +>updateElements : (axis: any, value: any) => void +>axis : any +>value : any + + const properties = {}; +>properties : { skip: any; } +>{} : { skip: any; } + + const pixel = properties[axis] = value; +>pixel : any +>properties[axis] = value : any +>properties[axis] : any +>properties : { skip: any; } +>axis : any +>value : any + + const otherPixel = properties[axis] = value; +>otherPixel : any +>properties[axis] = value : any +>properties[axis] : any +>properties : { skip: any; } +>axis : any +>value : any + + properties.skip = isNaN(pixel) || isNaN(otherPixel); +>properties.skip = isNaN(pixel) || isNaN(otherPixel) : boolean +>properties.skip : any +>properties : { skip: any; } +>skip : any +>isNaN(pixel) || isNaN(otherPixel) : boolean +>isNaN(pixel) : boolean +>isNaN : (number: number) => boolean +>pixel : any +>isNaN(otherPixel) : boolean +>isNaN : (number: number) => boolean +>otherPixel : any +} diff --git a/tsc/testdata/baselines/reference/compiler/jsxImportSourceNonPragmaComment(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/jsxImportSourceNonPragmaComment(checkorder=typesfirst).errors.txt index b45ab387a625b..191dc50e4166c 100644 --- a/tsc/testdata/baselines/reference/compiler/jsxImportSourceNonPragmaComment(checkorder=typesfirst).errors.txt +++ b/tsc/testdata/baselines/reference/compiler/jsxImportSourceNonPragmaComment(checkorder=typesfirst).errors.txt @@ -1,10 +1,9 @@ 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(7,6): error TS2552: Cannot find name 'input'. Did you mean 'oninput'? -==== jsxImportSourceNonPragmaComment.tsx (4 errors) ==== +==== jsxImportSourceNonPragmaComment.tsx (3 errors) ==== /* eslint-disable react/react-in-jsx-scope -- Unaware of @jsxImportSource */ /** @jsxImportSource @emotion/react */ import { css } from "@emotion/react"; @@ -16,9 +15,6 @@ jsxImportSourceNonPragmaComment.tsx(7,6): error TS2552: Cannot find name 'input' {} - } - - ; - ~ -!!! error TS2304: Cannot find name 'a'. - \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/jsxIntrinsicElementsExtendsRecord(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/jsxIntrinsicElementsExtendsRecord(checkorder=typesfirst).types index a2a76b6e77eed..30632f23d7dc4 100644 --- a/tsc/testdata/baselines/reference/compiler/jsxIntrinsicElementsExtendsRecord(checkorder=typesfirst).types +++ b/tsc/testdata/baselines/reference/compiler/jsxIntrinsicElementsExtendsRecord(checkorder=typesfirst).types @@ -6,6 +6,6 @@ declare namespace JSX { } ; -> : any +> : 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..5babffc1080a2 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(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: 'Model', 'ModelAttributes', 'Exclude'. -==== keyofGenericExtendingClassDoubleLayer.ts (3 errors) ==== +==== keyofGenericExtendingClassDoubleLayer.ts (4 errors) ==== class Model { public createdAt: Date; ~~~~~~~~~ @@ -23,6 +24,8 @@ keyofGenericExtendingClassDoubleLayer.ts(10,12): error TS2564: Property 'age' ha toJson() { let x: keyof this = 'createdAt'; + ~ +!!! error TS5115: Instantiations of the following types appear infinitely circular: 'Model', 'ModelAttributes', 'Exclude'. } } \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/lateBoundMutualMemberTables.errors.txt b/tsc/testdata/baselines/reference/compiler/lateBoundMutualMemberTables.errors.txt new file mode 100644 index 0000000000000..c1b01f83c3c86 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/lateBoundMutualMemberTables.errors.txt @@ -0,0 +1,26 @@ +lateBoundMutualMemberTables.ts(6,8): error TS2339: Property 'by' does not exist on type 'B<"b">'. +lateBoundMutualMemberTables.ts(15,21): error TS2339: Property 'fromA2' does not exist on type 'A<"a">'. + + +==== lateBoundMutualMemberTables.ts (2 errors) ==== + declare const a: A<"a">; + declare const b: B<"b">; + declare class A { + x: T; + [b.y]: "fromB"; + [b.by]: "fromB2"; + ~~ +!!! error TS2339: Property 'by' does not exist on type 'B<"b">'. + } + declare class B { + y: T; + [a.x]: "fromA"; + [a.b]: "fromA2"; + } + export const v1 = a.b; + export const v2 = b.a; + export const v3 = a.fromA2; + ~~~~~~ +!!! error TS2339: Property 'fromA2' does not exist on type 'A<"a">'. + export const v4 = b.fromB; + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/lateBoundMutualMemberTables.js b/tsc/testdata/baselines/reference/compiler/lateBoundMutualMemberTables.js new file mode 100644 index 0000000000000..aea4e1ea51859 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/lateBoundMutualMemberTables.js @@ -0,0 +1,33 @@ +//// [tests/cases/compiler/lateBoundMutualMemberTables.ts] //// + +//// [lateBoundMutualMemberTables.ts] +declare const a: A<"a">; +declare const b: B<"b">; +declare class A { + x: T; + [b.y]: "fromB"; + [b.by]: "fromB2"; +} +declare class B { + y: T; + [a.x]: "fromA"; + [a.b]: "fromA2"; +} +export const v1 = a.b; +export const v2 = b.a; +export const v3 = a.fromA2; +export const v4 = b.fromB; + + +//// [lateBoundMutualMemberTables.js] +export const v1 = a.b; +export const v2 = b.a; +export const v3 = a.fromA2; +export const v4 = b.fromB; + + +//// [lateBoundMutualMemberTables.d.ts] +export declare const v1: "fromB"; +export declare const v2: "fromA"; +export declare const v3: any; +export declare const v4: "fromA2"; diff --git a/tsc/testdata/baselines/reference/compiler/lateBoundMutualMemberTables.symbols b/tsc/testdata/baselines/reference/compiler/lateBoundMutualMemberTables.symbols new file mode 100644 index 0000000000000..24eba3a29f260 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/lateBoundMutualMemberTables.symbols @@ -0,0 +1,71 @@ +//// [tests/cases/compiler/lateBoundMutualMemberTables.ts] //// + +=== lateBoundMutualMemberTables.ts === +declare const a: A<"a">; +>a : Symbol(a, Decl(lateBoundMutualMemberTables.ts, 0, 13)) +>A : Symbol(A, Decl(lateBoundMutualMemberTables.ts, 1, 24)) + +declare const b: B<"b">; +>b : Symbol(b, Decl(lateBoundMutualMemberTables.ts, 1, 13)) +>B : Symbol(B, Decl(lateBoundMutualMemberTables.ts, 6, 1)) + +declare class A { +>A : Symbol(A, Decl(lateBoundMutualMemberTables.ts, 1, 24)) +>T : Symbol(T, Decl(lateBoundMutualMemberTables.ts, 2, 16)) + + x: T; +>x : Symbol(A.x, Decl(lateBoundMutualMemberTables.ts, 2, 20)) +>T : Symbol(T, Decl(lateBoundMutualMemberTables.ts, 2, 16)) + + [b.y]: "fromB"; +>[b.y] : Symbol(A[b.y], Decl(lateBoundMutualMemberTables.ts, 3, 9)) +>b.y : Symbol(B.y, Decl(lateBoundMutualMemberTables.ts, 7, 20)) +>b : Symbol(b, Decl(lateBoundMutualMemberTables.ts, 1, 13)) +>y : Symbol(B.y, Decl(lateBoundMutualMemberTables.ts, 7, 20)) + + [b.by]: "fromB2"; +>[b.by] : Symbol(A[b.by], Decl(lateBoundMutualMemberTables.ts, 4, 19)) +>b : Symbol(b, Decl(lateBoundMutualMemberTables.ts, 1, 13)) +} +declare class B { +>B : Symbol(B, Decl(lateBoundMutualMemberTables.ts, 6, 1)) +>T : Symbol(T, Decl(lateBoundMutualMemberTables.ts, 7, 16)) + + y: T; +>y : Symbol(B.y, Decl(lateBoundMutualMemberTables.ts, 7, 20)) +>T : Symbol(T, Decl(lateBoundMutualMemberTables.ts, 7, 16)) + + [a.x]: "fromA"; +>[a.x] : Symbol(B[a.x], Decl(lateBoundMutualMemberTables.ts, 8, 9)) +>a.x : Symbol(A.x, Decl(lateBoundMutualMemberTables.ts, 2, 20)) +>a : Symbol(a, Decl(lateBoundMutualMemberTables.ts, 0, 13)) +>x : Symbol(A.x, Decl(lateBoundMutualMemberTables.ts, 2, 20)) + + [a.b]: "fromA2"; +>[a.b] : Symbol(B[a.b], Decl(lateBoundMutualMemberTables.ts, 9, 19)) +>a.b : Symbol(A[b.y], Decl(lateBoundMutualMemberTables.ts, 3, 9)) +>a : Symbol(a, Decl(lateBoundMutualMemberTables.ts, 0, 13)) +>b : Symbol(A[b.y], Decl(lateBoundMutualMemberTables.ts, 3, 9)) +} +export const v1 = a.b; +>v1 : Symbol(v1, Decl(lateBoundMutualMemberTables.ts, 12, 12)) +>a.b : Symbol(A[b.y], Decl(lateBoundMutualMemberTables.ts, 3, 9)) +>a : Symbol(a, Decl(lateBoundMutualMemberTables.ts, 0, 13)) +>b : Symbol(A[b.y], Decl(lateBoundMutualMemberTables.ts, 3, 9)) + +export const v2 = b.a; +>v2 : Symbol(v2, Decl(lateBoundMutualMemberTables.ts, 13, 12)) +>b.a : Symbol(B[a.x], Decl(lateBoundMutualMemberTables.ts, 8, 9)) +>b : Symbol(b, Decl(lateBoundMutualMemberTables.ts, 1, 13)) +>a : Symbol(B[a.x], Decl(lateBoundMutualMemberTables.ts, 8, 9)) + +export const v3 = a.fromA2; +>v3 : Symbol(v3, Decl(lateBoundMutualMemberTables.ts, 14, 12)) +>a : Symbol(a, Decl(lateBoundMutualMemberTables.ts, 0, 13)) + +export const v4 = b.fromB; +>v4 : Symbol(v4, Decl(lateBoundMutualMemberTables.ts, 15, 12)) +>b.fromB : Symbol(B[a.b], Decl(lateBoundMutualMemberTables.ts, 9, 19)) +>b : Symbol(b, Decl(lateBoundMutualMemberTables.ts, 1, 13)) +>fromB : Symbol(B[a.b], Decl(lateBoundMutualMemberTables.ts, 9, 19)) + diff --git a/tsc/testdata/baselines/reference/compiler/lateBoundMutualMemberTables.types b/tsc/testdata/baselines/reference/compiler/lateBoundMutualMemberTables.types new file mode 100644 index 0000000000000..24f60ac31fc98 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/lateBoundMutualMemberTables.types @@ -0,0 +1,69 @@ +//// [tests/cases/compiler/lateBoundMutualMemberTables.ts] //// + +=== lateBoundMutualMemberTables.ts === +declare const a: A<"a">; +>a : A<"a"> + +declare const b: B<"b">; +>b : B<"b"> + +declare class A { +>A : A + + x: T; +>x : T + + [b.y]: "fromB"; +>[b.y] : "fromB" +>b.y : "b" +>b : B<"b"> +>y : "b" + + [b.by]: "fromB2"; +>[b.by] : "fromB2" +>b.by : any +>b : B<"b"> +>by : any +} +declare class B { +>B : B + + y: T; +>y : T + + [a.x]: "fromA"; +>[a.x] : "fromA" +>a.x : "a" +>a : A<"a"> +>x : "a" + + [a.b]: "fromA2"; +>[a.b] : "fromA2" +>a.b : "fromB" +>a : A<"a"> +>b : "fromB" +} +export const v1 = a.b; +>v1 : "fromB" +>a.b : "fromB" +>a : A<"a"> +>b : "fromB" + +export const v2 = b.a; +>v2 : "fromA" +>b.a : "fromA" +>b : B<"b"> +>a : "fromA" + +export const v3 = a.fromA2; +>v3 : any +>a.fromA2 : any +>a : A<"a"> +>fromA2 : any + +export const v4 = b.fromB; +>v4 : "fromA2" +>b.fromB : "fromA2" +>b : B<"b"> +>fromB : "fromA2" + diff --git a/tsc/testdata/baselines/reference/compiler/limitDeepInstantiations(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/limitDeepInstantiations(checkorder=default).errors.txt index a1b033edf54ba..b908bb32df049 100644 --- a/tsc/testdata/baselines/reference/compiler/limitDeepInstantiations(checkorder=default).errors.txt +++ b/tsc/testdata/baselines/reference/compiler/limitDeepInstantiations(checkorder=default).errors.txt @@ -1,12 +1,15 @@ +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 (2 errors) ==== +==== 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", {}>; diff --git a/tsc/testdata/baselines/reference/compiler/limitDeepInstantiations(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/limitDeepInstantiations(checkorder=typesfirst).errors.txt index 2998e94608985..b908bb32df049 100644 --- a/tsc/testdata/baselines/reference/compiler/limitDeepInstantiations(checkorder=typesfirst).errors.txt +++ b/tsc/testdata/baselines/reference/compiler/limitDeepInstantiations(checkorder=typesfirst).errors.txt @@ -1,13 +1,17 @@ -error TS5114: Instantiations of type 'Foo' appear infinitely circular. +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"'. -!!! error TS5114: Instantiations of type 'Foo' appear infinitely circular. -==== limitDeepInstantiations.ts (1 errors) ==== +==== 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"'. 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 0153880cec8d7..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: {}; } ->v : {} ->{ ...M } : {} +>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/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/noFlakyDeclarationEmitSharedCheckerOrder.types b/tsc/testdata/baselines/reference/compiler/noFlakyDeclarationEmitSharedCheckerOrder.types index 07b1f23ab8990..cde44436bf6e0 100644 --- a/tsc/testdata/baselines/reference/compiler/noFlakyDeclarationEmitSharedCheckerOrder.types +++ b/tsc/testdata/baselines/reference/compiler/noFlakyDeclarationEmitSharedCheckerOrder.types @@ -26,9 +26,9 @@ const M = /** @type {any} */ (null); const o = { v: { ...M } }; >o : { v: {}; } ->{ v: { ...M } } : { v: {}; } ->v : {} ->{ ...M } : {} +>{ 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; 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 753e075741287..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: {}; } ->v : {} ->{ ...M } : {} +>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 53a815348e451..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: {}; } ->v : {} ->{ ...M } : {} +>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/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/qualifiedNameCycleErrorCheckOrder(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/qualifiedNameCycleErrorCheckOrder(checkorder=default).errors.txt index 9377a11b042da..ee473361b43a4 100644 --- a/tsc/testdata/baselines/reference/compiler/qualifiedNameCycleErrorCheckOrder(checkorder=default).errors.txt +++ b/tsc/testdata/baselines/reference/compiler/qualifiedNameCycleErrorCheckOrder(checkorder=default).errors.txt @@ -1,8 +1,7 @@ qualifiedNameCycleErrorCheckOrder.ts(5,15): error TS2502: 'n' is referenced directly or indirectly in its own type annotation. -qualifiedNameCycleErrorCheckOrder.ts(5,20): error TS2694: Namespace 'n' has no exported member 'T'. -==== qualifiedNameCycleErrorCheckOrder.ts (2 errors) ==== +==== qualifiedNameCycleErrorCheckOrder.ts (1 errors) ==== // Resolving n.T looks for a value n to suggest typeof, which needs the type of // n, which is n.T. The missing member must be reported whichever is // resolved first. @@ -10,7 +9,5 @@ qualifiedNameCycleErrorCheckOrder.ts(5,20): error TS2694: Namespace 'n' has no e declare const n: n.T; ~ !!! error TS2502: 'n' is referenced directly or indirectly in its own type annotation. - ~ -!!! error TS2694: Namespace 'n' has no exported member 'T'. declare namespace n {} \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/relationComplexityError(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/relationComplexityError(checkorder=default).errors.txt index e8f947ec283b1..e208e03814c1f 100644 --- a/tsc/testdata/baselines/reference/compiler/relationComplexityError(checkorder=default).errors.txt +++ b/tsc/testdata/baselines/reference/compiler/relationComplexityError(checkorder=default).errors.txt @@ -1,13 +1,14 @@ 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 TS2322: Type '{ p: T1 & T2; }' is not assignable to type '{ p: T1 | null; }'. - Types of property 'p' are incompatible. - 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 (5 errors) ==== +==== 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. @@ -31,20 +32,24 @@ relationComplexityError.ts(26,5): error TS2322: Type '{ p: T1 & T2; }' is not as 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 TS2322: Type '{ p: T1 & T2; }' is not assignable to type '{ p: T1 | null; }'. -!!! error TS2322: Types of property 'p' are incompatible. -!!! error TS2322: Excessive complexity comparing types 'T1 & T2' and 'T1 | null'. +!!! 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).errors.txt b/tsc/testdata/baselines/reference/compiler/relationComplexityError(checkorder=typesfirst).errors.txt index 8a92179def8a5..e208e03814c1f 100644 --- a/tsc/testdata/baselines/reference/compiler/relationComplexityError(checkorder=typesfirst).errors.txt +++ b/tsc/testdata/baselines/reference/compiler/relationComplexityError(checkorder=typesfirst).errors.txt @@ -1,13 +1,14 @@ -relationComplexityError.ts(10,5): error TS2322: Type '{ p: T1 & T2; }' is not assignable to type '{ p: T1 | null; }'. - Types of property 'p' are incompatible. - Excessive complexity comparing types 'T1 & T2' and 'T1 | null'. +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 (5 errors) ==== +==== 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. @@ -19,9 +20,9 @@ relationComplexityError.ts(26,5): error TS2859: Excessive complexity comparing t function f0(x: { p: T1 | null }, y: { p: T1 & T2 }) { x = y; // Complexity error ~ -!!! error TS2322: Type '{ p: T1 & T2; }' is not assignable to type '{ p: T1 | null; }'. -!!! error TS2322: Types of property 'p' are incompatible. -!!! error TS2322: Excessive complexity comparing types 'T1 & T2' and 'T1 | null'. +!!! 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) { @@ -31,12 +32,16 @@ relationComplexityError.ts(26,5): error TS2859: Excessive complexity comparing t 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'. } diff --git a/tsc/testdata/baselines/reference/compiler/relationComplexitySharedCheckOrder(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/relationComplexitySharedCheckOrder(checkorder=default).errors.txt deleted file mode 100644 index e9850a7764ef6..0000000000000 --- a/tsc/testdata/baselines/reference/compiler/relationComplexitySharedCheckOrder(checkorder=default).errors.txt +++ /dev/null @@ -1,32 +0,0 @@ -relationComplexitySharedCheckOrder.ts(22,1): error TS2859: Excessive complexity comparing types 'T1 & T2' and 'T1 | null'. -relationComplexitySharedCheckOrder.ts(22,1): error TS2859: Excessive complexity comparing types 'T1 & T2' and 'T1 | null'. - - -==== relationComplexitySharedCheckOrder.ts (2 errors) ==== - // Relating y to x fresh caches too many comparisons. In program order the - // comparisons before it have cached all but a seventh of them. Whether - // relating y is too complex must not depend on which comes first. - - type D = '0' | '1' | '2' | '3' | '4' | '5' | '6'; - type T1 = `${D}${D}${D}${D}` | undefined; - type T2 = { a: string } | { b: number }; - declare let x: T1 | null; - declare const y1: (`${'0'}${D}${D}${D}` | undefined) & T2; - x = y1; - declare const y2: (`${'0' | '1'}${D}${D}${D}` | undefined) & T2; - x = y2; - declare const y3: (`${'0' | '1' | '2'}${D}${D}${D}` | undefined) & T2; - x = y3; - declare const y4: (`${'0' | '1' | '2' | '3'}${D}${D}${D}` | undefined) & T2; - x = y4; - declare const y5: (`${'0' | '1' | '2' | '3' | '4'}${D}${D}${D}` | undefined) & T2; - x = y5; - declare const y6: (`${'0' | '1' | '2' | '3' | '4' | '5'}${D}${D}${D}` | undefined) & T2; - x = y6; - declare const y: T1 & T2; - x = y; - ~ -!!! error TS2859: Excessive complexity comparing types 'T1 & T2' and 'T1 | null'. - ~~~~~ -!!! error TS2859: Excessive complexity comparing types 'T1 & T2' and 'T1 | null'. - \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/relationComplexitySharedCheckOrder(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/relationComplexitySharedCheckOrder(checkorder=typesfirst).errors.txt index 814b4254058e7..b09ae18f59a0c 100644 --- a/tsc/testdata/baselines/reference/compiler/relationComplexitySharedCheckOrder(checkorder=typesfirst).errors.txt +++ b/tsc/testdata/baselines/reference/compiler/relationComplexitySharedCheckOrder(checkorder=typesfirst).errors.txt @@ -1,9 +1,10 @@ relationComplexitySharedCheckOrder.ts(20,1): error TS2859: Excessive complexity comparing types '("0000" | "0001" | "0002" | "0003" | "0004" | "0005" | "0006" | "0010" | "0011" | "0012" | "0013" | "0014" | "0015" | "0016" | "0020" | "0021" | "0022" | "0023" | "0024" | "0025" | "0026" | "0030" | "0031" | "0032" | "0033" | "0034" | "0035" | "0036" | "0040" | "0041" | "0042" | "0043" | "0044" | "0045" | "0046" | "0050" | "0051" | "0052" | "0053" | "0054" | "0055" | "0056" | "0060" | "0061" | "0062" | "0063" | "0064" | "0065" | "0066" | "0100" | "0101" | "0102" | "0103" | "0104" | "0105" | "0106" | "0110" | "0111" | "0112" | "0113" | "0114" | "0115" | "0116" | "0120" | "0121" | "0122" | "0123" | "0124" | "0125" | "0126" | "0130" | "0131" | "0132" | "0133" | "0134" | "0135" | "0136" | "0140" | "0141" | "0142" | "0143" | "0144" | "0145" | "0146" | "0150" | "0151" | "0152" | "0153" | "0154" | "0155" | "0156" | "0160" | "0161" | "0162" | "0163" | "0164" | "0165" | "0166" | "0200" | "0201" | "0202" | "0203" | "0204" | "0205" | "0206" | "0210" | "0211" | "0212" | "0213" | "0214" | "0215" | "0216" | "0220" | "0221" | "0222" | "0223" | "0224" | "0225" | "0226" | "0230" | "0231" | "0232" | "0233" | "0234" | "0235" | "0236" | "0240" | "0241" | "0242" | "0243" | "0244" | "0245" | "0246" | "0250" | "0251" | "0252" | "0253" | "0254" | "0255" | "0256" | "0260" | "0261" | "0262" | "0263" | "0264" | "0265" | "0266" | "0300" | "0301" | "0302" | "0303" | "0304" | "0305" | "0306" | "0310" | "0311" | "0312" | "0313" | "0314" | "0315" | "0316" | "0320" | "0321" | "0322" | "0323" | "0324" | "0325" | "0326" | "0330" | "0331" | "0332" | "0333" | "0334" | "0335" | "0336" | "0340" | "0341" | "0342" | "0343" | "0344" | "0345" | "0346" | "0350" | "0351" | "0352" | "0353" | "0354" | "0355" | "0356" | "0360" | "0361" | "0362" | "0363" | "0364" | "0365" | "0366" | "0400" | "0401" | "0402" | "0403" | "0404" | "0405" | "0406" | "0410" | "0411" | "0412" | "0413" | "0414" | "0415" | "0416" | "0420" | "0421" | "0422" | "0423" | "0424" | "0425" | "0426" | "0430" | "0431" | "0432" | "0433" | "0434" | "0435" | "0436" | "0440" | "0441" | "0442" | "0443" | "0444" | "0445" | "0446" | "0450" | "0451" | "0452" | "0453" | "0454" | "0455" | "0456" | "0460" | "0461" | "0462" | "0463" | "0464" | "0465" | "0466" | "0500" | "0501" | "0502" | "0503" | "0504" | "0505" | "0506" | "0510" | "0511" | "0512" | "0513" | "0514" | "0515" | "0516" | "0520" | "0521" | "0522" | "0523" | "0524" | "0525" | "0526" | "0530" | "0531" | "0532" | "0533" | "0534" | "0535" | "0536" | "0540" | "0541" | "0542" | "0543" | "0544" | "0545" | "0546" | "0550" | "0551" | "0552" | "0553" | "0554" | "0555" | "0556" | "0560" | "0561" | "0562" | "0563" | "0564" | "0565" | "0566" | "0600" | "0601" | "0602" | "0603" | "0604" | "0605" | "0606" | "0610" | "0611" | "0612" | "0613" | "0614" | "0615" | "0616" | "0620" | "0621" | "0622" | "0623" | "0624" | "0625" | "0626" | "0630" | "0631" | "0632" | "0633" | "0634" | "0635" | "0636" | "0640" | "0641" | "0642" | "0643" | "0644" | "0645" | "0646" | "0650" | "0651" | "0652" | "0653" | "0654" | "0655" | "0656" | "0660" | "0661" | "0662" | "0663" | "0664" | "0665" | "0666" | "1000" | "1001" | "1002" | "1003" | "1004" | "1005" | "1006" | "1010" | "1011" | "1012" | "1013" | "1014" | "1015" | "1016" | "1020" | "1021" | "1022" | "1023" | "1024" | "1025" | "1026" | "1030" | "1031" | "1032" | "1033" | "1034" | "1035" | "1036" | "1040" | "1041" | "1042" | "1043" | "1044" | "1045" | "1046" | "1050" | "1051" | "1052" | "1053" | "1054" | "1055" | "1056" | "1060" | "1061" | "1062" | "1063" | "1064" | "1065" | "1066" | "1100" | "1101" | "1102" | "1103" | "1104" | "1105" | "1106" | "1110" | "1111" | "1112" | "1113" | "1114" | "1115" | "1116" | "1120" | "1121" | "1122" | "1123" | "1124" | "1125" | "1126" | "1130" | "1131" | "1132" | "1133" | "1134" | "1135" | "1136" | "1140" | "1141" | "1142" | "1143" | "1144" | "1145" | "1146" | "1150" | "1151" | "1152" | "1153" | "1154" | "1155" | "1156" | "1160" | "1161" | "1162" | "1163" | "1164" | "1165" | "1166" | "1200" | "1201" | "1202" | "1203" | "1204" | "1205" | "1206" | "1210" | "1211" | "1212" | "1213" | "1214" | "1215" | "1216" | "1220" | "1221" | "1222" | "1223" | "1224" | "1225" | "1226" | "1230" | "1231" | "1232" | "1233" | "1234" | "1235" | "1236" | "1240" | "1241" | "1242" | "1243" | "1244" | "1245" | "1246" | "1250" | "1251" | "1252" | "1253" | "1254" | "1255" | "1256" | "1260" | "1261" | "1262" | "1263" | "1264" | "1265" | "1266" | "1300" | "1301" | "1302" | "1303" | "1304" | "1305" | "1306" | "1310" | "1311" | "1312" | "1313" | "1314" | "1315" | "1316" | "1320" | "1321" | "1322" | "1323" | "1324" | "1325" | "1326" | "1330" | "1331" | "1332" | "1333" | "1334" | "1335" | "1336" | "1340" | "1341" | "1342" | "1343" | "1344" | "1345" | "1346" | "1350" | "1351" | "1352" | "1353" | "1354" | "1355" | "1356" | "1360" | "1361" | "1362" | "1363" | "1364" | "1365" | "1366" | "1400" | "1401" | "1402" | "1403" | "1404" | "1405" | "1406" | "1410" | "1411" | "1412" | "1413" | "1414" | "1415" | "1416" | "1420" | "1421" | "1422" | "1423" | "1424" | "1425" | "1426" | "1430" | "1431" | "1432" | "1433" | "1434" | "1435" | "1436" | "1440" | "1441" | "1442" | "1443" | "1444" | "1445" | "1446" | "1450" | "1451" | "1452" | "1453" | "1454" | "1455" | "1456" | "1460" | "1461" | "1462" | "1463" | "1464" | "1465" | "1466" | "1500" | "1501" | "1502" | "1503" | "1504" | "1505" | "1506" | "1510" | "1511" | "1512" | "1513" | "1514" | "1515" | "1516" | "1520" | "1521" | "1522" | "1523" | "1524" | "1525" | "1526" | "1530" | "1531" | "1532" | "1533" | "1534" | "1535" | "1536" | "1540" | "1541" | "1542" | "1543" | "1544" | "1545" | "1546" | "1550" | "1551" | "1552" | "1553" | "1554" | "1555" | "1556" | "1560" | "1561" | "1562" | "1563" | "1564" | "1565" | "1566" | "1600" | "1601" | "1602" | "1603" | "1604" | "1605" | "1606" | "1610" | "1611" | "1612" | "1613" | "1614" | "1615" | "1616" | "1620" | "1621" | "1622" | "1623" | "1624" | "1625" | "1626" | "1630" | "1631" | "1632" | "1633" | "1634" | "1635" | "1636" | "1640" | "1641" | "1642" | "1643" | "1644" | "1645" | "1646" | "1650" | "1651" | "1652" | "1653" | "1654" | "1655" | "1656" | "1660" | "1661" | "1662" | "1663" | "1664" | "1665" | "1666" | "2000" | "2001" | "2002" | "2003" | "2004" | "2005" | "2006" | "2010" | "2011" | "2012" | "2013" | "2014" | "2015" | "2016" | "2020" | "2021" | "2022" | "2023" | "2024" | "2025" | "2026" | "2030" | "2031" | "2032" | "2033" | "2034" | "2035" | "2036" | "2040" | "2041" | "2042" | "2043" | "2044" | "2045" | "2046" | "2050" | "2051" | "2052" | "2053" | "2054" | "2055" | "2056" | "2060" | "2061" | "2062" | "2063" | "2064" | "2065" | "2066" | "2100" | "2101" | "2102" | "2103" | "2104" | "2105" | "2106" | "2110" | "2111" | "2112" | "2113" | "2114" | "2115" | "2116" | "2120" | "2121" | "2122" | "2123" | "2124" | "2125" | "2126" | "2130" | "2131" | "2132" | "2133" | "2134" | "2135" | "2136" | "2140" | "2141" | "2142" | "2143" | "2144" | "2145" | "2146" | "2150" | "2151" | "2152" | "2153" | "2154" | "2155" | "2156" | "2160" | "2161" | "2162" | "2163" | "2164" | "2165" | "2166" | "2200" | "2201" | "2202" | "2203" | "2204" | "2205" | "2206" | "2210" | "2211" | "2212" | "2213" | "2214" | "2215" | "2216" | "2220" | "2221" | "2222" | "2223" | "2224" | "2225" | "2226" | "2230" | "2231" | "2232" | "2233" | "2234" | "2235" | "2236" | "2240" | "2241" | "2242" | "2243" | "2244" | "2245" | "2246" | "2250" | "2251" | "2252" | "2253" | "2254" | "2255" | "2256" | "2260" | "2261" | "2262" | "2263" | "2264" | "2265" | "2266" | "2300" | "2301" | "2302" | "2303" | "2304" | "2305" | "2306" | "2310" | "2311" | "2312" | "2313" | "2314" | "2315" | "2316" | "2320" | "2321" | "2322" | "2323" | "2324" | "2325" | "2326" | "2330" | "2331" | "2332" | "2333" | "2334" | "2335" | "2336" | "2340" | "2341" | "2342" | "2343" | "2344" | "2345" | "2346" | "2350" | "2351" | "2352" | "2353" | "2354" | "2355" | "2356" | "2360" | "2361" | "2362" | "2363" | "2364" | "2365" | "2366" | "2400" | "2401" | "2402" | "2403" | "2404" | "2405" | "2406" | "2410" | "2411" | "2412" | "2413" | "2414" | "2415" | "2416" | "2420" | "2421" | "2422" | "2423" | "2424" | "2425" | "2426" | "2430" | "2431" | "2432" | "2433" | "2434" | "2435" | "2436" | "2440" | "2441" | "2442" | "2443" | "2444" | "2445" | "2446" | "2450" | "2451" | "2452" | "2453" | "2454" | "2455" | "2456" | "2460" | "2461" | "2462" | "2463" | "2464" | "2465" | "2466" | "2500" | "2501" | "2502" | "2503" | "2504" | "2505" | "2506" | "2510" | "2511" | "2512" | "2513" | "2514" | "2515" | "2516" | "2520" | "2521" | "2522" | "2523" | "2524" | "2525" | "2526" | "2530" | "2531" | "2532" | "2533" | "2534" | "2535" | "2536" | "2540" | "2541" | "2542" | "2543" | "2544" | "2545" | "2546" | "2550" | "2551" | "2552" | "2553" | "2554" | "2555" | "2556" | "2560" | "2561" | "2562" | "2563" | "2564" | "2565" | "2566" | "2600" | "2601" | "2602" | "2603" | "2604" | "2605" | "2606" | "2610" | "2611" | "2612" | "2613" | "2614" | "2615" | "2616" | "2620" | "2621" | "2622" | "2623" | "2624" | "2625" | "2626" | "2630" | "2631" | "2632" | "2633" | "2634" | "2635" | "2636" | "2640" | "2641" | "2642" | "2643" | "2644" | "2645" | "2646" | "2650" | "2651" | "2652" | "2653" | "2654" | "2655" | "2656" | "2660" | "2661" | "2662" | "2663" | "2664" | "2665" | "2666" | "3000" | "3001" | "3002" | "3003" | "3004" | "3005" | "3006" | "3010" | "3011" | "3012" | "3013" | "3014" | "3015" | "3016" | "3020" | "3021" | "3022" | "3023" | "3024" | "3025" | "3026" | "3030" | "3031" | "3032" | "3033" | "3034" | "3035" | "3036" | "3040" | "3041" | "3042" | "3043" | "3044" | "3045" | "3046" | "3050" | "3051" | "3052" | "3053" | "3054" | "3055" | "3056" | "3060" | "3061" | "3062" | "3063" | "3064" | "3065" | "3066" | "3100" | "3101" | "3102" | "3103" | "3104" | "3105" | "3106" | "3110" | "3111" | "3112" | "3113" | "3114" | "3115" | "3116" | "3120" | "3121" | "3122" | "3123" | "3124" | "3125" | "3126" | "3130" | "3131" | "3132" | "3133" | "3134" | "3135" | "3136" | "3140" | "3141" | "3142" | "3143" | "3144" | "3145" | "3146" | "3150" | "3151" | "3152" | "3153" | "3154" | "3155" | "3156" | "3160" | "3161" | "3162" | "3163" | "3164" | "3165" | "3166" | "3200" | "3201" | "3202" | "3203" | "3204" | "3205" | "3206" | "3210" | "3211" | "3212" | "3213" | "3214" | "3215" | "3216" | "3220" | "3221" | "3222" | "3223" | "3224" | "3225" | "3226" | "3230" | "3231" | "3232" | "3233" | "3234" | "3235" | "3236" | "3240" | "3241" | "3242" | "3243" | "3244" | "3245" | "3246" | "3250" | "3251" | "3252" | "3253" | "3254" | "3255" | "3256" | "3260" | "3261" | "3262" | "3263" | "3264" | "3265" | "3266" | "3300" | "3301" | "3302" | "3303" | "3304" | "3305" | "3306" | "3310" | "3311" | "3312" | "3313" | "3314" | "3315" | "3316" | "3320" | "3321" | "3322" | "3323" | "3324" | "3325" | "3326" | "3330" | "3331" | "3332" | "3333" | "3334" | "3335" | "3336" | "3340" | "3341" | "3342" | "3343" | "3344" | "3345" | "3346" | "3350" | "3351" | "3352" | "3353" | "3354" | "3355" | "3356" | "3360" | "3361" | "3362" | "3363" | "3364" | "3365" | "3366" | "3400" | "3401" | "3402" | "3403" | "3404" | "3405" | "3406" | "3410" | "3411" | "3412" | "3413" | "3414" | "3415" | "3416" | "3420" | "3421" | "3422" | "3423" | "3424" | "3425" | "3426" | "3430" | "3431" | "3432" | "3433" | "3434" | "3435" | "3436" | "3440" | "3441" | "3442" | "3443" | "3444" | "3445" | "3446" | "3450" | "3451" | "3452" | "3453" | "3454" | "3455" | "3456" | "3460" | "3461" | "3462" | "3463" | "3464" | "3465" | "3466" | "3500" | "3501" | "3502" | "3503" | "3504" | "3505" | "3506" | "3510" | "3511" | "3512" | "3513" | "3514" | "3515" | "3516" | "3520" | "3521" | "3522" | "3523" | "3524" | "3525" | "3526" | "3530" | "3531" | "3532" | "3533" | "3534" | "3535" | "3536" | "3540" | "3541" | "3542" | "3543" | "3544" | "3545" | "3546" | "3550" | "3551" | "3552" | "3553" | "3554" | "3555" | "3556" | "3560" | "3561" | "3562" | "3563" | "3564" | "3565" | "3566" | "3600" | "3601" | "3602" | "3603" | "3604" | "3605" | "3606" | "3610" | "3611" | "3612" | "3613" | "3614" | "3615" | "3616" | "3620" | "3621" | "3622" | "3623" | "3624" | "3625" | "3626" | "3630" | "3631" | "3632" | "3633" | "3634" | "3635" | "3636" | "3640" | "3641" | "3642" | "3643" | "3644" | "3645" | "3646" | "3650" | "3651" | "3652" | "3653" | "3654" | "3655" | "3656" | "3660" | "3661" | "3662" | "3663" | "3664" | "3665" | "3666" | "4000" | "4001" | "4002" | "4003" | "4004" | "4005" | "4006" | "4010" | "4011" | "4012" | "4013" | "4014" | "4015" | "4016" | "4020" | "4021" | "4022" | "4023" | "4024" | "4025" | "4026" | "4030" | "4031" | "4032" | "4033" | "4034" | "4035" | "4036" | "4040" | "4041" | "4042" | "4043" | "4044" | "4045" | "4046" | "4050" | "4051" | "4052" | "4053" | "4054" | "4055" | "4056" | "4060" | "4061" | "4062" | "4063" | "4064" | "4065" | "4066" | "4100" | "4101" | "4102" | "4103" | "4104" | "4105" | "4106" | "4110" | "4111" | "4112" | "4113" | "4114" | "4115" | "4116" | "4120" | "4121" | "4122" | "4123" | "4124" | "4125" | "4126" | "4130" | "4131" | "4132" | "4133" | "4134" | "4135" | "4136" | "4140" | "4141" | "4142" | "4143" | "4144" | "4145" | "4146" | "4150" | "4151" | "4152" | "4153" | "4154" | "4155" | "4156" | "4160" | "4161" | "4162" | "4163" | "4164" | "4165" | "4166" | "4200" | "4201" | "4202" | "4203" | "4204" | "4205" | "4206" | "4210" | "4211" | "4212" | "4213" | "4214" | "4215" | "4216" | "4220" | "4221" | "4222" | "4223" | "4224" | "4225" | "4226" | "4230" | "4231" | "4232" | "4233" | "4234" | "4235" | "4236" | "4240" | "4241" | "4242" | "4243" | "4244" | "4245" | "4246" | "4250" | "4251" | "4252" | "4253" | "4254" | "4255" | "4256" | "4260" | "4261" | "4262" | "4263" | "4264" | "4265" | "4266" | "4300" | "4301" | "4302" | "4303" | "4304" | "4305" | "4306" | "4310" | "4311" | "4312" | "4313" | "4314" | "4315" | "4316" | "4320" | "4321" | "4322" | "4323" | "4324" | "4325" | "4326" | "4330" | "4331" | "4332" | "4333" | "4334" | "4335" | "4336" | "4340" | "4341" | "4342" | "4343" | "4344" | "4345" | "4346" | "4350" | "4351" | "4352" | "4353" | "4354" | "4355" | "4356" | "4360" | "4361" | "4362" | "4363" | "4364" | "4365" | "4366" | "4400" | "4401" | "4402" | "4403" | "4404" | "4405" | "4406" | "4410" | "4411" | "4412" | "4413" | "4414" | "4415" | "4416" | "4420" | "4421" | "4422" | "4423" | "4424" | "4425" | "4426" | "4430" | "4431" | "4432" | "4433" | "4434" | "4435" | "4436" | "4440" | "4441" | "4442" | "4443" | "4444" | "4445" | "4446" | "4450" | "4451" | "4452" | "4453" | "4454" | "4455" | "4456" | "4460" | "4461" | "4462" | "4463" | "4464" | "4465" | "4466" | "4500" | "4501" | "4502" | "4503" | "4504" | "4505" | "4506" | "4510" | "4511" | "4512" | "4513" | "4514" | "4515" | "4516" | "4520" | "4521" | "4522" | "4523" | "4524" | "4525" | "4526" | "4530" | "4531" | "4532" | "4533" | "4534" | "4535" | "4536" | "4540" | "4541" | "4542" | "4543" | "4544" | "4545" | "4546" | "4550" | "4551" | "4552" | "4553" | "4554" | "4555" | "4556" | "4560" | "4561" | "4562" | "4563" | "4564" | "4565" | "4566" | "4600" | "4601" | "4602" | "4603" | "4604" | "4605" | "4606" | "4610" | "4611" | "4612" | "4613" | "4614" | "4615" | "4616" | "4620" | "4621" | "4622" | "4623" | "4624" | "4625" | "4626" | "4630" | "4631" | "4632" | "4633" | "4634" | "4635" | "4636" | "4640" | "4641" | "4642" | "4643" | "4644" | "4645" | "4646" | "4650" | "4651" | "4652" | "4653" | "4654" | "4655" | "4656" | "4660" | "4661" | "4662" | "4663" | "4664" | "4665" | "4666" | "5000" | "5001" | "5002" | "5003" | "5004" | "5005" | "5006" | "5010" | "5011" | "5012" | "5013" | "5014" | "5015" | "5016" | "5020" | "5021" | "5022" | "5023" | "5024" | "5025" | "5026" | "5030" | "5031" | "5032" | "5033" | "5034" | "5035" | "5036" | "5040" | "5041" | "5042" | "5043" | "5044" | "5045" | "5046" | "5050" | "5051" | "5052" | "5053" | "5054" | "5055" | "5056" | "5060" | "5061" | "5062" | "5063" | "5064" | "5065" | "5066" | "5100" | "5101" | "5102" | "5103" | "5104" | "5105" | "5106" | "5110" | "5111" | "5112" | "5113" | "5114" | "5115" | "5116" | "5120" | "5121" | "5122" | "5123" | "5124" | "5125" | "5126" | "5130" | "5131" | "5132" | "5133" | "5134" | "5135" | "5136" | "5140" | "5141" | "5142" | "5143" | "5144" | "5145" | "5146" | "5150" | "5151" | "5152" | "5153" | "5154" | "5155" | "5156" | "5160" | "5161" | "5162" | "5163" | "5164" | "5165" | "5166" | "5200" | "5201" | "5202" | "5203" | "5204" | "5205" | "5206" | "5210" | "5211" | "5212" | "5213" | "5214" | "5215" | "5216" | "5220" | "5221" | "5222" | "5223" | "5224" | "5225" | "5226" | "5230" | "5231" | "5232" | "5233" | "5234" | "5235" | "5236" | "5240" | "5241" | "5242" | "5243" | "5244" | "5245" | "5246" | "5250" | "5251" | "5252" | "5253" | "5254" | "5255" | "5256" | "5260" | "5261" | "5262" | "5263" | "5264" | "5265" | "5266" | "5300" | "5301" | "5302" | "5303" | "5304" | "5305" | "5306" | "5310" | "5311" | "5312" | "5313" | "5314" | "5315" | "5316" | "5320" | "5321" | "5322" | "5323" | "5324" | "5325" | "5326" | "5330" | "5331" | "5332" | "5333" | "5334" | "5335" | "5336" | "5340" | "5341" | "5342" | "5343" | "5344" | "5345" | "5346" | "5350" | "5351" | "5352" | "5353" | "5354" | "5355" | "5356" | "5360" | "5361" | "5362" | "5363" | "5364" | "5365" | "5366" | "5400" | "5401" | "5402" | "5403" | "5404" | "5405" | "5406" | "5410" | "5411" | "5412" | "5413" | "5414" | "5415" | "5416" | "5420" | "5421" | "5422" | "5423" | "5424" | "5425" | "5426" | "5430" | "5431" | "5432" | "5433" | "5434" | "5435" | "5436" | "5440" | "5441" | "5442" | "5443" | "5444" | "5445" | "5446" | "5450" | "5451" | "5452" | "5453" | "5454" | "5455" | "5456" | "5460" | "5461" | "5462" | "5463" | "5464" | "5465" | "5466" | "5500" | "5501" | "5502" | "5503" | "5504" | "5505" | "5506" | "5510" | "5511" | "5512" | "5513" | "5514" | "5515" | "5516" | "5520" | "5521" | "5522" | "5523" | "5524" | "5525" | "5526" | "5530" | "5531" | "5532" | "5533" | "5534" | "5535" | "5536" | "5540" | "5541" | "5542" | "5543" | "5544" | "5545" | "5546" | "5550" | "5551" | "5552" | "5553" | "5554" | "5555" | "5556" | "5560" | "5561" | "5562" | "5563" | "5564" | "5565" | "5566" | "5600" | "5601" | "5602" | "5603" | "5604" | "5605" | "5606" | "5610" | "5611" | "5612" | "5613" | "5614" | "5615" | "5616" | "5620" | "5621" | "5622" | "5623" | "5624" | "5625" | "5626" | "5630" | "5631" | "5632" | "5633" | "5634" | "5635" | "5636" | "5640" | "5641" | "5642" | "5643" | "5644" | "5645" | "5646" | "5650" | "5651" | "5652" | "5653" | "5654" | "5655" | "5656" | "5660" | "5661" | "5662" | "5663" | "5664" | "5665" | "5666" | undefined) & T2' and 'T1 | null'. +relationComplexitySharedCheckOrder.ts(20,1): error TS2859: Excessive complexity comparing types '("0000" | "0001" | "0002" | "0003" | "0004" | "0005" | "0006" | "0010" | "0011" | "0012" | "0013" | "0014" | "0015" | "0016" | "0020" | "0021" | "0022" | "0023" | "0024" | "0025" | "0026" | "0030" | "0031" | "0032" | "0033" | "0034" | "0035" | "0036" | "0040" | "0041" | "0042" | "0043" | "0044" | "0045" | "0046" | "0050" | "0051" | "0052" | "0053" | "0054" | "0055" | "0056" | "0060" | "0061" | "0062" | "0063" | "0064" | "0065" | "0066" | "0100" | "0101" | "0102" | "0103" | "0104" | "0105" | "0106" | "0110" | "0111" | "0112" | "0113" | "0114" | "0115" | "0116" | "0120" | "0121" | "0122" | "0123" | "0124" | "0125" | "0126" | "0130" | "0131" | "0132" | "0133" | "0134" | "0135" | "0136" | "0140" | "0141" | "0142" | "0143" | "0144" | "0145" | "0146" | "0150" | "0151" | "0152" | "0153" | "0154" | "0155" | "0156" | "0160" | "0161" | "0162" | "0163" | "0164" | "0165" | "0166" | "0200" | "0201" | "0202" | "0203" | "0204" | "0205" | "0206" | "0210" | "0211" | "0212" | "0213" | "0214" | "0215" | "0216" | "0220" | "0221" | "0222" | "0223" | "0224" | "0225" | "0226" | "0230" | "0231" | "0232" | "0233" | "0234" | "0235" | "0236" | "0240" | "0241" | "0242" | "0243" | "0244" | "0245" | "0246" | "0250" | "0251" | "0252" | "0253" | "0254" | "0255" | "0256" | "0260" | "0261" | "0262" | "0263" | "0264" | "0265" | "0266" | "0300" | "0301" | "0302" | "0303" | "0304" | "0305" | "0306" | "0310" | "0311" | "0312" | "0313" | "0314" | "0315" | "0316" | "0320" | "0321" | "0322" | "0323" | "0324" | "0325" | "0326" | "0330" | "0331" | "0332" | "0333" | "0334" | "0335" | "0336" | "0340" | "0341" | "0342" | "0343" | "0344" | "0345" | "0346" | "0350" | "0351" | "0352" | "0353" | "0354" | "0355" | "0356" | "0360" | "0361" | "0362" | "0363" | "0364" | "0365" | "0366" | "0400" | "0401" | "0402" | "0403" | "0404" | "0405" | "0406" | "0410" | "0411" | "0412" | "0413" | "0414" | "0415" | "0416" | "0420" | "0421" | "0422" | "0423" | "0424" | "0425" | "0426" | "0430" | "0431" | "0432" | "0433" | "0434" | "0435" | "0436" | "0440" | "0441" | "0442" | "0443" | "0444" | "0445" | "0446" | "0450" | "0451" | "0452" | "0453" | "0454" | "0455" | "0456" | "0460" | "0461" | "0462" | "0463" | "0464" | "0465" | "0466" | "0500" | "0501" | "0502" | "0503" | "0504" | "0505" | "0506" | "0510" | "0511" | "0512" | "0513" | "0514" | "0515" | "0516" | "0520" | "0521" | "0522" | "0523" | "0524" | "0525" | "0526" | "0530" | "0531" | "0532" | "0533" | "0534" | "0535" | "0536" | "0540" | "0541" | "0542" | "0543" | "0544" | "0545" | "0546" | "0550" | "0551" | "0552" | "0553" | "0554" | "0555" | "0556" | "0560" | "0561" | "0562" | "0563" | "0564" | "0565" | "0566" | "0600" | "0601" | "0602" | "0603" | "0604" | "0605" | "0606" | "0610" | "0611" | "0612" | "0613" | "0614" | "0615" | "0616" | "0620" | "0621" | "0622" | "0623" | "0624" | "0625" | "0626" | "0630" | "0631" | "0632" | "0633" | "0634" | "0635" | "0636" | "0640" | "0641" | "0642" | "0643" | "0644" | "0645" | "0646" | "0650" | "0651" | "0652" | "0653" | "0654" | "0655" | "0656" | "0660" | "0661" | "0662" | "0663" | "0664" | "0665" | "0666" | "1000" | "1001" | "1002" | "1003" | "1004" | "1005" | "1006" | "1010" | "1011" | "1012" | "1013" | "1014" | "1015" | "1016" | "1020" | "1021" | "1022" | "1023" | "1024" | "1025" | "1026" | "1030" | "1031" | "1032" | "1033" | "1034" | "1035" | "1036" | "1040" | "1041" | "1042" | "1043" | "1044" | "1045" | "1046" | "1050" | "1051" | "1052" | "1053" | "1054" | "1055" | "1056" | "1060" | "1061" | "1062" | "1063" | "1064" | "1065" | "1066" | "1100" | "1101" | "1102" | "1103" | "1104" | "1105" | "1106" | "1110" | "1111" | "1112" | "1113" | "1114" | "1115" | "1116" | "1120" | "1121" | "1122" | "1123" | "1124" | "1125" | "1126" | "1130" | "1131" | "1132" | "1133" | "1134" | "1135" | "1136" | "1140" | "1141" | "1142" | "1143" | "1144" | "1145" | "1146" | "1150" | "1151" | "1152" | "1153" | "1154" | "1155" | "1156" | "1160" | "1161" | "1162" | "1163" | "1164" | "1165" | "1166" | "1200" | "1201" | "1202" | "1203" | "1204" | "1205" | "1206" | "1210" | "1211" | "1212" | "1213" | "1214" | "1215" | "1216" | "1220" | "1221" | "1222" | "1223" | "1224" | "1225" | "1226" | "1230" | "1231" | "1232" | "1233" | "1234" | "1235" | "1236" | "1240" | "1241" | "1242" | "1243" | "1244" | "1245" | "1246" | "1250" | "1251" | "1252" | "1253" | "1254" | "1255" | "1256" | "1260" | "1261" | "1262" | "1263" | "1264" | "1265" | "1266" | "1300" | "1301" | "1302" | "1303" | "1304" | "1305" | "1306" | "1310" | "1311" | "1312" | "1313" | "1314" | "1315" | "1316" | "1320" | "1321" | "1322" | "1323" | "1324" | "1325" | "1326" | "1330" | "1331" | "1332" | "1333" | "1334" | "1335" | "1336" | "1340" | "1341" | "1342" | "1343" | "1344" | "1345" | "1346" | "1350" | "1351" | "1352" | "1353" | "1354" | "1355" | "1356" | "1360" | "1361" | "1362" | "1363" | "1364" | "1365" | "1366" | "1400" | "1401" | "1402" | "1403" | "1404" | "1405" | "1406" | "1410" | "1411" | "1412" | "1413" | "1414" | "1415" | "1416" | "1420" | "1421" | "1422" | "1423" | "1424" | "1425" | "1426" | "1430" | "1431" | "1432" | "1433" | "1434" | "1435" | "1436" | "1440" | "1441" | "1442" | "1443" | "1444" | "1445" | "1446" | "1450" | "1451" | "1452" | "1453" | "1454" | "1455" | "1456" | "1460" | "1461" | "1462" | "1463" | "1464" | "1465" | "1466" | "1500" | "1501" | "1502" | "1503" | "1504" | "1505" | "1506" | "1510" | "1511" | "1512" | "1513" | "1514" | "1515" | "1516" | "1520" | "1521" | "1522" | "1523" | "1524" | "1525" | "1526" | "1530" | "1531" | "1532" | "1533" | "1534" | "1535" | "1536" | "1540" | "1541" | "1542" | "1543" | "1544" | "1545" | "1546" | "1550" | "1551" | "1552" | "1553" | "1554" | "1555" | "1556" | "1560" | "1561" | "1562" | "1563" | "1564" | "1565" | "1566" | "1600" | "1601" | "1602" | "1603" | "1604" | "1605" | "1606" | "1610" | "1611" | "1612" | "1613" | "1614" | "1615" | "1616" | "1620" | "1621" | "1622" | "1623" | "1624" | "1625" | "1626" | "1630" | "1631" | "1632" | "1633" | "1634" | "1635" | "1636" | "1640" | "1641" | "1642" | "1643" | "1644" | "1645" | "1646" | "1650" | "1651" | "1652" | "1653" | "1654" | "1655" | "1656" | "1660" | "1661" | "1662" | "1663" | "1664" | "1665" | "1666" | "2000" | "2001" | "2002" | "2003" | "2004" | "2005" | "2006" | "2010" | "2011" | "2012" | "2013" | "2014" | "2015" | "2016" | "2020" | "2021" | "2022" | "2023" | "2024" | "2025" | "2026" | "2030" | "2031" | "2032" | "2033" | "2034" | "2035" | "2036" | "2040" | "2041" | "2042" | "2043" | "2044" | "2045" | "2046" | "2050" | "2051" | "2052" | "2053" | "2054" | "2055" | "2056" | "2060" | "2061" | "2062" | "2063" | "2064" | "2065" | "2066" | "2100" | "2101" | "2102" | "2103" | "2104" | "2105" | "2106" | "2110" | "2111" | "2112" | "2113" | "2114" | "2115" | "2116" | "2120" | "2121" | "2122" | "2123" | "2124" | "2125" | "2126" | "2130" | "2131" | "2132" | "2133" | "2134" | "2135" | "2136" | "2140" | "2141" | "2142" | "2143" | "2144" | "2145" | "2146" | "2150" | "2151" | "2152" | "2153" | "2154" | "2155" | "2156" | "2160" | "2161" | "2162" | "2163" | "2164" | "2165" | "2166" | "2200" | "2201" | "2202" | "2203" | "2204" | "2205" | "2206" | "2210" | "2211" | "2212" | "2213" | "2214" | "2215" | "2216" | "2220" | "2221" | "2222" | "2223" | "2224" | "2225" | "2226" | "2230" | "2231" | "2232" | "2233" | "2234" | "2235" | "2236" | "2240" | "2241" | "2242" | "2243" | "2244" | "2245" | "2246" | "2250" | "2251" | "2252" | "2253" | "2254" | "2255" | "2256" | "2260" | "2261" | "2262" | "2263" | "2264" | "2265" | "2266" | "2300" | "2301" | "2302" | "2303" | "2304" | "2305" | "2306" | "2310" | "2311" | "2312" | "2313" | "2314" | "2315" | "2316" | "2320" | "2321" | "2322" | "2323" | "2324" | "2325" | "2326" | "2330" | "2331" | "2332" | "2333" | "2334" | "2335" | "2336" | "2340" | "2341" | "2342" | "2343" | "2344" | "2345" | "2346" | "2350" | "2351" | "2352" | "2353" | "2354" | "2355" | "2356" | "2360" | "2361" | "2362" | "2363" | "2364" | "2365" | "2366" | "2400" | "2401" | "2402" | "2403" | "2404" | "2405" | "2406" | "2410" | "2411" | "2412" | "2413" | "2414" | "2415" | "2416" | "2420" | "2421" | "2422" | "2423" | "2424" | "2425" | "2426" | "2430" | "2431" | "2432" | "2433" | "2434" | "2435" | "2436" | "2440" | "2441" | "2442" | "2443" | "2444" | "2445" | "2446" | "2450" | "2451" | "2452" | "2453" | "2454" | "2455" | "2456" | "2460" | "2461" | "2462" | "2463" | "2464" | "2465" | "2466" | "2500" | "2501" | "2502" | "2503" | "2504" | "2505" | "2506" | "2510" | "2511" | "2512" | "2513" | "2514" | "2515" | "2516" | "2520" | "2521" | "2522" | "2523" | "2524" | "2525" | "2526" | "2530" | "2531" | "2532" | "2533" | "2534" | "2535" | "2536" | "2540" | "2541" | "2542" | "2543" | "2544" | "2545" | "2546" | "2550" | "2551" | "2552" | "2553" | "2554" | "2555" | "2556" | "2560" | "2561" | "2562" | "2563" | "2564" | "2565" | "2566" | "2600" | "2601" | "2602" | "2603" | "2604" | "2605" | "2606" | "2610" | "2611" | "2612" | "2613" | "2614" | "2615" | "2616" | "2620" | "2621" | "2622" | "2623" | "2624" | "2625" | "2626" | "2630" | "2631" | "2632" | "2633" | "2634" | "2635" | "2636" | "2640" | "2641" | "2642" | "2643" | "2644" | "2645" | "2646" | "2650" | "2651" | "2652" | "2653" | "2654" | "2655" | "2656" | "2660" | "2661" | "2662" | "2663" | "2664" | "2665" | "2666" | "3000" | "3001" | "3002" | "3003" | "3004" | "3005" | "3006" | "3010" | "3011" | "3012" | "3013" | "3014" | "3015" | "3016" | "3020" | "3021" | "3022" | "3023" | "3024" | "3025" | "3026" | "3030" | "3031" | "3032" | "3033" | "3034" | "3035" | "3036" | "3040" | "3041" | "3042" | "3043" | "3044" | "3045" | "3046" | "3050" | "3051" | "3052" | "3053" | "3054" | "3055" | "3056" | "3060" | "3061" | "3062" | "3063" | "3064" | "3065" | "3066" | "3100" | "3101" | "3102" | "3103" | "3104" | "3105" | "3106" | "3110" | "3111" | "3112" | "3113" | "3114" | "3115" | "3116" | "3120" | "3121" | "3122" | "3123" | "3124" | "3125" | "3126" | "3130" | "3131" | "3132" | "3133" | "3134" | "3135" | "3136" | "3140" | "3141" | "3142" | "3143" | "3144" | "3145" | "3146" | "3150" | "3151" | "3152" | "3153" | "3154" | "3155" | "3156" | "3160" | "3161" | "3162" | "3163" | "3164" | "3165" | "3166" | "3200" | "3201" | "3202" | "3203" | "3204" | "3205" | "3206" | "3210" | "3211" | "3212" | "3213" | "3214" | "3215" | "3216" | "3220" | "3221" | "3222" | "3223" | "3224" | "3225" | "3226" | "3230" | "3231" | "3232" | "3233" | "3234" | "3235" | "3236" | "3240" | "3241" | "3242" | "3243" | "3244" | "3245" | "3246" | "3250" | "3251" | "3252" | "3253" | "3254" | "3255" | "3256" | "3260" | "3261" | "3262" | "3263" | "3264" | "3265" | "3266" | "3300" | "3301" | "3302" | "3303" | "3304" | "3305" | "3306" | "3310" | "3311" | "3312" | "3313" | "3314" | "3315" | "3316" | "3320" | "3321" | "3322" | "3323" | "3324" | "3325" | "3326" | "3330" | "3331" | "3332" | "3333" | "3334" | "3335" | "3336" | "3340" | "3341" | "3342" | "3343" | "3344" | "3345" | "3346" | "3350" | "3351" | "3352" | "3353" | "3354" | "3355" | "3356" | "3360" | "3361" | "3362" | "3363" | "3364" | "3365" | "3366" | "3400" | "3401" | "3402" | "3403" | "3404" | "3405" | "3406" | "3410" | "3411" | "3412" | "3413" | "3414" | "3415" | "3416" | "3420" | "3421" | "3422" | "3423" | "3424" | "3425" | "3426" | "3430" | "3431" | "3432" | "3433" | "3434" | "3435" | "3436" | "3440" | "3441" | "3442" | "3443" | "3444" | "3445" | "3446" | "3450" | "3451" | "3452" | "3453" | "3454" | "3455" | "3456" | "3460" | "3461" | "3462" | "3463" | "3464" | "3465" | "3466" | "3500" | "3501" | "3502" | "3503" | "3504" | "3505" | "3506" | "3510" | "3511" | "3512" | "3513" | "3514" | "3515" | "3516" | "3520" | "3521" | "3522" | "3523" | "3524" | "3525" | "3526" | "3530" | "3531" | "3532" | "3533" | "3534" | "3535" | "3536" | "3540" | "3541" | "3542" | "3543" | "3544" | "3545" | "3546" | "3550" | "3551" | "3552" | "3553" | "3554" | "3555" | "3556" | "3560" | "3561" | "3562" | "3563" | "3564" | "3565" | "3566" | "3600" | "3601" | "3602" | "3603" | "3604" | "3605" | "3606" | "3610" | "3611" | "3612" | "3613" | "3614" | "3615" | "3616" | "3620" | "3621" | "3622" | "3623" | "3624" | "3625" | "3626" | "3630" | "3631" | "3632" | "3633" | "3634" | "3635" | "3636" | "3640" | "3641" | "3642" | "3643" | "3644" | "3645" | "3646" | "3650" | "3651" | "3652" | "3653" | "3654" | "3655" | "3656" | "3660" | "3661" | "3662" | "3663" | "3664" | "3665" | "3666" | "4000" | "4001" | "4002" | "4003" | "4004" | "4005" | "4006" | "4010" | "4011" | "4012" | "4013" | "4014" | "4015" | "4016" | "4020" | "4021" | "4022" | "4023" | "4024" | "4025" | "4026" | "4030" | "4031" | "4032" | "4033" | "4034" | "4035" | "4036" | "4040" | "4041" | "4042" | "4043" | "4044" | "4045" | "4046" | "4050" | "4051" | "4052" | "4053" | "4054" | "4055" | "4056" | "4060" | "4061" | "4062" | "4063" | "4064" | "4065" | "4066" | "4100" | "4101" | "4102" | "4103" | "4104" | "4105" | "4106" | "4110" | "4111" | "4112" | "4113" | "4114" | "4115" | "4116" | "4120" | "4121" | "4122" | "4123" | "4124" | "4125" | "4126" | "4130" | "4131" | "4132" | "4133" | "4134" | "4135" | "4136" | "4140" | "4141" | "4142" | "4143" | "4144" | "4145" | "4146" | "4150" | "4151" | "4152" | "4153" | "4154" | "4155" | "4156" | "4160" | "4161" | "4162" | "4163" | "4164" | "4165" | "4166" | "4200" | "4201" | "4202" | "4203" | "4204" | "4205" | "4206" | "4210" | "4211" | "4212" | "4213" | "4214" | "4215" | "4216" | "4220" | "4221" | "4222" | "4223" | "4224" | "4225" | "4226" | "4230" | "4231" | "4232" | "4233" | "4234" | "4235" | "4236" | "4240" | "4241" | "4242" | "4243" | "4244" | "4245" | "4246" | "4250" | "4251" | "4252" | "4253" | "4254" | "4255" | "4256" | "4260" | "4261" | "4262" | "4263" | "4264" | "4265" | "4266" | "4300" | "4301" | "4302" | "4303" | "4304" | "4305" | "4306" | "4310" | "4311" | "4312" | "4313" | "4314" | "4315" | "4316" | "4320" | "4321" | "4322" | "4323" | "4324" | "4325" | "4326" | "4330" | "4331" | "4332" | "4333" | "4334" | "4335" | "4336" | "4340" | "4341" | "4342" | "4343" | "4344" | "4345" | "4346" | "4350" | "4351" | "4352" | "4353" | "4354" | "4355" | "4356" | "4360" | "4361" | "4362" | "4363" | "4364" | "4365" | "4366" | "4400" | "4401" | "4402" | "4403" | "4404" | "4405" | "4406" | "4410" | "4411" | "4412" | "4413" | "4414" | "4415" | "4416" | "4420" | "4421" | "4422" | "4423" | "4424" | "4425" | "4426" | "4430" | "4431" | "4432" | "4433" | "4434" | "4435" | "4436" | "4440" | "4441" | "4442" | "4443" | "4444" | "4445" | "4446" | "4450" | "4451" | "4452" | "4453" | "4454" | "4455" | "4456" | "4460" | "4461" | "4462" | "4463" | "4464" | "4465" | "4466" | "4500" | "4501" | "4502" | "4503" | "4504" | "4505" | "4506" | "4510" | "4511" | "4512" | "4513" | "4514" | "4515" | "4516" | "4520" | "4521" | "4522" | "4523" | "4524" | "4525" | "4526" | "4530" | "4531" | "4532" | "4533" | "4534" | "4535" | "4536" | "4540" | "4541" | "4542" | "4543" | "4544" | "4545" | "4546" | "4550" | "4551" | "4552" | "4553" | "4554" | "4555" | "4556" | "4560" | "4561" | "4562" | "4563" | "4564" | "4565" | "4566" | "4600" | "4601" | "4602" | "4603" | "4604" | "4605" | "4606" | "4610" | "4611" | "4612" | "4613" | "4614" | "4615" | "4616" | "4620" | "4621" | "4622" | "4623" | "4624" | "4625" | "4626" | "4630" | "4631" | "4632" | "4633" | "4634" | "4635" | "4636" | "4640" | "4641" | "4642" | "4643" | "4644" | "4645" | "4646" | "4650" | "4651" | "4652" | "4653" | "4654" | "4655" | "4656" | "4660" | "4661" | "4662" | "4663" | "4664" | "4665" | "4666" | "5000" | "5001" | "5002" | "5003" | "5004" | "5005" | "5006" | "5010" | "5011" | "5012" | "5013" | "5014" | "5015" | "5016" | "5020" | "5021" | "5022" | "5023" | "5024" | "5025" | "5026" | "5030" | "5031" | "5032" | "5033" | "5034" | "5035" | "5036" | "5040" | "5041" | "5042" | "5043" | "5044" | "5045" | "5046" | "5050" | "5051" | "5052" | "5053" | "5054" | "5055" | "5056" | "5060" | "5061" | "5062" | "5063" | "5064" | "5065" | "5066" | "5100" | "5101" | "5102" | "5103" | "5104" | "5105" | "5106" | "5110" | "5111" | "5112" | "5113" | "5114" | "5115" | "5116" | "5120" | "5121" | "5122" | "5123" | "5124" | "5125" | "5126" | "5130" | "5131" | "5132" | "5133" | "5134" | "5135" | "5136" | "5140" | "5141" | "5142" | "5143" | "5144" | "5145" | "5146" | "5150" | "5151" | "5152" | "5153" | "5154" | "5155" | "5156" | "5160" | "5161" | "5162" | "5163" | "5164" | "5165" | "5166" | "5200" | "5201" | "5202" | "5203" | "5204" | "5205" | "5206" | "5210" | "5211" | "5212" | "5213" | "5214" | "5215" | "5216" | "5220" | "5221" | "5222" | "5223" | "5224" | "5225" | "5226" | "5230" | "5231" | "5232" | "5233" | "5234" | "5235" | "5236" | "5240" | "5241" | "5242" | "5243" | "5244" | "5245" | "5246" | "5250" | "5251" | "5252" | "5253" | "5254" | "5255" | "5256" | "5260" | "5261" | "5262" | "5263" | "5264" | "5265" | "5266" | "5300" | "5301" | "5302" | "5303" | "5304" | "5305" | "5306" | "5310" | "5311" | "5312" | "5313" | "5314" | "5315" | "5316" | "5320" | "5321" | "5322" | "5323" | "5324" | "5325" | "5326" | "5330" | "5331" | "5332" | "5333" | "5334" | "5335" | "5336" | "5340" | "5341" | "5342" | "5343" | "5344" | "5345" | "5346" | "5350" | "5351" | "5352" | "5353" | "5354" | "5355" | "5356" | "5360" | "5361" | "5362" | "5363" | "5364" | "5365" | "5366" | "5400" | "5401" | "5402" | "5403" | "5404" | "5405" | "5406" | "5410" | "5411" | "5412" | "5413" | "5414" | "5415" | "5416" | "5420" | "5421" | "5422" | "5423" | "5424" | "5425" | "5426" | "5430" | "5431" | "5432" | "5433" | "5434" | "5435" | "5436" | "5440" | "5441" | "5442" | "5443" | "5444" | "5445" | "5446" | "5450" | "5451" | "5452" | "5453" | "5454" | "5455" | "5456" | "5460" | "5461" | "5462" | "5463" | "5464" | "5465" | "5466" | "5500" | "5501" | "5502" | "5503" | "5504" | "5505" | "5506" | "5510" | "5511" | "5512" | "5513" | "5514" | "5515" | "5516" | "5520" | "5521" | "5522" | "5523" | "5524" | "5525" | "5526" | "5530" | "5531" | "5532" | "5533" | "5534" | "5535" | "5536" | "5540" | "5541" | "5542" | "5543" | "5544" | "5545" | "5546" | "5550" | "5551" | "5552" | "5553" | "5554" | "5555" | "5556" | "5560" | "5561" | "5562" | "5563" | "5564" | "5565" | "5566" | "5600" | "5601" | "5602" | "5603" | "5604" | "5605" | "5606" | "5610" | "5611" | "5612" | "5613" | "5614" | "5615" | "5616" | "5620" | "5621" | "5622" | "5623" | "5624" | "5625" | "5626" | "5630" | "5631" | "5632" | "5633" | "5634" | "5635" | "5636" | "5640" | "5641" | "5642" | "5643" | "5644" | "5645" | "5646" | "5650" | "5651" | "5652" | "5653" | "5654" | "5655" | "5656" | "5660" | "5661" | "5662" | "5663" | "5664" | "5665" | "5666" | undefined) & T2' and 'T1 | null'. relationComplexitySharedCheckOrder.ts(22,1): error TS2859: Excessive complexity comparing types 'T1 & T2' and 'T1 | null'. relationComplexitySharedCheckOrder.ts(22,1): error TS2859: Excessive complexity comparing types 'T1 & T2' and 'T1 | null'. -==== relationComplexitySharedCheckOrder.ts (3 errors) ==== +==== relationComplexitySharedCheckOrder.ts (4 errors) ==== // Relating y to x fresh caches too many comparisons. In program order the // comparisons before it have cached all but a seventh of them. Whether // relating y is too complex must not depend on which comes first. @@ -25,6 +26,8 @@ relationComplexitySharedCheckOrder.ts(22,1): error TS2859: Excessive complexity declare const y6: (`${'0' | '1' | '2' | '3' | '4' | '5'}${D}${D}${D}` | undefined) & T2; x = y6; ~ +!!! error TS2859: Excessive complexity comparing types '("0000" | "0001" | "0002" | "0003" | "0004" | "0005" | "0006" | "0010" | "0011" | "0012" | "0013" | "0014" | "0015" | "0016" | "0020" | "0021" | "0022" | "0023" | "0024" | "0025" | "0026" | "0030" | "0031" | "0032" | "0033" | "0034" | "0035" | "0036" | "0040" | "0041" | "0042" | "0043" | "0044" | "0045" | "0046" | "0050" | "0051" | "0052" | "0053" | "0054" | "0055" | "0056" | "0060" | "0061" | "0062" | "0063" | "0064" | "0065" | "0066" | "0100" | "0101" | "0102" | "0103" | "0104" | "0105" | "0106" | "0110" | "0111" | "0112" | "0113" | "0114" | "0115" | "0116" | "0120" | "0121" | "0122" | "0123" | "0124" | "0125" | "0126" | "0130" | "0131" | "0132" | "0133" | "0134" | "0135" | "0136" | "0140" | "0141" | "0142" | "0143" | "0144" | "0145" | "0146" | "0150" | "0151" | "0152" | "0153" | "0154" | "0155" | "0156" | "0160" | "0161" | "0162" | "0163" | "0164" | "0165" | "0166" | "0200" | "0201" | "0202" | "0203" | "0204" | "0205" | "0206" | "0210" | "0211" | "0212" | "0213" | "0214" | "0215" | "0216" | "0220" | "0221" | "0222" | "0223" | "0224" | "0225" | "0226" | "0230" | "0231" | "0232" | "0233" | "0234" | "0235" | "0236" | "0240" | "0241" | "0242" | "0243" | "0244" | "0245" | "0246" | "0250" | "0251" | "0252" | "0253" | "0254" | "0255" | "0256" | "0260" | "0261" | "0262" | "0263" | "0264" | "0265" | "0266" | "0300" | "0301" | "0302" | "0303" | "0304" | "0305" | "0306" | "0310" | "0311" | "0312" | "0313" | "0314" | "0315" | "0316" | "0320" | "0321" | "0322" | "0323" | "0324" | "0325" | "0326" | "0330" | "0331" | "0332" | "0333" | "0334" | "0335" | "0336" | "0340" | "0341" | "0342" | "0343" | "0344" | "0345" | "0346" | "0350" | "0351" | "0352" | "0353" | "0354" | "0355" | "0356" | "0360" | "0361" | "0362" | "0363" | "0364" | "0365" | "0366" | "0400" | "0401" | "0402" | "0403" | "0404" | "0405" | "0406" | "0410" | "0411" | "0412" | "0413" | "0414" | "0415" | "0416" | "0420" | "0421" | "0422" | "0423" | "0424" | "0425" | "0426" | "0430" | "0431" | "0432" | "0433" | "0434" | "0435" | "0436" | "0440" | "0441" | "0442" | "0443" | "0444" | "0445" | "0446" | "0450" | "0451" | "0452" | "0453" | "0454" | "0455" | "0456" | "0460" | "0461" | "0462" | "0463" | "0464" | "0465" | "0466" | "0500" | "0501" | "0502" | "0503" | "0504" | "0505" | "0506" | "0510" | "0511" | "0512" | "0513" | "0514" | "0515" | "0516" | "0520" | "0521" | "0522" | "0523" | "0524" | "0525" | "0526" | "0530" | "0531" | "0532" | "0533" | "0534" | "0535" | "0536" | "0540" | "0541" | "0542" | "0543" | "0544" | "0545" | "0546" | "0550" | "0551" | "0552" | "0553" | "0554" | "0555" | "0556" | "0560" | "0561" | "0562" | "0563" | "0564" | "0565" | "0566" | "0600" | "0601" | "0602" | "0603" | "0604" | "0605" | "0606" | "0610" | "0611" | "0612" | "0613" | "0614" | "0615" | "0616" | "0620" | "0621" | "0622" | "0623" | "0624" | "0625" | "0626" | "0630" | "0631" | "0632" | "0633" | "0634" | "0635" | "0636" | "0640" | "0641" | "0642" | "0643" | "0644" | "0645" | "0646" | "0650" | "0651" | "0652" | "0653" | "0654" | "0655" | "0656" | "0660" | "0661" | "0662" | "0663" | "0664" | "0665" | "0666" | "1000" | "1001" | "1002" | "1003" | "1004" | "1005" | "1006" | "1010" | "1011" | "1012" | "1013" | "1014" | "1015" | "1016" | "1020" | "1021" | "1022" | "1023" | "1024" | "1025" | "1026" | "1030" | "1031" | "1032" | "1033" | "1034" | "1035" | "1036" | "1040" | "1041" | "1042" | "1043" | "1044" | "1045" | "1046" | "1050" | "1051" | "1052" | "1053" | "1054" | "1055" | "1056" | "1060" | "1061" | "1062" | "1063" | "1064" | "1065" | "1066" | "1100" | "1101" | "1102" | "1103" | "1104" | "1105" | "1106" | "1110" | "1111" | "1112" | "1113" | "1114" | "1115" | "1116" | "1120" | "1121" | "1122" | "1123" | "1124" | "1125" | "1126" | "1130" | "1131" | "1132" | "1133" | "1134" | "1135" | "1136" | "1140" | "1141" | "1142" | "1143" | "1144" | "1145" | "1146" | "1150" | "1151" | "1152" | "1153" | "1154" | "1155" | "1156" | "1160" | "1161" | "1162" | "1163" | "1164" | "1165" | "1166" | "1200" | "1201" | "1202" | "1203" | "1204" | "1205" | "1206" | "1210" | "1211" | "1212" | "1213" | "1214" | "1215" | "1216" | "1220" | "1221" | "1222" | "1223" | "1224" | "1225" | "1226" | "1230" | "1231" | "1232" | "1233" | "1234" | "1235" | "1236" | "1240" | "1241" | "1242" | "1243" | "1244" | "1245" | "1246" | "1250" | "1251" | "1252" | "1253" | "1254" | "1255" | "1256" | "1260" | "1261" | "1262" | "1263" | "1264" | "1265" | "1266" | "1300" | "1301" | "1302" | "1303" | "1304" | "1305" | "1306" | "1310" | "1311" | "1312" | "1313" | "1314" | "1315" | "1316" | "1320" | "1321" | "1322" | "1323" | "1324" | "1325" | "1326" | "1330" | "1331" | "1332" | "1333" | "1334" | "1335" | "1336" | "1340" | "1341" | "1342" | "1343" | "1344" | "1345" | "1346" | "1350" | "1351" | "1352" | "1353" | "1354" | "1355" | "1356" | "1360" | "1361" | "1362" | "1363" | "1364" | "1365" | "1366" | "1400" | "1401" | "1402" | "1403" | "1404" | "1405" | "1406" | "1410" | "1411" | "1412" | "1413" | "1414" | "1415" | "1416" | "1420" | "1421" | "1422" | "1423" | "1424" | "1425" | "1426" | "1430" | "1431" | "1432" | "1433" | "1434" | "1435" | "1436" | "1440" | "1441" | "1442" | "1443" | "1444" | "1445" | "1446" | "1450" | "1451" | "1452" | "1453" | "1454" | "1455" | "1456" | "1460" | "1461" | "1462" | "1463" | "1464" | "1465" | "1466" | "1500" | "1501" | "1502" | "1503" | "1504" | "1505" | "1506" | "1510" | "1511" | "1512" | "1513" | "1514" | "1515" | "1516" | "1520" | "1521" | "1522" | "1523" | "1524" | "1525" | "1526" | "1530" | "1531" | "1532" | "1533" | "1534" | "1535" | "1536" | "1540" | "1541" | "1542" | "1543" | "1544" | "1545" | "1546" | "1550" | "1551" | "1552" | "1553" | "1554" | "1555" | "1556" | "1560" | "1561" | "1562" | "1563" | "1564" | "1565" | "1566" | "1600" | "1601" | "1602" | "1603" | "1604" | "1605" | "1606" | "1610" | "1611" | "1612" | "1613" | "1614" | "1615" | "1616" | "1620" | "1621" | "1622" | "1623" | "1624" | "1625" | "1626" | "1630" | "1631" | "1632" | "1633" | "1634" | "1635" | "1636" | "1640" | "1641" | "1642" | "1643" | "1644" | "1645" | "1646" | "1650" | "1651" | "1652" | "1653" | "1654" | "1655" | "1656" | "1660" | "1661" | "1662" | "1663" | "1664" | "1665" | "1666" | "2000" | "2001" | "2002" | "2003" | "2004" | "2005" | "2006" | "2010" | "2011" | "2012" | "2013" | "2014" | "2015" | "2016" | "2020" | "2021" | "2022" | "2023" | "2024" | "2025" | "2026" | "2030" | "2031" | "2032" | "2033" | "2034" | "2035" | "2036" | "2040" | "2041" | "2042" | "2043" | "2044" | "2045" | "2046" | "2050" | "2051" | "2052" | "2053" | "2054" | "2055" | "2056" | "2060" | "2061" | "2062" | "2063" | "2064" | "2065" | "2066" | "2100" | "2101" | "2102" | "2103" | "2104" | "2105" | "2106" | "2110" | "2111" | "2112" | "2113" | "2114" | "2115" | "2116" | "2120" | "2121" | "2122" | "2123" | "2124" | "2125" | "2126" | "2130" | "2131" | "2132" | "2133" | "2134" | "2135" | "2136" | "2140" | "2141" | "2142" | "2143" | "2144" | "2145" | "2146" | "2150" | "2151" | "2152" | "2153" | "2154" | "2155" | "2156" | "2160" | "2161" | "2162" | "2163" | "2164" | "2165" | "2166" | "2200" | "2201" | "2202" | "2203" | "2204" | "2205" | "2206" | "2210" | "2211" | "2212" | "2213" | "2214" | "2215" | "2216" | "2220" | "2221" | "2222" | "2223" | "2224" | "2225" | "2226" | "2230" | "2231" | "2232" | "2233" | "2234" | "2235" | "2236" | "2240" | "2241" | "2242" | "2243" | "2244" | "2245" | "2246" | "2250" | "2251" | "2252" | "2253" | "2254" | "2255" | "2256" | "2260" | "2261" | "2262" | "2263" | "2264" | "2265" | "2266" | "2300" | "2301" | "2302" | "2303" | "2304" | "2305" | "2306" | "2310" | "2311" | "2312" | "2313" | "2314" | "2315" | "2316" | "2320" | "2321" | "2322" | "2323" | "2324" | "2325" | "2326" | "2330" | "2331" | "2332" | "2333" | "2334" | "2335" | "2336" | "2340" | "2341" | "2342" | "2343" | "2344" | "2345" | "2346" | "2350" | "2351" | "2352" | "2353" | "2354" | "2355" | "2356" | "2360" | "2361" | "2362" | "2363" | "2364" | "2365" | "2366" | "2400" | "2401" | "2402" | "2403" | "2404" | "2405" | "2406" | "2410" | "2411" | "2412" | "2413" | "2414" | "2415" | "2416" | "2420" | "2421" | "2422" | "2423" | "2424" | "2425" | "2426" | "2430" | "2431" | "2432" | "2433" | "2434" | "2435" | "2436" | "2440" | "2441" | "2442" | "2443" | "2444" | "2445" | "2446" | "2450" | "2451" | "2452" | "2453" | "2454" | "2455" | "2456" | "2460" | "2461" | "2462" | "2463" | "2464" | "2465" | "2466" | "2500" | "2501" | "2502" | "2503" | "2504" | "2505" | "2506" | "2510" | "2511" | "2512" | "2513" | "2514" | "2515" | "2516" | "2520" | "2521" | "2522" | "2523" | "2524" | "2525" | "2526" | "2530" | "2531" | "2532" | "2533" | "2534" | "2535" | "2536" | "2540" | "2541" | "2542" | "2543" | "2544" | "2545" | "2546" | "2550" | "2551" | "2552" | "2553" | "2554" | "2555" | "2556" | "2560" | "2561" | "2562" | "2563" | "2564" | "2565" | "2566" | "2600" | "2601" | "2602" | "2603" | "2604" | "2605" | "2606" | "2610" | "2611" | "2612" | "2613" | "2614" | "2615" | "2616" | "2620" | "2621" | "2622" | "2623" | "2624" | "2625" | "2626" | "2630" | "2631" | "2632" | "2633" | "2634" | "2635" | "2636" | "2640" | "2641" | "2642" | "2643" | "2644" | "2645" | "2646" | "2650" | "2651" | "2652" | "2653" | "2654" | "2655" | "2656" | "2660" | "2661" | "2662" | "2663" | "2664" | "2665" | "2666" | "3000" | "3001" | "3002" | "3003" | "3004" | "3005" | "3006" | "3010" | "3011" | "3012" | "3013" | "3014" | "3015" | "3016" | "3020" | "3021" | "3022" | "3023" | "3024" | "3025" | "3026" | "3030" | "3031" | "3032" | "3033" | "3034" | "3035" | "3036" | "3040" | "3041" | "3042" | "3043" | "3044" | "3045" | "3046" | "3050" | "3051" | "3052" | "3053" | "3054" | "3055" | "3056" | "3060" | "3061" | "3062" | "3063" | "3064" | "3065" | "3066" | "3100" | "3101" | "3102" | "3103" | "3104" | "3105" | "3106" | "3110" | "3111" | "3112" | "3113" | "3114" | "3115" | "3116" | "3120" | "3121" | "3122" | "3123" | "3124" | "3125" | "3126" | "3130" | "3131" | "3132" | "3133" | "3134" | "3135" | "3136" | "3140" | "3141" | "3142" | "3143" | "3144" | "3145" | "3146" | "3150" | "3151" | "3152" | "3153" | "3154" | "3155" | "3156" | "3160" | "3161" | "3162" | "3163" | "3164" | "3165" | "3166" | "3200" | "3201" | "3202" | "3203" | "3204" | "3205" | "3206" | "3210" | "3211" | "3212" | "3213" | "3214" | "3215" | "3216" | "3220" | "3221" | "3222" | "3223" | "3224" | "3225" | "3226" | "3230" | "3231" | "3232" | "3233" | "3234" | "3235" | "3236" | "3240" | "3241" | "3242" | "3243" | "3244" | "3245" | "3246" | "3250" | "3251" | "3252" | "3253" | "3254" | "3255" | "3256" | "3260" | "3261" | "3262" | "3263" | "3264" | "3265" | "3266" | "3300" | "3301" | "3302" | "3303" | "3304" | "3305" | "3306" | "3310" | "3311" | "3312" | "3313" | "3314" | "3315" | "3316" | "3320" | "3321" | "3322" | "3323" | "3324" | "3325" | "3326" | "3330" | "3331" | "3332" | "3333" | "3334" | "3335" | "3336" | "3340" | "3341" | "3342" | "3343" | "3344" | "3345" | "3346" | "3350" | "3351" | "3352" | "3353" | "3354" | "3355" | "3356" | "3360" | "3361" | "3362" | "3363" | "3364" | "3365" | "3366" | "3400" | "3401" | "3402" | "3403" | "3404" | "3405" | "3406" | "3410" | "3411" | "3412" | "3413" | "3414" | "3415" | "3416" | "3420" | "3421" | "3422" | "3423" | "3424" | "3425" | "3426" | "3430" | "3431" | "3432" | "3433" | "3434" | "3435" | "3436" | "3440" | "3441" | "3442" | "3443" | "3444" | "3445" | "3446" | "3450" | "3451" | "3452" | "3453" | "3454" | "3455" | "3456" | "3460" | "3461" | "3462" | "3463" | "3464" | "3465" | "3466" | "3500" | "3501" | "3502" | "3503" | "3504" | "3505" | "3506" | "3510" | "3511" | "3512" | "3513" | "3514" | "3515" | "3516" | "3520" | "3521" | "3522" | "3523" | "3524" | "3525" | "3526" | "3530" | "3531" | "3532" | "3533" | "3534" | "3535" | "3536" | "3540" | "3541" | "3542" | "3543" | "3544" | "3545" | "3546" | "3550" | "3551" | "3552" | "3553" | "3554" | "3555" | "3556" | "3560" | "3561" | "3562" | "3563" | "3564" | "3565" | "3566" | "3600" | "3601" | "3602" | "3603" | "3604" | "3605" | "3606" | "3610" | "3611" | "3612" | "3613" | "3614" | "3615" | "3616" | "3620" | "3621" | "3622" | "3623" | "3624" | "3625" | "3626" | "3630" | "3631" | "3632" | "3633" | "3634" | "3635" | "3636" | "3640" | "3641" | "3642" | "3643" | "3644" | "3645" | "3646" | "3650" | "3651" | "3652" | "3653" | "3654" | "3655" | "3656" | "3660" | "3661" | "3662" | "3663" | "3664" | "3665" | "3666" | "4000" | "4001" | "4002" | "4003" | "4004" | "4005" | "4006" | "4010" | "4011" | "4012" | "4013" | "4014" | "4015" | "4016" | "4020" | "4021" | "4022" | "4023" | "4024" | "4025" | "4026" | "4030" | "4031" | "4032" | "4033" | "4034" | "4035" | "4036" | "4040" | "4041" | "4042" | "4043" | "4044" | "4045" | "4046" | "4050" | "4051" | "4052" | "4053" | "4054" | "4055" | "4056" | "4060" | "4061" | "4062" | "4063" | "4064" | "4065" | "4066" | "4100" | "4101" | "4102" | "4103" | "4104" | "4105" | "4106" | "4110" | "4111" | "4112" | "4113" | "4114" | "4115" | "4116" | "4120" | "4121" | "4122" | "4123" | "4124" | "4125" | "4126" | "4130" | "4131" | "4132" | "4133" | "4134" | "4135" | "4136" | "4140" | "4141" | "4142" | "4143" | "4144" | "4145" | "4146" | "4150" | "4151" | "4152" | "4153" | "4154" | "4155" | "4156" | "4160" | "4161" | "4162" | "4163" | "4164" | "4165" | "4166" | "4200" | "4201" | "4202" | "4203" | "4204" | "4205" | "4206" | "4210" | "4211" | "4212" | "4213" | "4214" | "4215" | "4216" | "4220" | "4221" | "4222" | "4223" | "4224" | "4225" | "4226" | "4230" | "4231" | "4232" | "4233" | "4234" | "4235" | "4236" | "4240" | "4241" | "4242" | "4243" | "4244" | "4245" | "4246" | "4250" | "4251" | "4252" | "4253" | "4254" | "4255" | "4256" | "4260" | "4261" | "4262" | "4263" | "4264" | "4265" | "4266" | "4300" | "4301" | "4302" | "4303" | "4304" | "4305" | "4306" | "4310" | "4311" | "4312" | "4313" | "4314" | "4315" | "4316" | "4320" | "4321" | "4322" | "4323" | "4324" | "4325" | "4326" | "4330" | "4331" | "4332" | "4333" | "4334" | "4335" | "4336" | "4340" | "4341" | "4342" | "4343" | "4344" | "4345" | "4346" | "4350" | "4351" | "4352" | "4353" | "4354" | "4355" | "4356" | "4360" | "4361" | "4362" | "4363" | "4364" | "4365" | "4366" | "4400" | "4401" | "4402" | "4403" | "4404" | "4405" | "4406" | "4410" | "4411" | "4412" | "4413" | "4414" | "4415" | "4416" | "4420" | "4421" | "4422" | "4423" | "4424" | "4425" | "4426" | "4430" | "4431" | "4432" | "4433" | "4434" | "4435" | "4436" | "4440" | "4441" | "4442" | "4443" | "4444" | "4445" | "4446" | "4450" | "4451" | "4452" | "4453" | "4454" | "4455" | "4456" | "4460" | "4461" | "4462" | "4463" | "4464" | "4465" | "4466" | "4500" | "4501" | "4502" | "4503" | "4504" | "4505" | "4506" | "4510" | "4511" | "4512" | "4513" | "4514" | "4515" | "4516" | "4520" | "4521" | "4522" | "4523" | "4524" | "4525" | "4526" | "4530" | "4531" | "4532" | "4533" | "4534" | "4535" | "4536" | "4540" | "4541" | "4542" | "4543" | "4544" | "4545" | "4546" | "4550" | "4551" | "4552" | "4553" | "4554" | "4555" | "4556" | "4560" | "4561" | "4562" | "4563" | "4564" | "4565" | "4566" | "4600" | "4601" | "4602" | "4603" | "4604" | "4605" | "4606" | "4610" | "4611" | "4612" | "4613" | "4614" | "4615" | "4616" | "4620" | "4621" | "4622" | "4623" | "4624" | "4625" | "4626" | "4630" | "4631" | "4632" | "4633" | "4634" | "4635" | "4636" | "4640" | "4641" | "4642" | "4643" | "4644" | "4645" | "4646" | "4650" | "4651" | "4652" | "4653" | "4654" | "4655" | "4656" | "4660" | "4661" | "4662" | "4663" | "4664" | "4665" | "4666" | "5000" | "5001" | "5002" | "5003" | "5004" | "5005" | "5006" | "5010" | "5011" | "5012" | "5013" | "5014" | "5015" | "5016" | "5020" | "5021" | "5022" | "5023" | "5024" | "5025" | "5026" | "5030" | "5031" | "5032" | "5033" | "5034" | "5035" | "5036" | "5040" | "5041" | "5042" | "5043" | "5044" | "5045" | "5046" | "5050" | "5051" | "5052" | "5053" | "5054" | "5055" | "5056" | "5060" | "5061" | "5062" | "5063" | "5064" | "5065" | "5066" | "5100" | "5101" | "5102" | "5103" | "5104" | "5105" | "5106" | "5110" | "5111" | "5112" | "5113" | "5114" | "5115" | "5116" | "5120" | "5121" | "5122" | "5123" | "5124" | "5125" | "5126" | "5130" | "5131" | "5132" | "5133" | "5134" | "5135" | "5136" | "5140" | "5141" | "5142" | "5143" | "5144" | "5145" | "5146" | "5150" | "5151" | "5152" | "5153" | "5154" | "5155" | "5156" | "5160" | "5161" | "5162" | "5163" | "5164" | "5165" | "5166" | "5200" | "5201" | "5202" | "5203" | "5204" | "5205" | "5206" | "5210" | "5211" | "5212" | "5213" | "5214" | "5215" | "5216" | "5220" | "5221" | "5222" | "5223" | "5224" | "5225" | "5226" | "5230" | "5231" | "5232" | "5233" | "5234" | "5235" | "5236" | "5240" | "5241" | "5242" | "5243" | "5244" | "5245" | "5246" | "5250" | "5251" | "5252" | "5253" | "5254" | "5255" | "5256" | "5260" | "5261" | "5262" | "5263" | "5264" | "5265" | "5266" | "5300" | "5301" | "5302" | "5303" | "5304" | "5305" | "5306" | "5310" | "5311" | "5312" | "5313" | "5314" | "5315" | "5316" | "5320" | "5321" | "5322" | "5323" | "5324" | "5325" | "5326" | "5330" | "5331" | "5332" | "5333" | "5334" | "5335" | "5336" | "5340" | "5341" | "5342" | "5343" | "5344" | "5345" | "5346" | "5350" | "5351" | "5352" | "5353" | "5354" | "5355" | "5356" | "5360" | "5361" | "5362" | "5363" | "5364" | "5365" | "5366" | "5400" | "5401" | "5402" | "5403" | "5404" | "5405" | "5406" | "5410" | "5411" | "5412" | "5413" | "5414" | "5415" | "5416" | "5420" | "5421" | "5422" | "5423" | "5424" | "5425" | "5426" | "5430" | "5431" | "5432" | "5433" | "5434" | "5435" | "5436" | "5440" | "5441" | "5442" | "5443" | "5444" | "5445" | "5446" | "5450" | "5451" | "5452" | "5453" | "5454" | "5455" | "5456" | "5460" | "5461" | "5462" | "5463" | "5464" | "5465" | "5466" | "5500" | "5501" | "5502" | "5503" | "5504" | "5505" | "5506" | "5510" | "5511" | "5512" | "5513" | "5514" | "5515" | "5516" | "5520" | "5521" | "5522" | "5523" | "5524" | "5525" | "5526" | "5530" | "5531" | "5532" | "5533" | "5534" | "5535" | "5536" | "5540" | "5541" | "5542" | "5543" | "5544" | "5545" | "5546" | "5550" | "5551" | "5552" | "5553" | "5554" | "5555" | "5556" | "5560" | "5561" | "5562" | "5563" | "5564" | "5565" | "5566" | "5600" | "5601" | "5602" | "5603" | "5604" | "5605" | "5606" | "5610" | "5611" | "5612" | "5613" | "5614" | "5615" | "5616" | "5620" | "5621" | "5622" | "5623" | "5624" | "5625" | "5626" | "5630" | "5631" | "5632" | "5633" | "5634" | "5635" | "5636" | "5640" | "5641" | "5642" | "5643" | "5644" | "5645" | "5646" | "5650" | "5651" | "5652" | "5653" | "5654" | "5655" | "5656" | "5660" | "5661" | "5662" | "5663" | "5664" | "5665" | "5666" | undefined) & T2' and 'T1 | null'. + ~~~~~~ !!! error TS2859: Excessive complexity comparing types '("0000" | "0001" | "0002" | "0003" | "0004" | "0005" | "0006" | "0010" | "0011" | "0012" | "0013" | "0014" | "0015" | "0016" | "0020" | "0021" | "0022" | "0023" | "0024" | "0025" | "0026" | "0030" | "0031" | "0032" | "0033" | "0034" | "0035" | "0036" | "0040" | "0041" | "0042" | "0043" | "0044" | "0045" | "0046" | "0050" | "0051" | "0052" | "0053" | "0054" | "0055" | "0056" | "0060" | "0061" | "0062" | "0063" | "0064" | "0065" | "0066" | "0100" | "0101" | "0102" | "0103" | "0104" | "0105" | "0106" | "0110" | "0111" | "0112" | "0113" | "0114" | "0115" | "0116" | "0120" | "0121" | "0122" | "0123" | "0124" | "0125" | "0126" | "0130" | "0131" | "0132" | "0133" | "0134" | "0135" | "0136" | "0140" | "0141" | "0142" | "0143" | "0144" | "0145" | "0146" | "0150" | "0151" | "0152" | "0153" | "0154" | "0155" | "0156" | "0160" | "0161" | "0162" | "0163" | "0164" | "0165" | "0166" | "0200" | "0201" | "0202" | "0203" | "0204" | "0205" | "0206" | "0210" | "0211" | "0212" | "0213" | "0214" | "0215" | "0216" | "0220" | "0221" | "0222" | "0223" | "0224" | "0225" | "0226" | "0230" | "0231" | "0232" | "0233" | "0234" | "0235" | "0236" | "0240" | "0241" | "0242" | "0243" | "0244" | "0245" | "0246" | "0250" | "0251" | "0252" | "0253" | "0254" | "0255" | "0256" | "0260" | "0261" | "0262" | "0263" | "0264" | "0265" | "0266" | "0300" | "0301" | "0302" | "0303" | "0304" | "0305" | "0306" | "0310" | "0311" | "0312" | "0313" | "0314" | "0315" | "0316" | "0320" | "0321" | "0322" | "0323" | "0324" | "0325" | "0326" | "0330" | "0331" | "0332" | "0333" | "0334" | "0335" | "0336" | "0340" | "0341" | "0342" | "0343" | "0344" | "0345" | "0346" | "0350" | "0351" | "0352" | "0353" | "0354" | "0355" | "0356" | "0360" | "0361" | "0362" | "0363" | "0364" | "0365" | "0366" | "0400" | "0401" | "0402" | "0403" | "0404" | "0405" | "0406" | "0410" | "0411" | "0412" | "0413" | "0414" | "0415" | "0416" | "0420" | "0421" | "0422" | "0423" | "0424" | "0425" | "0426" | "0430" | "0431" | "0432" | "0433" | "0434" | "0435" | "0436" | "0440" | "0441" | "0442" | "0443" | "0444" | "0445" | "0446" | "0450" | "0451" | "0452" | "0453" | "0454" | "0455" | "0456" | "0460" | "0461" | "0462" | "0463" | "0464" | "0465" | "0466" | "0500" | "0501" | "0502" | "0503" | "0504" | "0505" | "0506" | "0510" | "0511" | "0512" | "0513" | "0514" | "0515" | "0516" | "0520" | "0521" | "0522" | "0523" | "0524" | "0525" | "0526" | "0530" | "0531" | "0532" | "0533" | "0534" | "0535" | "0536" | "0540" | "0541" | "0542" | "0543" | "0544" | "0545" | "0546" | "0550" | "0551" | "0552" | "0553" | "0554" | "0555" | "0556" | "0560" | "0561" | "0562" | "0563" | "0564" | "0565" | "0566" | "0600" | "0601" | "0602" | "0603" | "0604" | "0605" | "0606" | "0610" | "0611" | "0612" | "0613" | "0614" | "0615" | "0616" | "0620" | "0621" | "0622" | "0623" | "0624" | "0625" | "0626" | "0630" | "0631" | "0632" | "0633" | "0634" | "0635" | "0636" | "0640" | "0641" | "0642" | "0643" | "0644" | "0645" | "0646" | "0650" | "0651" | "0652" | "0653" | "0654" | "0655" | "0656" | "0660" | "0661" | "0662" | "0663" | "0664" | "0665" | "0666" | "1000" | "1001" | "1002" | "1003" | "1004" | "1005" | "1006" | "1010" | "1011" | "1012" | "1013" | "1014" | "1015" | "1016" | "1020" | "1021" | "1022" | "1023" | "1024" | "1025" | "1026" | "1030" | "1031" | "1032" | "1033" | "1034" | "1035" | "1036" | "1040" | "1041" | "1042" | "1043" | "1044" | "1045" | "1046" | "1050" | "1051" | "1052" | "1053" | "1054" | "1055" | "1056" | "1060" | "1061" | "1062" | "1063" | "1064" | "1065" | "1066" | "1100" | "1101" | "1102" | "1103" | "1104" | "1105" | "1106" | "1110" | "1111" | "1112" | "1113" | "1114" | "1115" | "1116" | "1120" | "1121" | "1122" | "1123" | "1124" | "1125" | "1126" | "1130" | "1131" | "1132" | "1133" | "1134" | "1135" | "1136" | "1140" | "1141" | "1142" | "1143" | "1144" | "1145" | "1146" | "1150" | "1151" | "1152" | "1153" | "1154" | "1155" | "1156" | "1160" | "1161" | "1162" | "1163" | "1164" | "1165" | "1166" | "1200" | "1201" | "1202" | "1203" | "1204" | "1205" | "1206" | "1210" | "1211" | "1212" | "1213" | "1214" | "1215" | "1216" | "1220" | "1221" | "1222" | "1223" | "1224" | "1225" | "1226" | "1230" | "1231" | "1232" | "1233" | "1234" | "1235" | "1236" | "1240" | "1241" | "1242" | "1243" | "1244" | "1245" | "1246" | "1250" | "1251" | "1252" | "1253" | "1254" | "1255" | "1256" | "1260" | "1261" | "1262" | "1263" | "1264" | "1265" | "1266" | "1300" | "1301" | "1302" | "1303" | "1304" | "1305" | "1306" | "1310" | "1311" | "1312" | "1313" | "1314" | "1315" | "1316" | "1320" | "1321" | "1322" | "1323" | "1324" | "1325" | "1326" | "1330" | "1331" | "1332" | "1333" | "1334" | "1335" | "1336" | "1340" | "1341" | "1342" | "1343" | "1344" | "1345" | "1346" | "1350" | "1351" | "1352" | "1353" | "1354" | "1355" | "1356" | "1360" | "1361" | "1362" | "1363" | "1364" | "1365" | "1366" | "1400" | "1401" | "1402" | "1403" | "1404" | "1405" | "1406" | "1410" | "1411" | "1412" | "1413" | "1414" | "1415" | "1416" | "1420" | "1421" | "1422" | "1423" | "1424" | "1425" | "1426" | "1430" | "1431" | "1432" | "1433" | "1434" | "1435" | "1436" | "1440" | "1441" | "1442" | "1443" | "1444" | "1445" | "1446" | "1450" | "1451" | "1452" | "1453" | "1454" | "1455" | "1456" | "1460" | "1461" | "1462" | "1463" | "1464" | "1465" | "1466" | "1500" | "1501" | "1502" | "1503" | "1504" | "1505" | "1506" | "1510" | "1511" | "1512" | "1513" | "1514" | "1515" | "1516" | "1520" | "1521" | "1522" | "1523" | "1524" | "1525" | "1526" | "1530" | "1531" | "1532" | "1533" | "1534" | "1535" | "1536" | "1540" | "1541" | "1542" | "1543" | "1544" | "1545" | "1546" | "1550" | "1551" | "1552" | "1553" | "1554" | "1555" | "1556" | "1560" | "1561" | "1562" | "1563" | "1564" | "1565" | "1566" | "1600" | "1601" | "1602" | "1603" | "1604" | "1605" | "1606" | "1610" | "1611" | "1612" | "1613" | "1614" | "1615" | "1616" | "1620" | "1621" | "1622" | "1623" | "1624" | "1625" | "1626" | "1630" | "1631" | "1632" | "1633" | "1634" | "1635" | "1636" | "1640" | "1641" | "1642" | "1643" | "1644" | "1645" | "1646" | "1650" | "1651" | "1652" | "1653" | "1654" | "1655" | "1656" | "1660" | "1661" | "1662" | "1663" | "1664" | "1665" | "1666" | "2000" | "2001" | "2002" | "2003" | "2004" | "2005" | "2006" | "2010" | "2011" | "2012" | "2013" | "2014" | "2015" | "2016" | "2020" | "2021" | "2022" | "2023" | "2024" | "2025" | "2026" | "2030" | "2031" | "2032" | "2033" | "2034" | "2035" | "2036" | "2040" | "2041" | "2042" | "2043" | "2044" | "2045" | "2046" | "2050" | "2051" | "2052" | "2053" | "2054" | "2055" | "2056" | "2060" | "2061" | "2062" | "2063" | "2064" | "2065" | "2066" | "2100" | "2101" | "2102" | "2103" | "2104" | "2105" | "2106" | "2110" | "2111" | "2112" | "2113" | "2114" | "2115" | "2116" | "2120" | "2121" | "2122" | "2123" | "2124" | "2125" | "2126" | "2130" | "2131" | "2132" | "2133" | "2134" | "2135" | "2136" | "2140" | "2141" | "2142" | "2143" | "2144" | "2145" | "2146" | "2150" | "2151" | "2152" | "2153" | "2154" | "2155" | "2156" | "2160" | "2161" | "2162" | "2163" | "2164" | "2165" | "2166" | "2200" | "2201" | "2202" | "2203" | "2204" | "2205" | "2206" | "2210" | "2211" | "2212" | "2213" | "2214" | "2215" | "2216" | "2220" | "2221" | "2222" | "2223" | "2224" | "2225" | "2226" | "2230" | "2231" | "2232" | "2233" | "2234" | "2235" | "2236" | "2240" | "2241" | "2242" | "2243" | "2244" | "2245" | "2246" | "2250" | "2251" | "2252" | "2253" | "2254" | "2255" | "2256" | "2260" | "2261" | "2262" | "2263" | "2264" | "2265" | "2266" | "2300" | "2301" | "2302" | "2303" | "2304" | "2305" | "2306" | "2310" | "2311" | "2312" | "2313" | "2314" | "2315" | "2316" | "2320" | "2321" | "2322" | "2323" | "2324" | "2325" | "2326" | "2330" | "2331" | "2332" | "2333" | "2334" | "2335" | "2336" | "2340" | "2341" | "2342" | "2343" | "2344" | "2345" | "2346" | "2350" | "2351" | "2352" | "2353" | "2354" | "2355" | "2356" | "2360" | "2361" | "2362" | "2363" | "2364" | "2365" | "2366" | "2400" | "2401" | "2402" | "2403" | "2404" | "2405" | "2406" | "2410" | "2411" | "2412" | "2413" | "2414" | "2415" | "2416" | "2420" | "2421" | "2422" | "2423" | "2424" | "2425" | "2426" | "2430" | "2431" | "2432" | "2433" | "2434" | "2435" | "2436" | "2440" | "2441" | "2442" | "2443" | "2444" | "2445" | "2446" | "2450" | "2451" | "2452" | "2453" | "2454" | "2455" | "2456" | "2460" | "2461" | "2462" | "2463" | "2464" | "2465" | "2466" | "2500" | "2501" | "2502" | "2503" | "2504" | "2505" | "2506" | "2510" | "2511" | "2512" | "2513" | "2514" | "2515" | "2516" | "2520" | "2521" | "2522" | "2523" | "2524" | "2525" | "2526" | "2530" | "2531" | "2532" | "2533" | "2534" | "2535" | "2536" | "2540" | "2541" | "2542" | "2543" | "2544" | "2545" | "2546" | "2550" | "2551" | "2552" | "2553" | "2554" | "2555" | "2556" | "2560" | "2561" | "2562" | "2563" | "2564" | "2565" | "2566" | "2600" | "2601" | "2602" | "2603" | "2604" | "2605" | "2606" | "2610" | "2611" | "2612" | "2613" | "2614" | "2615" | "2616" | "2620" | "2621" | "2622" | "2623" | "2624" | "2625" | "2626" | "2630" | "2631" | "2632" | "2633" | "2634" | "2635" | "2636" | "2640" | "2641" | "2642" | "2643" | "2644" | "2645" | "2646" | "2650" | "2651" | "2652" | "2653" | "2654" | "2655" | "2656" | "2660" | "2661" | "2662" | "2663" | "2664" | "2665" | "2666" | "3000" | "3001" | "3002" | "3003" | "3004" | "3005" | "3006" | "3010" | "3011" | "3012" | "3013" | "3014" | "3015" | "3016" | "3020" | "3021" | "3022" | "3023" | "3024" | "3025" | "3026" | "3030" | "3031" | "3032" | "3033" | "3034" | "3035" | "3036" | "3040" | "3041" | "3042" | "3043" | "3044" | "3045" | "3046" | "3050" | "3051" | "3052" | "3053" | "3054" | "3055" | "3056" | "3060" | "3061" | "3062" | "3063" | "3064" | "3065" | "3066" | "3100" | "3101" | "3102" | "3103" | "3104" | "3105" | "3106" | "3110" | "3111" | "3112" | "3113" | "3114" | "3115" | "3116" | "3120" | "3121" | "3122" | "3123" | "3124" | "3125" | "3126" | "3130" | "3131" | "3132" | "3133" | "3134" | "3135" | "3136" | "3140" | "3141" | "3142" | "3143" | "3144" | "3145" | "3146" | "3150" | "3151" | "3152" | "3153" | "3154" | "3155" | "3156" | "3160" | "3161" | "3162" | "3163" | "3164" | "3165" | "3166" | "3200" | "3201" | "3202" | "3203" | "3204" | "3205" | "3206" | "3210" | "3211" | "3212" | "3213" | "3214" | "3215" | "3216" | "3220" | "3221" | "3222" | "3223" | "3224" | "3225" | "3226" | "3230" | "3231" | "3232" | "3233" | "3234" | "3235" | "3236" | "3240" | "3241" | "3242" | "3243" | "3244" | "3245" | "3246" | "3250" | "3251" | "3252" | "3253" | "3254" | "3255" | "3256" | "3260" | "3261" | "3262" | "3263" | "3264" | "3265" | "3266" | "3300" | "3301" | "3302" | "3303" | "3304" | "3305" | "3306" | "3310" | "3311" | "3312" | "3313" | "3314" | "3315" | "3316" | "3320" | "3321" | "3322" | "3323" | "3324" | "3325" | "3326" | "3330" | "3331" | "3332" | "3333" | "3334" | "3335" | "3336" | "3340" | "3341" | "3342" | "3343" | "3344" | "3345" | "3346" | "3350" | "3351" | "3352" | "3353" | "3354" | "3355" | "3356" | "3360" | "3361" | "3362" | "3363" | "3364" | "3365" | "3366" | "3400" | "3401" | "3402" | "3403" | "3404" | "3405" | "3406" | "3410" | "3411" | "3412" | "3413" | "3414" | "3415" | "3416" | "3420" | "3421" | "3422" | "3423" | "3424" | "3425" | "3426" | "3430" | "3431" | "3432" | "3433" | "3434" | "3435" | "3436" | "3440" | "3441" | "3442" | "3443" | "3444" | "3445" | "3446" | "3450" | "3451" | "3452" | "3453" | "3454" | "3455" | "3456" | "3460" | "3461" | "3462" | "3463" | "3464" | "3465" | "3466" | "3500" | "3501" | "3502" | "3503" | "3504" | "3505" | "3506" | "3510" | "3511" | "3512" | "3513" | "3514" | "3515" | "3516" | "3520" | "3521" | "3522" | "3523" | "3524" | "3525" | "3526" | "3530" | "3531" | "3532" | "3533" | "3534" | "3535" | "3536" | "3540" | "3541" | "3542" | "3543" | "3544" | "3545" | "3546" | "3550" | "3551" | "3552" | "3553" | "3554" | "3555" | "3556" | "3560" | "3561" | "3562" | "3563" | "3564" | "3565" | "3566" | "3600" | "3601" | "3602" | "3603" | "3604" | "3605" | "3606" | "3610" | "3611" | "3612" | "3613" | "3614" | "3615" | "3616" | "3620" | "3621" | "3622" | "3623" | "3624" | "3625" | "3626" | "3630" | "3631" | "3632" | "3633" | "3634" | "3635" | "3636" | "3640" | "3641" | "3642" | "3643" | "3644" | "3645" | "3646" | "3650" | "3651" | "3652" | "3653" | "3654" | "3655" | "3656" | "3660" | "3661" | "3662" | "3663" | "3664" | "3665" | "3666" | "4000" | "4001" | "4002" | "4003" | "4004" | "4005" | "4006" | "4010" | "4011" | "4012" | "4013" | "4014" | "4015" | "4016" | "4020" | "4021" | "4022" | "4023" | "4024" | "4025" | "4026" | "4030" | "4031" | "4032" | "4033" | "4034" | "4035" | "4036" | "4040" | "4041" | "4042" | "4043" | "4044" | "4045" | "4046" | "4050" | "4051" | "4052" | "4053" | "4054" | "4055" | "4056" | "4060" | "4061" | "4062" | "4063" | "4064" | "4065" | "4066" | "4100" | "4101" | "4102" | "4103" | "4104" | "4105" | "4106" | "4110" | "4111" | "4112" | "4113" | "4114" | "4115" | "4116" | "4120" | "4121" | "4122" | "4123" | "4124" | "4125" | "4126" | "4130" | "4131" | "4132" | "4133" | "4134" | "4135" | "4136" | "4140" | "4141" | "4142" | "4143" | "4144" | "4145" | "4146" | "4150" | "4151" | "4152" | "4153" | "4154" | "4155" | "4156" | "4160" | "4161" | "4162" | "4163" | "4164" | "4165" | "4166" | "4200" | "4201" | "4202" | "4203" | "4204" | "4205" | "4206" | "4210" | "4211" | "4212" | "4213" | "4214" | "4215" | "4216" | "4220" | "4221" | "4222" | "4223" | "4224" | "4225" | "4226" | "4230" | "4231" | "4232" | "4233" | "4234" | "4235" | "4236" | "4240" | "4241" | "4242" | "4243" | "4244" | "4245" | "4246" | "4250" | "4251" | "4252" | "4253" | "4254" | "4255" | "4256" | "4260" | "4261" | "4262" | "4263" | "4264" | "4265" | "4266" | "4300" | "4301" | "4302" | "4303" | "4304" | "4305" | "4306" | "4310" | "4311" | "4312" | "4313" | "4314" | "4315" | "4316" | "4320" | "4321" | "4322" | "4323" | "4324" | "4325" | "4326" | "4330" | "4331" | "4332" | "4333" | "4334" | "4335" | "4336" | "4340" | "4341" | "4342" | "4343" | "4344" | "4345" | "4346" | "4350" | "4351" | "4352" | "4353" | "4354" | "4355" | "4356" | "4360" | "4361" | "4362" | "4363" | "4364" | "4365" | "4366" | "4400" | "4401" | "4402" | "4403" | "4404" | "4405" | "4406" | "4410" | "4411" | "4412" | "4413" | "4414" | "4415" | "4416" | "4420" | "4421" | "4422" | "4423" | "4424" | "4425" | "4426" | "4430" | "4431" | "4432" | "4433" | "4434" | "4435" | "4436" | "4440" | "4441" | "4442" | "4443" | "4444" | "4445" | "4446" | "4450" | "4451" | "4452" | "4453" | "4454" | "4455" | "4456" | "4460" | "4461" | "4462" | "4463" | "4464" | "4465" | "4466" | "4500" | "4501" | "4502" | "4503" | "4504" | "4505" | "4506" | "4510" | "4511" | "4512" | "4513" | "4514" | "4515" | "4516" | "4520" | "4521" | "4522" | "4523" | "4524" | "4525" | "4526" | "4530" | "4531" | "4532" | "4533" | "4534" | "4535" | "4536" | "4540" | "4541" | "4542" | "4543" | "4544" | "4545" | "4546" | "4550" | "4551" | "4552" | "4553" | "4554" | "4555" | "4556" | "4560" | "4561" | "4562" | "4563" | "4564" | "4565" | "4566" | "4600" | "4601" | "4602" | "4603" | "4604" | "4605" | "4606" | "4610" | "4611" | "4612" | "4613" | "4614" | "4615" | "4616" | "4620" | "4621" | "4622" | "4623" | "4624" | "4625" | "4626" | "4630" | "4631" | "4632" | "4633" | "4634" | "4635" | "4636" | "4640" | "4641" | "4642" | "4643" | "4644" | "4645" | "4646" | "4650" | "4651" | "4652" | "4653" | "4654" | "4655" | "4656" | "4660" | "4661" | "4662" | "4663" | "4664" | "4665" | "4666" | "5000" | "5001" | "5002" | "5003" | "5004" | "5005" | "5006" | "5010" | "5011" | "5012" | "5013" | "5014" | "5015" | "5016" | "5020" | "5021" | "5022" | "5023" | "5024" | "5025" | "5026" | "5030" | "5031" | "5032" | "5033" | "5034" | "5035" | "5036" | "5040" | "5041" | "5042" | "5043" | "5044" | "5045" | "5046" | "5050" | "5051" | "5052" | "5053" | "5054" | "5055" | "5056" | "5060" | "5061" | "5062" | "5063" | "5064" | "5065" | "5066" | "5100" | "5101" | "5102" | "5103" | "5104" | "5105" | "5106" | "5110" | "5111" | "5112" | "5113" | "5114" | "5115" | "5116" | "5120" | "5121" | "5122" | "5123" | "5124" | "5125" | "5126" | "5130" | "5131" | "5132" | "5133" | "5134" | "5135" | "5136" | "5140" | "5141" | "5142" | "5143" | "5144" | "5145" | "5146" | "5150" | "5151" | "5152" | "5153" | "5154" | "5155" | "5156" | "5160" | "5161" | "5162" | "5163" | "5164" | "5165" | "5166" | "5200" | "5201" | "5202" | "5203" | "5204" | "5205" | "5206" | "5210" | "5211" | "5212" | "5213" | "5214" | "5215" | "5216" | "5220" | "5221" | "5222" | "5223" | "5224" | "5225" | "5226" | "5230" | "5231" | "5232" | "5233" | "5234" | "5235" | "5236" | "5240" | "5241" | "5242" | "5243" | "5244" | "5245" | "5246" | "5250" | "5251" | "5252" | "5253" | "5254" | "5255" | "5256" | "5260" | "5261" | "5262" | "5263" | "5264" | "5265" | "5266" | "5300" | "5301" | "5302" | "5303" | "5304" | "5305" | "5306" | "5310" | "5311" | "5312" | "5313" | "5314" | "5315" | "5316" | "5320" | "5321" | "5322" | "5323" | "5324" | "5325" | "5326" | "5330" | "5331" | "5332" | "5333" | "5334" | "5335" | "5336" | "5340" | "5341" | "5342" | "5343" | "5344" | "5345" | "5346" | "5350" | "5351" | "5352" | "5353" | "5354" | "5355" | "5356" | "5360" | "5361" | "5362" | "5363" | "5364" | "5365" | "5366" | "5400" | "5401" | "5402" | "5403" | "5404" | "5405" | "5406" | "5410" | "5411" | "5412" | "5413" | "5414" | "5415" | "5416" | "5420" | "5421" | "5422" | "5423" | "5424" | "5425" | "5426" | "5430" | "5431" | "5432" | "5433" | "5434" | "5435" | "5436" | "5440" | "5441" | "5442" | "5443" | "5444" | "5445" | "5446" | "5450" | "5451" | "5452" | "5453" | "5454" | "5455" | "5456" | "5460" | "5461" | "5462" | "5463" | "5464" | "5465" | "5466" | "5500" | "5501" | "5502" | "5503" | "5504" | "5505" | "5506" | "5510" | "5511" | "5512" | "5513" | "5514" | "5515" | "5516" | "5520" | "5521" | "5522" | "5523" | "5524" | "5525" | "5526" | "5530" | "5531" | "5532" | "5533" | "5534" | "5535" | "5536" | "5540" | "5541" | "5542" | "5543" | "5544" | "5545" | "5546" | "5550" | "5551" | "5552" | "5553" | "5554" | "5555" | "5556" | "5560" | "5561" | "5562" | "5563" | "5564" | "5565" | "5566" | "5600" | "5601" | "5602" | "5603" | "5604" | "5605" | "5606" | "5610" | "5611" | "5612" | "5613" | "5614" | "5615" | "5616" | "5620" | "5621" | "5622" | "5623" | "5624" | "5625" | "5626" | "5630" | "5631" | "5632" | "5633" | "5634" | "5635" | "5636" | "5640" | "5641" | "5642" | "5643" | "5644" | "5645" | "5646" | "5650" | "5651" | "5652" | "5653" | "5654" | "5655" | "5656" | "5660" | "5661" | "5662" | "5663" | "5664" | "5665" | "5666" | undefined) & T2' and 'T1 | null'. declare const y: T1 & T2; x = y; diff --git a/tsc/testdata/baselines/reference/compiler/relationDeeplyNestedCheckOrder.errors.txt b/tsc/testdata/baselines/reference/compiler/relationDeeplyNestedCheckOrder.errors.txt deleted file mode 100644 index b12e3d7fff298..0000000000000 --- a/tsc/testdata/baselines/reference/compiler/relationDeeplyNestedCheckOrder.errors.txt +++ /dev/null @@ -1,32 +0,0 @@ -relationDeeplyNestedCheckOrder.ts(13,1): error TS2322: Type 'A<{ a: string; }>' is not assignable to type 'A<{ a: "lit"; }>'. - The types of 'm1.a.m0.m1' are incompatible between these types. - Type 'string' is not assignable to type '"lit"'. -relationDeeplyNestedCheckOrder.ts(14,1): error TS2322: Type 'B<{ a: string; }>' is not assignable to type 'B<{ a: "lit"; }>'. - The types of 'm0.m1.a.m0.m1' are incompatible between these types. - Type 'string' is not assignable to type '"lit"'. - - -==== relationDeeplyNestedCheckOrder.ts (2 errors) ==== - // 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; - ~~ -!!! error TS2322: Type 'A<{ a: string; }>' is not assignable to type 'A<{ a: "lit"; }>'. -!!! error TS2322: The types of 'm1.a.m0.m1' are incompatible between these types. -!!! error TS2322: Type 'string' is not assignable to type '"lit"'. - b2 = b1; - ~~ -!!! error TS2322: Type 'B<{ a: string; }>' is not assignable to type 'B<{ a: "lit"; }>'. -!!! error TS2322: The types of 'm0.m1.a.m0.m1' 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/templateLiteralTypeExcessiveLength(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/templateLiteralTypeExcessiveLength(checkorder=default).errors.txt index 2c10283c820ef..afb511fd91c39 100644 --- a/tsc/testdata/baselines/reference/compiler/templateLiteralTypeExcessiveLength(checkorder=default).errors.txt +++ b/tsc/testdata/baselines/reference/compiler/templateLiteralTypeExcessiveLength(checkorder=default).errors.txt @@ -1,9 +1,18 @@ +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 (3 errors) ==== +==== 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. @@ -18,17 +27,33 @@ templateLiteralTypeExcessiveLength.ts(34,11): error TS2589: Type instantiation i // 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. @@ -41,8 +66,16 @@ templateLiteralTypeExcessiveLength.ts(34,11): error TS2589: Type instantiation i 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).errors.txt b/tsc/testdata/baselines/reference/compiler/templateLiteralTypeExcessiveLength(checkorder=typesfirst).errors.txt index a7a577d5080f1..75017c0b48808 100644 --- a/tsc/testdata/baselines/reference/compiler/templateLiteralTypeExcessiveLength(checkorder=typesfirst).errors.txt +++ b/tsc/testdata/baselines/reference/compiler/templateLiteralTypeExcessiveLength(checkorder=typesfirst).errors.txt @@ -1,8 +1,15 @@ -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(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(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. -!!! error TS2589: Type instantiation is excessively deep and possibly infinite. -==== templateLiteralTypeExcessiveLength.ts (0 errors) ==== +==== templateLiteralTypeExcessiveLength.ts (9 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. @@ -18,11 +25,23 @@ error TS2589: Type instantiation is excessively deep and possibly infinite. // 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. }; // 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. }; // Every text segment stays small, but the number of segments doubles on every iteration, @@ -37,5 +56,11 @@ error TS2589: Type instantiation is excessively deep and possibly infinite. 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. }; \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/typeParameterDefaultInCallInsideGenericCallback.errors.txt b/tsc/testdata/baselines/reference/compiler/typeParameterDefaultInCallInsideGenericCallback.errors.txt deleted file mode 100644 index 8c9d175baec15..0000000000000 --- a/tsc/testdata/baselines/reference/compiler/typeParameterDefaultInCallInsideGenericCallback.errors.txt +++ /dev/null @@ -1,28 +0,0 @@ -typeParameterDefaultInCallInsideGenericCallback.ts(18,28): error TS2345: Argument of type '{ v: number; }' is not assignable to parameter of type 'undefined'. - - -==== typeParameterDefaultInCallInsideGenericCallback.ts (1 errors) ==== - // The default of T applies to the call inside the callback passed to another - // generic function as it does elsewhere, so data is accepted. - - declare function fetcher(cfg: unknown): Promise; - - type Routes = R extends 'x' ? { IN: { v: number }, OUT: string } : never; - - function executeFetch>( - route: R, - body?: T extends Record<'IN', any> ? T['IN'] : never - ) { - return fetcher ? T['OUT'] : T>({ route, body }); - } - - declare function useCallback(cb: T, deps: unknown[]): T; - - export const cb = useCallback((data: { v: number }) => { - return executeFetch('x', data); - ~~~~ -!!! error TS2345: Argument of type '{ v: number; }' is not assignable to parameter of type 'undefined'. - }, []); - - export const check: Promise = cb({ v: 1 }); - \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/typeParameterHasSelfAsConstraint(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/typeParameterHasSelfAsConstraint(checkorder=typesfirst).errors.txt index 83997ce99f298..b7a0b982aceb6 100644 --- a/tsc/testdata/baselines/reference/compiler/typeParameterHasSelfAsConstraint(checkorder=typesfirst).errors.txt +++ b/tsc/testdata/baselines/reference/compiler/typeParameterHasSelfAsConstraint(checkorder=typesfirst).errors.txt @@ -6,7 +6,6 @@ typeParameterHasSelfAsConstraint.ts(2,5): error TS2322: Type 'T' is not assignab function foo(x: T): number { ~ !!! error TS2313: Type parameter 'T' has a circular constraint. -!!! related TS2751 typeParameterHasSelfAsConstraint.ts:2:12: Circularity originates in type at this location. return x; ~~~~~~ !!! error TS2322: Type 'T' is not assignable to type 'number'. 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=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1(checkorder=typesfirst).errors.txt index 387fe2f14d0be..f2bff262ffc44 100644 --- a/tsc/testdata/baselines/reference/compiler/unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1(checkorder=typesfirst).errors.txt +++ b/tsc/testdata/baselines/reference/compiler/unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1(checkorder=typesfirst).errors.txt @@ -1,14 +1,17 @@ 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 (5 errors) ==== +==== 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. diff --git a/tsc/testdata/baselines/reference/compiler/varianceCircularConsistency.errors.txt b/tsc/testdata/baselines/reference/compiler/varianceCircularConsistency.errors.txt index a4725d41bf2bf..060c23148616c 100644 --- a/tsc/testdata/baselines/reference/compiler/varianceCircularConsistency.errors.txt +++ b/tsc/testdata/baselines/reference/compiler/varianceCircularConsistency.errors.txt @@ -1,14 +1,22 @@ +varianceCircularConsistency.ts(25,7): error TS2322: Type 'EntryPoint void; }, {}>, { slug: string; }>' is not assignable to type 'EntryPoint'. + Types of property 'root' are incompatible. + Type 'Ref>' is not assignable to type 'Ref, never, never, {}>>'. + Type 'EntryPointComponent<{ q: { readonly variables: { slug: string; }; }; }, never, never, {}>' is not assignable to type 'EntryPointComponent, never, never, {}>'. + Type '(props: Props<{ q: { readonly variables: { slug: string; }; }; }, never, never, {}>) => void' is not assignable to type 'EntryPointComponent, never, never, {}>'. + Type '(props: Props<{ q: { readonly variables: { slug: string; }; }; }, never, never, {}>) => void' is not assignable to type '(props: Props, never, never, {}>) => void'. + Types of parameters 'props' and 'props' are incompatible. + Type 'Props, never, never, {}>' is not assignable to type 'Props<{ q: { readonly variables: { slug: string; }; }; }, never, never, {}>'. + Property 'q' is missing in type 'Record' but required in type '{ q: { readonly variables: { slug: string; }; }; }'. varianceCircularConsistency.ts(26,7): error TS2322: Type 'Ref>' is not assignable to type 'Ref, never, never, {}>>'. Type 'EntryPointComponent<{ q: { readonly variables: { slug: string; }; }; }, never, never, {}>' is not assignable to type 'EntryPointComponent, never, never, {}>'. Type '(props: Props<{ q: { readonly variables: { slug: string; }; }; }, never, never, {}>) => void' is not assignable to type 'EntryPointComponent, never, never, {}>'. Type '(props: Props<{ q: { readonly variables: { slug: string; }; }; }, never, never, {}>) => void' is not assignable to type '(props: Props, never, never, {}>) => void'. Types of parameters 'props' and 'props' are incompatible. Type 'Props, never, never, {}>' is not assignable to type 'Props<{ q: { readonly variables: { slug: string; }; }; }, never, never, {}>'. - Types of property 'queries' are incompatible. - Property 'q' is missing in type 'Record' but required in type '{ q: { readonly variables: { slug: string; }; }; }'. + Property 'q' is missing in type 'Record' but required in type '{ q: { readonly variables: { slug: string; }; }; }'. -==== varianceCircularConsistency.ts (1 errors) ==== +==== 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"]`. @@ -34,6 +42,17 @@ varianceCircularConsistency.ts(26,7): error TS2322: Type 'Ref void }>; declare const e: EntryPoint; const whole: EntryPoint = e; + ~~~~~ +!!! error TS2322: Type 'EntryPoint void; }, {}>, { slug: string; }>' is not assignable to type 'EntryPoint'. +!!! error TS2322: Types of property 'root' are incompatible. +!!! error TS2322: Type 'Ref>' is not assignable to type 'Ref, never, never, {}>>'. +!!! error TS2322: Type 'EntryPointComponent<{ q: { readonly variables: { slug: string; }; }; }, never, never, {}>' is not assignable to type 'EntryPointComponent, never, never, {}>'. +!!! error TS2322: Type '(props: Props<{ q: { readonly variables: { slug: string; }; }; }, never, never, {}>) => void' is not assignable to type 'EntryPointComponent, never, never, {}>'. +!!! error TS2322: Type '(props: Props<{ q: { readonly variables: { slug: string; }; }; }, never, never, {}>) => void' is not assignable to type '(props: Props, never, never, {}>) => void'. +!!! error TS2322: Types of parameters 'props' and 'props' are incompatible. +!!! error TS2322: Type 'Props, never, never, {}>' is not assignable to type 'Props<{ q: { readonly variables: { slug: string; }; }; }, never, never, {}>'. +!!! error TS2322: Property 'q' is missing in type 'Record' but required in type '{ q: { readonly variables: { slug: string; }; }; }'. +!!! related TS2728 varianceCircularConsistency.ts:23:40: 'q' is declared here. const root: EntryPoint["root"] = e.root; ~~~~ !!! error TS2322: Type 'Ref>' is not assignable to type 'Ref, never, never, {}>>'. @@ -42,7 +61,6 @@ varianceCircularConsistency.ts(26,7): error TS2322: Type 'Ref) => 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; }; }; }'. +!!! 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/varianceCircularityEnteredByInference(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/varianceCircularityEnteredByInference(checkorder=default).errors.txt new file mode 100644 index 0000000000000..4a1acaffb8ffb --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/varianceCircularityEnteredByInference(checkorder=default).errors.txt @@ -0,0 +1,56 @@ +varianceCircularityEnteredByInference.ts(45,16): error TS2345: Argument of type 'AstObject' is not assignable to parameter of type 'AstObject'. + Property 'decorators' is missing in type 'Empty' but required in type 'WithDecorators'. + + +==== varianceCircularityEnteredByInference.ts (1 errors) ==== + // AstObject and AstValue form a variance circularity. AstValue is covariant + // in T through typeBrand, and AstObject reaches it through getValue, so + // AstObject is not assignable to AstObject and the + // call below must be an error. Checking getValue first infers the type + // arguments of `new AstValue` from its return type, which measures AstValue + // first; AstObject, measured inside it, then sees T only in references to + // the types in progress, and main recorded it as independent of T and + // accepted the call. Main reports the error when AstObject's variance is + // measured first. + + export {}; + + type ObjectType = T extends object ? T : never; + + class AstObject { + constructor(private host: E) {} + + getObject(key: K): AstObject, E> { + return new AstObject, E>(this.host); + } + + getValue(key: K): AstValue { + return new AstValue(this.host); + } + } + + class AstValue { + declare typeBrand: T; + + constructor(private host: E) {} + + getObject(): AstObject, E> { + return new AstObject(this.host); + } + } + + interface Empty {} + interface WithDecorators { + decorators: string; + } + + declare function useDerived(obj: AstObject): void; + + function useBase(obj: AstObject) { + useDerived(obj); + ~~~ +!!! error TS2345: Argument of type 'AstObject' is not assignable to parameter of type 'AstObject'. +!!! error TS2345: Property 'decorators' is missing in type 'Empty' but required in type 'WithDecorators'. +!!! related TS2728 varianceCircularityEnteredByInference.ts:39:5: 'decorators' is declared here. + } + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/varianceCircularityHidesInvariance(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/varianceCircularityHidesInvariance(checkorder=default).errors.txt new file mode 100644 index 0000000000000..ded3dbea54a67 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/varianceCircularityHidesInvariance(checkorder=default).errors.txt @@ -0,0 +1,141 @@ +varianceCircularityHidesInvariance.ts(69,37): error TS2322: Type '(chart: Chart) => void' is not assignable to type '(chart: Chart<"bar", "bar">) => void'. + Types of parameters 'chart' and 'chart' are incompatible. + Type 'Chart<"bar", "bar">' is not assignable to type 'Chart'. + The types of 'config.options' are incompatible between these types. + Type '_DeepPartialObject & DatasetChartOptions<"bar"> & "bar">' is not assignable to type '_DeepPartialObject & DatasetChartOptions & "bar"> | _DeepPartialObject & DatasetChartOptions & "line">'. + Type '_DeepPartialObject & DatasetChartOptions<"bar"> & "bar">' is not assignable to type '_DeepPartialObject & DatasetChartOptions & "line">'. + Types of property 'backgroundColor' are incompatible. + Type 'Scriptable> | undefined' is not assignable to type 'Scriptable> | undefined'. + Type 'Scriptable>' is not assignable to type 'Scriptable>'. + Type 'ScriptableContext' is not assignable to type 'ScriptableContext<"bar">'. + Types of property 'dataset' are incompatible. + Type '_DeepPartialObject<{ defaultDataPoint: []; } & PluginDatasetOptionsByType> & ChartDatasetProperties & _DeepPartialObject<{ defaultDataPoint: null; } & PluginDatasetOptionsByType>' is not assignable to type '_DeepPartialObject<{ defaultDataPoint: []; } & PluginDatasetOptionsByType<"bar">> & ChartDatasetProperties<"bar", "bar">'. + Type '_DeepPartialObject<{ defaultDataPoint: []; } & PluginDatasetOptionsByType> & ChartDatasetProperties & _DeepPartialObject<{ defaultDataPoint: null; } & PluginDatasetOptionsByType>' is not assignable to type '_DeepPartialObject<{ defaultDataPoint: []; } & PluginDatasetOptionsByType<"bar">>'. + Types of property 'tooltip' are incompatible. + Type '_DeepPartialObject> | undefined' is not assignable to type '_DeepPartialObject> | undefined'. + Type '_DeepPartialObject>' is not assignable to type '_DeepPartialObject>'. + Types of property 'callbacks' are incompatible. + Type 'TooltipDatasetCallbacks> | undefined' is not assignable to type 'TooltipDatasetCallbacks<"bar", TooltipModel<"bar">> | undefined'. + Type 'TooltipDatasetCallbacks>' is not assignable to type 'TooltipDatasetCallbacks<"bar", TooltipModel<"bar">>'. + Type 'TooltipModel<"bar">' is not assignable to type 'TooltipModel'. + The types of 'chart.config.options' are incompatible between these types. + Type '_DeepPartialObject & DatasetChartOptions<"bar"> & "bar">' is not assignable to type '_DeepPartialObject & DatasetChartOptions & "bar"> | _DeepPartialObject & DatasetChartOptions & "line">'. + Type '_DeepPartialObject & DatasetChartOptions<"bar"> & "bar">' is not assignable to type '_DeepPartialObject & DatasetChartOptions & "line">'. + Types of property 'backgroundColor' are incompatible. + Type 'Scriptable> | undefined' is not assignable to type 'Scriptable> | undefined'. + Type 'Scriptable>' is not assignable to type 'Scriptable>'. + Type 'ScriptableContext' is not assignable to type 'ScriptableContext<"bar">'. + Types of property 'dataset' are incompatible. + Type '_DeepPartialObject<{ defaultDataPoint: []; } & PluginDatasetOptionsByType> & ChartDatasetProperties & _DeepPartialObject<{ defaultDataPoint: null; } & PluginDatasetOptionsByType>' is not assignable to type '_DeepPartialObject<{ defaultDataPoint: []; } & PluginDatasetOptionsByType<"bar">> & ChartDatasetProperties<"bar", "bar">'. + Type '_DeepPartialObject<{ defaultDataPoint: []; } & PluginDatasetOptionsByType> & ChartDatasetProperties & _DeepPartialObject<{ defaultDataPoint: null; } & PluginDatasetOptionsByType>' is not assignable to type 'ChartDatasetProperties<"bar", "bar">'. + Types of property 'data' are incompatible. + Type 'keyof ChartTypeRegistry' is not assignable to type '"bar"'. + Type '"line"' is not assignable to type '"bar"'. + + +==== varianceCircularityHidesInvariance.ts (1 errors) ==== + // Reduced from chart.js typings (PeerTube, Unleash). Chart, TooltipModel and + // ScriptableContext form a variance circularity. ScriptableContext is in + // fact invariant: ScriptableContext<"bar" | "line"> is not assignable to + // ScriptableContext<"bar"> ('dataset.data' differs), so Chart<"bar"> is not + // assignable to Chart and the assignment below must be an error. + // Measuring variances from the circularity's entry, main recorded + // ScriptableContext/TooltipModel as bivariant (measured mid-cycle) and + // accepted it; main reports this error too when ScriptableContext's variance + // is measured first (e.g. after checking a ScriptableContext assignment). + + declare class Element { options: O } + type DeepPartial = T extends Function ? T : T extends object ? _DeepPartialObject : undefined + type _DeepPartialObject = { [P in keyof T]?: DeepPartial } + type UnionToIntersection = (U extends unknown ? (k: U) => void : never) extends (k: infer I) => void ? I : never + type AnyObject = Record + interface ScriptableContext { + dataset: UnionToIntersection> + } + type Scriptable = (ctx: TContext) => T + declare class Chart { + config: ChartConfigurationCustomTypesPerDataset + } + interface Plugin { + id: string; + beforeDraw(chart: Chart): void + } + interface CoreChartOptions { + backgroundColor: Scriptable> + } + interface AnimationSpec { + delay: Scriptable> + } + interface TooltipModel extends Element> { + chart: Chart + } + interface TooltipDatasetCallbacks> { + (this: Model): void + } + interface TooltipOptions { + animation: AnimationSpec + } + interface TooltipDatasetOptions { + callbacks: TooltipDatasetCallbacks + } + interface PluginDatasetOptionsByType { + tooltip: TooltipDatasetOptions + } + interface ChartTypeRegistry { + bar: { defaultDataPoint: [] } + line: { defaultDataPoint: null } + } + type ChartType = keyof ChartTypeRegistry + type DatasetChartOptions = { [key in TType]: {} } + type ChartOptions = Exclude & DatasetChartOptions & TType>, undefined> + interface ChartDatasetProperties { + data: TData + } + type ChartDataset = + DeepPartial> & ChartDatasetProperties + type ChartDatasetCustomTypesPerDataset = DeepPartial> + interface ChartDataCustomTypesPerDataset { + datasets: ChartDatasetCustomTypesPerDataset + } + export interface ChartConfigurationCustomTypesPerDataset { + data: ChartDataCustomTypesPerDataset + options: ChartOptions + } + + const p: Plugin<"bar"> = { id: "x", beforeDraw: (chart: Chart) => {} }; + ~~~~~~~~~~ +!!! error TS2322: Type '(chart: Chart) => void' is not assignable to type '(chart: Chart<"bar", "bar">) => void'. +!!! error TS2322: Types of parameters 'chart' and 'chart' are incompatible. +!!! error TS2322: Type 'Chart<"bar", "bar">' is not assignable to type 'Chart'. +!!! error TS2322: The types of 'config.options' are incompatible between these types. +!!! error TS2322: Type '_DeepPartialObject & DatasetChartOptions<"bar"> & "bar">' is not assignable to type '_DeepPartialObject & DatasetChartOptions & "bar"> | _DeepPartialObject & DatasetChartOptions & "line">'. +!!! error TS2322: Type '_DeepPartialObject & DatasetChartOptions<"bar"> & "bar">' is not assignable to type '_DeepPartialObject & DatasetChartOptions & "line">'. +!!! error TS2322: Types of property 'backgroundColor' are incompatible. +!!! error TS2322: Type 'Scriptable> | undefined' is not assignable to type 'Scriptable> | undefined'. +!!! error TS2322: Type 'Scriptable>' is not assignable to type 'Scriptable>'. +!!! error TS2322: Type 'ScriptableContext' is not assignable to type 'ScriptableContext<"bar">'. +!!! error TS2322: Types of property 'dataset' are incompatible. +!!! error TS2322: Type '_DeepPartialObject<{ defaultDataPoint: []; } & PluginDatasetOptionsByType> & ChartDatasetProperties & _DeepPartialObject<{ defaultDataPoint: null; } & PluginDatasetOptionsByType>' is not assignable to type '_DeepPartialObject<{ defaultDataPoint: []; } & PluginDatasetOptionsByType<"bar">> & ChartDatasetProperties<"bar", "bar">'. +!!! error TS2322: Type '_DeepPartialObject<{ defaultDataPoint: []; } & PluginDatasetOptionsByType> & ChartDatasetProperties & _DeepPartialObject<{ defaultDataPoint: null; } & PluginDatasetOptionsByType>' is not assignable to type '_DeepPartialObject<{ defaultDataPoint: []; } & PluginDatasetOptionsByType<"bar">>'. +!!! error TS2322: Types of property 'tooltip' are incompatible. +!!! error TS2322: Type '_DeepPartialObject> | undefined' is not assignable to type '_DeepPartialObject> | undefined'. +!!! error TS2322: Type '_DeepPartialObject>' is not assignable to type '_DeepPartialObject>'. +!!! error TS2322: Types of property 'callbacks' are incompatible. +!!! error TS2322: Type 'TooltipDatasetCallbacks> | undefined' is not assignable to type 'TooltipDatasetCallbacks<"bar", TooltipModel<"bar">> | undefined'. +!!! error TS2322: Type 'TooltipDatasetCallbacks>' is not assignable to type 'TooltipDatasetCallbacks<"bar", TooltipModel<"bar">>'. +!!! error TS2322: Type 'TooltipModel<"bar">' is not assignable to type 'TooltipModel'. +!!! error TS2322: The types of 'chart.config.options' are incompatible between these types. +!!! error TS2322: Type '_DeepPartialObject & DatasetChartOptions<"bar"> & "bar">' is not assignable to type '_DeepPartialObject & DatasetChartOptions & "bar"> | _DeepPartialObject & DatasetChartOptions & "line">'. +!!! error TS2322: Type '_DeepPartialObject & DatasetChartOptions<"bar"> & "bar">' is not assignable to type '_DeepPartialObject & DatasetChartOptions & "line">'. +!!! error TS2322: Types of property 'backgroundColor' are incompatible. +!!! error TS2322: Type 'Scriptable> | undefined' is not assignable to type 'Scriptable> | undefined'. +!!! error TS2322: Type 'Scriptable>' is not assignable to type 'Scriptable>'. +!!! error TS2322: Type 'ScriptableContext' is not assignable to type 'ScriptableContext<"bar">'. +!!! error TS2322: Types of property 'dataset' are incompatible. +!!! error TS2322: Type '_DeepPartialObject<{ defaultDataPoint: []; } & PluginDatasetOptionsByType> & ChartDatasetProperties & _DeepPartialObject<{ defaultDataPoint: null; } & PluginDatasetOptionsByType>' is not assignable to type '_DeepPartialObject<{ defaultDataPoint: []; } & PluginDatasetOptionsByType<"bar">> & ChartDatasetProperties<"bar", "bar">'. +!!! error TS2322: Type '_DeepPartialObject<{ defaultDataPoint: []; } & PluginDatasetOptionsByType> & ChartDatasetProperties & _DeepPartialObject<{ defaultDataPoint: null; } & PluginDatasetOptionsByType>' is not assignable to type 'ChartDatasetProperties<"bar", "bar">'. +!!! error TS2322: Types of property 'data' are incompatible. +!!! error TS2322: Type 'keyof ChartTypeRegistry' is not assignable to type '"bar"'. +!!! error TS2322: Type '"line"' is not assignable to type '"bar"'. +!!! related TS6500 varianceCircularityHidesInvariance.ts:25:5: The expected type comes from property 'beforeDraw' which is declared here on type 'Plugin<"bar">' + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/varianceCircularityHidesInvariance(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/varianceCircularityHidesInvariance(checkorder=typesfirst).errors.txt new file mode 100644 index 0000000000000..ded3dbea54a67 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/varianceCircularityHidesInvariance(checkorder=typesfirst).errors.txt @@ -0,0 +1,141 @@ +varianceCircularityHidesInvariance.ts(69,37): error TS2322: Type '(chart: Chart) => void' is not assignable to type '(chart: Chart<"bar", "bar">) => void'. + Types of parameters 'chart' and 'chart' are incompatible. + Type 'Chart<"bar", "bar">' is not assignable to type 'Chart'. + The types of 'config.options' are incompatible between these types. + Type '_DeepPartialObject & DatasetChartOptions<"bar"> & "bar">' is not assignable to type '_DeepPartialObject & DatasetChartOptions & "bar"> | _DeepPartialObject & DatasetChartOptions & "line">'. + Type '_DeepPartialObject & DatasetChartOptions<"bar"> & "bar">' is not assignable to type '_DeepPartialObject & DatasetChartOptions & "line">'. + Types of property 'backgroundColor' are incompatible. + Type 'Scriptable> | undefined' is not assignable to type 'Scriptable> | undefined'. + Type 'Scriptable>' is not assignable to type 'Scriptable>'. + Type 'ScriptableContext' is not assignable to type 'ScriptableContext<"bar">'. + Types of property 'dataset' are incompatible. + Type '_DeepPartialObject<{ defaultDataPoint: []; } & PluginDatasetOptionsByType> & ChartDatasetProperties & _DeepPartialObject<{ defaultDataPoint: null; } & PluginDatasetOptionsByType>' is not assignable to type '_DeepPartialObject<{ defaultDataPoint: []; } & PluginDatasetOptionsByType<"bar">> & ChartDatasetProperties<"bar", "bar">'. + Type '_DeepPartialObject<{ defaultDataPoint: []; } & PluginDatasetOptionsByType> & ChartDatasetProperties & _DeepPartialObject<{ defaultDataPoint: null; } & PluginDatasetOptionsByType>' is not assignable to type '_DeepPartialObject<{ defaultDataPoint: []; } & PluginDatasetOptionsByType<"bar">>'. + Types of property 'tooltip' are incompatible. + Type '_DeepPartialObject> | undefined' is not assignable to type '_DeepPartialObject> | undefined'. + Type '_DeepPartialObject>' is not assignable to type '_DeepPartialObject>'. + Types of property 'callbacks' are incompatible. + Type 'TooltipDatasetCallbacks> | undefined' is not assignable to type 'TooltipDatasetCallbacks<"bar", TooltipModel<"bar">> | undefined'. + Type 'TooltipDatasetCallbacks>' is not assignable to type 'TooltipDatasetCallbacks<"bar", TooltipModel<"bar">>'. + Type 'TooltipModel<"bar">' is not assignable to type 'TooltipModel'. + The types of 'chart.config.options' are incompatible between these types. + Type '_DeepPartialObject & DatasetChartOptions<"bar"> & "bar">' is not assignable to type '_DeepPartialObject & DatasetChartOptions & "bar"> | _DeepPartialObject & DatasetChartOptions & "line">'. + Type '_DeepPartialObject & DatasetChartOptions<"bar"> & "bar">' is not assignable to type '_DeepPartialObject & DatasetChartOptions & "line">'. + Types of property 'backgroundColor' are incompatible. + Type 'Scriptable> | undefined' is not assignable to type 'Scriptable> | undefined'. + Type 'Scriptable>' is not assignable to type 'Scriptable>'. + Type 'ScriptableContext' is not assignable to type 'ScriptableContext<"bar">'. + Types of property 'dataset' are incompatible. + Type '_DeepPartialObject<{ defaultDataPoint: []; } & PluginDatasetOptionsByType> & ChartDatasetProperties & _DeepPartialObject<{ defaultDataPoint: null; } & PluginDatasetOptionsByType>' is not assignable to type '_DeepPartialObject<{ defaultDataPoint: []; } & PluginDatasetOptionsByType<"bar">> & ChartDatasetProperties<"bar", "bar">'. + Type '_DeepPartialObject<{ defaultDataPoint: []; } & PluginDatasetOptionsByType> & ChartDatasetProperties & _DeepPartialObject<{ defaultDataPoint: null; } & PluginDatasetOptionsByType>' is not assignable to type 'ChartDatasetProperties<"bar", "bar">'. + Types of property 'data' are incompatible. + Type 'keyof ChartTypeRegistry' is not assignable to type '"bar"'. + Type '"line"' is not assignable to type '"bar"'. + + +==== varianceCircularityHidesInvariance.ts (1 errors) ==== + // Reduced from chart.js typings (PeerTube, Unleash). Chart, TooltipModel and + // ScriptableContext form a variance circularity. ScriptableContext is in + // fact invariant: ScriptableContext<"bar" | "line"> is not assignable to + // ScriptableContext<"bar"> ('dataset.data' differs), so Chart<"bar"> is not + // assignable to Chart and the assignment below must be an error. + // Measuring variances from the circularity's entry, main recorded + // ScriptableContext/TooltipModel as bivariant (measured mid-cycle) and + // accepted it; main reports this error too when ScriptableContext's variance + // is measured first (e.g. after checking a ScriptableContext assignment). + + declare class Element { options: O } + type DeepPartial = T extends Function ? T : T extends object ? _DeepPartialObject : undefined + type _DeepPartialObject = { [P in keyof T]?: DeepPartial } + type UnionToIntersection = (U extends unknown ? (k: U) => void : never) extends (k: infer I) => void ? I : never + type AnyObject = Record + interface ScriptableContext { + dataset: UnionToIntersection> + } + type Scriptable = (ctx: TContext) => T + declare class Chart { + config: ChartConfigurationCustomTypesPerDataset + } + interface Plugin { + id: string; + beforeDraw(chart: Chart): void + } + interface CoreChartOptions { + backgroundColor: Scriptable> + } + interface AnimationSpec { + delay: Scriptable> + } + interface TooltipModel extends Element> { + chart: Chart + } + interface TooltipDatasetCallbacks> { + (this: Model): void + } + interface TooltipOptions { + animation: AnimationSpec + } + interface TooltipDatasetOptions { + callbacks: TooltipDatasetCallbacks + } + interface PluginDatasetOptionsByType { + tooltip: TooltipDatasetOptions + } + interface ChartTypeRegistry { + bar: { defaultDataPoint: [] } + line: { defaultDataPoint: null } + } + type ChartType = keyof ChartTypeRegistry + type DatasetChartOptions = { [key in TType]: {} } + type ChartOptions = Exclude & DatasetChartOptions & TType>, undefined> + interface ChartDatasetProperties { + data: TData + } + type ChartDataset = + DeepPartial> & ChartDatasetProperties + type ChartDatasetCustomTypesPerDataset = DeepPartial> + interface ChartDataCustomTypesPerDataset { + datasets: ChartDatasetCustomTypesPerDataset + } + export interface ChartConfigurationCustomTypesPerDataset { + data: ChartDataCustomTypesPerDataset + options: ChartOptions + } + + const p: Plugin<"bar"> = { id: "x", beforeDraw: (chart: Chart) => {} }; + ~~~~~~~~~~ +!!! error TS2322: Type '(chart: Chart) => void' is not assignable to type '(chart: Chart<"bar", "bar">) => void'. +!!! error TS2322: Types of parameters 'chart' and 'chart' are incompatible. +!!! error TS2322: Type 'Chart<"bar", "bar">' is not assignable to type 'Chart'. +!!! error TS2322: The types of 'config.options' are incompatible between these types. +!!! error TS2322: Type '_DeepPartialObject & DatasetChartOptions<"bar"> & "bar">' is not assignable to type '_DeepPartialObject & DatasetChartOptions & "bar"> | _DeepPartialObject & DatasetChartOptions & "line">'. +!!! error TS2322: Type '_DeepPartialObject & DatasetChartOptions<"bar"> & "bar">' is not assignable to type '_DeepPartialObject & DatasetChartOptions & "line">'. +!!! error TS2322: Types of property 'backgroundColor' are incompatible. +!!! error TS2322: Type 'Scriptable> | undefined' is not assignable to type 'Scriptable> | undefined'. +!!! error TS2322: Type 'Scriptable>' is not assignable to type 'Scriptable>'. +!!! error TS2322: Type 'ScriptableContext' is not assignable to type 'ScriptableContext<"bar">'. +!!! error TS2322: Types of property 'dataset' are incompatible. +!!! error TS2322: Type '_DeepPartialObject<{ defaultDataPoint: []; } & PluginDatasetOptionsByType> & ChartDatasetProperties & _DeepPartialObject<{ defaultDataPoint: null; } & PluginDatasetOptionsByType>' is not assignable to type '_DeepPartialObject<{ defaultDataPoint: []; } & PluginDatasetOptionsByType<"bar">> & ChartDatasetProperties<"bar", "bar">'. +!!! error TS2322: Type '_DeepPartialObject<{ defaultDataPoint: []; } & PluginDatasetOptionsByType> & ChartDatasetProperties & _DeepPartialObject<{ defaultDataPoint: null; } & PluginDatasetOptionsByType>' is not assignable to type '_DeepPartialObject<{ defaultDataPoint: []; } & PluginDatasetOptionsByType<"bar">>'. +!!! error TS2322: Types of property 'tooltip' are incompatible. +!!! error TS2322: Type '_DeepPartialObject> | undefined' is not assignable to type '_DeepPartialObject> | undefined'. +!!! error TS2322: Type '_DeepPartialObject>' is not assignable to type '_DeepPartialObject>'. +!!! error TS2322: Types of property 'callbacks' are incompatible. +!!! error TS2322: Type 'TooltipDatasetCallbacks> | undefined' is not assignable to type 'TooltipDatasetCallbacks<"bar", TooltipModel<"bar">> | undefined'. +!!! error TS2322: Type 'TooltipDatasetCallbacks>' is not assignable to type 'TooltipDatasetCallbacks<"bar", TooltipModel<"bar">>'. +!!! error TS2322: Type 'TooltipModel<"bar">' is not assignable to type 'TooltipModel'. +!!! error TS2322: The types of 'chart.config.options' are incompatible between these types. +!!! error TS2322: Type '_DeepPartialObject & DatasetChartOptions<"bar"> & "bar">' is not assignable to type '_DeepPartialObject & DatasetChartOptions & "bar"> | _DeepPartialObject & DatasetChartOptions & "line">'. +!!! error TS2322: Type '_DeepPartialObject & DatasetChartOptions<"bar"> & "bar">' is not assignable to type '_DeepPartialObject & DatasetChartOptions & "line">'. +!!! error TS2322: Types of property 'backgroundColor' are incompatible. +!!! error TS2322: Type 'Scriptable> | undefined' is not assignable to type 'Scriptable> | undefined'. +!!! error TS2322: Type 'Scriptable>' is not assignable to type 'Scriptable>'. +!!! error TS2322: Type 'ScriptableContext' is not assignable to type 'ScriptableContext<"bar">'. +!!! error TS2322: Types of property 'dataset' are incompatible. +!!! error TS2322: Type '_DeepPartialObject<{ defaultDataPoint: []; } & PluginDatasetOptionsByType> & ChartDatasetProperties & _DeepPartialObject<{ defaultDataPoint: null; } & PluginDatasetOptionsByType>' is not assignable to type '_DeepPartialObject<{ defaultDataPoint: []; } & PluginDatasetOptionsByType<"bar">> & ChartDatasetProperties<"bar", "bar">'. +!!! error TS2322: Type '_DeepPartialObject<{ defaultDataPoint: []; } & PluginDatasetOptionsByType> & ChartDatasetProperties & _DeepPartialObject<{ defaultDataPoint: null; } & PluginDatasetOptionsByType>' is not assignable to type 'ChartDatasetProperties<"bar", "bar">'. +!!! error TS2322: Types of property 'data' are incompatible. +!!! error TS2322: Type 'keyof ChartTypeRegistry' is not assignable to type '"bar"'. +!!! error TS2322: Type '"line"' is not assignable to type '"bar"'. +!!! related TS6500 varianceCircularityHidesInvariance.ts:25:5: The expected type comes from property 'beforeDraw' which is declared here on type 'Plugin<"bar">' + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/varianceCycleDiscardedDiagnostics.errors.txt b/tsc/testdata/baselines/reference/compiler/varianceCycleDiscardedDiagnostics.errors.txt index 570f693fae100..67a74da6b9b6d 100644 --- a/tsc/testdata/baselines/reference/compiler/varianceCycleDiscardedDiagnostics.errors.txt +++ b/tsc/testdata/baselines/reference/compiler/varianceCycleDiscardedDiagnostics.errors.txt @@ -1,4 +1,4 @@ -varianceCycleDiscardedDiagnostics.ts(14,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. +varianceCycleDiscardedDiagnostics.ts(14,33): error TS2339: Property 'foo' does not exist on type 'A'. ==== varianceCycleDiscardedDiagnostics.ts (1 errors) ==== @@ -16,8 +16,8 @@ varianceCycleDiscardedDiagnostics.ts(14,5): error TS7022: 'Value' implicitly has class Bar { x!: T; Value = pick(new Foo(this)).foo; - ~~~~~ -!!! 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. + ~~~ +!!! error TS2339: Property 'foo' does not exist on type 'A'. } class Foo { diff --git a/tsc/testdata/baselines/reference/compiler/varianceCycleDiscardedDiagnostics.symbols b/tsc/testdata/baselines/reference/compiler/varianceCycleDiscardedDiagnostics.symbols index 437eb30b0dc81..e08928ce4a02d 100644 --- a/tsc/testdata/baselines/reference/compiler/varianceCycleDiscardedDiagnostics.symbols +++ b/tsc/testdata/baselines/reference/compiler/varianceCycleDiscardedDiagnostics.symbols @@ -36,11 +36,9 @@ class Bar { Value = pick(new Foo(this)).foo; >Value : Symbol(Bar.Value, Decl(varianceCycleDiscardedDiagnostics.ts, 12, 10)) ->pick(new Foo(this)).foo : Symbol(B.foo, Decl(varianceCycleDiscardedDiagnostics.ts, 7, 13)) >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)) ->foo : Symbol(B.foo, Decl(varianceCycleDiscardedDiagnostics.ts, 7, 13)) } class Foo { diff --git a/tsc/testdata/baselines/reference/compiler/varianceCycleDiscardedDiagnostics.types b/tsc/testdata/baselines/reference/compiler/varianceCycleDiscardedDiagnostics.types index 6d56cf12120d4..ad994f6a17985 100644 --- a/tsc/testdata/baselines/reference/compiler/varianceCycleDiscardedDiagnostics.types +++ b/tsc/testdata/baselines/reference/compiler/varianceCycleDiscardedDiagnostics.types @@ -29,13 +29,13 @@ class Bar { Value = pick(new Foo(this)).foo; >Value : any ->pick(new Foo(this)).foo : string ->pick(new Foo(this)) : B +>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 : string +>foo : any } class Foo { diff --git a/tsc/testdata/baselines/reference/conformance/dependentDestructuredVariablesReferenceInDeclaration1(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/conformance/dependentDestructuredVariablesReferenceInDeclaration1(checkorder=typesfirst).errors.txt index 981a83e22c019..5529a3e5e68c6 100644 --- a/tsc/testdata/baselines/reference/conformance/dependentDestructuredVariablesReferenceInDeclaration1(checkorder=typesfirst).errors.txt +++ b/tsc/testdata/baselines/reference/conformance/dependentDestructuredVariablesReferenceInDeclaration1(checkorder=typesfirst).errors.txt @@ -22,12 +22,11 @@ dependentDestructuredVariablesReferenceInDeclaration1.ts(25,14): error TS2339: P 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(35,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(58,14): error TS2451: Cannot redeclare block-scoped variable 'f'. dependentDestructuredVariablesReferenceInDeclaration1.ts(58,17): error TS2451: Cannot redeclare block-scoped variable 'f'. -==== dependentDestructuredVariablesReferenceInDeclaration1.ts (27 errors) ==== +==== dependentDestructuredVariablesReferenceInDeclaration1.ts (26 errors) ==== // https://github.com/microsoft/TypeScript/issues/62993 { @@ -113,8 +112,6 @@ dependentDestructuredVariablesReferenceInDeclaration1.ts(58,17): error TS2451: C { const { c, f }: { c: 0; f: () => unknown } | { c: 1; f: string } = { - ~ -!!! 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. c: 0, f: () => f, }; diff --git a/tsc/testdata/baselines/reference/conformance/dependentDestructuredVariablesReferenceInDeclaration1(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/conformance/dependentDestructuredVariablesReferenceInDeclaration1(checkorder=typesfirst).types index fda8b5b052297..1e1c61a26976d 100644 --- a/tsc/testdata/baselines/reference/conformance/dependentDestructuredVariablesReferenceInDeclaration1(checkorder=typesfirst).types +++ b/tsc/testdata/baselines/reference/conformance/dependentDestructuredVariablesReferenceInDeclaration1(checkorder=typesfirst).types @@ -103,7 +103,7 @@ { const { c, f }: { c: 0; f: () => unknown } | { c: 1; f: string } = { >c : 0 | 1 ->f : any +>f : string | (() => unknown) >c : 0 >f : () => unknown >c : 1 diff --git a/tsc/testdata/baselines/reference/conformance/importTag13(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/conformance/importTag13(checkorder=typesfirst).errors.txt index de660063858df..3427c0e358148 100644 --- a/tsc/testdata/baselines/reference/conformance/importTag13(checkorder=typesfirst).errors.txt +++ b/tsc/testdata/baselines/reference/conformance/importTag13(checkorder=typesfirst).errors.txt @@ -1,16 +1,13 @@ /foo.js(1,15): error TS1005: 'from' expected. /foo.js(1,15): error TS1141: String literal expected. -/foo.js(1,25): error TS2307: Cannot find module 'types' or its corresponding type declarations. -==== /foo.js (3 errors) ==== +==== /foo.js (2 errors) ==== /** @import x = require("types") */ ~ !!! error TS1005: 'from' expected. ~~~~~~~~~~~~~~~~~~ !!! error TS1141: String literal expected. - ~~~~~~~ -!!! error TS2307: Cannot find module 'types' or its corresponding type declarations. ==== /types.ts (0 errors) ==== export interface Foo { diff --git a/tsc/testdata/baselines/reference/conformance/privateNameNestedClassFieldShadowing(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/conformance/privateNameNestedClassFieldShadowing(checkorder=typesfirst).errors.txt index d4d3aede55faf..634c2349e1ecb 100644 --- a/tsc/testdata/baselines/reference/conformance/privateNameNestedClassFieldShadowing(checkorder=typesfirst).errors.txt +++ b/tsc/testdata/baselines/reference/conformance/privateNameNestedClassFieldShadowing(checkorder=typesfirst).errors.txt @@ -11,8 +11,8 @@ privateNameNestedClassFieldShadowing.ts(7,31): error TS18014: The property '#x' 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 TS18018 privateNameNestedClassFieldShadowing.ts:2:5: The declaration of '#x' that you probably intended to use is defined here !!! 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); diff --git a/tsc/testdata/baselines/reference/conformance/recursiveMappedTypes.errors.txt b/tsc/testdata/baselines/reference/conformance/recursiveMappedTypes.errors.txt index 5d6e45f1ffa2e..efdd2fe453ad5 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 = { @@ -43,9 +45,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 +106,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/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/tsc/incremental/global-diagnostics-produced-during-semantic-checking.js b/tsc/testdata/baselines/reference/tsc/incremental/global-diagnostics-produced-during-semantic-checking.js index ede9c55f1530e..47afd6e8c58c4 100644 --- a/tsc/testdata/baselines/reference/tsc/incremental/global-diagnostics-produced-during-semantic-checking.js +++ b/tsc/testdata/baselines/reference/tsc/incremental/global-diagnostics-produced-during-semantic-checking.js @@ -191,10 +191,14 @@ export function* values() { yield 1; } tsc -ExitStatus:: Success +ExitStatus:: DiagnosticsPresent_OutputsGenerated Output:: +error TS2318: Cannot find global type 'IterableIterator'. + +Found 1 error. + //// [/home/src/workspaces/project/tsconfig.tsbuildinfo] *modified* -{"version":"FakeTSVersion","errors":true,"root":[2],"fileNames":["lib.es2026.full.d.ts","./repro.ts"],"fileInfos":[{"version":"8859c12c614ce56ba9a18e58384a198f-/// \ninterface Boolean {}\ninterface Function {}\ninterface CallableFunction {}\ninterface NewableFunction {}\ninterface IArguments {}\ninterface Number { toExponential: any; }\ninterface Object {}\ninterface RegExp {}\ninterface String { charAt: any; }\ninterface Array { length: number; [n: number]: T; }\ninterface ReadonlyArray {}\ninterface SymbolConstructor {\n (desc?: string | number): symbol;\n for(name: string): symbol;\n readonly toStringTag: symbol;\n}\ndeclare var Symbol: SymbolConstructor;\ninterface Symbol {\n readonly [Symbol.toStringTag]: string;\n}\ndeclare const console: { log(msg: any): void; };","affectsGlobalScope":true,"impliedNodeFormat":1},{"version":"303d5119b8941b887ef975780b83caec-export function* values() { yield 1; }\n// comment-only edit\n","signature":"b9f7a0d32d9887fdd864bf1c0dcd3591-export declare function values(): {};\n","impliedNodeFormat":1}],"affectedFilesPendingEmit":[2]} +{"version":"FakeTSVersion","errors":true,"root":[2],"fileNames":["lib.es2026.full.d.ts","./repro.ts"],"fileInfos":[{"version":"8859c12c614ce56ba9a18e58384a198f-/// \ninterface Boolean {}\ninterface Function {}\ninterface CallableFunction {}\ninterface NewableFunction {}\ninterface IArguments {}\ninterface Number { toExponential: any; }\ninterface Object {}\ninterface RegExp {}\ninterface String { charAt: any; }\ninterface Array { length: number; [n: number]: T; }\ninterface ReadonlyArray {}\ninterface SymbolConstructor {\n (desc?: string | number): symbol;\n for(name: string): symbol;\n readonly toStringTag: symbol;\n}\ndeclare var Symbol: SymbolConstructor;\ninterface Symbol {\n readonly [Symbol.toStringTag]: string;\n}\ndeclare const console: { log(msg: any): void; };","affectsGlobalScope":true,"impliedNodeFormat":1},{"version":"303d5119b8941b887ef975780b83caec-export function* values() { yield 1; }\n// comment-only edit\n","signature":"b9f7a0d32d9887fdd864bf1c0dcd3591-export declare function values(): {};\n","impliedNodeFormat":1}],"semanticDiagnosticsPerFile":[[2,[{"noFile":true,"code":2318,"category":1,"messageKey":"Cannot_find_global_type_0_2318","messageArgs":["IterableIterator"]}]]],"affectedFilesPendingEmit":[2]} //// [/home/src/workspaces/project/tsconfig.tsbuildinfo.readable.baseline.txt] *modified* { "version": "FakeTSVersion", @@ -236,6 +240,22 @@ Output:: } } ], + "semanticDiagnosticsPerFile": [ + [ + "./repro.ts", + [ + { + "noFile": true, + "code": 2318, + "category": 1, + "messageKey": "Cannot_find_global_type_0_2318", + "messageArgs": [ + "IterableIterator" + ] + } + ] + ] + ], "affectedFilesPendingEmit": [ [ "./repro.ts", @@ -243,7 +263,7 @@ Output:: 2 ] ], - "size": 1136 + "size": 1295 } tsconfig.json:: @@ -253,22 +273,17 @@ Signatures:: (computed .d.ts) /home/src/workspaces/project/repro.ts -Diff:: Like Strada, signature generation produces the missing-global diagnostic before semantic checking, so it is excluded from the file's semantic diagnostics. ---- nonIncremental.output.txt -+++ incremental.output.txt -@@ -1,4 +0,0 @@ --error TS2318: Cannot find global type 'IterableIterator'. -- --Found 1 error. -- - Edit [2]:: no change tsc -ExitStatus:: Success +ExitStatus:: DiagnosticsPresent_OutputsGenerated Output:: +error TS2318: Cannot find global type 'IterableIterator'. + +Found 1 error. + //// [/home/src/workspaces/project/tsconfig.tsbuildinfo] *modified* -{"version":"FakeTSVersion","root":[2],"fileNames":["lib.es2026.full.d.ts","./repro.ts"],"fileInfos":[{"version":"8859c12c614ce56ba9a18e58384a198f-/// \ninterface Boolean {}\ninterface Function {}\ninterface CallableFunction {}\ninterface NewableFunction {}\ninterface IArguments {}\ninterface Number { toExponential: any; }\ninterface Object {}\ninterface RegExp {}\ninterface String { charAt: any; }\ninterface Array { length: number; [n: number]: T; }\ninterface ReadonlyArray {}\ninterface SymbolConstructor {\n (desc?: string | number): symbol;\n for(name: string): symbol;\n readonly toStringTag: symbol;\n}\ndeclare var Symbol: SymbolConstructor;\ninterface Symbol {\n readonly [Symbol.toStringTag]: string;\n}\ndeclare const console: { log(msg: any): void; };","affectsGlobalScope":true,"impliedNodeFormat":1},{"version":"303d5119b8941b887ef975780b83caec-export function* values() { yield 1; }\n// comment-only edit\n","signature":"b9f7a0d32d9887fdd864bf1c0dcd3591-export declare function values(): {};\n","impliedNodeFormat":1}],"affectedFilesPendingEmit":[2]} +{"version":"FakeTSVersion","root":[2],"fileNames":["lib.es2026.full.d.ts","./repro.ts"],"fileInfos":[{"version":"8859c12c614ce56ba9a18e58384a198f-/// \ninterface Boolean {}\ninterface Function {}\ninterface CallableFunction {}\ninterface NewableFunction {}\ninterface IArguments {}\ninterface Number { toExponential: any; }\ninterface Object {}\ninterface RegExp {}\ninterface String { charAt: any; }\ninterface Array { length: number; [n: number]: T; }\ninterface ReadonlyArray {}\ninterface SymbolConstructor {\n (desc?: string | number): symbol;\n for(name: string): symbol;\n readonly toStringTag: symbol;\n}\ndeclare var Symbol: SymbolConstructor;\ninterface Symbol {\n readonly [Symbol.toStringTag]: string;\n}\ndeclare const console: { log(msg: any): void; };","affectsGlobalScope":true,"impliedNodeFormat":1},{"version":"303d5119b8941b887ef975780b83caec-export function* values() { yield 1; }\n// comment-only edit\n","signature":"b9f7a0d32d9887fdd864bf1c0dcd3591-export declare function values(): {};\n","impliedNodeFormat":1}],"semanticDiagnosticsPerFile":[[2,[{"noFile":true,"code":2318,"category":1,"messageKey":"Cannot_find_global_type_0_2318","messageArgs":["IterableIterator"]}]]],"affectedFilesPendingEmit":[2]} //// [/home/src/workspaces/project/tsconfig.tsbuildinfo.readable.baseline.txt] *modified* { "version": "FakeTSVersion", @@ -309,6 +324,22 @@ Output:: } } ], + "semanticDiagnosticsPerFile": [ + [ + "./repro.ts", + [ + { + "noFile": true, + "code": 2318, + "category": 1, + "messageKey": "Cannot_find_global_type_0_2318", + "messageArgs": [ + "IterableIterator" + ] + } + ] + ] + ], "affectedFilesPendingEmit": [ [ "./repro.ts", @@ -316,7 +347,7 @@ Output:: 2 ] ], - "size": 1122 + "size": 1281 } tsconfig.json:: @@ -324,15 +355,6 @@ SemanticDiagnostics:: Signatures:: -Diff:: Like Strada, the cached semantic diagnostics do not include the missing-global diagnostic produced during signature generation. ---- nonIncremental.output.txt -+++ incremental.output.txt -@@ -1,4 +0,0 @@ --error TS2318: Cannot find global type 'IterableIterator'. -- --Found 1 error. -- - Edit [3]:: delete build info to restore the semantic diagnostic //// [/home/src/workspaces/project/tsconfig.tsbuildinfo] *deleted* diff --git a/tsc/testdata/baselines/reference/tsc/incremental/recursive-mapped-type-after-comment-only-edit.js b/tsc/testdata/baselines/reference/tsc/incremental/recursive-mapped-type-after-comment-only-edit.js index af64cf4493a8d..bc2db8d85b071 100644 --- a/tsc/testdata/baselines/reference/tsc/incremental/recursive-mapped-type-after-comment-only-edit.js +++ b/tsc/testdata/baselines/reference/tsc/incremental/recursive-mapped-type-after-comment-only-edit.js @@ -105,11 +105,10 @@ tsc ExitStatus:: Success Output:: //// [/home/src/workspaces/project/tsconfig.tsbuildinfo] *modified* -{"version":"FakeTSVersion","errors":true,"root":[2],"fileNames":["lib.es2026.full.d.ts","./repro.ts"],"fileInfos":[{"version":"0e330bc1e98a7e2601e4b38548df5e2b-/// \ninterface Boolean {}\ninterface Function {}\ninterface CallableFunction {}\ninterface NewableFunction {}\ninterface IArguments {}\ninterface Number { toExponential: any; }\ninterface Object {}\ninterface RegExp {}\ninterface String { charAt: any; }\ninterface Array { length: number; [n: number]: T; }\ninterface ReadonlyArray { readonly length: number; readonly [n: number]: T; }\ninterface SymbolConstructor {\n (desc?: string | number): symbol;\n for(name: string): symbol;\n readonly toStringTag: symbol;\n}\ndeclare var Symbol: SymbolConstructor;\ninterface Symbol {\n readonly [Symbol.toStringTag]: string;\n}\ndeclare const console: { log(msg: any): void; };","affectsGlobalScope":true,"impliedNodeFormat":1},{"version":"05e6c83fc809e0d08962e5b3425da798-type Json = string | Json[];\ntype Parsed = T extends object ? { [K in keyof T]: Parsed } : T;\ndeclare function wrap(value: T): Parsed;\nexport const value = wrap({ items: [] as Json[] });\n// comment-only edit\n","signature":"93e92d0786a923286e91eb7834b5ae1a-type Json = string | Json[];\nexport declare const value: {\n items: Json[];\n};\nexport {};\n","impliedNodeFormat":1}],"options":{"strict":true},"affectedFilesPendingEmit":[2]} +{"version":"FakeTSVersion","root":[2],"fileNames":["lib.es2026.full.d.ts","./repro.ts"],"fileInfos":[{"version":"0e330bc1e98a7e2601e4b38548df5e2b-/// \ninterface Boolean {}\ninterface Function {}\ninterface CallableFunction {}\ninterface NewableFunction {}\ninterface IArguments {}\ninterface Number { toExponential: any; }\ninterface Object {}\ninterface RegExp {}\ninterface String { charAt: any; }\ninterface Array { length: number; [n: number]: T; }\ninterface ReadonlyArray { readonly length: number; readonly [n: number]: T; }\ninterface SymbolConstructor {\n (desc?: string | number): symbol;\n for(name: string): symbol;\n readonly toStringTag: symbol;\n}\ndeclare var Symbol: SymbolConstructor;\ninterface Symbol {\n readonly [Symbol.toStringTag]: string;\n}\ndeclare const console: { log(msg: any): void; };","affectsGlobalScope":true,"impliedNodeFormat":1},{"version":"05e6c83fc809e0d08962e5b3425da798-type Json = string | Json[];\ntype Parsed = T extends object ? { [K in keyof T]: Parsed } : T;\ndeclare function wrap(value: T): Parsed;\nexport const value = wrap({ items: [] as Json[] });\n// comment-only edit\n","signature":"93e92d0786a923286e91eb7834b5ae1a-type Json = string | Json[];\nexport declare const value: {\n items: Json[];\n};\nexport {};\n","impliedNodeFormat":1}],"options":{"strict":true},"affectedFilesPendingEmit":[2]} //// [/home/src/workspaces/project/tsconfig.tsbuildinfo.readable.baseline.txt] *modified* { "version": "FakeTSVersion", - "errors": true, "root": [ { "files": [ @@ -157,7 +156,7 @@ Output:: 2 ] ], - "size": 1437 + "size": 1423 } tsconfig.json:: @@ -172,60 +171,6 @@ Edit [1]:: no change tsc ExitStatus:: Success Output:: -//// [/home/src/workspaces/project/tsconfig.tsbuildinfo] *modified* -{"version":"FakeTSVersion","root":[2],"fileNames":["lib.es2026.full.d.ts","./repro.ts"],"fileInfos":[{"version":"0e330bc1e98a7e2601e4b38548df5e2b-/// \ninterface Boolean {}\ninterface Function {}\ninterface CallableFunction {}\ninterface NewableFunction {}\ninterface IArguments {}\ninterface Number { toExponential: any; }\ninterface Object {}\ninterface RegExp {}\ninterface String { charAt: any; }\ninterface Array { length: number; [n: number]: T; }\ninterface ReadonlyArray { readonly length: number; readonly [n: number]: T; }\ninterface SymbolConstructor {\n (desc?: string | number): symbol;\n for(name: string): symbol;\n readonly toStringTag: symbol;\n}\ndeclare var Symbol: SymbolConstructor;\ninterface Symbol {\n readonly [Symbol.toStringTag]: string;\n}\ndeclare const console: { log(msg: any): void; };","affectsGlobalScope":true,"impliedNodeFormat":1},{"version":"05e6c83fc809e0d08962e5b3425da798-type Json = string | Json[];\ntype Parsed = T extends object ? { [K in keyof T]: Parsed } : T;\ndeclare function wrap(value: T): Parsed;\nexport const value = wrap({ items: [] as Json[] });\n// comment-only edit\n","signature":"93e92d0786a923286e91eb7834b5ae1a-type Json = string | Json[];\nexport declare const value: {\n items: Json[];\n};\nexport {};\n","impliedNodeFormat":1}],"options":{"strict":true},"affectedFilesPendingEmit":[2]} -//// [/home/src/workspaces/project/tsconfig.tsbuildinfo.readable.baseline.txt] *modified* -{ - "version": "FakeTSVersion", - "root": [ - { - "files": [ - "./repro.ts" - ], - "original": 2 - } - ], - "fileNames": [ - "lib.es2026.full.d.ts", - "./repro.ts" - ], - "fileInfos": [ - { - "fileName": "lib.es2026.full.d.ts", - "version": "0e330bc1e98a7e2601e4b38548df5e2b-/// \ninterface Boolean {}\ninterface Function {}\ninterface CallableFunction {}\ninterface NewableFunction {}\ninterface IArguments {}\ninterface Number { toExponential: any; }\ninterface Object {}\ninterface RegExp {}\ninterface String { charAt: any; }\ninterface Array { length: number; [n: number]: T; }\ninterface ReadonlyArray { readonly length: number; readonly [n: number]: T; }\ninterface SymbolConstructor {\n (desc?: string | number): symbol;\n for(name: string): symbol;\n readonly toStringTag: symbol;\n}\ndeclare var Symbol: SymbolConstructor;\ninterface Symbol {\n readonly [Symbol.toStringTag]: string;\n}\ndeclare const console: { log(msg: any): void; };", - "signature": "0e330bc1e98a7e2601e4b38548df5e2b-/// \ninterface Boolean {}\ninterface Function {}\ninterface CallableFunction {}\ninterface NewableFunction {}\ninterface IArguments {}\ninterface Number { toExponential: any; }\ninterface Object {}\ninterface RegExp {}\ninterface String { charAt: any; }\ninterface Array { length: number; [n: number]: T; }\ninterface ReadonlyArray { readonly length: number; readonly [n: number]: T; }\ninterface SymbolConstructor {\n (desc?: string | number): symbol;\n for(name: string): symbol;\n readonly toStringTag: symbol;\n}\ndeclare var Symbol: SymbolConstructor;\ninterface Symbol {\n readonly [Symbol.toStringTag]: string;\n}\ndeclare const console: { log(msg: any): void; };", - "affectsGlobalScope": true, - "impliedNodeFormat": "CommonJS", - "original": { - "version": "0e330bc1e98a7e2601e4b38548df5e2b-/// \ninterface Boolean {}\ninterface Function {}\ninterface CallableFunction {}\ninterface NewableFunction {}\ninterface IArguments {}\ninterface Number { toExponential: any; }\ninterface Object {}\ninterface RegExp {}\ninterface String { charAt: any; }\ninterface Array { length: number; [n: number]: T; }\ninterface ReadonlyArray { readonly length: number; readonly [n: number]: T; }\ninterface SymbolConstructor {\n (desc?: string | number): symbol;\n for(name: string): symbol;\n readonly toStringTag: symbol;\n}\ndeclare var Symbol: SymbolConstructor;\ninterface Symbol {\n readonly [Symbol.toStringTag]: string;\n}\ndeclare const console: { log(msg: any): void; };", - "affectsGlobalScope": true, - "impliedNodeFormat": 1 - } - }, - { - "fileName": "./repro.ts", - "version": "05e6c83fc809e0d08962e5b3425da798-type Json = string | Json[];\ntype Parsed = T extends object ? { [K in keyof T]: Parsed } : T;\ndeclare function wrap(value: T): Parsed;\nexport const value = wrap({ items: [] as Json[] });\n// comment-only edit\n", - "signature": "93e92d0786a923286e91eb7834b5ae1a-type Json = string | Json[];\nexport declare const value: {\n items: Json[];\n};\nexport {};\n", - "impliedNodeFormat": "CommonJS", - "original": { - "version": "05e6c83fc809e0d08962e5b3425da798-type Json = string | Json[];\ntype Parsed = T extends object ? { [K in keyof T]: Parsed } : T;\ndeclare function wrap(value: T): Parsed;\nexport const value = wrap({ items: [] as Json[] });\n// comment-only edit\n", - "signature": "93e92d0786a923286e91eb7834b5ae1a-type Json = string | Json[];\nexport declare const value: {\n items: Json[];\n};\nexport {};\n", - "impliedNodeFormat": 1 - } - } - ], - "options": { - "strict": true - }, - "affectedFilesPendingEmit": [ - [ - "./repro.ts", - "Js", - 2 - ] - ], - "size": 1423 -} tsconfig.json:: SemanticDiagnostics:: @@ -247,11 +192,10 @@ tsc ExitStatus:: Success Output:: //// [/home/src/workspaces/project/tsconfig.tsbuildinfo] *modified* -{"version":"FakeTSVersion","errors":true,"root":[2],"fileNames":["lib.es2026.full.d.ts","./repro.ts"],"fileInfos":[{"version":"0e330bc1e98a7e2601e4b38548df5e2b-/// \ninterface Boolean {}\ninterface Function {}\ninterface CallableFunction {}\ninterface NewableFunction {}\ninterface IArguments {}\ninterface Number { toExponential: any; }\ninterface Object {}\ninterface RegExp {}\ninterface String { charAt: any; }\ninterface Array { length: number; [n: number]: T; }\ninterface ReadonlyArray { readonly length: number; readonly [n: number]: T; }\ninterface SymbolConstructor {\n (desc?: string | number): symbol;\n for(name: string): symbol;\n readonly toStringTag: symbol;\n}\ndeclare var Symbol: SymbolConstructor;\ninterface Symbol {\n readonly [Symbol.toStringTag]: string;\n}\ndeclare const console: { log(msg: any): void; };","affectsGlobalScope":true,"impliedNodeFormat":1},{"version":"989f15878b40fd4e572d65e47a8cc845-type Json = string | Json[];\ntype Parsed = T extends object ? { [K in keyof T]: Parsed } : T;\ndeclare function wrap(value: T): Parsed;\nexport const value = wrap({ items: [] as Json[] });\n// comment-only edit\n\n// another comment\n","signature":"93e92d0786a923286e91eb7834b5ae1a-type Json = string | Json[];\nexport declare const value: {\n items: Json[];\n};\nexport {};\n","impliedNodeFormat":1}],"options":{"strict":true},"affectedFilesPendingEmit":[2]} +{"version":"FakeTSVersion","root":[2],"fileNames":["lib.es2026.full.d.ts","./repro.ts"],"fileInfos":[{"version":"0e330bc1e98a7e2601e4b38548df5e2b-/// \ninterface Boolean {}\ninterface Function {}\ninterface CallableFunction {}\ninterface NewableFunction {}\ninterface IArguments {}\ninterface Number { toExponential: any; }\ninterface Object {}\ninterface RegExp {}\ninterface String { charAt: any; }\ninterface Array { length: number; [n: number]: T; }\ninterface ReadonlyArray { readonly length: number; readonly [n: number]: T; }\ninterface SymbolConstructor {\n (desc?: string | number): symbol;\n for(name: string): symbol;\n readonly toStringTag: symbol;\n}\ndeclare var Symbol: SymbolConstructor;\ninterface Symbol {\n readonly [Symbol.toStringTag]: string;\n}\ndeclare const console: { log(msg: any): void; };","affectsGlobalScope":true,"impliedNodeFormat":1},{"version":"989f15878b40fd4e572d65e47a8cc845-type Json = string | Json[];\ntype Parsed = T extends object ? { [K in keyof T]: Parsed } : T;\ndeclare function wrap(value: T): Parsed;\nexport const value = wrap({ items: [] as Json[] });\n// comment-only edit\n\n// another comment\n","signature":"93e92d0786a923286e91eb7834b5ae1a-type Json = string | Json[];\nexport declare const value: {\n items: Json[];\n};\nexport {};\n","impliedNodeFormat":1}],"options":{"strict":true},"affectedFilesPendingEmit":[2]} //// [/home/src/workspaces/project/tsconfig.tsbuildinfo.readable.baseline.txt] *modified* { "version": "FakeTSVersion", - "errors": true, "root": [ { "files": [ @@ -299,7 +243,7 @@ Output:: 2 ] ], - "size": 1459 + "size": 1445 } tsconfig.json:: @@ -314,60 +258,6 @@ Edit [3]:: no change tsc ExitStatus:: Success Output:: -//// [/home/src/workspaces/project/tsconfig.tsbuildinfo] *modified* -{"version":"FakeTSVersion","root":[2],"fileNames":["lib.es2026.full.d.ts","./repro.ts"],"fileInfos":[{"version":"0e330bc1e98a7e2601e4b38548df5e2b-/// \ninterface Boolean {}\ninterface Function {}\ninterface CallableFunction {}\ninterface NewableFunction {}\ninterface IArguments {}\ninterface Number { toExponential: any; }\ninterface Object {}\ninterface RegExp {}\ninterface String { charAt: any; }\ninterface Array { length: number; [n: number]: T; }\ninterface ReadonlyArray { readonly length: number; readonly [n: number]: T; }\ninterface SymbolConstructor {\n (desc?: string | number): symbol;\n for(name: string): symbol;\n readonly toStringTag: symbol;\n}\ndeclare var Symbol: SymbolConstructor;\ninterface Symbol {\n readonly [Symbol.toStringTag]: string;\n}\ndeclare const console: { log(msg: any): void; };","affectsGlobalScope":true,"impliedNodeFormat":1},{"version":"989f15878b40fd4e572d65e47a8cc845-type Json = string | Json[];\ntype Parsed = T extends object ? { [K in keyof T]: Parsed } : T;\ndeclare function wrap(value: T): Parsed;\nexport const value = wrap({ items: [] as Json[] });\n// comment-only edit\n\n// another comment\n","signature":"93e92d0786a923286e91eb7834b5ae1a-type Json = string | Json[];\nexport declare const value: {\n items: Json[];\n};\nexport {};\n","impliedNodeFormat":1}],"options":{"strict":true},"affectedFilesPendingEmit":[2]} -//// [/home/src/workspaces/project/tsconfig.tsbuildinfo.readable.baseline.txt] *modified* -{ - "version": "FakeTSVersion", - "root": [ - { - "files": [ - "./repro.ts" - ], - "original": 2 - } - ], - "fileNames": [ - "lib.es2026.full.d.ts", - "./repro.ts" - ], - "fileInfos": [ - { - "fileName": "lib.es2026.full.d.ts", - "version": "0e330bc1e98a7e2601e4b38548df5e2b-/// \ninterface Boolean {}\ninterface Function {}\ninterface CallableFunction {}\ninterface NewableFunction {}\ninterface IArguments {}\ninterface Number { toExponential: any; }\ninterface Object {}\ninterface RegExp {}\ninterface String { charAt: any; }\ninterface Array { length: number; [n: number]: T; }\ninterface ReadonlyArray { readonly length: number; readonly [n: number]: T; }\ninterface SymbolConstructor {\n (desc?: string | number): symbol;\n for(name: string): symbol;\n readonly toStringTag: symbol;\n}\ndeclare var Symbol: SymbolConstructor;\ninterface Symbol {\n readonly [Symbol.toStringTag]: string;\n}\ndeclare const console: { log(msg: any): void; };", - "signature": "0e330bc1e98a7e2601e4b38548df5e2b-/// \ninterface Boolean {}\ninterface Function {}\ninterface CallableFunction {}\ninterface NewableFunction {}\ninterface IArguments {}\ninterface Number { toExponential: any; }\ninterface Object {}\ninterface RegExp {}\ninterface String { charAt: any; }\ninterface Array { length: number; [n: number]: T; }\ninterface ReadonlyArray { readonly length: number; readonly [n: number]: T; }\ninterface SymbolConstructor {\n (desc?: string | number): symbol;\n for(name: string): symbol;\n readonly toStringTag: symbol;\n}\ndeclare var Symbol: SymbolConstructor;\ninterface Symbol {\n readonly [Symbol.toStringTag]: string;\n}\ndeclare const console: { log(msg: any): void; };", - "affectsGlobalScope": true, - "impliedNodeFormat": "CommonJS", - "original": { - "version": "0e330bc1e98a7e2601e4b38548df5e2b-/// \ninterface Boolean {}\ninterface Function {}\ninterface CallableFunction {}\ninterface NewableFunction {}\ninterface IArguments {}\ninterface Number { toExponential: any; }\ninterface Object {}\ninterface RegExp {}\ninterface String { charAt: any; }\ninterface Array { length: number; [n: number]: T; }\ninterface ReadonlyArray { readonly length: number; readonly [n: number]: T; }\ninterface SymbolConstructor {\n (desc?: string | number): symbol;\n for(name: string): symbol;\n readonly toStringTag: symbol;\n}\ndeclare var Symbol: SymbolConstructor;\ninterface Symbol {\n readonly [Symbol.toStringTag]: string;\n}\ndeclare const console: { log(msg: any): void; };", - "affectsGlobalScope": true, - "impliedNodeFormat": 1 - } - }, - { - "fileName": "./repro.ts", - "version": "989f15878b40fd4e572d65e47a8cc845-type Json = string | Json[];\ntype Parsed = T extends object ? { [K in keyof T]: Parsed } : T;\ndeclare function wrap(value: T): Parsed;\nexport const value = wrap({ items: [] as Json[] });\n// comment-only edit\n\n// another comment\n", - "signature": "93e92d0786a923286e91eb7834b5ae1a-type Json = string | Json[];\nexport declare const value: {\n items: Json[];\n};\nexport {};\n", - "impliedNodeFormat": "CommonJS", - "original": { - "version": "989f15878b40fd4e572d65e47a8cc845-type Json = string | Json[];\ntype Parsed = T extends object ? { [K in keyof T]: Parsed } : T;\ndeclare function wrap(value: T): Parsed;\nexport const value = wrap({ items: [] as Json[] });\n// comment-only edit\n\n// another comment\n", - "signature": "93e92d0786a923286e91eb7834b5ae1a-type Json = string | Json[];\nexport declare const value: {\n items: Json[];\n};\nexport {};\n", - "impliedNodeFormat": 1 - } - } - ], - "options": { - "strict": true - }, - "affectedFilesPendingEmit": [ - [ - "./repro.ts", - "Js", - 2 - ] - ], - "size": 1445 -} tsconfig.json:: SemanticDiagnostics:: diff --git a/tsc/testdata/baselines/reference/tsc/incremental/recursive-readonly-mapped-type-after-comment-only-edit.js b/tsc/testdata/baselines/reference/tsc/incremental/recursive-readonly-mapped-type-after-comment-only-edit.js index fdf8a7119c57e..a602b051a678c 100644 --- a/tsc/testdata/baselines/reference/tsc/incremental/recursive-readonly-mapped-type-after-comment-only-edit.js +++ b/tsc/testdata/baselines/reference/tsc/incremental/recursive-readonly-mapped-type-after-comment-only-edit.js @@ -105,11 +105,10 @@ tsc ExitStatus:: Success Output:: //// [/home/src/workspaces/project/tsconfig.tsbuildinfo] *modified* -{"version":"FakeTSVersion","errors":true,"root":[2],"fileNames":["lib.es2026.full.d.ts","./repro.ts"],"fileInfos":[{"version":"0e330bc1e98a7e2601e4b38548df5e2b-/// \ninterface Boolean {}\ninterface Function {}\ninterface CallableFunction {}\ninterface NewableFunction {}\ninterface IArguments {}\ninterface Number { toExponential: any; }\ninterface Object {}\ninterface RegExp {}\ninterface String { charAt: any; }\ninterface Array { length: number; [n: number]: T; }\ninterface ReadonlyArray { readonly length: number; readonly [n: number]: T; }\ninterface SymbolConstructor {\n (desc?: string | number): symbol;\n for(name: string): symbol;\n readonly toStringTag: symbol;\n}\ndeclare var Symbol: SymbolConstructor;\ninterface Symbol {\n readonly [Symbol.toStringTag]: string;\n}\ndeclare const console: { log(msg: any): void; };","affectsGlobalScope":true,"impliedNodeFormat":1},{"version":"44adeee334483dab0e3927db949cf78a-type Json = string | readonly Json[];\ntype Parsed = T extends object ? { [K in keyof T]: Parsed } : T;\ndeclare function wrap(value: T): Parsed;\nexport const value = wrap({ items: [] as readonly Json[] });\n// comment-only edit\n","signature":"ac9ba36fbad04eb70b8f2b14cdf772ef-type Json = string | readonly Json[];\nexport declare const value: {\n items: readonly Json[];\n};\nexport {};\n","impliedNodeFormat":1}],"options":{"strict":true},"affectedFilesPendingEmit":[2]} +{"version":"FakeTSVersion","root":[2],"fileNames":["lib.es2026.full.d.ts","./repro.ts"],"fileInfos":[{"version":"0e330bc1e98a7e2601e4b38548df5e2b-/// \ninterface Boolean {}\ninterface Function {}\ninterface CallableFunction {}\ninterface NewableFunction {}\ninterface IArguments {}\ninterface Number { toExponential: any; }\ninterface Object {}\ninterface RegExp {}\ninterface String { charAt: any; }\ninterface Array { length: number; [n: number]: T; }\ninterface ReadonlyArray { readonly length: number; readonly [n: number]: T; }\ninterface SymbolConstructor {\n (desc?: string | number): symbol;\n for(name: string): symbol;\n readonly toStringTag: symbol;\n}\ndeclare var Symbol: SymbolConstructor;\ninterface Symbol {\n readonly [Symbol.toStringTag]: string;\n}\ndeclare const console: { log(msg: any): void; };","affectsGlobalScope":true,"impliedNodeFormat":1},{"version":"44adeee334483dab0e3927db949cf78a-type Json = string | readonly Json[];\ntype Parsed = T extends object ? { [K in keyof T]: Parsed } : T;\ndeclare function wrap(value: T): Parsed;\nexport const value = wrap({ items: [] as readonly Json[] });\n// comment-only edit\n","signature":"ac9ba36fbad04eb70b8f2b14cdf772ef-type Json = string | readonly Json[];\nexport declare const value: {\n items: readonly Json[];\n};\nexport {};\n","impliedNodeFormat":1}],"options":{"strict":true},"affectedFilesPendingEmit":[2]} //// [/home/src/workspaces/project/tsconfig.tsbuildinfo.readable.baseline.txt] *modified* { "version": "FakeTSVersion", - "errors": true, "root": [ { "files": [ @@ -157,7 +156,7 @@ Output:: 2 ] ], - "size": 1473 + "size": 1459 } tsconfig.json:: @@ -172,60 +171,6 @@ Edit [1]:: no change tsc ExitStatus:: Success Output:: -//// [/home/src/workspaces/project/tsconfig.tsbuildinfo] *modified* -{"version":"FakeTSVersion","root":[2],"fileNames":["lib.es2026.full.d.ts","./repro.ts"],"fileInfos":[{"version":"0e330bc1e98a7e2601e4b38548df5e2b-/// \ninterface Boolean {}\ninterface Function {}\ninterface CallableFunction {}\ninterface NewableFunction {}\ninterface IArguments {}\ninterface Number { toExponential: any; }\ninterface Object {}\ninterface RegExp {}\ninterface String { charAt: any; }\ninterface Array { length: number; [n: number]: T; }\ninterface ReadonlyArray { readonly length: number; readonly [n: number]: T; }\ninterface SymbolConstructor {\n (desc?: string | number): symbol;\n for(name: string): symbol;\n readonly toStringTag: symbol;\n}\ndeclare var Symbol: SymbolConstructor;\ninterface Symbol {\n readonly [Symbol.toStringTag]: string;\n}\ndeclare const console: { log(msg: any): void; };","affectsGlobalScope":true,"impliedNodeFormat":1},{"version":"44adeee334483dab0e3927db949cf78a-type Json = string | readonly Json[];\ntype Parsed = T extends object ? { [K in keyof T]: Parsed } : T;\ndeclare function wrap(value: T): Parsed;\nexport const value = wrap({ items: [] as readonly Json[] });\n// comment-only edit\n","signature":"ac9ba36fbad04eb70b8f2b14cdf772ef-type Json = string | readonly Json[];\nexport declare const value: {\n items: readonly Json[];\n};\nexport {};\n","impliedNodeFormat":1}],"options":{"strict":true},"affectedFilesPendingEmit":[2]} -//// [/home/src/workspaces/project/tsconfig.tsbuildinfo.readable.baseline.txt] *modified* -{ - "version": "FakeTSVersion", - "root": [ - { - "files": [ - "./repro.ts" - ], - "original": 2 - } - ], - "fileNames": [ - "lib.es2026.full.d.ts", - "./repro.ts" - ], - "fileInfos": [ - { - "fileName": "lib.es2026.full.d.ts", - "version": "0e330bc1e98a7e2601e4b38548df5e2b-/// \ninterface Boolean {}\ninterface Function {}\ninterface CallableFunction {}\ninterface NewableFunction {}\ninterface IArguments {}\ninterface Number { toExponential: any; }\ninterface Object {}\ninterface RegExp {}\ninterface String { charAt: any; }\ninterface Array { length: number; [n: number]: T; }\ninterface ReadonlyArray { readonly length: number; readonly [n: number]: T; }\ninterface SymbolConstructor {\n (desc?: string | number): symbol;\n for(name: string): symbol;\n readonly toStringTag: symbol;\n}\ndeclare var Symbol: SymbolConstructor;\ninterface Symbol {\n readonly [Symbol.toStringTag]: string;\n}\ndeclare const console: { log(msg: any): void; };", - "signature": "0e330bc1e98a7e2601e4b38548df5e2b-/// \ninterface Boolean {}\ninterface Function {}\ninterface CallableFunction {}\ninterface NewableFunction {}\ninterface IArguments {}\ninterface Number { toExponential: any; }\ninterface Object {}\ninterface RegExp {}\ninterface String { charAt: any; }\ninterface Array { length: number; [n: number]: T; }\ninterface ReadonlyArray { readonly length: number; readonly [n: number]: T; }\ninterface SymbolConstructor {\n (desc?: string | number): symbol;\n for(name: string): symbol;\n readonly toStringTag: symbol;\n}\ndeclare var Symbol: SymbolConstructor;\ninterface Symbol {\n readonly [Symbol.toStringTag]: string;\n}\ndeclare const console: { log(msg: any): void; };", - "affectsGlobalScope": true, - "impliedNodeFormat": "CommonJS", - "original": { - "version": "0e330bc1e98a7e2601e4b38548df5e2b-/// \ninterface Boolean {}\ninterface Function {}\ninterface CallableFunction {}\ninterface NewableFunction {}\ninterface IArguments {}\ninterface Number { toExponential: any; }\ninterface Object {}\ninterface RegExp {}\ninterface String { charAt: any; }\ninterface Array { length: number; [n: number]: T; }\ninterface ReadonlyArray { readonly length: number; readonly [n: number]: T; }\ninterface SymbolConstructor {\n (desc?: string | number): symbol;\n for(name: string): symbol;\n readonly toStringTag: symbol;\n}\ndeclare var Symbol: SymbolConstructor;\ninterface Symbol {\n readonly [Symbol.toStringTag]: string;\n}\ndeclare const console: { log(msg: any): void; };", - "affectsGlobalScope": true, - "impliedNodeFormat": 1 - } - }, - { - "fileName": "./repro.ts", - "version": "44adeee334483dab0e3927db949cf78a-type Json = string | readonly Json[];\ntype Parsed = T extends object ? { [K in keyof T]: Parsed } : T;\ndeclare function wrap(value: T): Parsed;\nexport const value = wrap({ items: [] as readonly Json[] });\n// comment-only edit\n", - "signature": "ac9ba36fbad04eb70b8f2b14cdf772ef-type Json = string | readonly Json[];\nexport declare const value: {\n items: readonly Json[];\n};\nexport {};\n", - "impliedNodeFormat": "CommonJS", - "original": { - "version": "44adeee334483dab0e3927db949cf78a-type Json = string | readonly Json[];\ntype Parsed = T extends object ? { [K in keyof T]: Parsed } : T;\ndeclare function wrap(value: T): Parsed;\nexport const value = wrap({ items: [] as readonly Json[] });\n// comment-only edit\n", - "signature": "ac9ba36fbad04eb70b8f2b14cdf772ef-type Json = string | readonly Json[];\nexport declare const value: {\n items: readonly Json[];\n};\nexport {};\n", - "impliedNodeFormat": 1 - } - } - ], - "options": { - "strict": true - }, - "affectedFilesPendingEmit": [ - [ - "./repro.ts", - "Js", - 2 - ] - ], - "size": 1459 -} tsconfig.json:: SemanticDiagnostics:: @@ -247,11 +192,10 @@ tsc ExitStatus:: Success Output:: //// [/home/src/workspaces/project/tsconfig.tsbuildinfo] *modified* -{"version":"FakeTSVersion","errors":true,"root":[2],"fileNames":["lib.es2026.full.d.ts","./repro.ts"],"fileInfos":[{"version":"0e330bc1e98a7e2601e4b38548df5e2b-/// \ninterface Boolean {}\ninterface Function {}\ninterface CallableFunction {}\ninterface NewableFunction {}\ninterface IArguments {}\ninterface Number { toExponential: any; }\ninterface Object {}\ninterface RegExp {}\ninterface String { charAt: any; }\ninterface Array { length: number; [n: number]: T; }\ninterface ReadonlyArray { readonly length: number; readonly [n: number]: T; }\ninterface SymbolConstructor {\n (desc?: string | number): symbol;\n for(name: string): symbol;\n readonly toStringTag: symbol;\n}\ndeclare var Symbol: SymbolConstructor;\ninterface Symbol {\n readonly [Symbol.toStringTag]: string;\n}\ndeclare const console: { log(msg: any): void; };","affectsGlobalScope":true,"impliedNodeFormat":1},{"version":"123beaefc70ba63a9447b94fb12d09b5-type Json = string | readonly Json[];\ntype Parsed = T extends object ? { [K in keyof T]: Parsed } : T;\ndeclare function wrap(value: T): Parsed;\nexport const value = wrap({ items: [] as readonly Json[] });\n// comment-only edit\n\n// another comment\n","signature":"ac9ba36fbad04eb70b8f2b14cdf772ef-type Json = string | readonly Json[];\nexport declare const value: {\n items: readonly Json[];\n};\nexport {};\n","impliedNodeFormat":1}],"options":{"strict":true},"affectedFilesPendingEmit":[2]} +{"version":"FakeTSVersion","root":[2],"fileNames":["lib.es2026.full.d.ts","./repro.ts"],"fileInfos":[{"version":"0e330bc1e98a7e2601e4b38548df5e2b-/// \ninterface Boolean {}\ninterface Function {}\ninterface CallableFunction {}\ninterface NewableFunction {}\ninterface IArguments {}\ninterface Number { toExponential: any; }\ninterface Object {}\ninterface RegExp {}\ninterface String { charAt: any; }\ninterface Array { length: number; [n: number]: T; }\ninterface ReadonlyArray { readonly length: number; readonly [n: number]: T; }\ninterface SymbolConstructor {\n (desc?: string | number): symbol;\n for(name: string): symbol;\n readonly toStringTag: symbol;\n}\ndeclare var Symbol: SymbolConstructor;\ninterface Symbol {\n readonly [Symbol.toStringTag]: string;\n}\ndeclare const console: { log(msg: any): void; };","affectsGlobalScope":true,"impliedNodeFormat":1},{"version":"123beaefc70ba63a9447b94fb12d09b5-type Json = string | readonly Json[];\ntype Parsed = T extends object ? { [K in keyof T]: Parsed } : T;\ndeclare function wrap(value: T): Parsed;\nexport const value = wrap({ items: [] as readonly Json[] });\n// comment-only edit\n\n// another comment\n","signature":"ac9ba36fbad04eb70b8f2b14cdf772ef-type Json = string | readonly Json[];\nexport declare const value: {\n items: readonly Json[];\n};\nexport {};\n","impliedNodeFormat":1}],"options":{"strict":true},"affectedFilesPendingEmit":[2]} //// [/home/src/workspaces/project/tsconfig.tsbuildinfo.readable.baseline.txt] *modified* { "version": "FakeTSVersion", - "errors": true, "root": [ { "files": [ @@ -299,7 +243,7 @@ Output:: 2 ] ], - "size": 1495 + "size": 1481 } tsconfig.json:: @@ -314,60 +258,6 @@ Edit [3]:: no change tsc ExitStatus:: Success Output:: -//// [/home/src/workspaces/project/tsconfig.tsbuildinfo] *modified* -{"version":"FakeTSVersion","root":[2],"fileNames":["lib.es2026.full.d.ts","./repro.ts"],"fileInfos":[{"version":"0e330bc1e98a7e2601e4b38548df5e2b-/// \ninterface Boolean {}\ninterface Function {}\ninterface CallableFunction {}\ninterface NewableFunction {}\ninterface IArguments {}\ninterface Number { toExponential: any; }\ninterface Object {}\ninterface RegExp {}\ninterface String { charAt: any; }\ninterface Array { length: number; [n: number]: T; }\ninterface ReadonlyArray { readonly length: number; readonly [n: number]: T; }\ninterface SymbolConstructor {\n (desc?: string | number): symbol;\n for(name: string): symbol;\n readonly toStringTag: symbol;\n}\ndeclare var Symbol: SymbolConstructor;\ninterface Symbol {\n readonly [Symbol.toStringTag]: string;\n}\ndeclare const console: { log(msg: any): void; };","affectsGlobalScope":true,"impliedNodeFormat":1},{"version":"123beaefc70ba63a9447b94fb12d09b5-type Json = string | readonly Json[];\ntype Parsed = T extends object ? { [K in keyof T]: Parsed } : T;\ndeclare function wrap(value: T): Parsed;\nexport const value = wrap({ items: [] as readonly Json[] });\n// comment-only edit\n\n// another comment\n","signature":"ac9ba36fbad04eb70b8f2b14cdf772ef-type Json = string | readonly Json[];\nexport declare const value: {\n items: readonly Json[];\n};\nexport {};\n","impliedNodeFormat":1}],"options":{"strict":true},"affectedFilesPendingEmit":[2]} -//// [/home/src/workspaces/project/tsconfig.tsbuildinfo.readable.baseline.txt] *modified* -{ - "version": "FakeTSVersion", - "root": [ - { - "files": [ - "./repro.ts" - ], - "original": 2 - } - ], - "fileNames": [ - "lib.es2026.full.d.ts", - "./repro.ts" - ], - "fileInfos": [ - { - "fileName": "lib.es2026.full.d.ts", - "version": "0e330bc1e98a7e2601e4b38548df5e2b-/// \ninterface Boolean {}\ninterface Function {}\ninterface CallableFunction {}\ninterface NewableFunction {}\ninterface IArguments {}\ninterface Number { toExponential: any; }\ninterface Object {}\ninterface RegExp {}\ninterface String { charAt: any; }\ninterface Array { length: number; [n: number]: T; }\ninterface ReadonlyArray { readonly length: number; readonly [n: number]: T; }\ninterface SymbolConstructor {\n (desc?: string | number): symbol;\n for(name: string): symbol;\n readonly toStringTag: symbol;\n}\ndeclare var Symbol: SymbolConstructor;\ninterface Symbol {\n readonly [Symbol.toStringTag]: string;\n}\ndeclare const console: { log(msg: any): void; };", - "signature": "0e330bc1e98a7e2601e4b38548df5e2b-/// \ninterface Boolean {}\ninterface Function {}\ninterface CallableFunction {}\ninterface NewableFunction {}\ninterface IArguments {}\ninterface Number { toExponential: any; }\ninterface Object {}\ninterface RegExp {}\ninterface String { charAt: any; }\ninterface Array { length: number; [n: number]: T; }\ninterface ReadonlyArray { readonly length: number; readonly [n: number]: T; }\ninterface SymbolConstructor {\n (desc?: string | number): symbol;\n for(name: string): symbol;\n readonly toStringTag: symbol;\n}\ndeclare var Symbol: SymbolConstructor;\ninterface Symbol {\n readonly [Symbol.toStringTag]: string;\n}\ndeclare const console: { log(msg: any): void; };", - "affectsGlobalScope": true, - "impliedNodeFormat": "CommonJS", - "original": { - "version": "0e330bc1e98a7e2601e4b38548df5e2b-/// \ninterface Boolean {}\ninterface Function {}\ninterface CallableFunction {}\ninterface NewableFunction {}\ninterface IArguments {}\ninterface Number { toExponential: any; }\ninterface Object {}\ninterface RegExp {}\ninterface String { charAt: any; }\ninterface Array { length: number; [n: number]: T; }\ninterface ReadonlyArray { readonly length: number; readonly [n: number]: T; }\ninterface SymbolConstructor {\n (desc?: string | number): symbol;\n for(name: string): symbol;\n readonly toStringTag: symbol;\n}\ndeclare var Symbol: SymbolConstructor;\ninterface Symbol {\n readonly [Symbol.toStringTag]: string;\n}\ndeclare const console: { log(msg: any): void; };", - "affectsGlobalScope": true, - "impliedNodeFormat": 1 - } - }, - { - "fileName": "./repro.ts", - "version": "123beaefc70ba63a9447b94fb12d09b5-type Json = string | readonly Json[];\ntype Parsed = T extends object ? { [K in keyof T]: Parsed } : T;\ndeclare function wrap(value: T): Parsed;\nexport const value = wrap({ items: [] as readonly Json[] });\n// comment-only edit\n\n// another comment\n", - "signature": "ac9ba36fbad04eb70b8f2b14cdf772ef-type Json = string | readonly Json[];\nexport declare const value: {\n items: readonly Json[];\n};\nexport {};\n", - "impliedNodeFormat": "CommonJS", - "original": { - "version": "123beaefc70ba63a9447b94fb12d09b5-type Json = string | readonly Json[];\ntype Parsed = T extends object ? { [K in keyof T]: Parsed } : T;\ndeclare function wrap(value: T): Parsed;\nexport const value = wrap({ items: [] as readonly Json[] });\n// comment-only edit\n\n// another comment\n", - "signature": "ac9ba36fbad04eb70b8f2b14cdf772ef-type Json = string | readonly Json[];\nexport declare const value: {\n items: readonly Json[];\n};\nexport {};\n", - "impliedNodeFormat": 1 - } - } - ], - "options": { - "strict": true - }, - "affectedFilesPendingEmit": [ - [ - "./repro.ts", - "Js", - 2 - ] - ], - "size": 1481 -} tsconfig.json:: SemanticDiagnostics:: diff --git a/tsc/testdata/tests/cases/compiler/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/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/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/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; From d92a57b539ff9f2a564159a60d0a94536ecd5e4e Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Mon, 9 Nov 2026 12:48:39 -0800 Subject: [PATCH 37/60] Do not report nonexistent properties where errors are never shown MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Building the error for a nonexistent property prints types. In code that is not checked, such as a generated "// @ts-nocheck" validator, printing a function type infers its return type from its body, which can report more nonexistent properties, whose errors are built in turn. Since the errors are built once the check finishes, nothing in progress cuts this short: on webpack, it builds 1400 errors in one schema file, inferring the return types of most of its validators, though the program never reports any error in that file. So the checker asks the program whether it would report errors in the file before reporting one there. webpack and vscode, default GC, default checkers: │ before.txt │ after.txt │ │ sec/op │ sec/op vs base │ webpack 2.980 ± 24% 2.685 ± 36% -9.90% (p=0.007 n=8) vscode 14.32 ± 3% 14.57 ± 8% ~ (p=0.878 n=8) geomean 6.531 6.254 -4.25% │ before.txt │ after.txt │ │ peak-RSS-bytes │ peak-RSS-bytes vs base │ webpack 983.3Mi ± 3% 919.1Mi ± 6% -6.53% (p=0.000 n=8) vscode 5.034Gi ± 3% 4.943Gi ± 2% ~ (p=0.195 n=8) geomean 2.199Gi 2.106Gi -4.20% │ before.txt │ after.txt │ │ instructions/op │ instructions/op vs base │ webpack 50.95G ± 3% 46.17G ± 4% -9.37% (p=0.000 n=8) vscode 224.3G ± 2% 228.0G ± 3% ~ (p=0.382 n=8) geomean 106.9G 102.6G -4.02% --- tsc/internal/checker/checker.go | 7 +++++++ tsc/internal/checker/memopeek_test.go | 3 ++- tsc/internal/ls/autoimport/aliasresolver.go | 5 +++++ .../transformers/tstransforms/importelision_test.go | 4 ++++ 4 files changed, 18 insertions(+), 1 deletion(-) diff --git a/tsc/internal/checker/checker.go b/tsc/internal/checker/checker.go index 3c6943a6ff679..29a027bfa09e8 100644 --- a/tsc/internal/checker/checker.go +++ b/tsc/internal/checker/checker.go @@ -615,6 +615,7 @@ type Program interface { GetImportHelpersImportSpecifier(path tspath.PathKey) *ast.Node SourceFileMayBeEmitted(sourceFile *ast.SourceFile, forceDtsEmit bool) bool IsSourceFileDefaultLibrary(path tspath.PathKey) bool + SkipTypeChecking(sourceFile *ast.SourceFile, ignoreNoCheck bool) bool GetProjectReferenceFromOutputDts(path tspath.PathKey) *tsoptions.SourceOutputAndProjectReference GetRedirectForResolution(file ast.HasFileName) *tsoptions.ParsedCommandLine CommonSourceDirectory() tspath.RootedDirectoryPath @@ -12335,6 +12336,12 @@ func (c *Checker) reportNonexistentProperty(propNode *ast.Node, containingType * c.recordEffect(func(c *Checker) { c.reportNonexistentProperty(propNode, containingType, isUncheckedJS) }) return } + // The diagnostic would never be reported, and building it prints types, + // which in unchecked code can infer return types that report more of + // them. + if c.program.SkipTypeChecking(ast.GetSourceFileOfNode(propNode), false) { + return + } // Only the first report for a name is made, even if it is reported again // on another containing type. if c.nonExistentPropertyNodes.Has(propNode) { diff --git a/tsc/internal/checker/memopeek_test.go b/tsc/internal/checker/memopeek_test.go index ba773d7232d51..a9bdd089e17ae 100644 --- a/tsc/internal/checker/memopeek_test.go +++ b/tsc/internal/checker/memopeek_test.go @@ -305,7 +305,8 @@ func TestDeferredEffectsOnlyApply(t *testing.T) { if sel.Sel.Name == "addDeferredDiagnostic" { return false } - if appliedCalls[sel.Sel.Name] { + // The program computes nothing in the checker. + if appliedCalls[sel.Sel.Name] || text(sel.X) == "c.program" { return true } if sel.Sel.Name == owner.Name.Name && text(sel.X) == "c" { diff --git a/tsc/internal/ls/autoimport/aliasresolver.go b/tsc/internal/ls/autoimport/aliasresolver.go index 3ac34d7d7e473..bec660bfde011 100644 --- a/tsc/internal/ls/autoimport/aliasresolver.go +++ b/tsc/internal/ls/autoimport/aliasresolver.go @@ -65,6 +65,11 @@ func (r *aliasResolver) Options() *core.CompilerOptions { } } +// SkipTypeChecking implements checker.Program. +func (r *aliasResolver) SkipTypeChecking(sourceFile *ast.SourceFile, ignoreNoCheck bool) bool { + return !ignoreNoCheck +} + // BaseDirectory implements checker.Program. func (r *aliasResolver) BaseDirectory() tspath.RootedDirectoryPath { return r.moduleResolver.BaseDirectory() diff --git a/tsc/internal/transformers/tstransforms/importelision_test.go b/tsc/internal/transformers/tstransforms/importelision_test.go index f2f2ca4014044..350e2d65c98a3 100644 --- a/tsc/internal/transformers/tstransforms/importelision_test.go +++ b/tsc/internal/transformers/tstransforms/importelision_test.go @@ -36,6 +36,10 @@ func (p *fakeProgram) GetRedirectForResolution(file ast.HasFileName) *tsoptions. } // SourceFileMayBeEmitted implements checker.Program. +func (p *fakeProgram) SkipTypeChecking(sourceFile *ast.SourceFile, ignoreNoCheck bool) bool { + return false +} + func (p *fakeProgram) SourceFileMayBeEmitted(sourceFile *ast.SourceFile, forceDtsEmit bool) bool { panic("unimplemented") } From 59d54ee21f298f3d2cb6337ed4ff5c89cbf55eed Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Thu, 22 Oct 2026 09:49:12 -0700 Subject: [PATCH 38/60] Do not blame a use for the circular constraint of a declaration A declared type parameter with a circular constraint is circular no matter how it is used, and checking its declaration reports it. Which use happened to resolve the constraint before that is an accident of check order, so pointing at it as the origin of the cycle made the diagnostic depend on that order. Only an instantiated type parameter has a cycle that originates at a use. --- tsc/internal/checker/checker.go | 6 +++++- .../reference/conformance/recursiveMappedTypes.errors.txt | 1 - 2 files changed, 5 insertions(+), 2 deletions(-) diff --git a/tsc/internal/checker/checker.go b/tsc/internal/checker/checker.go index 29a027bfa09e8..82d2244894252 100644 --- a/tsc/internal/checker/checker.go +++ b/tsc/internal/checker/checker.go @@ -30662,9 +30662,13 @@ func (c *Checker) resolveBaseConstraint(t *Type, stack []RecursionId, propertyNa // 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 node != nil && !isNodeDescendantOf(errorNode, node) && !isNodeDescendantOf(node, errorNode) { + if instantiated && node != nil && !isNodeDescendantOf(errorNode, node) && !isNodeDescendantOf(node, errorNode) { diagnostic.AddRelatedInfo(NewDiagnosticForNode(node, diagnostics.Circularity_originates_in_type_at_this_location)) } }) diff --git a/tsc/testdata/baselines/reference/conformance/recursiveMappedTypes.errors.txt b/tsc/testdata/baselines/reference/conformance/recursiveMappedTypes.errors.txt index efdd2fe453ad5..9d4e77b1bfb1f 100644 --- a/tsc/testdata/baselines/reference/conformance/recursiveMappedTypes.errors.txt +++ b/tsc/testdata/baselines/reference/conformance/recursiveMappedTypes.errors.txt @@ -36,7 +36,6 @@ recursiveMappedTypes.ts(73,13): error TS2615: Type of property '"each"' circular [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 From a831b9aea1723ec66676dceaf5e1deda083963cd Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Thu, 22 Oct 2026 16:11:34 -0700 Subject: [PATCH 39/60] Resolve mapped type constraints whenever the mapped type is requested A mapped type resolves its constraint eagerly so that errors in the constraint are reported at the mapped type. It did so only when the type was created, so when the type was first created while checking another node, the mapped type itself never reported those errors. --- tsc/internal/checker/checker.go | 11 +++++++---- ...siveLength(checkorder=typesfirst).errors.txt | 17 ++++++++++++++++- 2 files changed, 23 insertions(+), 5 deletions(-) diff --git a/tsc/internal/checker/checker.go b/tsc/internal/checker/checker.go index 82d2244894252..856cda444c1fe 100644 --- a/tsc/internal/checker/checker.go +++ b/tsc/internal/checker/checker.go @@ -27258,11 +27258,14 @@ func (c *Checker) getTypeFromMappedTypeNode(node *ast.Node) *Type { t.AsMappedType().declaration = node.AsMappedTypeNode() t.alias = c.getAliasForTypeNode(node) links.resolvedType.set(c, 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.cached(c) + t := links.resolvedType.cached(c) + // Eagerly resolve the constraint type which forces an error if the constraint type circularly + // references itself through one or more type aliases. This happens on every request rather + // than only when the type is created, so its errors do not depend on whether the type was + // created while checking another node. + c.getConstraintTypeFromMappedType(t) + return t } func (c *Checker) getTypeFromConditionalTypeNode(node *ast.Node) *Type { diff --git a/tsc/testdata/baselines/reference/compiler/templateLiteralTypeExcessiveLength(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/templateLiteralTypeExcessiveLength(checkorder=typesfirst).errors.txt index 75017c0b48808..afb511fd91c39 100644 --- a/tsc/testdata/baselines/reference/compiler/templateLiteralTypeExcessiveLength(checkorder=typesfirst).errors.txt +++ b/tsc/testdata/baselines/reference/compiler/templateLiteralTypeExcessiveLength(checkorder=typesfirst).errors.txt @@ -1,15 +1,18 @@ +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 (9 errors) ==== +==== 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. @@ -24,7 +27,9 @@ templateLiteralTypeExcessiveLength.ts(34,38): error TS2589: Type instantiation i // 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. ~~~~~~~~~~~~~ @@ -32,10 +37,14 @@ templateLiteralTypeExcessiveLength.ts(34,38): error TS2589: Type instantiation i ~~~~~~~~~~ !!! 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. ~~~~~~~~~~~~~~~~ @@ -43,6 +52,8 @@ templateLiteralTypeExcessiveLength.ts(34,38): error TS2589: Type instantiation i ~~~~~~~~~~ !!! 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. @@ -55,7 +66,9 @@ templateLiteralTypeExcessiveLength.ts(34,38): error TS2589: Type instantiation i 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. ~~~~~~~~~~~~~~~~~~~~~~~ @@ -63,4 +76,6 @@ templateLiteralTypeExcessiveLength.ts(34,38): error TS2589: Type instantiation i ~~~~~~~~~~ !!! 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 From 99888b48f402cc503d6c82969dc7b1212bf68fc3 Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Sat, 31 Oct 2026 21:32:24 -0700 Subject: [PATCH 40/60] Resolve return type cycles as if entered at their first member A cycle through return types gave different results depending on where it was entered. Entered at rebuild's return type, re-entering it fails rebuild, so both members report an implicit any. Entered at b's return type, subtype reduction of rebuild's return type finds b in progress and compares as if it returned any, without failing anything, so rebuild returns B and was kept as a participant of the cycle, though computing it from scratch fails. Cycles through the types of symbols are already resolved from the member declared first (see yieldCycle). The same now applies to the return types of declared signatures, both when a cycle re-enters a return type and when it only observes one in progress, so that each order gives the result of resolving the first declared member first (seen in effect's SchemaAST). Contextually checking a function expression infers its return type from its body, and that inference was pushed as a return type resolution of the function's signature. When the body calls a function whose return type depends on the call enclosing the function expression, resolving that call requests the function expression's return type, which, seen in progress, returned any without detecting a cycle, so the enclosing function's return type was inferred from a provisional any instead of reporting the circularity (seen in OmniRoute). The inference now runs without marking the signature in progress, as in TypeScript: the nested request computes the return type itself, reaches the enclosing function, and the cycle is reported on both. The result is cached only if no request has already cached one, the same as when the return type is requested directly. The flag marking a function as contextually checked is set before its return type is inferred, and is TypeScript's guard against re-checking the function from within its own check, so it is never discarded. The inferred return type is now kept whenever the flag is, so that a discarded cycle in between cannot leave the flag without the return type, which made a const assertion in the body readonly when queried before its binding pattern. --- tsc/internal/checker/checker.go | 147 ++++++++++++++---- tsc/internal/checker/memopeek_test.go | 4 - tsc/internal/checker/relater.go | 10 +- ...ReturnTypeSubtypeReductionOrder.errors.txt | 8 +- ...cularReturnTypeSubtypeReductionOrder.types | 12 +- ...hCallbackArgument(strict=false).errors.txt | 38 ----- ...hroughCallbackArgument(strict=false).types | 24 +-- ...ghCallbackArgument(strict=true).errors.txt | 30 ++-- ...ThroughCallbackArgument(strict=true).types | 24 +-- 9 files changed, 182 insertions(+), 115 deletions(-) delete mode 100644 tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallbackArgument(strict=false).errors.txt diff --git a/tsc/internal/checker/checker.go b/tsc/internal/checker/checker.go index 856cda444c1fe..daf86fcbd3ab8 100644 --- a/tsc/internal/checker/checker.go +++ b/tsc/internal/checker/checker.go @@ -10836,23 +10836,30 @@ func (c *Checker) contextuallyCheckFunctionExpressionOrObjectLiteralMethodUncach if links.flags&NodeCheckFlagsContextChecked == 0 || links.flags&NodeCheckFlagsSignatureContextChecked != 0 && !hidden { return } + // The flag guards against checking the function again from within the + // check, so it is set now, and is only discarded if a cycle in progress + // logs it. + markerLogged := c.logResults() setFlagMemoBits(c, memoKeyOf(node, memoContextChecked), &links.flags, NodeCheckFlagsSignatureContextChecked, NodeCheckFlagsSignatureContextChecked) signature := c.getSignatureFromDeclarationUncontextual(node) contextualSignature := c.getContextualSignature(node) // The return type is inferred now, while the contextual types of the // function's enclosing expressions are in place; a later request may // come from where they are not. - if contextualSignature != nil && checkMode&^CheckModeTypeOnly == CheckModeNormal && c.getReturnTypeFromAnnotation(node) == nil && !c.isResolvingReturnTypeOfSignature(signature) { - c.getReturnTypeOfSignature(signature) - } else if contextualSignature != nil && c.getReturnTypeFromAnnotation(node) == nil && signature.resolvedReturnType.cached(c) == nil && !c.isResolvingReturnTypeOfSignature(signature) && c.pushTypeResolution(signature, TypeSystemPropertyNameResolvedReturnType, nil) { + if contextualSignature != nil && c.getReturnTypeFromAnnotation(node) == nil && signature.resolvedReturnType.cached(c) == nil && !c.isResolvingReturnTypeOfSignature(signature) { // resolvedReturnType is cached indefinitely, so the return type here has to be computed without CheckModeSkipContextSensitive; // otherwise anyFunctionType could leak as part of the computed (and cached) return type. returnType := c.getReturnTypeFromBody(node, checkMode&^CheckModeSkipContextSensitive) - if !c.popTypeResolution() { - returnType = c.circularReturnType(signature) - } if signature.resolvedReturnType.cached(c) == nil { - signature.resolvedReturnType.set(c, returnType) + 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) @@ -20571,36 +20578,116 @@ type shadowedResolving struct { // 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 the -// types of symbols declared before the one re-entered (if it is one) -// fails at the first of those instead, as if that symbol had been resolved -// first: its type 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. +// 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 - var first *ast.Symbol - if r.propertyName == TypeSystemPropertyNameType { - first = r.target.(*ast.Symbol) + r := c.resolutions[start].typeResolution + if c.isYieldingTo(r.target, r.propertyName) { + return false + } + first := c.firstCycleMember(start) + if first == nil { + return false + } + c.resolveCycleMember(*first) + c.beginCycleYield(r.target, r.propertyName, len(c.resolutions), len(c.resolutions)) + return true +} + +// 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) + } +} + +// 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 } - entered := first for i := start + 1; i < len(c.resolutions); i++ { - if f := &c.resolutions[i]; f.isTypeResolution && f.typeResolution.propertyName == TypeSystemPropertyNameType { - if s := f.typeResolution.target.(*ast.Symbol); first == nil || c.compareSymbols(s, first) < 0 { - first = s - } + 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, TypeSystemPropertyNameType) || c.isYieldingTo(r.target, r.propertyName) { - return false + 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.beginCycleYield(first, TypeSystemPropertyNameType, -1, len(c.resolutions)) - c.getTypeOfSymbol(first) c.endCycleYield() - c.beginCycleYield(r.target, r.propertyName, len(c.resolutions), len(c.resolutions)) - return true } // yieldCycleToMembers handles re-entering the type resolution in progress diff --git a/tsc/internal/checker/memopeek_test.go b/tsc/internal/checker/memopeek_test.go index a9bdd089e17ae..e707418680e09 100644 --- a/tsc/internal/checker/memopeek_test.go +++ b/tsc/internal/checker/memopeek_test.go @@ -148,10 +148,6 @@ var memoAccessors = map[string]map[string]bool{ }, "lateMergedSymbols": {"getLateMergedSymbol": true, "combineSymbolTables": true}, "relation": {"cachedRelation": true}, - // Inferring the return type of a contextually typed function resolves - // it without its memo, so whether it is in progress cannot be asked of - // the memo. - "resolvedReturnType": {"isResolvingReturnTypeOfSignature": true}, } // A result an entity's creator sets is part of the entity, which can outlive diff --git a/tsc/internal/checker/relater.go b/tsc/internal/checker/relater.go index 8d9bf4a25f657..f53f01f78e8fd 100644 --- a/tsc/internal/checker/relater.go +++ b/tsc/internal/checker/relater.go @@ -2523,7 +2523,15 @@ func (c *Checker) isResolvingReturnTypeOfSignature(signature *Signature) bool { if signature.getComposite() != nil && core.Some(signature.getComposite().signatures, c.isResolvingReturnTypeOfSignature) { return true } - return signature.resolvedReturnType.cached(c) == nil && c.isResolutionInProgress(signature, TypeSystemPropertyNameResolvedReturnType) + start := c.findResolutionCycleStartIndex(signature, TypeSystemPropertyNameResolvedReturnType) + if start < 0 { + return false + } + c.markTypeResolutionCircular(start) + // Computed from the first member of the cycle, the return type may be + // available after all. + c.yieldObservedCycle(start) + return signature.resolvedReturnType.inProgress(c) == nil } func (c *Checker) findMatchingSignatures(signatureLists [][]*Signature, signature *Signature, listIndex int) []*Signature { diff --git a/tsc/testdata/baselines/reference/compiler/circularReturnTypeSubtypeReductionOrder.errors.txt b/tsc/testdata/baselines/reference/compiler/circularReturnTypeSubtypeReductionOrder.errors.txt index b93093c154d7d..5f36a6dd6ba9d 100644 --- a/tsc/testdata/baselines/reference/compiler/circularReturnTypeSubtypeReductionOrder.errors.txt +++ b/tsc/testdata/baselines/reference/compiler/circularReturnTypeSubtypeReductionOrder.errors.txt @@ -1,3 +1,5 @@ +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. @@ -38,16 +40,20 @@ expression.ts(14,5): error TS7023: 'b' implicitly has return type 'any' because }; export {}; -==== declaration.ts (0 errors) ==== +==== 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(); } } diff --git a/tsc/testdata/baselines/reference/compiler/circularReturnTypeSubtypeReductionOrder.types b/tsc/testdata/baselines/reference/compiler/circularReturnTypeSubtypeReductionOrder.types index a44fd2123e1c2..421302078810c 100644 --- a/tsc/testdata/baselines/reference/compiler/circularReturnTypeSubtypeReductionOrder.types +++ b/tsc/testdata/baselines/reference/compiler/circularReturnTypeSubtypeReductionOrder.types @@ -61,23 +61,23 @@ class K { >K : K rebuild() { ->rebuild : () => B +>rebuild : () => any return flag ? this : new B(); ->flag ? this : new B() : B +>flag ? this : new B() : this | B >flag : boolean >this : this >new B() : B >B : new () => B } b() { ->b : () => B +>b : () => any return this.rebuild(); ->this.rebuild() : B ->this.rebuild : () => B +>this.rebuild() : any +>this.rebuild : () => any >this : this ->rebuild : () => B +>rebuild : () => any } } const B: new () => B = K; diff --git a/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallbackArgument(strict=false).errors.txt b/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallbackArgument(strict=false).errors.txt deleted file mode 100644 index 3c7a84d051ca9..0000000000000 --- a/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallbackArgument(strict=false).errors.txt +++ /dev/null @@ -1,38 +0,0 @@ -circularReturnTypeThroughCallbackArgument.ts(23,25): error TS2322: Type 'Promise' is not assignable to type 'Promise'. - Type 'Other | Result' is not assignable to type 'Result'. - Type 'Other' is not assignable to type 'Result'. - Index signature for type 'string' is missing in type 'Other'. - - -==== circularReturnTypeThroughCallbackArgument.ts (1 errors) ==== - 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)); - ~~~~~~~~ -!!! error TS2322: Type 'Promise' is not assignable to type 'Promise'. -!!! error TS2322: Type 'Other | Result' is not assignable to type 'Result'. -!!! error TS2322: Type 'Other' is not assignable to type 'Result'. -!!! error TS2322: Index signature for type 'string' is missing in type 'Other'. -!!! related TS6502 circularReturnTypeThroughCallbackArgument.ts:18:38: The expected type comes from the return type of this signature. - } - \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallbackArgument(strict=false).types b/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallbackArgument(strict=false).types index c3e8f0316281f..fb9e85bf2b1d7 100644 --- a/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallbackArgument(strict=false).types +++ b/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallbackArgument(strict=false).types @@ -6,15 +6,15 @@ declare function fan(g: () => number): number; >g : () => number export function a(n: number) { ->a : (n: number) => number +>a : (n: number) => any >n : number return fan(() => a(n)); >fan(() => a(n)) : number >fan : (g: () => number) => number ->() => a(n) : () => number ->a(n) : number ->a : (n: number) => number +>() => a(n) : () => any +>a(n) : any +>a : (n: number) => any >n : number } @@ -25,7 +25,7 @@ declare function fanAll(g: () => Promise<{ ok: boolean }>): Promise<{ ok: boolea >ok : boolean export async function b(n: number) { ->b : (n: number) => Promise<{ ok: boolean; }> +>b : (n: number) => any >n : number if (n > 0) { @@ -36,9 +36,9 @@ export async function b(n: number) { return fanAll(() => b(n - 1)); >fanAll(() => b(n - 1)) : Promise<{ ok: boolean; }> >fanAll : (g: () => Promise<{ ok: boolean; }>) => Promise<{ ok: boolean; }> ->() => b(n - 1) : () => Promise<{ ok: boolean; }> ->b(n - 1) : Promise<{ ok: boolean; }> ->b : (n: number) => Promise<{ ok: boolean; }> +>() => b(n - 1) : () => any +>b(n - 1) : any +>b : (n: number) => any >n - 1 : number >n : number >1 : 1 @@ -66,7 +66,7 @@ declare const other: Other; >other : Other export async function c(n: number) { ->c : (n: number) => Promise +>c : (n: number) => any >n : number if (n) return other; @@ -76,9 +76,9 @@ export async function c(n: number) { return fanOut(() => c(n - 1)); >fanOut(() => c(n - 1)) : Promise >fanOut : (generateOne: () => Promise) => Promise ->() => c(n - 1) : () => Promise ->c(n - 1) : Promise ->c : (n: number) => 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 index 3c7a84d051ca9..a10fc6bcbe59c 100644 --- a/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallbackArgument(strict=true).errors.txt +++ b/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallbackArgument(strict=true).errors.txt @@ -1,21 +1,31 @@ -circularReturnTypeThroughCallbackArgument.ts(23,25): error TS2322: Type 'Promise' is not assignable to type 'Promise'. - Type 'Other | Result' is not assignable to type 'Result'. - Type 'Other' is not assignable to type 'Result'. - Index signature for type 'string' is missing in type 'Other'. +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 (1 errors) ==== +==== 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 }; } @@ -26,13 +36,11 @@ circularReturnTypeThroughCallbackArgument.ts(23,25): error TS2322: Type '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 TS2322: Type 'Promise' is not assignable to type 'Promise'. -!!! error TS2322: Type 'Other | Result' is not assignable to type 'Result'. -!!! error TS2322: Type 'Other' is not assignable to type 'Result'. -!!! error TS2322: Index signature for type 'string' is missing in type 'Other'. -!!! related TS6502 circularReturnTypeThroughCallbackArgument.ts:18:38: The expected type comes from the return type of this signature. + ~~~~~~~~~~~~~~ +!!! 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).types b/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallbackArgument(strict=true).types index c3e8f0316281f..fb9e85bf2b1d7 100644 --- a/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallbackArgument(strict=true).types +++ b/tsc/testdata/baselines/reference/compiler/circularReturnTypeThroughCallbackArgument(strict=true).types @@ -6,15 +6,15 @@ declare function fan(g: () => number): number; >g : () => number export function a(n: number) { ->a : (n: number) => number +>a : (n: number) => any >n : number return fan(() => a(n)); >fan(() => a(n)) : number >fan : (g: () => number) => number ->() => a(n) : () => number ->a(n) : number ->a : (n: number) => number +>() => a(n) : () => any +>a(n) : any +>a : (n: number) => any >n : number } @@ -25,7 +25,7 @@ declare function fanAll(g: () => Promise<{ ok: boolean }>): Promise<{ ok: boolea >ok : boolean export async function b(n: number) { ->b : (n: number) => Promise<{ ok: boolean; }> +>b : (n: number) => any >n : number if (n > 0) { @@ -36,9 +36,9 @@ export async function b(n: number) { return fanAll(() => b(n - 1)); >fanAll(() => b(n - 1)) : Promise<{ ok: boolean; }> >fanAll : (g: () => Promise<{ ok: boolean; }>) => Promise<{ ok: boolean; }> ->() => b(n - 1) : () => Promise<{ ok: boolean; }> ->b(n - 1) : Promise<{ ok: boolean; }> ->b : (n: number) => Promise<{ ok: boolean; }> +>() => b(n - 1) : () => any +>b(n - 1) : any +>b : (n: number) => any >n - 1 : number >n : number >1 : 1 @@ -66,7 +66,7 @@ declare const other: Other; >other : Other export async function c(n: number) { ->c : (n: number) => Promise +>c : (n: number) => any >n : number if (n) return other; @@ -76,9 +76,9 @@ export async function c(n: number) { return fanOut(() => c(n - 1)); >fanOut(() => c(n - 1)) : Promise >fanOut : (generateOne: () => Promise) => Promise ->() => c(n - 1) : () => Promise ->c(n - 1) : Promise ->c : (n: number) => Promise +>() => c(n - 1) : () => any +>c(n - 1) : any +>c : (n: number) => any >n - 1 : number >n : number >1 : 1 From 97ea5c3bec757bc7a6a5c4df652e597657857d8b Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Sat, 31 Oct 2026 23:48:50 -0700 Subject: [PATCH 41/60] Use JSDoc type tags when assigning contextual parameter types Completing contextual signatures before anyone reads them switched parameter assignment from the signature of the function's symbol to the signature built from its declaration. In JavaScript the symbol's signature comes from a @type tag when one is present, and the function's parameters take their types from that tag. Using the declaration's signature wrote the outer contextual types onto those parameters instead, producing errors inside the function body that the tag rules out (seen in webpack). Prefer the tag's signature, as before, and fall back to the declaration's signature otherwise. --- tsc/internal/checker/checker.go | 7 ++++- ...eTagOnContextuallyTypedFunction.errors.txt | 12 +------- ...TypeTagOnContextuallyTypedFunction.symbols | 8 +++-- ...ocTypeTagOnContextuallyTypedFunction.types | 30 +++++++++---------- 4 files changed, 28 insertions(+), 29 deletions(-) diff --git a/tsc/internal/checker/checker.go b/tsc/internal/checker/checker.go index daf86fcbd3ab8..bd61969151ca6 100644 --- a/tsc/internal/checker/checker.go +++ b/tsc/internal/checker/checker.go @@ -10888,7 +10888,12 @@ func (c *Checker) assignContextualParameterTypesOfFunctionUncached(node *ast.Nod // from within the assignment, so it is set now. flagLogged := c.logResults() setFlagMemoBits(c, memoKeyOf(node, memoContextualParameters), &links.flags, NodeCheckFlagsContextChecked, NodeCheckFlagsContextChecked) - signature := c.getSignatureFromDeclarationUncontextual(node) + // 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 { + signature = c.getSignatureFromDeclarationUncontextual(node) + } c.beginTypeResolution(node, TypeSystemPropertyNameContextChecked, nil) if c.isContextSensitive(node) { if contextualSignature != nil { diff --git a/tsc/testdata/baselines/reference/compiler/jsdocTypeTagOnContextuallyTypedFunction.errors.txt b/tsc/testdata/baselines/reference/compiler/jsdocTypeTagOnContextuallyTypedFunction.errors.txt index f19e5b3afede1..f9f9a2d8d5885 100644 --- a/tsc/testdata/baselines/reference/compiler/jsdocTypeTagOnContextuallyTypedFunction.errors.txt +++ b/tsc/testdata/baselines/reference/compiler/jsdocTypeTagOnContextuallyTypedFunction.errors.txt @@ -2,17 +2,13 @@ a.js(4,1): error TS2322: Type '(content: string, rest_0?: boolean | undefined) = 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(6,35): error TS2339: Property 'toUpperCase' does not exist on type 'string | number'. - Property 'toUpperCase' does not exist on type 'number'. 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(11,26): error TS2339: Property 'toUpperCase' does not exist on type 'string | number'. - Property 'toUpperCase' does not exist on type 'number'. -==== a.js (4 errors) ==== +==== a.js (2 errors) ==== /** @type {{ f: (a: string | number, ...rest: unknown[]) => string }} */ const context = { f: (a) => "" }; @@ -24,9 +20,6 @@ a.js(11,26): error TS2339: Property 'toUpperCase' does not exist on type 'string !!! error TS2322: Type 'number' is not assignable to type 'string'. /** @type {(content: string, ...rest: [boolean?]) => string} */ (content, ...rest) => content.toUpperCase() + rest.length; - ~~~~~~~~~~~ -!!! error TS2339: Property 'toUpperCase' does not exist on type 'string | number'. -!!! error TS2339: Property 'toUpperCase' does not exist on type 'number'. /** @type {(content: string | number) => string} */ const g = @@ -37,7 +30,4 @@ a.js(11,26): error TS2339: Property 'toUpperCase' does not exist on type 'string !!! error TS2322: Type 'number' is not assignable to type 'string'. /** @type {(content: string) => string} */ (content) => content.toUpperCase(); - ~~~~~~~~~~~ -!!! error TS2339: Property 'toUpperCase' does not exist on type 'string | number'. -!!! error TS2339: Property 'toUpperCase' does not exist on type 'number'. \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/jsdocTypeTagOnContextuallyTypedFunction.symbols b/tsc/testdata/baselines/reference/compiler/jsdocTypeTagOnContextuallyTypedFunction.symbols index 17ba749362f25..15ffe15bb65e2 100644 --- a/tsc/testdata/baselines/reference/compiler/jsdocTypeTagOnContextuallyTypedFunction.symbols +++ b/tsc/testdata/baselines/reference/compiler/jsdocTypeTagOnContextuallyTypedFunction.symbols @@ -16,10 +16,12 @@ context.f = (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)) ->rest.length : Symbol(Array.length, Decl(lib.es5.d.ts, --, --)) +>toUpperCase : Symbol(String.toUpperCase, Decl(lib.es5.d.ts, --, --)) +>rest.length : Symbol(length) >rest : Symbol(rest, Decl(a.js, 5, 13)) ->length : Symbol(Array.length, Decl(lib.es5.d.ts, --, --)) +>length : Symbol(length) /** @type {(content: string | number) => string} */ const g = @@ -28,5 +30,7 @@ const g = /** @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 index 7511697864aa1..6defe743de587 100644 --- a/tsc/testdata/baselines/reference/compiler/jsdocTypeTagOnContextuallyTypedFunction.types +++ b/tsc/testdata/baselines/reference/compiler/jsdocTypeTagOnContextuallyTypedFunction.types @@ -19,16 +19,16 @@ context.f = /** @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 | number ->rest : unknown[] ->content.toUpperCase() + rest.length : any ->content.toUpperCase() : any ->content.toUpperCase : any ->content : string | number ->toUpperCase : any ->rest.length : number ->rest : unknown[] ->length : number +>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 = @@ -37,9 +37,9 @@ const g = /** @type {(content: string) => string} */ (content) => content.toUpperCase(); >(content) => content.toUpperCase() : (content: string) => string ->content : string | number ->content.toUpperCase() : any ->content.toUpperCase : any ->content : string | number ->toUpperCase : any +>content : string +>content.toUpperCase() : string +>content.toUpperCase : () => string +>content : string +>toUpperCase : () => string From e90331018894c53a56545f3ac74d41a27c417d50 Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Sun, 1 Nov 2026 03:25:56 -0800 Subject: [PATCH 42/60] Name an instantiation cycle from its first declared type An instantiation stopped by the limit on the depth of the whole instantiation names every type that recurs in it, in the order in which they recur. Which type of the cycle the instantiation entered first depends on the results cached before, so checkers that had checked different files named the same cycle starting from different types, and reported the same error twice with different messages (seen in zod, with checkers running concurrently). The names now start from the type declared first, so the message is the same wherever the cycle is entered. The limit on the depth of a single computation already names only the types that computation instantiated, which does not depend on where it was entered, so its messages keep the order in which the types recur. --- tsc/internal/checker/checker.go | 29 +++++++++++++++---- ...enericExtendingClassDoubleLayer.errors.txt | 8 ++--- 2 files changed, 27 insertions(+), 10 deletions(-) diff --git a/tsc/internal/checker/checker.go b/tsc/internal/checker/checker.go index bd61969151ca6..74e8282277108 100644 --- a/tsc/internal/checker/checker.go +++ b/tsc/internal/checker/checker.go @@ -25050,12 +25050,13 @@ func getActiveMapperCacheKey(t *Type, alias *TypeAlias) CacheHashKey { func (c *Checker) getCircularTypeNames() []string { typeCounts := make(map[*Type]int) - var circularTypeNames []string + 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 - if len(stack) != instantiationTotalDepthLimit { + total := len(stack) == instantiationTotalDepthLimit + if !total { stack = stack[c.currentResolution().depthStart:] } for _, t := range stack { @@ -25065,12 +25066,28 @@ func (c *Checker) getCircularTypeNames() []string { 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 } diff --git a/tsc/testdata/baselines/reference/compiler/keyofGenericExtendingClassDoubleLayer.errors.txt b/tsc/testdata/baselines/reference/compiler/keyofGenericExtendingClassDoubleLayer.errors.txt index 5babffc1080a2..8c8a4f0003e86 100644 --- a/tsc/testdata/baselines/reference/compiler/keyofGenericExtendingClassDoubleLayer.errors.txt +++ b/tsc/testdata/baselines/reference/compiler/keyofGenericExtendingClassDoubleLayer.errors.txt @@ -1,7 +1,7 @@ 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: 'Model', 'ModelAttributes', 'Exclude'. +keyofGenericExtendingClassDoubleLayer.ts(13,13): error TS5115: Instantiations of the following types appear infinitely circular: 'Exclude', 'Model', 'ModelAttributes'. ==== keyofGenericExtendingClassDoubleLayer.ts (4 errors) ==== @@ -17,7 +17,7 @@ keyofGenericExtendingClassDoubleLayer.ts(13,13): error TS5115: Instantiations of 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. @@ -25,7 +25,7 @@ keyofGenericExtendingClassDoubleLayer.ts(13,13): error TS5115: Instantiations of toJson() { let x: keyof this = 'createdAt'; ~ -!!! 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'. } } \ No newline at end of file From 08449c77edd4f00b8c051d7fe5a5a4c8e7c00a15 Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Sun, 1 Nov 2026 20:24:28 -0800 Subject: [PATCH 43/60] Discard results computed from a binding pattern's own elements While the type implied by a binding pattern is computed as the contextual type of its initializer, references to the pattern's elements from the elements' defaults are any. The calls and types computed from them were cached anyway, so asking for the contextual type of the initializer first left `extra` in const { kind, payload, extra = kind === "a" ? ... : ... } = u; as any rather than unknown. TypeScript behaves the same way. Track the patterns as resolutions in progress rather than a separate stack, so that a reference returning any marks the computation circular and the results cached from it are discarded. (seen in check order fuzzing) --- tsc/internal/checker/checker.go | 14 +++++++++----- ...entInitializer(checkorder=typesfirst).types | 4 ++-- ...gThroughCall(checkorder=default).errors.txt | 11 +++++++---- ...iblingThroughCall(checkorder=default).types | 18 +++++++++--------- ...roughCall(checkorder=typesfirst).errors.txt | 11 +++++++---- ...ingThroughCall(checkorder=typesfirst).types | 18 +++++++++--------- 6 files changed, 43 insertions(+), 33 deletions(-) diff --git a/tsc/internal/checker/checker.go b/tsc/internal/checker/checker.go index 74e8282277108..8ece0fd753620 100644 --- a/tsc/internal/checker/checker.go +++ b/tsc/internal/checker/checker.go @@ -80,6 +80,7 @@ const ( TypeSystemPropertyNameCallResolution TypeSystemPropertyNameAssertionOperand TypeSystemPropertyNamePatternInitializer + TypeSystemPropertyNameContextualBindingPattern TypeSystemPropertyNameBaseConstraintInWalk ) @@ -693,7 +694,6 @@ type Checker struct { reportUnmeasurableMapper *TypeMapper restrictiveMapper *TypeMapper permissiveMapper *TypeMapper - contextualBindingPatterns []*ast.Node resolving resolvingTable // Index in resolutions of the outermost computation of each key in progress typeResolutionTop int // 1-based index in resolutions of the innermost resolution, or 0 resolutionStart int // Index in resolutions below which resolutions are not searched for cycles @@ -11875,8 +11875,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) @@ -19645,7 +19646,10 @@ func (c *Checker) getParentElementAccess(node *ast.Node) *ast.Node { // the parameter. func (c *Checker) getTypeFromBindingPattern(pattern *ast.Node, includePatternInType bool, reportErrors bool) *Type { if includePatternInType { - c.contextualBindingPatterns = append(c.contextualBindingPatterns, pattern) + // While the implied type is computed, references to the pattern's own + // elements are any (see checkIdentifier), so nothing computed from + // them may be cached; see isResolvingAnywhere. + c.beginTypeResolution(pattern, TypeSystemPropertyNameContextualBindingPattern, nil) } var result *Type if ast.IsObjectBindingPattern(pattern) { @@ -19654,7 +19658,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 } diff --git a/tsc/testdata/baselines/reference/compiler/dependentDestructuringBindingElementInitializer(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/dependentDestructuringBindingElementInitializer(checkorder=typesfirst).types index 265e9b075cacf..0dcd3d8a64cef 100644 --- a/tsc/testdata/baselines/reference/compiler/dependentDestructuringBindingElementInitializer(checkorder=typesfirst).types +++ b/tsc/testdata/baselines/reference/compiler/dependentDestructuringBindingElementInitializer(checkorder=typesfirst).types @@ -25,8 +25,8 @@ const { >payload : string | number extra = kind === "a" ? payload.toFixed() : payload.toUpperCase(), ->extra : any ->kind === "a" ? payload.toFixed() : payload.toUpperCase() : any +>extra : unknown +>kind === "a" ? payload.toFixed() : payload.toUpperCase() : string >kind === "a" : boolean >kind : "a" | "b" >"a" : "a" diff --git a/tsc/testdata/baselines/reference/compiler/parameterBindingDefaultReferencesSiblingThroughCall(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/parameterBindingDefaultReferencesSiblingThroughCall(checkorder=default).errors.txt index fab2d38147e93..28167de70ad61 100644 --- a/tsc/testdata/baselines/reference/compiler/parameterBindingDefaultReferencesSiblingThroughCall(checkorder=default).errors.txt +++ b/tsc/testdata/baselines/reference/compiler/parameterBindingDefaultReferencesSiblingThroughCall(checkorder=default).errors.txt @@ -1,9 +1,10 @@ parameterBindingDefaultReferencesSiblingThroughCall.ts(11,19): error TS7022: 'a' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. -parameterBindingDefaultReferencesSiblingThroughCall.ts(16,11): error TS2322: Type 'unknown' is not assignable to type 'string'. +parameterBindingDefaultReferencesSiblingThroughCall.ts(15,20): error TS7022: 'a' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. +parameterBindingDefaultReferencesSiblingThroughCall.ts(19,25): error TS7022: 'a' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. parameterBindingDefaultReferencesSiblingThroughCall.ts(20,11): error TS2322: Type 'any[]' is not assignable to type 'string'. -==== parameterBindingDefaultReferencesSiblingThroughCall.ts (3 errors) ==== +==== parameterBindingDefaultReferencesSiblingThroughCall.ts (4 errors) ==== // A default in a destructured parameter that references a sibling element // makes the sibling's type depend on itself: the type of 'a' comes from the // parameter initializer '{}', which is padded with the types of the defaults, @@ -21,12 +22,14 @@ parameterBindingDefaultReferencesSiblingThroughCall.ts(20,11): error TS2322: Typ } function viaCall({ a = 1 as number | undefined, b = id(a) } = {}) { + ~ +!!! error TS7022: 'a' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. const n: string = b; - ~ -!!! error TS2322: Type 'unknown' is not assignable to type 'string'. } function viaCallArray({ a = 1 as number | undefined, b = id([a]) } = {}) { + ~ +!!! error TS7022: 'a' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. const n: string = b; ~ !!! error TS2322: Type 'any[]' is not assignable to type 'string'. diff --git a/tsc/testdata/baselines/reference/compiler/parameterBindingDefaultReferencesSiblingThroughCall(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/parameterBindingDefaultReferencesSiblingThroughCall(checkorder=default).types index d8b5d78c1e02b..7c1aeb46582c6 100644 --- a/tsc/testdata/baselines/reference/compiler/parameterBindingDefaultReferencesSiblingThroughCall(checkorder=default).types +++ b/tsc/testdata/baselines/reference/compiler/parameterBindingDefaultReferencesSiblingThroughCall(checkorder=default).types @@ -28,31 +28,31 @@ function direct({ a = 1 as number | undefined, b = a } = {}) { } function viaCall({ a = 1 as number | undefined, b = id(a) } = {}) { ->viaCall : ({ a, b }?: { a?: number | undefined; b?: unknown; }) => void ->a : number | undefined +>viaCall : ({ a, b }?: { a?: number | undefined; b?: any; }) => void +>a : any >1 as number | undefined : number | undefined >1 : 1 ->b : unknown ->id(a) : unknown +>b : any +>id(a) : any >id : (v: T) => T ->a : number | undefined +>a : any >{} : {} const n: string = b; >n : string ->b : unknown +>b : any } function viaCallArray({ a = 1 as number | undefined, b = id([a]) } = {}) { >viaCallArray : ({ a, b }?: { a?: number | undefined; b?: any[] | undefined; }) => void ->a : number | undefined +>a : any >1 as number | undefined : number | undefined >1 : 1 >b : any[] >id([a]) : any[] >id : (v: T) => T ->[a] : (number | undefined)[] ->a : number | undefined +>[a] : any[] +>a : any >{} : {} const n: string = b; diff --git a/tsc/testdata/baselines/reference/compiler/parameterBindingDefaultReferencesSiblingThroughCall(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/parameterBindingDefaultReferencesSiblingThroughCall(checkorder=typesfirst).errors.txt index fab2d38147e93..28167de70ad61 100644 --- a/tsc/testdata/baselines/reference/compiler/parameterBindingDefaultReferencesSiblingThroughCall(checkorder=typesfirst).errors.txt +++ b/tsc/testdata/baselines/reference/compiler/parameterBindingDefaultReferencesSiblingThroughCall(checkorder=typesfirst).errors.txt @@ -1,9 +1,10 @@ parameterBindingDefaultReferencesSiblingThroughCall.ts(11,19): error TS7022: 'a' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. -parameterBindingDefaultReferencesSiblingThroughCall.ts(16,11): error TS2322: Type 'unknown' is not assignable to type 'string'. +parameterBindingDefaultReferencesSiblingThroughCall.ts(15,20): error TS7022: 'a' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. +parameterBindingDefaultReferencesSiblingThroughCall.ts(19,25): error TS7022: 'a' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. parameterBindingDefaultReferencesSiblingThroughCall.ts(20,11): error TS2322: Type 'any[]' is not assignable to type 'string'. -==== parameterBindingDefaultReferencesSiblingThroughCall.ts (3 errors) ==== +==== parameterBindingDefaultReferencesSiblingThroughCall.ts (4 errors) ==== // A default in a destructured parameter that references a sibling element // makes the sibling's type depend on itself: the type of 'a' comes from the // parameter initializer '{}', which is padded with the types of the defaults, @@ -21,12 +22,14 @@ parameterBindingDefaultReferencesSiblingThroughCall.ts(20,11): error TS2322: Typ } function viaCall({ a = 1 as number | undefined, b = id(a) } = {}) { + ~ +!!! error TS7022: 'a' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. const n: string = b; - ~ -!!! error TS2322: Type 'unknown' is not assignable to type 'string'. } function viaCallArray({ a = 1 as number | undefined, b = id([a]) } = {}) { + ~ +!!! error TS7022: 'a' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. const n: string = b; ~ !!! error TS2322: Type 'any[]' is not assignable to type 'string'. diff --git a/tsc/testdata/baselines/reference/compiler/parameterBindingDefaultReferencesSiblingThroughCall(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/parameterBindingDefaultReferencesSiblingThroughCall(checkorder=typesfirst).types index d8b5d78c1e02b..7c1aeb46582c6 100644 --- a/tsc/testdata/baselines/reference/compiler/parameterBindingDefaultReferencesSiblingThroughCall(checkorder=typesfirst).types +++ b/tsc/testdata/baselines/reference/compiler/parameterBindingDefaultReferencesSiblingThroughCall(checkorder=typesfirst).types @@ -28,31 +28,31 @@ function direct({ a = 1 as number | undefined, b = a } = {}) { } function viaCall({ a = 1 as number | undefined, b = id(a) } = {}) { ->viaCall : ({ a, b }?: { a?: number | undefined; b?: unknown; }) => void ->a : number | undefined +>viaCall : ({ a, b }?: { a?: number | undefined; b?: any; }) => void +>a : any >1 as number | undefined : number | undefined >1 : 1 ->b : unknown ->id(a) : unknown +>b : any +>id(a) : any >id : (v: T) => T ->a : number | undefined +>a : any >{} : {} const n: string = b; >n : string ->b : unknown +>b : any } function viaCallArray({ a = 1 as number | undefined, b = id([a]) } = {}) { >viaCallArray : ({ a, b }?: { a?: number | undefined; b?: any[] | undefined; }) => void ->a : number | undefined +>a : any >1 as number | undefined : number | undefined >1 : 1 >b : any[] >id([a]) : any[] >id : (v: T) => T ->[a] : (number | undefined)[] ->a : number | undefined +>[a] : any[] +>a : any >{} : {} const n: string = b; From cbe0384b9edb122eb40a27fc40dfa1e796a58ead Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Sun, 1 Nov 2026 02:57:06 -0800 Subject: [PATCH 44/60] Keep the result of a resolution nested in a hidden one of itself A call resolution hides the resolutions below it, so a symbol whose initializer reaches itself through a call argument is computed again, nested in itself, as in main. The nested computation observes things in progress that the outer one entered: here, a mapped property whose contextual type is skipped, and the reverse mapping whose depth cutoff it reaches. Those mark everything since as circular, so the nested result was discarded, and the outer computation, reaching the same types again outside that context, then failed with a circularity. When everything the nested computation observed in progress was entered by the outermost hidden resolution of the same target, the nested computation is the one that resolution always computes first from scratch, whichever entry led to it, so its result is kept as a cycle participant, as main keeps the first result set. Main also keeps the reverse-mapped property type computed under the depth cutoff, so it types the property as unknown. That result still depends on the cutoff and is discarded, so the property is computed again from scratch afterwards, giving its full type: an improvement over main rather than a match (seen in arktype). --- tsc/internal/checker/checker.go | 33 ++++++++++++ ...verseMapped(checkorder=default).errors.txt | 40 -------------- ...kReverseMapped(checkorder=default).symbols | 8 +++ ...unkReverseMapped(checkorder=default).types | 54 +++++++++---------- ...seMapped(checkorder=typesfirst).errors.txt | 40 -------------- ...verseMapped(checkorder=typesfirst).symbols | 8 +++ ...ReverseMapped(checkorder=typesfirst).types | 54 +++++++++---------- 7 files changed, 103 insertions(+), 134 deletions(-) delete mode 100644 tsc/testdata/baselines/reference/compiler/circularScopeThunkReverseMapped(checkorder=default).errors.txt delete mode 100644 tsc/testdata/baselines/reference/compiler/circularScopeThunkReverseMapped(checkorder=typesfirst).errors.txt diff --git a/tsc/internal/checker/checker.go b/tsc/internal/checker/checker.go index 8ece0fd753620..8048057177483 100644 --- a/tsc/internal/checker/checker.go +++ b/tsc/internal/checker/checker.go @@ -97,6 +97,10 @@ type TypeResolution struct { // restartHidden records that a cycle entered below this resolution of a // module table passes through it; see resolveModuleTableMembers. restartHidden bool + // outerSelf is one more than the index in resolutions of the outermost + // resolution of the same property of target hidden below this one, or 0; + // see popTypeResolution. + outerSelf int32 } // ContextualInfo @@ -20565,9 +20569,29 @@ func (c *Checker) pushTypeResolution(target TypeSystemEntity, propertyName TypeS } } c.beginTypeResolution(target, propertyName, memo) + if resolutionCycleStartIndex < 0 && c.resolutionStart > 0 { + if i := c.findHiddenResolution(target, propertyName); i >= 0 { + c.resolutions[len(c.resolutions)-1].typeResolution.outerSelf = int32(i + 1) + } + } return true } +// findHiddenResolution returns the index in resolutions of the outermost +// resolution of the property of target in progress below resolutionStart, +// or -1. +func (c *Checker) findHiddenResolution(target TypeSystemEntity, propertyName TypeSystemPropertyName) int { + found := -1 + for i := int(c.resolutions[len(c.resolutions)-1].prevTypeResolution) - 1; i >= 0; i = int(c.resolutions[i].prevTypeResolution) - 1 { + if i < c.resolutionStart { + if r := &c.resolutions[i].typeResolution; r.target == target && r.propertyName == propertyName { + found = i + } + } + } + return found +} + // cycleYield is a canonical recomputation in progress; see yieldCycle. type cycleYield struct { end int // Index in resolutions of the resolution whose pop ends it, or -1 @@ -21081,6 +21105,15 @@ func (c *Checker) popTypeResolution() bool { debug.Assert(c.typeResolutionTop == n+1, "resolutions left above a type resolution") f := &c.resolutions[n] result := f.typeResolution.result + if r := &f.typeResolution; r.outerSelf != 0 && result && r.memo != nil && c.circularityStart != 0 && c.circularityStart <= n && c.circularityStart >= int(r.outerSelf) && !r.participant { + // 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 outer one + // keeps it, as must the cycle. + r.participant = true + c.cycleParticipants = append(c.cycleParticipants, r.memo) + } c.typeResolutionTop = int(f.prevTypeResolution) c.dropResolution(n) if len(c.cycleYields) != 0 && c.cycleYields[len(c.cycleYields)-1].end == n { diff --git a/tsc/testdata/baselines/reference/compiler/circularScopeThunkReverseMapped(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/circularScopeThunkReverseMapped(checkorder=default).errors.txt deleted file mode 100644 index 495583f737e9e..0000000000000 --- a/tsc/testdata/baselines/reference/compiler/circularScopeThunkReverseMapped(checkorder=default).errors.txt +++ /dev/null @@ -1,40 +0,0 @@ -circularScopeThunkReverseMapped.ts(12,14): error TS7022: '$' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. -circularScopeThunkReverseMapped.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. -circularScopeThunkReverseMapped.ts(14,41): error TS7006: Parameter 'n' implicitly has an 'any' type. -circularScopeThunkReverseMapped.ts(18,14): error TS7022: '$2' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. -circularScopeThunkReverseMapped.ts(20,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. - - -==== circularScopeThunkReverseMapped.ts (5 errors) ==== - 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({ - ~ -!!! error TS7022: '$' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. - a: type("string").pipe(function (s) { return s.length; }), - b: () => $.type("a").pipe(function (n) { return n === 0; }), - ~ -!!! 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. - ~ -!!! error TS7006: Parameter 'n' implicitly has an 'any' type. - }); - - // Entered from the function in the first property when queried in reverse - export const $2 = scope({ - ~~ -!!! error TS7022: '$2' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. - a: type("string").pipe(function (s) { return s.length; }), - b: () => $2.type("a").pipe((n: number) => n === 0), - ~ -!!! 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. - }); - \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/circularScopeThunkReverseMapped(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/circularScopeThunkReverseMapped(checkorder=default).symbols index 162296d91ea40..cefed83354abf 100644 --- a/tsc/testdata/baselines/reference/compiler/circularScopeThunkReverseMapped(checkorder=default).symbols +++ b/tsc/testdata/baselines/reference/compiler/circularScopeThunkReverseMapped(checkorder=default).symbols @@ -82,7 +82,11 @@ export const $ = scope({ 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)) @@ -105,7 +109,11 @@ export const $2 = scope({ 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 index cd86ca9ddbbf9..6edac2ffefa43 100644 --- a/tsc/testdata/baselines/reference/compiler/circularScopeThunkReverseMapped(checkorder=default).types +++ b/tsc/testdata/baselines/reference/compiler/circularScopeThunkReverseMapped(checkorder=default).types @@ -27,10 +27,10 @@ declare function type(x: T): Type; >x : T export const $ = scope({ ->$ : any ->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: () => any; }> +>$ : Scope<{ readonly a: Type; readonly b: () => Type; }> +>scope({ a: type("string").pipe(function (s) { return s.length; }), b: () => $.type("a").pipe(function (n) { return n === 0; }),}) : Scope<{ readonly a: Type; readonly b: () => Type; }> >scope : (def: Validate) => Scope ->{ a: type("string").pipe(function (s) { return s.length; }), b: () => $.type("a").pipe(function (n) { return n === 0; }),} : { a: Type; b: () => any; } +>{ 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 @@ -47,30 +47,30 @@ export const $ = scope({ >length : number b: () => $.type("a").pipe(function (n) { return n === 0; }), ->b : () => any ->() => $.type("a").pipe(function (n) { return n === 0; }) : () => any ->$.type("a").pipe(function (n) { return n === 0; }) : any ->$.type("a").pipe : any ->$.type("a") : any ->$.type : any ->$ : any ->type : any +>b : () => Type +>() => $.type("a").pipe(function (n) { return n === 0; }) : () => Type +>$.type("a").pipe(function (n) { return n === 0; }) : Type +>$.type("a").pipe : (f: (x: number) => U) => Type +>$.type("a") : Type +>$.type : (k: k_1) => Resolve<{ readonly a: Type; readonly b: () => Type; }[k_1]> +>$ : Scope<{ readonly a: Type; readonly b: () => Type; }> +>type : (k: k_1) => Resolve<{ readonly a: Type; readonly b: () => Type; }[k_1]> >"a" : "a" ->pipe : any ->function (n) { return n === 0; } : (n: any) => boolean ->n : any +>pipe : (f: (x: number) => U) => Type +>function (n) { return n === 0; } : (n: number) => n is 0 +>n : number >n === 0 : boolean ->n : any +>n : number >0 : 0 }); // Entered from the function in the first property when queried in reverse export const $2 = scope({ ->$2 : any ->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: () => any; }> +>$2 : Scope<{ readonly a: Type; readonly b: () => Type; }> +>scope({ a: type("string").pipe(function (s) { return s.length; }), b: () => $2.type("a").pipe((n: number) => n === 0),}) : Scope<{ readonly a: Type; readonly b: () => Type; }> >scope : (def: Validate) => Scope ->{ a: type("string").pipe(function (s) { return s.length; }), b: () => $2.type("a").pipe((n: number) => n === 0),} : { a: Type; b: () => any; } +>{ 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 @@ -87,16 +87,16 @@ export const $2 = scope({ >length : number b: () => $2.type("a").pipe((n: number) => n === 0), ->b : () => any ->() => $2.type("a").pipe((n: number) => n === 0) : () => any ->$2.type("a").pipe((n: number) => n === 0) : any ->$2.type("a").pipe : any ->$2.type("a") : any ->$2.type : any ->$2 : any ->type : any +>b : () => Type +>() => $2.type("a").pipe((n: number) => n === 0) : () => Type +>$2.type("a").pipe((n: number) => n === 0) : Type +>$2.type("a").pipe : (f: (x: number) => U) => Type +>$2.type("a") : Type +>$2.type : (k: k_1) => Resolve<{ readonly a: Type; readonly b: () => Type; }[k_1]> +>$2 : Scope<{ readonly a: Type; readonly b: () => Type; }> +>type : (k: k_1) => Resolve<{ readonly a: Type; readonly b: () => Type; }[k_1]> >"a" : "a" ->pipe : any +>pipe : (f: (x: number) => U) => Type >(n: number) => n === 0 : (n: number) => n is 0 >n : number >n === 0 : boolean diff --git a/tsc/testdata/baselines/reference/compiler/circularScopeThunkReverseMapped(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/circularScopeThunkReverseMapped(checkorder=typesfirst).errors.txt deleted file mode 100644 index 495583f737e9e..0000000000000 --- a/tsc/testdata/baselines/reference/compiler/circularScopeThunkReverseMapped(checkorder=typesfirst).errors.txt +++ /dev/null @@ -1,40 +0,0 @@ -circularScopeThunkReverseMapped.ts(12,14): error TS7022: '$' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. -circularScopeThunkReverseMapped.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. -circularScopeThunkReverseMapped.ts(14,41): error TS7006: Parameter 'n' implicitly has an 'any' type. -circularScopeThunkReverseMapped.ts(18,14): error TS7022: '$2' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. -circularScopeThunkReverseMapped.ts(20,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. - - -==== circularScopeThunkReverseMapped.ts (5 errors) ==== - 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({ - ~ -!!! error TS7022: '$' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. - a: type("string").pipe(function (s) { return s.length; }), - b: () => $.type("a").pipe(function (n) { return n === 0; }), - ~ -!!! 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. - ~ -!!! error TS7006: Parameter 'n' implicitly has an 'any' type. - }); - - // Entered from the function in the first property when queried in reverse - export const $2 = scope({ - ~~ -!!! error TS7022: '$2' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. - a: type("string").pipe(function (s) { return s.length; }), - b: () => $2.type("a").pipe((n: number) => n === 0), - ~ -!!! 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. - }); - \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/circularScopeThunkReverseMapped(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/circularScopeThunkReverseMapped(checkorder=typesfirst).symbols index 162296d91ea40..cefed83354abf 100644 --- a/tsc/testdata/baselines/reference/compiler/circularScopeThunkReverseMapped(checkorder=typesfirst).symbols +++ b/tsc/testdata/baselines/reference/compiler/circularScopeThunkReverseMapped(checkorder=typesfirst).symbols @@ -82,7 +82,11 @@ export const $ = scope({ 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)) @@ -105,7 +109,11 @@ export const $2 = scope({ 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 index cd86ca9ddbbf9..6edac2ffefa43 100644 --- a/tsc/testdata/baselines/reference/compiler/circularScopeThunkReverseMapped(checkorder=typesfirst).types +++ b/tsc/testdata/baselines/reference/compiler/circularScopeThunkReverseMapped(checkorder=typesfirst).types @@ -27,10 +27,10 @@ declare function type(x: T): Type; >x : T export const $ = scope({ ->$ : any ->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: () => any; }> +>$ : Scope<{ readonly a: Type; readonly b: () => Type; }> +>scope({ a: type("string").pipe(function (s) { return s.length; }), b: () => $.type("a").pipe(function (n) { return n === 0; }),}) : Scope<{ readonly a: Type; readonly b: () => Type; }> >scope : (def: Validate) => Scope ->{ a: type("string").pipe(function (s) { return s.length; }), b: () => $.type("a").pipe(function (n) { return n === 0; }),} : { a: Type; b: () => any; } +>{ 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 @@ -47,30 +47,30 @@ export const $ = scope({ >length : number b: () => $.type("a").pipe(function (n) { return n === 0; }), ->b : () => any ->() => $.type("a").pipe(function (n) { return n === 0; }) : () => any ->$.type("a").pipe(function (n) { return n === 0; }) : any ->$.type("a").pipe : any ->$.type("a") : any ->$.type : any ->$ : any ->type : any +>b : () => Type +>() => $.type("a").pipe(function (n) { return n === 0; }) : () => Type +>$.type("a").pipe(function (n) { return n === 0; }) : Type +>$.type("a").pipe : (f: (x: number) => U) => Type +>$.type("a") : Type +>$.type : (k: k_1) => Resolve<{ readonly a: Type; readonly b: () => Type; }[k_1]> +>$ : Scope<{ readonly a: Type; readonly b: () => Type; }> +>type : (k: k_1) => Resolve<{ readonly a: Type; readonly b: () => Type; }[k_1]> >"a" : "a" ->pipe : any ->function (n) { return n === 0; } : (n: any) => boolean ->n : any +>pipe : (f: (x: number) => U) => Type +>function (n) { return n === 0; } : (n: number) => n is 0 +>n : number >n === 0 : boolean ->n : any +>n : number >0 : 0 }); // Entered from the function in the first property when queried in reverse export const $2 = scope({ ->$2 : any ->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: () => any; }> +>$2 : Scope<{ readonly a: Type; readonly b: () => Type; }> +>scope({ a: type("string").pipe(function (s) { return s.length; }), b: () => $2.type("a").pipe((n: number) => n === 0),}) : Scope<{ readonly a: Type; readonly b: () => Type; }> >scope : (def: Validate) => Scope ->{ a: type("string").pipe(function (s) { return s.length; }), b: () => $2.type("a").pipe((n: number) => n === 0),} : { a: Type; b: () => any; } +>{ 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 @@ -87,16 +87,16 @@ export const $2 = scope({ >length : number b: () => $2.type("a").pipe((n: number) => n === 0), ->b : () => any ->() => $2.type("a").pipe((n: number) => n === 0) : () => any ->$2.type("a").pipe((n: number) => n === 0) : any ->$2.type("a").pipe : any ->$2.type("a") : any ->$2.type : any ->$2 : any ->type : any +>b : () => Type +>() => $2.type("a").pipe((n: number) => n === 0) : () => Type +>$2.type("a").pipe((n: number) => n === 0) : Type +>$2.type("a").pipe : (f: (x: number) => U) => Type +>$2.type("a") : Type +>$2.type : (k: k_1) => Resolve<{ readonly a: Type; readonly b: () => Type; }[k_1]> +>$2 : Scope<{ readonly a: Type; readonly b: () => Type; }> +>type : (k: k_1) => Resolve<{ readonly a: Type; readonly b: () => Type; }[k_1]> >"a" : "a" ->pipe : any +>pipe : (f: (x: number) => U) => Type >(n: number) => n === 0 : (n: number) => n is 0 >n : number >n === 0 : boolean From d9318678dcd7e8876a03e2062371eaa8ce990a04 Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Sun, 1 Nov 2026 23:09:01 -0800 Subject: [PATCH 45/60] Keep results a cycle yield computes from scratch When a query enters a cycle somewhere other than its program-order entry, the cycle yields to its first member and recomputes it with the resolutions below hidden. Two things made that recomputation differ from computing the member first: - The reverse mapping stacks, contextual types and inference contexts of the hidden resolutions stayed visible, so the recomputation saw contexts that a computation from scratch never has. A yield now hides them along with the resolutions and restores them when it ends. - Results were kept as cycle participants only by comparing the outermost cycle head in progress against the resolution. A cycle headed below the yield, which the yield cannot observe, caused the yield root and the hidden re-entries of itself to be discarded, so the member was computed again and genuinely re-entered itself. Each type resolution now tracks the lowest cycle head it observed, and a result is kept when the computations it observed were entered from scratch: by the outer resolution of itself, by the yield it is the root of, or by the outermost measurement of variances. (seen in circularScopeThunkReverseMapped) --- tsc/internal/checker/checker.go | 63 ++++++++++++++++++++++++++--- tsc/internal/checker/memo.go | 1 + tsc/internal/checker/resolutions.go | 1 + 3 files changed, 59 insertions(+), 6 deletions(-) diff --git a/tsc/internal/checker/checker.go b/tsc/internal/checker/checker.go index 8048057177483..45a8fdb786e51 100644 --- a/tsc/internal/checker/checker.go +++ b/tsc/internal/checker/checker.go @@ -712,6 +712,7 @@ type Checker struct { circularityMark int // Length of discard log when the cycle in progress was detected innerCycles []innerCycle // Cycles detected inside the one in progress; see extendCircularity flowDepthFailures map[FlowLoopKey]int // Largest depth budget known to be too small for a flow walk from a node; see getTypeAtFlowNode + observedHead int32 // 1 + index in resolutions of the lowest head of a cycle observed by the innermost type resolution in progress, or 0 cycleParticipants []*memoHeader // Computations that observed a cycle in progress effectsMarkDepth int // 1 + resolution index of the innermost effects mark that may be discarded, or 0 varianceStack []VarianceStackEntry @@ -20601,9 +20602,19 @@ type cycleYield struct { savedVisibleStart int savedVisibleSigs int savedDepths [3]depthLimit + savedReverseMapped reverseMappedState + savedContextual []ContextualInfo + savedInference []InferenceContextInfo shadowed []shadowedResolving } +type reverseMappedState struct { + sourceStack []*Type + targetStack []*Type + expandingFlags ExpandingFlags + start int32 +} + type shadowedResolving struct { key memoKey index int32 @@ -20794,7 +20805,14 @@ func (c *Checker) beginCycleYield(target TypeSystemEntity, propertyName TypeSyst savedVisibleStart: c.visibleStart, savedVisibleSigs: c.visibleSignatures, savedDepths: [3]depthLimit{c.serializationLevel, c.inlineLevel, c.conditionalConstraintDepth}, + savedReverseMapped: reverseMappedState{c.reverseMappedSourceStack, c.reverseMappedTargetStack, c.reverseExpandingFlags, c.reverseMappedStart}, + savedContextual: c.contextualInfos, + savedInference: c.inferenceContextInfos, }) + // The contexts the hidden resolutions entered are hidden too, so that the + // recomputation is from scratch. + c.reverseMappedSourceStack, c.reverseMappedTargetStack, c.reverseExpandingFlags, c.reverseMappedStart = nil, nil, 0, 0 + c.contextualInfos, c.inferenceContextInfos = nil, nil c.resolutionStart = n c.visibleStart = n c.visibleSignatures = len(c.signaturesResolving) @@ -20807,6 +20825,9 @@ func (c *Checker) endCycleYield() { c.visibleStart = y.savedVisibleStart c.visibleSignatures = y.savedVisibleSigs c.serializationLevel, c.inlineLevel, c.conditionalConstraintDepth = y.savedDepths[0], y.savedDepths[1], y.savedDepths[2] + r := y.savedReverseMapped + c.reverseMappedSourceStack, c.reverseMappedTargetStack, c.reverseExpandingFlags, c.reverseMappedStart = r.sourceStack, r.targetStack, r.expandingFlags, r.start + c.contextualInfos, c.inferenceContextInfos = y.savedContextual, y.savedInference for _, sh := range y.shadowed { c.resolving.set(sh.key, sh.index) } @@ -21051,6 +21072,37 @@ func (c *Checker) markTypeResolutionCircular(start int) { c.markCircular(start) } +// keepsResultInCycle reports whether the type resolution at index n, which +// observed the cycles whose lowest head is observed (see Checker.observedHead), +// computes what it computes first from scratch although a cycle is in +// progress, so that its result is kept as a participant of the cycle: +// - The resolution re-entered a hidden resolution of itself, which a +// computation from scratch of the outer one always does, and what it +// observed in progress was all entered by the outer one, so its result is +// what the outer one computes first from scratch. +// - The resolution is the one a cycle yield computes again from scratch, +// with everything below it hidden, and it observed nothing hidden. +func (c *Checker) keepsResultInCycle(n int, f *resolution, observed int32) bool { + r := &f.typeResolution + if r.outerSelf != 0 && observed != 0 && observed >= r.outerSelf && int(observed) <= n { + return true + } + if len(c.cycleYields) != 0 { + // The innermost yield hides what is below visibleStart. + if floor := c.visibleStart; n >= floor && int(f.prevTypeResolution) <= floor && (observed == 0 || int(observed) > floor) { + return true + } + } + return false +} + +func minObservedHead(a int32, b int32) int32 { + if a == 0 || b != 0 && b < a { + return b + } + return a +} + // markCircular records that the computations from the resolution at start to // the top of the stack observed the incomplete computation at start, so // results cached while it is in progress are discarded when it finishes. @@ -21105,12 +21157,9 @@ func (c *Checker) popTypeResolution() bool { debug.Assert(c.typeResolutionTop == n+1, "resolutions left above a type resolution") f := &c.resolutions[n] result := f.typeResolution.result - if r := &f.typeResolution; r.outerSelf != 0 && result && r.memo != nil && c.circularityStart != 0 && c.circularityStart <= n && c.circularityStart >= int(r.outerSelf) && !r.participant { - // 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 outer one - // keeps it, as must the cycle. + observed := c.observedHead + c.observedHead = minObservedHead(f.prevObservedHead, observed) + if r := &f.typeResolution; result && !r.participant && r.memo != nil && c.circularityStart != 0 && c.keepsResultInCycle(n, f, observed) { r.participant = true c.cycleParticipants = append(c.cycleParticipants, r.memo) } @@ -21133,6 +21182,8 @@ func (c *Checker) beginTypeResolution(target TypeSystemEntity, propertyName Type f.prevMemo = int32(c.memoTop) f.isTypeResolution = true f.prevTypeResolution = int32(c.typeResolutionTop) + f.prevObservedHead = c.observedHead + c.observedHead = 0 f.typeResolution.target = target f.typeResolution.memo = memo f.typeResolution.propertyName = propertyName diff --git a/tsc/internal/checker/memo.go b/tsc/internal/checker/memo.go index fcce77d3177e1..9847b828de83d 100644 --- a/tsc/internal/checker/memo.go +++ b/tsc/internal/checker/memo.go @@ -1930,6 +1930,7 @@ func (c *Checker) discardCycle(mark int, retain bool) { // 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)) c.recordFromCheck() switch { case c.circularityStart == 0: diff --git a/tsc/internal/checker/resolutions.go b/tsc/internal/checker/resolutions.go index a0b5e9449e2a2..1236dd4d9cbcb 100644 --- a/tsc/internal/checker/resolutions.go +++ b/tsc/internal/checker/resolutions.go @@ -54,6 +54,7 @@ type resolution struct { typeResolution TypeResolution isTypeResolution bool prevTypeResolution int32 // Checker.typeResolutionTop on entry + prevObservedHead int32 // Checker.observedHead on entry } // A memoStateSource creates the memo state of a computation in progress on From 5e08332683a3aed01044081789b9927c62d9b060 Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Thu, 5 Nov 2026 09:07:53 -0800 Subject: [PATCH 46/60] Record per-node check facts eagerly instead of as effects Which symbols are referenced, which nodes need deferred or unused checks, and which aliases are referenced are facts about a node that only the check of its file consumes. Recording them as effects made nearly every query result carry effects, so emit and other queries without a check retained and walked a large effect graph: --noCheck emit of VS Code used twice the time and memory of main. Each fact now depends only on its node, and the check reaches every node, so the first computation reaching a fact records it. Write-only names are not uses wherever a name is resolved. The check now also checks methods and accessors in destructuring targets and decorators where they are not valid, which only a query computing their types reached before, and follows referenced import = declarations itself once the file's references are marked, so that following them reports errors regardless of which computation cached them first. Marks are written only by checking, or by a computation a check started that entered a cycle. A query records them on its result, and they are replayed even when its other effects are dropped, as whether a computation reaches the nodes they mark does not depend on the results it read. Following a referenced alias to the aliases it refers to computes, so it happens where the alias is referenced, and the mark only records the aliases found. A test finds marks written anywhere else. --- tsc/internal/checker/checker.go | 134 ++++++++++++------ tsc/internal/checker/checker_test.go | 1 - tsc/internal/checker/emitresolver.go | 8 +- tsc/internal/checker/markwrites_test.go | 97 +++++++++++++ tsc/internal/checker/memo.go | 84 +++++------ tsc/internal/checker/resolutions.go | 6 - tsc/internal/checker/types.go | 1 - .../classExpressionWithDecorator1.errors.txt | 7 +- ...torWithIncompleteTypeAnnotation.errors.txt | 5 +- ...mitUnknownImport(target=es2015).errors.txt | 5 +- ...itUnknownImport2(target=es2015).errors.txt | 5 +- .../importDeclWithClassModifiers.errors.txt | 11 +- .../importDeclWithExportModifier.errors.txt | 5 +- ...portModifierAndExportAssignment.errors.txt | 5 +- ...lse,verbatimmodulesyntax=false).errors.txt | 5 +- ...rue,verbatimmodulesyntax=false).errors.txt | 5 +- ...decorators=false,target=es2015).errors.txt | 8 +- ...decorators=false,target=es2022).errors.txt | 8 +- ...ldecorators=true,target=es2015).errors.txt | 8 +- ...ldecorators=true,target=es2022).errors.txt | 8 +- ...tructuringAssignmentClassFields.errors.txt | 5 +- ...ructuringAssignmentESDecorators.errors.txt | 8 +- ...LocalsReferencedInCycleDuringCheck.symbols | 74 ++++++++++ ...edLocalsReferencedInCycleDuringCheck.types | 92 ++++++++++++ ...2(experimentaldecorators=false).errors.txt | 26 +++- .../conformance/parser519458.errors.txt | 5 +- .../thisTypeInFunctionsNegative.errors.txt | 5 +- ...nusedLocalsReferencedInCycleDuringCheck.ts | 22 +++ 28 files changed, 495 insertions(+), 158 deletions(-) create mode 100644 tsc/internal/checker/markwrites_test.go create mode 100644 tsc/testdata/baselines/reference/compiler/unusedLocalsReferencedInCycleDuringCheck.symbols create mode 100644 tsc/testdata/baselines/reference/compiler/unusedLocalsReferencedInCycleDuringCheck.types create mode 100644 tsc/testdata/tests/cases/compiler/unusedLocalsReferencedInCycleDuringCheck.ts diff --git a/tsc/internal/checker/checker.go b/tsc/internal/checker/checker.go index 45a8fdb786e51..164010d9c8355 100644 --- a/tsc/internal/checker/checker.go +++ b/tsc/internal/checker/checker.go @@ -721,8 +721,8 @@ type Checker struct { varianceProvisional []*ast.Symbol // Types measured in a circularity with a measurement in progress; see isGuessedVariance flushBuf []*memoState resumeBuf []int - deferredAttach []*memoState // See attachState - recordingFromCheck bool // A query begun in a check is in progress; see recordFromCheck + deferredAttach []deferredAttachment // See attachState + recordingFromCheck bool // A query begun in a check is in progress; see recordFromCheck apparentArgumentCount *int lastGetCombinedNodeFlagsNode *ast.Node lastGetCombinedNodeFlagsResult ast.NodeFlags @@ -817,6 +817,7 @@ type Checker struct { typeToStringNodebuilder *NodeBuilder tracer *Tracer // Optional tracer for trace events and type recording (for --generateTrace) checking bool // Whether side effects such as diagnostics are applied; see memo.go + markingForEmit bool // Whether emit is marking the references of a file; see writesMarks observingMemos bool // See syncObserving instantiationCount uint32 // Instantiations since the start of the current statement, expression or outermost computation; see "Instantiation limits" memoTop int // 1 + index in resolutions of the innermost computation recording effects, or 0; see memo.go @@ -1760,13 +1761,25 @@ 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) }) + if !c.writesMarks() { + c.recordMark(func(c *Checker) { c.symbolReferenced(symbol, meaning) }) return } c.symbolReferenceLinks.Get(symbol).referenceKinds |= meaning } +// writesMarks reports whether marks that checking accumulates for later +// checks and emit to read, such as which symbols are referenced, are written +// now: when checking, including while a check records what it computes in a +// cycle, which may discard the results but not that their source was +// reached, or when emit marks the references of a file itself. Otherwise a +// computation answering a query records them as an effect, so that they are +// written only once checking reaches its result, as if checking had computed +// it, and a query, such as printing a type, writes none of its own. +func (c *Checker) writesMarks() bool { + return c.checking || c.recordingFromCheck || c.markingForEmit +} + func (c *Checker) getRequiresScopeChangeCache(node *ast.Node) core.Tristate { return c.nodeLinks.Get(node).declarationRequiresScopeChange } @@ -2783,8 +2796,8 @@ 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) }) + if !c.writesMarks() { + c.recordMark(func(c *Checker) { c.checkNodeDeferred(node) }) return } enclosingFile := ast.GetSourceFileOfNode(node) @@ -6462,6 +6475,13 @@ func (c *Checker) checkDecorators(node *ast.Node) { // skip this check for nodes that cannot have decorators. These should have already had an error reported by // checkGrammarModifiers. if !ast.CanHaveDecorators(node) || !ast.HasDecorators(node) || !ast.NodeCanBeDecorated(c.legacyDecorators, node, node.Parent, node.Parent.Parent) { + // The expressions of decorators that are not valid here are still + // checked, as they are when anything computes their types. + for _, modifier := range node.ModifierNodes() { + if ast.IsDecorator(modifier) { + c.checkExpression(modifier.Expression()) + } + } return } firstDecorator := core.Find(node.ModifierNodes(), ast.IsDecorator) @@ -7486,8 +7506,8 @@ 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) }) + if !c.writesMarks() { + c.recordMark(func(c *Checker) { c.registerForUnusedIdentifiersCheck(node) }) return } sourceFile := ast.GetSourceFileOfNode(node) @@ -13503,6 +13523,14 @@ func (c *Checker) checkObjectLiteralDestructuringPropertyAssignment(node *ast.No return c.checkDestructuringAssignment(property.Expression(), t, CheckModeNormal, false) } c.error(property, diagnostics.Property_assignment_expected) + // The member is still checked as it would be in an object literal, as + // it is when anything computes the type of the literal. + switch property.Kind { + case ast.KindMethodDeclaration: + c.checkObjectLiteralMethod(property, CheckModeNormal) + case ast.KindGetAccessor, ast.KindSetAccessor: + c.checkNodeDeferred(property) + } return nil } @@ -17200,20 +17228,23 @@ func (c *Checker) resolveEntityNameEx(name *ast.Node, meaning ast.SymbolFlags, i if resolveLocation == nil { resolveLocation = name } + // As for getResolvedSymbol, so that whatever resolves a name marks + // the same uses. + isUse := use && !ast.IsWriteOnlyAccess(name) if meaning == ast.SymbolFlagsNamespace { - symbol = c.getMergedSymbol(c.resolveName(resolveLocation, name.Text(), meaning, nil, use /*isUse*/, false /*excludeGlobals*/)) + symbol = c.getMergedSymbol(c.resolveName(resolveLocation, name.Text(), meaning, nil, isUse, false /*excludeGlobals*/)) if symbol == nil { - alias := c.getMergedSymbol(c.resolveName(resolveLocation, name.Text(), ast.SymbolFlagsAlias, nil, use /*isUse*/, false /*excludeGlobals*/)) + alias := c.getMergedSymbol(c.resolveName(resolveLocation, name.Text(), ast.SymbolFlagsAlias, nil, isUse, false /*excludeGlobals*/)) if alias != nil && alias.Name() == ast.InternalSymbolNameExportEquals { // resolve typedefs exported from commonjs, stored on the module symbol symbol = alias.Parent() } } if symbol == nil && message != nil { - c.resolveName(resolveLocation, name.Text(), meaning, message, use /*isUse*/, false /*excludeGlobals*/) + c.resolveName(resolveLocation, name.Text(), meaning, message, isUse, false /*excludeGlobals*/) } } else { - symbol = c.getMergedSymbol(c.resolveName(resolveLocation, name.Text(), meaning, message, use /*isUse*/, false /*excludeGlobals*/)) + symbol = c.getMergedSymbol(c.resolveName(resolveLocation, name.Text(), meaning, message, isUse, false /*excludeGlobals*/)) } case ast.KindQualifiedName: qualified := name.AsQualifiedName() @@ -32287,8 +32318,16 @@ func (c *Checker) getEntityNameForDecoratorMetadataFromTypeList(typeNodes []*ast } func (c *Checker) markAliasReferenced(symbol *ast.Symbol, location *ast.Node) { + if c.isAliasReferencedAt(symbol, location) { + c.markAliasSymbolAsReferenced(symbol) + } +} + +// isAliasReferencedAt reports whether a reference to symbol at location +// references it as an alias, so that the alias cannot be elided. +func (c *Checker) isAliasReferencedAt(symbol *ast.Symbol, location *ast.Node) bool { if !c.canCollectSymbolAliasAccessibilityData { - return + return false } if ast.IsNonLocalAlias(symbol, ast.SymbolFlagsValue /*excludes*/) && !IsInTypeQuery(location) { target := c.resolveAlias(symbol) @@ -32296,52 +32335,57 @@ func (c *Checker) markAliasReferenced(symbol *ast.Symbol, location *ast.Node) { // An alias resolving to a const enum cannot be elided if (1) 'isolatedModules' is enabled // (because the const enum value will not be inlined), or if (2) the alias is an export // of a const enum declaration that will be preserved. - if c.compilerOptions.GetIsolatedModules() || + return c.compilerOptions.GetIsolatedModules() || c.compilerOptions.ShouldPreserveConstEnums() && isExportOrExportExpression(location) || - !isConstEnumOrConstEnumOnlyModule(c.getExportSymbolOfValueSymbolIfExported(target)) { - c.markAliasSymbolAsReferenced(symbol) - } + !isConstEnumOrConstEnumOnlyModule(c.getExportSymbolOfValueSymbolIfExported(target)) } } + return false } // When an alias symbol is referenced, we need to mark the entity it references as referenced and in turn repeat that until -// we reach a non-alias or an exported entity (which is always considered referenced). We do this by checking the target of -// the alias as an expression (which recursively takes us back here if the target references another alias). +// we reach a non-alias or an exported entity (which is always considered referenced). Following the aliases computes, so +// they are followed here whether checking or a query reaches this; only marking them waits for checking. func (c *Checker) markAliasSymbolAsReferenced(symbol *ast.Symbol) { - if !c.checking { - c.recordReferenceMark(symbol) + var aliases []*ast.Symbol + for symbol != nil && !slices.Contains(aliases, symbol) { + aliases = append(aliases, symbol) + symbol = c.getAliasReferencedByAlias(symbol) + } + c.markAliasesReferenced(aliases) +} + +func (c *Checker) markAliasesReferenced(aliases []*ast.Symbol) { + if !c.writesMarks() { + c.recordMark(func(c *Checker) { c.markAliasesReferenced(aliases) }) return } - c.referenceAliasSymbol(symbol) + for _, alias := range aliases { + c.aliasSymbolLinks.Get(alias).referenced = true + } } -func (c *Checker) referenceAliasSymbol(symbol *ast.Symbol) { - links := c.aliasSymbolLinks.Get(symbol) - // 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 { - panic("Unexpected nil in markAliasSymbolAsReferenced") - } - // We defer checking of the reference of an `import =` until the import itself is referenced, - // This way a chain of imports can be elided if ultimately the final input is only used in a type - // position. - if ast.IsImportEqualsDeclaration(node) && node.AsImportEqualsDeclaration().ModuleReference.Kind != ast.KindExternalModuleReference { - if c.getSymbolFlags(c.resolveSymbol(symbol))&ast.SymbolFlagsValue != 0 { - // import foo = - left := ast.GetFirstIdentifier(node.AsImportEqualsDeclaration().ModuleReference) - c.markIdentifierAliasReferenced(left) +// getAliasReferencedByAlias returns the alias that referencing the alias +// symbol references in turn, if any. We defer checking of the reference of +// an `import =` until the import itself is referenced, this way a chain of +// imports can be elided if ultimately the final input is only used in a +// type position. Following it reports nothing; checking the declaration +// reports what is wrong with its reference. +func (c *Checker) getAliasReferencedByAlias(symbol *ast.Symbol) *ast.Symbol { + node := c.getDeclarationOfAliasSymbol(symbol) + if node == nil { + panic("Unexpected nil in markAliasSymbolAsReferenced") + } + if ast.IsImportEqualsDeclaration(node) && node.AsImportEqualsDeclaration().ModuleReference.Kind != ast.KindExternalModuleReference { + if c.getSymbolFlags(c.resolveSymbol(symbol))&ast.SymbolFlagsValue != 0 { + // import foo = + left := ast.GetFirstIdentifier(node.AsImportEqualsDeclaration().ModuleReference) + if target := c.resolveName(left, left.Text(), ast.SymbolFlagsValue|ast.SymbolFlagsExportValue, nil /*nameNotFoundMessage*/, true /*isUse*/, false /*excludeGlobals*/); target != nil && c.isAliasReferencedAt(target, left) { + return target } } } + return nil } func (c *Checker) markExportAsReferenced(node *ast.Node /*ImportEqualsDeclaration | ExportSpecifier*/) { diff --git a/tsc/internal/checker/checker_test.go b/tsc/internal/checker/checker_test.go index e3a40fe50771e..14fa6fd60831c 100644 --- a/tsc/internal/checker/checker_test.go +++ b/tsc/internal/checker/checker_test.go @@ -671,7 +671,6 @@ var unmemoizedCacheFields = map[string]string{ "memoStore.deferredDiagnosticCallbacks": unmemoizedChecking, "SymbolReferenceLinks.referenceKinds": unmemoizedChecking, "AliasSymbolLinks.referenced": unmemoizedMark, - "AliasSymbolLinks.referenceChecked": unmemoizedChecking, "SourceFileLinks.typeChecked": unmemoizedChecking, "SourceFileLinks.unusedChecked": unmemoizedChecking, "SourceFileLinks.deferredNodes": unmemoizedChecking, diff --git a/tsc/internal/checker/emitresolver.go b/tsc/internal/checker/emitresolver.go index 48a8932e93c25..0f96089a8fefe 100644 --- a/tsc/internal/checker/emitresolver.go +++ b/tsc/internal/checker/emitresolver.go @@ -511,12 +511,8 @@ 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) { - { + r.checker.markingForEmit = true + defer func() { r.checker.markingForEmit = false }() var visit ast.Visitor visit = func(n *ast.Node) bool { if ast.IsImportEqualsDeclaration(n) && n.ModifierFlags()&ast.ModifierFlagsExport == 0 { diff --git a/tsc/internal/checker/markwrites_test.go b/tsc/internal/checker/markwrites_test.go new file mode 100644 index 0000000000000..f975da6772f5c --- /dev/null +++ b/tsc/internal/checker/markwrites_test.go @@ -0,0 +1,97 @@ +package checker_test + +import ( + goast "go/ast" + "go/parser" + "go/token" + "path/filepath" + "strings" + "testing" + + "gotest.tools/v3/assert" +) + +// markFields are fields holding what checking accumulates for later checks +// and emit to read, such as which symbols are referenced or which nodes are +// checked once a file is: a computation answering a query must not write +// them, or what checking reports depends on what was asked first (see +// writesMarks). +var markFields = map[string]bool{ + "referenceKinds": true, + "referenced": true, + "deferredNodes": true, + "identifierCheckNodes": true, + "externalHelperRequests": true, + "requestedExternalEmitHelpers": true, + "nonExistentPropertyNodes": true, + "deferredDiagnosticCallbacks": true, +} + +// Marks may only be written by functions that test whether they may be, +// which record them as an effect otherwise, or by those listed in +// allowedMarkWriters with the reason they only run when checking. +func TestMarksAreWrittenOnlyWhenChecking(t *testing.T) { + t.Parallel() + fset := token.NewFileSet() + files, err := filepath.Glob("*.go") + assert.NilError(t, err) + seen := make(map[string]bool) + for _, name := range files { + if strings.HasSuffix(name, "_test.go") { + continue + } + file, err := parser.ParseFile(fset, name, nil, parser.SkipObjectResolution) + assert.NilError(t, err) + for _, decl := range file.Decls { + fn, isFunc := decl.(*goast.FuncDecl) + if !isFunc || fn.Body == nil { + continue + } + guarded := false + goast.Inspect(fn.Body, func(n goast.Node) bool { + if sel, ok := n.(*goast.SelectorExpr); ok && (sel.Sel.Name == "writesMarks" || sel.Sel.Name == "checking") { + guarded = true + } + return !guarded + }) + check := func(pos token.Pos, e goast.Expr) { + sel, ok := e.(*goast.SelectorExpr) + if !ok || !markFields[sel.Sel.Name] { + return + } + key := fn.Name.Name + ": " + sel.Sel.Name + seen[key] = true + if _, ok := allowedMarkWriters[key]; !ok && !guarded { + t.Errorf("%s: %s writes %s without testing whether checking may", fset.Position(pos), fn.Name.Name, sel.Sel.Name) + } + } + goast.Inspect(fn.Body, func(n goast.Node) bool { + switch n := n.(type) { + case *goast.AssignStmt: + for _, lhs := range n.Lhs { + check(n.Pos(), lhs) + } + case *goast.CallExpr: + if sel, ok := n.Fun.(*goast.SelectorExpr); ok && (sel.Sel.Name == "Add" || sel.Sel.Name == "Delete" || sel.Sel.Name == "Clear") { + check(n.Pos(), sel.X) + } + } + return true + }) + } + } + for key := range allowedMarkWriters { + if !seen[key] { + t.Errorf("allowedMarkWriters lists %s, which writes no mark", key) + } + } +} + +// allowedMarkWriters lists functions writing marks without testing, keyed by +// function and field, with why they only run when checking. +var allowedMarkWriters = map[string]string{ + "checkDeferredNodes: deferredNodes": "called by checkSourceFileWorker", + "checkExternalHelperRequests: externalHelperRequests": "called by checkSourceFileWorker", + "produceDeferredDiagnostics: deferredDiagnosticCallbacks": "called by checkSourceFileWorker", + "checkExternalEmitHelpersAt: requestedExternalEmitHelpers": "called by checkExternalEmitHelpers once it may write, and checkExternalHelperRequests", +} diff --git a/tsc/internal/checker/memo.go b/tsc/internal/checker/memo.go index 9847b828de83d..4ef884c0097bc 100644 --- a/tsc/internal/checker/memo.go +++ b/tsc/internal/checker/memo.go @@ -147,8 +147,11 @@ type memoEffects struct { // 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 + // Marks the computation recorded (see writesMarks), replayed even if its + // effects are dropped: that the computation reached what it marks does + // not depend on what it read. + marks []func(c *Checker) } func (f *memoEffects) rareFields() *memoEffectsRare { @@ -994,9 +997,22 @@ func (c *Checker) memoAttach(key memoKey) { if f := &c.resolutions[c.memoTop-1]; f.source == nil && f.key == key { return } + if c.resolutions[c.memoTop-1].effects == nil && !c.logEffects() { + // See attachState; the memo state is created only if needed. + c.deferredAttach = append(c.deferredAttach, deferredAttachment{key: key}) + return + } c.attachState(c.memoState(key)) } +// A deferredAttachment is a result cached by a computation that had no +// effects yet; see attachState. A result of a memo cell is identified by its +// key, so that its memo state is created only if needed. +type deferredAttachment struct { + state *memoState + key memoKey +} + // attachState is memoAttach for the memo state of a result. func (c *Checker) attachState(state *memoState) { n := c.memoTop - 1 @@ -1012,7 +1028,7 @@ func (c *Checker) attachState(state *memoState) { // 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) + c.deferredAttach = append(c.deferredAttach, deferredAttachment{state: state}) return } c.linkState(state, c.memoEffectsAt(n), c.logResults()) @@ -1255,7 +1271,7 @@ func (c *Checker) endMemoUncached() { } f := res.effects if parent := c.currentMemoEffects(); parent != nil { - if len(f.effects) == 0 && f.entry == parent.entry { + if len(f.effects) == 0 && (f.rare == nil || len(f.rare.marks) == 0) && f.entry == parent.entry { // Without effects of its own, and located like the enclosing // computation, the computation adds nothing but what it observed. for _, d := range f.deps { @@ -1351,6 +1367,10 @@ func (c *Checker) replayMemo(f *memoEffects) { // other dependencies replays nothing. func (c *Checker) replayEffects(f *memoEffects, outerEntry *ast.Node, outerEntered bool) { effects, deps := f.effects, f.deps + var marks []func(c *Checker) + if f.rare != nil { + marks = f.rare.marks + } f.effects, f.deps, f.rare = nil, nil, nil saveCurrentNode := c.currentNode if f.entered { @@ -1366,6 +1386,9 @@ func (c *Checker) replayEffects(f *memoEffects, outerEntry *ast.Node, outerEnter e(c) } } + for _, m := range marks { + m(c) + } for _, d := range deps { c.replayEffects(d, outerEntry, outerEntered) } @@ -1395,49 +1418,12 @@ func (c *Checker) recordEffect(effect func(c *Checker)) { } } -// recordReferenceMark records marking an alias referenced, an effect that -// emit applies itself (see withReferenceMarks). -func (c *Checker) recordReferenceMark(symbol *ast.Symbol) { +// recordMark records mark, which writes a mark (see writesMarks), as an +// effect of the computation in progress that dropping its effects keeps. +func (c *Checker) recordMark(mark func(c *Checker)) { if f := c.currentMemoEffects(); f != nil { - 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 && !f.dropped { - 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) }) + rare.marks = append(rare.marks, mark) } } @@ -1671,9 +1657,13 @@ func (c *Checker) attachDeferred(i int, f *memoEffects) { return } for k := start; k < end; k++ { - if state := c.deferredAttach[k]; state != nil { - c.deferredAttach[k] = nil - c.linkState(state, f, c.logResults()) + d := c.deferredAttach[k] + c.deferredAttach[k] = deferredAttachment{} + switch { + case d.state != nil: + c.linkState(d.state, f, false) + case d.key != 0: + c.linkState(c.memoState(d.key), f, false) } } } diff --git a/tsc/internal/checker/resolutions.go b/tsc/internal/checker/resolutions.go index 1236dd4d9cbcb..942409ed43660 100644 --- a/tsc/internal/checker/resolutions.go +++ b/tsc/internal/checker/resolutions.go @@ -103,12 +103,6 @@ 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() diff --git a/tsc/internal/checker/types.go b/tsc/internal/checker/types.go index f9c3552ab38fd..5fd105bf14cf9 100644 --- a/tsc/internal/checker/types.go +++ b/tsc/internal/checker/types.go @@ -318,7 +318,6 @@ type AliasSymbolLinks struct { 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 } diff --git a/tsc/testdata/baselines/reference/compiler/classExpressionWithDecorator1.errors.txt b/tsc/testdata/baselines/reference/compiler/classExpressionWithDecorator1.errors.txt index 1d2d3f5568b0f..9a749f4c13ab3 100644 --- a/tsc/testdata/baselines/reference/compiler/classExpressionWithDecorator1.errors.txt +++ b/tsc/testdata/baselines/reference/compiler/classExpressionWithDecorator1.errors.txt @@ -1,7 +1,10 @@ classExpressionWithDecorator1.ts(1,9): error TS1206: Decorators are not valid here. +classExpressionWithDecorator1.ts(1,10): error TS2304: Cannot find name 'decorate'. -==== classExpressionWithDecorator1.ts (1 errors) ==== +==== classExpressionWithDecorator1.ts (2 errors) ==== var v = @decorate class C { static p = 1 }; ~ -!!! error TS1206: Decorators are not valid here. \ No newline at end of file +!!! error TS1206: Decorators are not valid here. + ~~~~~~~~ +!!! error TS2304: Cannot find name 'decorate'. \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/constructorWithIncompleteTypeAnnotation.errors.txt b/tsc/testdata/baselines/reference/compiler/constructorWithIncompleteTypeAnnotation.errors.txt index 81ac42365af10..2852054f9325f 100644 --- a/tsc/testdata/baselines/reference/compiler/constructorWithIncompleteTypeAnnotation.errors.txt +++ b/tsc/testdata/baselines/reference/compiler/constructorWithIncompleteTypeAnnotation.errors.txt @@ -1,5 +1,4 @@ constructorWithIncompleteTypeAnnotation.ts(11,13): error TS2503: Cannot find namespace 'module'. -constructorWithIncompleteTypeAnnotation.ts(11,13): error TS2591: Cannot find name 'module'. Do you need to install type definitions for node? Try `npm i --save-dev @types/node` and then add 'node' to the types field in your tsconfig. constructorWithIncompleteTypeAnnotation.ts(11,19): error TS1005: ';' expected. constructorWithIncompleteTypeAnnotation.ts(22,35): error TS1005: ')' expected. constructorWithIncompleteTypeAnnotation.ts(22,39): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number', 'bigint' or an enum type. @@ -95,7 +94,7 @@ constructorWithIncompleteTypeAnnotation.ts(259,55): error TS1005: ';' expected. constructorWithIncompleteTypeAnnotation.ts(261,1): error TS1128: Declaration or statement expected. -==== constructorWithIncompleteTypeAnnotation.ts (95 errors) ==== +==== constructorWithIncompleteTypeAnnotation.ts (94 errors) ==== declare module "fs" { export class File { constructor(filename: string); @@ -109,8 +108,6 @@ constructorWithIncompleteTypeAnnotation.ts(261,1): error TS1128: Declaration or import fs = module("fs"); ~~~~~~ !!! error TS2503: Cannot find namespace 'module'. - ~~~~~~ -!!! error TS2591: Cannot find name 'module'. Do you need to install type definitions for node? Try `npm i --save-dev @types/node` and then add 'node' to the types field in your tsconfig. ~ !!! error TS1005: ';' expected. diff --git a/tsc/testdata/baselines/reference/compiler/declarationEmitUnknownImport(target=es2015).errors.txt b/tsc/testdata/baselines/reference/compiler/declarationEmitUnknownImport(target=es2015).errors.txt index 512f22fa8a9b6..8dcbaf204205d 100644 --- a/tsc/testdata/baselines/reference/compiler/declarationEmitUnknownImport(target=es2015).errors.txt +++ b/tsc/testdata/baselines/reference/compiler/declarationEmitUnknownImport(target=es2015).errors.txt @@ -1,11 +1,8 @@ -declarationEmitUnknownImport.ts(1,14): error TS2304: Cannot find name 'SomeNonExistingName'. declarationEmitUnknownImport.ts(1,14): error TS2503: Cannot find namespace 'SomeNonExistingName'. -==== declarationEmitUnknownImport.ts (2 errors) ==== +==== declarationEmitUnknownImport.ts (1 errors) ==== import Foo = SomeNonExistingName ~~~~~~~~~~~~~~~~~~~ -!!! error TS2304: Cannot find name 'SomeNonExistingName'. - ~~~~~~~~~~~~~~~~~~~ !!! error TS2503: Cannot find namespace 'SomeNonExistingName'. 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 07239f7d2748f..db5cb25071de4 100644 --- a/tsc/testdata/baselines/reference/compiler/declarationEmitUnknownImport2(target=es2015).errors.txt +++ b/tsc/testdata/baselines/reference/compiler/declarationEmitUnknownImport2(target=es2015).errors.txt @@ -1,16 +1,13 @@ 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 (4 errors) ==== +==== declarationEmitUnknownImport2.ts (3 errors) ==== import Foo From './Foo'; // Syntax error ~~~~ !!! error TS1005: '=' expected. ~~~~ -!!! error TS2304: Cannot find name 'From'. - ~~~~ !!! error TS2503: Cannot find namespace 'From'. ~~~~~~~ !!! error TS1005: ';' expected. diff --git a/tsc/testdata/baselines/reference/compiler/importDeclWithClassModifiers.errors.txt b/tsc/testdata/baselines/reference/compiler/importDeclWithClassModifiers.errors.txt index 12e30795fff58..ddfbafc65341d 100644 --- a/tsc/testdata/baselines/reference/compiler/importDeclWithClassModifiers.errors.txt +++ b/tsc/testdata/baselines/reference/compiler/importDeclWithClassModifiers.errors.txt @@ -1,15 +1,12 @@ importDeclWithClassModifiers.ts(5,8): error TS1044: 'public' modifier cannot appear on a module or namespace element. -importDeclWithClassModifiers.ts(5,26): error TS2708: Cannot use namespace 'x' as a value. importDeclWithClassModifiers.ts(5,28): error TS2694: Namespace 'x' has no exported member 'c'. importDeclWithClassModifiers.ts(6,8): error TS1044: 'private' modifier cannot appear on a module or namespace element. -importDeclWithClassModifiers.ts(6,27): error TS2708: Cannot use namespace 'x' as a value. importDeclWithClassModifiers.ts(6,29): error TS2694: Namespace 'x' has no exported member 'c'. importDeclWithClassModifiers.ts(7,8): error TS1044: 'static' modifier cannot appear on a module or namespace element. -importDeclWithClassModifiers.ts(7,26): error TS2708: Cannot use namespace 'x' as a value. importDeclWithClassModifiers.ts(7,28): error TS2694: Namespace 'x' has no exported member 'c'. -==== importDeclWithClassModifiers.ts (9 errors) ==== +==== importDeclWithClassModifiers.ts (6 errors) ==== namespace x { interface c { } @@ -17,22 +14,16 @@ importDeclWithClassModifiers.ts(7,28): error TS2694: Namespace 'x' has no export export public import a = x.c; ~~~~~~ !!! error TS1044: 'public' modifier cannot appear on a module or namespace element. - ~ -!!! error TS2708: Cannot use namespace 'x' as a value. ~ !!! error TS2694: Namespace 'x' has no exported member 'c'. export private import b = x.c; ~~~~~~~ !!! error TS1044: 'private' modifier cannot appear on a module or namespace element. - ~ -!!! error TS2708: Cannot use namespace 'x' as a value. ~ !!! error TS2694: Namespace 'x' has no exported member 'c'. export static import c = x.c; ~~~~~~ !!! error TS1044: 'static' modifier cannot appear on a module or namespace element. - ~ -!!! error TS2708: Cannot use namespace 'x' as a value. ~ !!! error TS2694: Namespace 'x' has no exported member 'c'. var b: a; diff --git a/tsc/testdata/baselines/reference/compiler/importDeclWithExportModifier.errors.txt b/tsc/testdata/baselines/reference/compiler/importDeclWithExportModifier.errors.txt index 8da059494431f..282fc28e8acd5 100644 --- a/tsc/testdata/baselines/reference/compiler/importDeclWithExportModifier.errors.txt +++ b/tsc/testdata/baselines/reference/compiler/importDeclWithExportModifier.errors.txt @@ -1,15 +1,12 @@ -importDeclWithExportModifier.ts(5,19): error TS2708: Cannot use namespace 'x' as a value. importDeclWithExportModifier.ts(5,21): error TS2694: Namespace 'x' has no exported member 'c'. -==== importDeclWithExportModifier.ts (2 errors) ==== +==== importDeclWithExportModifier.ts (1 errors) ==== namespace x { interface c { } } export import a = x.c; - ~ -!!! error TS2708: Cannot use namespace 'x' as a value. ~ !!! error TS2694: Namespace 'x' has no exported member 'c'. var b: a; diff --git a/tsc/testdata/baselines/reference/compiler/importDeclWithExportModifierAndExportAssignment.errors.txt b/tsc/testdata/baselines/reference/compiler/importDeclWithExportModifierAndExportAssignment.errors.txt index d4420d401f29a..083e112ea0c32 100644 --- a/tsc/testdata/baselines/reference/compiler/importDeclWithExportModifierAndExportAssignment.errors.txt +++ b/tsc/testdata/baselines/reference/compiler/importDeclWithExportModifierAndExportAssignment.errors.txt @@ -1,16 +1,13 @@ -importDeclWithExportModifierAndExportAssignment.ts(5,19): error TS2708: Cannot use namespace 'x' as a value. importDeclWithExportModifierAndExportAssignment.ts(5,21): error TS2694: Namespace 'x' has no exported member 'c'. importDeclWithExportModifierAndExportAssignment.ts(6,1): error TS2309: An export assignment cannot be used in a module with other exported elements. -==== importDeclWithExportModifierAndExportAssignment.ts (3 errors) ==== +==== importDeclWithExportModifierAndExportAssignment.ts (2 errors) ==== namespace x { interface c { } } export import a = x.c; - ~ -!!! error TS2708: Cannot use namespace 'x' as a value. ~ !!! error TS2694: Namespace 'x' has no exported member 'c'. export = x; diff --git a/tsc/testdata/baselines/reference/compiler/isolatedModulesMergedImportAlias(isolatedmodules=false,verbatimmodulesyntax=false).errors.txt b/tsc/testdata/baselines/reference/compiler/isolatedModulesMergedImportAlias(isolatedmodules=false,verbatimmodulesyntax=false).errors.txt index 4687c6ca6a727..8f54167c9ef56 100644 --- a/tsc/testdata/baselines/reference/compiler/isolatedModulesMergedImportAlias(isolatedmodules=false,verbatimmodulesyntax=false).errors.txt +++ b/tsc/testdata/baselines/reference/compiler/isolatedModulesMergedImportAlias(isolatedmodules=false,verbatimmodulesyntax=false).errors.txt @@ -1,14 +1,11 @@ -a.ts(2,23): error TS2304: Cannot find name 'x'. a.ts(2,23): error TS2503: Cannot find namespace 'x'. a.ts(13,5): error TS2440: Import declaration conflicts with local declaration of 'A'. -==== a.ts (3 errors) ==== +==== a.ts (2 errors) ==== namespace a { export import A = x.A; ~ -!!! error TS2304: Cannot find name 'x'. - ~ !!! error TS2503: Cannot find namespace 'x'. export type A = number; } diff --git a/tsc/testdata/baselines/reference/compiler/isolatedModulesMergedImportAlias(isolatedmodules=true,verbatimmodulesyntax=false).errors.txt b/tsc/testdata/baselines/reference/compiler/isolatedModulesMergedImportAlias(isolatedmodules=true,verbatimmodulesyntax=false).errors.txt index adf7becde9bb2..e4cc587d6a4c5 100644 --- a/tsc/testdata/baselines/reference/compiler/isolatedModulesMergedImportAlias(isolatedmodules=true,verbatimmodulesyntax=false).errors.txt +++ b/tsc/testdata/baselines/reference/compiler/isolatedModulesMergedImportAlias(isolatedmodules=true,verbatimmodulesyntax=false).errors.txt @@ -1,18 +1,15 @@ a.ts(1,11): error TS1280: Namespaces are not allowed in global script files when 'isolatedModules' is enabled. If this file is not intended to be a global script, set 'moduleDetection' to 'force' or add an empty 'export {}' statement. -a.ts(2,23): error TS2304: Cannot find name 'x'. a.ts(2,23): error TS2503: Cannot find namespace 'x'. a.ts(12,11): error TS1280: Namespaces are not allowed in global script files when 'isolatedModules' is enabled. If this file is not intended to be a global script, set 'moduleDetection' to 'force' or add an empty 'export {}' statement. a.ts(13,5): error TS2440: Import declaration conflicts with local declaration of 'A'. -==== a.ts (5 errors) ==== +==== a.ts (4 errors) ==== namespace a { ~ !!! error TS1280: Namespaces are not allowed in global script files when 'isolatedModules' is enabled. If this file is not intended to be a global script, set 'moduleDetection' to 'force' or add an empty 'export {}' statement. export import A = x.A; ~ -!!! error TS2304: Cannot find name 'x'. - ~ !!! error TS2503: Cannot find namespace 'x'. export type A = number; } diff --git a/tsc/testdata/baselines/reference/compiler/malformedDestructuringAssignmentTransformVariants(experimentaldecorators=false,target=es2015).errors.txt b/tsc/testdata/baselines/reference/compiler/malformedDestructuringAssignmentTransformVariants(experimentaldecorators=false,target=es2015).errors.txt index a8197d380d119..d292daee34b3f 100644 --- a/tsc/testdata/baselines/reference/compiler/malformedDestructuringAssignmentTransformVariants(experimentaldecorators=false,target=es2015).errors.txt +++ b/tsc/testdata/baselines/reference/compiler/malformedDestructuringAssignmentTransformVariants(experimentaldecorators=false,target=es2015).errors.txt @@ -5,11 +5,13 @@ malformedDestructuringAssignmentTransformVariants.ts(17,19): error TS2364: The l malformedDestructuringAssignmentTransformVariants.ts(21,24): error TS1136: Property assignment expected. malformedDestructuringAssignmentTransformVariants.ts(22,28): error TS1136: Property assignment expected. malformedDestructuringAssignmentTransformVariants.ts(23,28): error TS1136: Property assignment expected. +malformedDestructuringAssignmentTransformVariants.ts(23,28): error TS7032: Property 's' implicitly has type 'any', because its set accessor lacks a parameter type annotation. +malformedDestructuringAssignmentTransformVariants.ts(23,30): error TS7006: Parameter 'v' implicitly has an 'any' type. malformedDestructuringAssignmentTransformVariants.ts(24,25): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. malformedDestructuringAssignmentTransformVariants.ts(24,38): error TS1136: Property assignment expected. -==== malformedDestructuringAssignmentTransformVariants.ts (9 errors) ==== +==== malformedDestructuringAssignmentTransformVariants.ts (11 errors) ==== declare function dec(...args: any[]): any; declare const value: any; @@ -47,6 +49,10 @@ malformedDestructuringAssignmentTransformVariants.ts(24,38): error TS1136: Prope ({ x: super.x, set s(v) {}, private: this.#x } = value); ~ !!! error TS1136: Property assignment expected. + ~ +!!! error TS7032: Property 's' implicitly has type 'any', because its set accessor lacks a parameter type annotation. + ~ +!!! error TS7006: Parameter 'v' implicitly has an 'any' type. ({ x: [super.x, 0, this.#x], m() {} } = value); ~ !!! error TS2364: The left-hand side of an assignment expression must be a variable or a property access. diff --git a/tsc/testdata/baselines/reference/compiler/malformedDestructuringAssignmentTransformVariants(experimentaldecorators=false,target=es2022).errors.txt b/tsc/testdata/baselines/reference/compiler/malformedDestructuringAssignmentTransformVariants(experimentaldecorators=false,target=es2022).errors.txt index a8197d380d119..d292daee34b3f 100644 --- a/tsc/testdata/baselines/reference/compiler/malformedDestructuringAssignmentTransformVariants(experimentaldecorators=false,target=es2022).errors.txt +++ b/tsc/testdata/baselines/reference/compiler/malformedDestructuringAssignmentTransformVariants(experimentaldecorators=false,target=es2022).errors.txt @@ -5,11 +5,13 @@ malformedDestructuringAssignmentTransformVariants.ts(17,19): error TS2364: The l malformedDestructuringAssignmentTransformVariants.ts(21,24): error TS1136: Property assignment expected. malformedDestructuringAssignmentTransformVariants.ts(22,28): error TS1136: Property assignment expected. malformedDestructuringAssignmentTransformVariants.ts(23,28): error TS1136: Property assignment expected. +malformedDestructuringAssignmentTransformVariants.ts(23,28): error TS7032: Property 's' implicitly has type 'any', because its set accessor lacks a parameter type annotation. +malformedDestructuringAssignmentTransformVariants.ts(23,30): error TS7006: Parameter 'v' implicitly has an 'any' type. malformedDestructuringAssignmentTransformVariants.ts(24,25): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. malformedDestructuringAssignmentTransformVariants.ts(24,38): error TS1136: Property assignment expected. -==== malformedDestructuringAssignmentTransformVariants.ts (9 errors) ==== +==== malformedDestructuringAssignmentTransformVariants.ts (11 errors) ==== declare function dec(...args: any[]): any; declare const value: any; @@ -47,6 +49,10 @@ malformedDestructuringAssignmentTransformVariants.ts(24,38): error TS1136: Prope ({ x: super.x, set s(v) {}, private: this.#x } = value); ~ !!! error TS1136: Property assignment expected. + ~ +!!! error TS7032: Property 's' implicitly has type 'any', because its set accessor lacks a parameter type annotation. + ~ +!!! error TS7006: Parameter 'v' implicitly has an 'any' type. ({ x: [super.x, 0, this.#x], m() {} } = value); ~ !!! error TS2364: The left-hand side of an assignment expression must be a variable or a property access. diff --git a/tsc/testdata/baselines/reference/compiler/malformedDestructuringAssignmentTransformVariants(experimentaldecorators=true,target=es2015).errors.txt b/tsc/testdata/baselines/reference/compiler/malformedDestructuringAssignmentTransformVariants(experimentaldecorators=true,target=es2015).errors.txt index eef60bbd5ed70..3cb0cbebf0544 100644 --- a/tsc/testdata/baselines/reference/compiler/malformedDestructuringAssignmentTransformVariants(experimentaldecorators=true,target=es2015).errors.txt +++ b/tsc/testdata/baselines/reference/compiler/malformedDestructuringAssignmentTransformVariants(experimentaldecorators=true,target=es2015).errors.txt @@ -6,11 +6,13 @@ malformedDestructuringAssignmentTransformVariants.ts(17,19): error TS2364: The l malformedDestructuringAssignmentTransformVariants.ts(21,24): error TS1136: Property assignment expected. malformedDestructuringAssignmentTransformVariants.ts(22,28): error TS1136: Property assignment expected. malformedDestructuringAssignmentTransformVariants.ts(23,28): error TS1136: Property assignment expected. +malformedDestructuringAssignmentTransformVariants.ts(23,28): error TS7032: Property 's' implicitly has type 'any', because its set accessor lacks a parameter type annotation. +malformedDestructuringAssignmentTransformVariants.ts(23,30): error TS7006: Parameter 'v' implicitly has an 'any' type. malformedDestructuringAssignmentTransformVariants.ts(24,25): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. malformedDestructuringAssignmentTransformVariants.ts(24,38): error TS1136: Property assignment expected. -==== malformedDestructuringAssignmentTransformVariants.ts (10 errors) ==== +==== malformedDestructuringAssignmentTransformVariants.ts (12 errors) ==== declare function dec(...args: any[]): any; declare const value: any; @@ -50,6 +52,10 @@ malformedDestructuringAssignmentTransformVariants.ts(24,38): error TS1136: Prope ({ x: super.x, set s(v) {}, private: this.#x } = value); ~ !!! error TS1136: Property assignment expected. + ~ +!!! error TS7032: Property 's' implicitly has type 'any', because its set accessor lacks a parameter type annotation. + ~ +!!! error TS7006: Parameter 'v' implicitly has an 'any' type. ({ x: [super.x, 0, this.#x], m() {} } = value); ~ !!! error TS2364: The left-hand side of an assignment expression must be a variable or a property access. diff --git a/tsc/testdata/baselines/reference/compiler/malformedDestructuringAssignmentTransformVariants(experimentaldecorators=true,target=es2022).errors.txt b/tsc/testdata/baselines/reference/compiler/malformedDestructuringAssignmentTransformVariants(experimentaldecorators=true,target=es2022).errors.txt index eef60bbd5ed70..3cb0cbebf0544 100644 --- a/tsc/testdata/baselines/reference/compiler/malformedDestructuringAssignmentTransformVariants(experimentaldecorators=true,target=es2022).errors.txt +++ b/tsc/testdata/baselines/reference/compiler/malformedDestructuringAssignmentTransformVariants(experimentaldecorators=true,target=es2022).errors.txt @@ -6,11 +6,13 @@ malformedDestructuringAssignmentTransformVariants.ts(17,19): error TS2364: The l malformedDestructuringAssignmentTransformVariants.ts(21,24): error TS1136: Property assignment expected. malformedDestructuringAssignmentTransformVariants.ts(22,28): error TS1136: Property assignment expected. malformedDestructuringAssignmentTransformVariants.ts(23,28): error TS1136: Property assignment expected. +malformedDestructuringAssignmentTransformVariants.ts(23,28): error TS7032: Property 's' implicitly has type 'any', because its set accessor lacks a parameter type annotation. +malformedDestructuringAssignmentTransformVariants.ts(23,30): error TS7006: Parameter 'v' implicitly has an 'any' type. malformedDestructuringAssignmentTransformVariants.ts(24,25): error TS2364: The left-hand side of an assignment expression must be a variable or a property access. malformedDestructuringAssignmentTransformVariants.ts(24,38): error TS1136: Property assignment expected. -==== malformedDestructuringAssignmentTransformVariants.ts (10 errors) ==== +==== malformedDestructuringAssignmentTransformVariants.ts (12 errors) ==== declare function dec(...args: any[]): any; declare const value: any; @@ -50,6 +52,10 @@ malformedDestructuringAssignmentTransformVariants.ts(24,38): error TS1136: Prope ({ x: super.x, set s(v) {}, private: this.#x } = value); ~ !!! error TS1136: Property assignment expected. + ~ +!!! error TS7032: Property 's' implicitly has type 'any', because its set accessor lacks a parameter type annotation. + ~ +!!! error TS7006: Parameter 'v' implicitly has an 'any' type. ({ x: [super.x, 0, this.#x], m() {} } = value); ~ !!! error TS2364: The left-hand side of an assignment expression must be a variable or a property access. diff --git a/tsc/testdata/baselines/reference/compiler/malformedObjectDestructuringAssignmentClassFields.errors.txt b/tsc/testdata/baselines/reference/compiler/malformedObjectDestructuringAssignmentClassFields.errors.txt index 87e4aba639e60..c355d51097e83 100644 --- a/tsc/testdata/baselines/reference/compiler/malformedObjectDestructuringAssignmentClassFields.errors.txt +++ b/tsc/testdata/baselines/reference/compiler/malformedObjectDestructuringAssignmentClassFields.errors.txt @@ -1,14 +1,17 @@ malformedObjectDestructuringAssignmentClassFields.ts(1,3): error TS1136: Property assignment expected. +malformedObjectDestructuringAssignmentClassFields.ts(1,5): error TS7006: Parameter 'A' implicitly has an 'any' type. malformedObjectDestructuringAssignmentClassFields.ts(1,6): error TS1005: ',' expected. malformedObjectDestructuringAssignmentClassFields.ts(1,7): error TS1127: Invalid character. malformedObjectDestructuringAssignmentClassFields.ts(1,10): error TS1109: Expression expected. malformedObjectDestructuringAssignmentClassFields.ts(2,1): error TS1005: ')' expected. -==== malformedObjectDestructuringAssignmentClassFields.ts (5 errors) ==== +==== malformedObjectDestructuringAssignmentClassFields.ts (6 errors) ==== ({x(A.#}= ~ !!! error TS1136: Property assignment expected. + ~ +!!! error TS7006: Parameter 'A' implicitly has an 'any' type. ~ !!! error TS1005: ',' expected. ~ diff --git a/tsc/testdata/baselines/reference/compiler/malformedObjectDestructuringAssignmentESDecorators.errors.txt b/tsc/testdata/baselines/reference/compiler/malformedObjectDestructuringAssignmentESDecorators.errors.txt index e398726486b0a..a8cd58532857e 100644 --- a/tsc/testdata/baselines/reference/compiler/malformedObjectDestructuringAssignmentESDecorators.errors.txt +++ b/tsc/testdata/baselines/reference/compiler/malformedObjectDestructuringAssignmentESDecorators.errors.txt @@ -1,9 +1,11 @@ malformedObjectDestructuringAssignmentESDecorators.ts(6,12): error TS1136: Property assignment expected. malformedObjectDestructuringAssignmentESDecorators.ts(6,24): error TS1136: Property assignment expected. malformedObjectDestructuringAssignmentESDecorators.ts(6,47): error TS1136: Property assignment expected. +malformedObjectDestructuringAssignmentESDecorators.ts(6,47): error TS7032: Property 's' implicitly has type 'any', because its set accessor lacks a parameter type annotation. +malformedObjectDestructuringAssignmentESDecorators.ts(6,49): error TS7006: Parameter 'v' implicitly has an 'any' type. -==== malformedObjectDestructuringAssignmentESDecorators.ts (3 errors) ==== +==== malformedObjectDestructuringAssignmentESDecorators.ts (5 errors) ==== declare function dec(...args: any[]): any; @dec @@ -16,6 +18,10 @@ malformedObjectDestructuringAssignmentESDecorators.ts(6,47): error TS1136: Prope !!! error TS1136: Property assignment expected. ~ !!! error TS1136: Property assignment expected. + ~ +!!! error TS7032: Property 's' implicitly has type 'any', because its set accessor lacks a parameter type annotation. + ~ +!!! error TS7006: Parameter 'v' implicitly has an 'any' type. } } \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/unusedLocalsReferencedInCycleDuringCheck.symbols b/tsc/testdata/baselines/reference/compiler/unusedLocalsReferencedInCycleDuringCheck.symbols new file mode 100644 index 0000000000000..7920b1fa322d0 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/unusedLocalsReferencedInCycleDuringCheck.symbols @@ -0,0 +1,74 @@ +//// [tests/cases/compiler/unusedLocalsReferencedInCycleDuringCheck.ts] //// + +=== unusedLocalsReferencedInCycleDuringCheck.ts === +// Checking the call resolves it within a cycle of flow analysis, during which +// what checking computes is recorded, yet its references are still uses. + +declare const assert: { deepStrictEqual(actual: unknown, expected: T): asserts actual is T }; +>assert : Symbol(assert, Decl(unusedLocalsReferencedInCycleDuringCheck.ts, 3, 13)) +>deepStrictEqual : Symbol(deepStrictEqual, Decl(unusedLocalsReferencedInCycleDuringCheck.ts, 3, 23)) +>T : Symbol(T, Decl(unusedLocalsReferencedInCycleDuringCheck.ts, 3, 40)) +>actual : Symbol(actual, Decl(unusedLocalsReferencedInCycleDuringCheck.ts, 3, 43)) +>expected : Symbol(expected, Decl(unusedLocalsReferencedInCycleDuringCheck.ts, 3, 59)) +>T : Symbol(T, Decl(unusedLocalsReferencedInCycleDuringCheck.ts, 3, 40)) +>actual : Symbol(actual, Decl(unusedLocalsReferencedInCycleDuringCheck.ts, 3, 43)) +>T : Symbol(T, Decl(unusedLocalsReferencedInCycleDuringCheck.ts, 3, 40)) + +declare function make(): { width: number }; +>make : Symbol(make, Decl(unusedLocalsReferencedInCycleDuringCheck.ts, 3, 96)) +>width : Symbol(width, Decl(unusedLocalsReferencedInCycleDuringCheck.ts, 4, 26)) + +export function test() { +>test : Symbol(test, Decl(unusedLocalsReferencedInCycleDuringCheck.ts, 4, 43)) + + const first = make(); +>first : Symbol(first, Decl(unusedLocalsReferencedInCycleDuringCheck.ts, 6, 6)) +>make : Symbol(make, Decl(unusedLocalsReferencedInCycleDuringCheck.ts, 3, 96)) + + let baseline: number[][] | undefined; +>baseline : Symbol(baseline, Decl(unusedLocalsReferencedInCycleDuringCheck.ts, 7, 4)) + + const geometry = () => [first].map(e => [e.width]); +>geometry : Symbol(geometry, Decl(unusedLocalsReferencedInCycleDuringCheck.ts, 8, 6)) +>[first].map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --)) +>first : Symbol(first, Decl(unusedLocalsReferencedInCycleDuringCheck.ts, 6, 6)) +>map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --)) +>e : Symbol(e, Decl(unusedLocalsReferencedInCycleDuringCheck.ts, 8, 36)) +>e.width : Symbol(width, Decl(unusedLocalsReferencedInCycleDuringCheck.ts, 4, 26)) +>e : Symbol(e, Decl(unusedLocalsReferencedInCycleDuringCheck.ts, 8, 36)) +>width : Symbol(width, Decl(unusedLocalsReferencedInCycleDuringCheck.ts, 4, 26)) + + for (const themeType of ['a', 'b']) { +>themeType : Symbol(themeType, Decl(unusedLocalsReferencedInCycleDuringCheck.ts, 9, 11)) + + baseline ??= geometry(); +>baseline : Symbol(baseline, Decl(unusedLocalsReferencedInCycleDuringCheck.ts, 7, 4)) +>geometry : Symbol(geometry, Decl(unusedLocalsReferencedInCycleDuringCheck.ts, 8, 6)) + + for (const active of [true, false]) { +>active : Symbol(active, Decl(unusedLocalsReferencedInCycleDuringCheck.ts, 11, 12)) + + const border = active ? themeType : 'x'; +>border : Symbol(border, Decl(unusedLocalsReferencedInCycleDuringCheck.ts, 12, 8)) +>active : Symbol(active, Decl(unusedLocalsReferencedInCycleDuringCheck.ts, 11, 12)) +>themeType : Symbol(themeType, Decl(unusedLocalsReferencedInCycleDuringCheck.ts, 9, 11)) + + assert.deepStrictEqual({ geometry: geometry(), w: first.width, border }, { geometry: baseline, w: 0, border: '' }); +>assert.deepStrictEqual : Symbol(deepStrictEqual, Decl(unusedLocalsReferencedInCycleDuringCheck.ts, 3, 23)) +>assert : Symbol(assert, Decl(unusedLocalsReferencedInCycleDuringCheck.ts, 3, 13)) +>deepStrictEqual : Symbol(deepStrictEqual, Decl(unusedLocalsReferencedInCycleDuringCheck.ts, 3, 23)) +>geometry : Symbol(geometry, Decl(unusedLocalsReferencedInCycleDuringCheck.ts, 13, 27)) +>geometry : Symbol(geometry, Decl(unusedLocalsReferencedInCycleDuringCheck.ts, 8, 6)) +>w : Symbol(w, Decl(unusedLocalsReferencedInCycleDuringCheck.ts, 13, 49)) +>first.width : Symbol(width, Decl(unusedLocalsReferencedInCycleDuringCheck.ts, 4, 26)) +>first : Symbol(first, Decl(unusedLocalsReferencedInCycleDuringCheck.ts, 6, 6)) +>width : Symbol(width, Decl(unusedLocalsReferencedInCycleDuringCheck.ts, 4, 26)) +>border : Symbol(border, Decl(unusedLocalsReferencedInCycleDuringCheck.ts, 13, 65)) +>geometry : Symbol(geometry, Decl(unusedLocalsReferencedInCycleDuringCheck.ts, 13, 77)) +>baseline : Symbol(baseline, Decl(unusedLocalsReferencedInCycleDuringCheck.ts, 7, 4)) +>w : Symbol(w, Decl(unusedLocalsReferencedInCycleDuringCheck.ts, 13, 97)) +>border : Symbol(border, Decl(unusedLocalsReferencedInCycleDuringCheck.ts, 13, 103)) + } + } +} + diff --git a/tsc/testdata/baselines/reference/compiler/unusedLocalsReferencedInCycleDuringCheck.types b/tsc/testdata/baselines/reference/compiler/unusedLocalsReferencedInCycleDuringCheck.types new file mode 100644 index 0000000000000..c2b73c9bc9146 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/unusedLocalsReferencedInCycleDuringCheck.types @@ -0,0 +1,92 @@ +//// [tests/cases/compiler/unusedLocalsReferencedInCycleDuringCheck.ts] //// + +=== unusedLocalsReferencedInCycleDuringCheck.ts === +// Checking the call resolves it within a cycle of flow analysis, during which +// what checking computes is recorded, yet its references are still uses. + +declare const assert: { deepStrictEqual(actual: unknown, expected: T): asserts actual is T }; +>assert : { deepStrictEqual(actual: unknown, expected: T): asserts actual is T; } +>deepStrictEqual : (actual: unknown, expected: T) => asserts actual is T +>actual : unknown +>expected : T + +declare function make(): { width: number }; +>make : () => { width: number; } +>width : number + +export function test() { +>test : () => void + + const first = make(); +>first : { width: number; } +>make() : { width: number; } +>make : () => { width: number; } + + let baseline: number[][] | undefined; +>baseline : number[][] | undefined + + const geometry = () => [first].map(e => [e.width]); +>geometry : () => number[][] +>() => [first].map(e => [e.width]) : () => number[][] +>[first].map(e => [e.width]) : number[][] +>[first].map : (callbackfn: (value: { width: number; }, index: number, array: { width: number; }[]) => U, thisArg?: any) => U[] +>[first] : { width: number; }[] +>first : { width: number; } +>map : (callbackfn: (value: { width: number; }, index: number, array: { width: number; }[]) => U, thisArg?: any) => U[] +>e => [e.width] : (e: { width: number; }) => number[] +>e : { width: number; } +>[e.width] : number[] +>e.width : number +>e : { width: number; } +>width : number + + for (const themeType of ['a', 'b']) { +>themeType : string +>['a', 'b'] : string[] +>'a' : "a" +>'b' : "b" + + baseline ??= geometry(); +>baseline ??= geometry() : number[][] +>baseline : number[][] | undefined +>geometry() : number[][] +>geometry : () => number[][] + + for (const active of [true, false]) { +>active : boolean +>[true, false] : boolean[] +>true : true +>false : false + + const border = active ? themeType : 'x'; +>border : string +>active ? themeType : 'x' : string +>active : boolean +>themeType : string +>'x' : "x" + + assert.deepStrictEqual({ geometry: geometry(), w: first.width, border }, { geometry: baseline, w: 0, border: '' }); +>assert.deepStrictEqual({ geometry: geometry(), w: first.width, border }, { geometry: baseline, w: 0, border: '' }) : void +>assert.deepStrictEqual : (actual: unknown, expected: T) => asserts actual is T +>assert : { deepStrictEqual(actual: unknown, expected: T): asserts actual is T; } +>deepStrictEqual : (actual: unknown, expected: T) => asserts actual is T +>{ geometry: geometry(), w: first.width, border } : { geometry: number[][]; w: number; border: string; } +>geometry : number[][] +>geometry() : number[][] +>geometry : () => number[][] +>w : number +>first.width : number +>first : { width: number; } +>width : number +>border : string +>{ geometry: baseline, w: 0, border: '' } : { geometry: number[][]; w: number; border: string; } +>geometry : number[][] +>baseline : number[][] +>w : number +>0 : 0 +>border : string +>'' : "" + } + } +} + diff --git a/tsc/testdata/baselines/reference/compiler/useBeforeDeclaration_classDecorators.2(experimentaldecorators=false).errors.txt b/tsc/testdata/baselines/reference/compiler/useBeforeDeclaration_classDecorators.2(experimentaldecorators=false).errors.txt index 38d1631f0deab..3ccd49b9642ed 100644 --- a/tsc/testdata/baselines/reference/compiler/useBeforeDeclaration_classDecorators.2(experimentaldecorators=false).errors.txt +++ b/tsc/testdata/baselines/reference/compiler/useBeforeDeclaration_classDecorators.2(experimentaldecorators=false).errors.txt @@ -14,8 +14,11 @@ useBeforeDeclaration_classDecorators.2.ts(41,10): error TS2449: Class 'C5' used useBeforeDeclaration_classDecorators.2.ts(42,10): error TS2449: Class 'C5' used before its declaration. useBeforeDeclaration_classDecorators.2.ts(43,10): error TS2449: Class 'C5' used before its declaration. useBeforeDeclaration_classDecorators.2.ts(46,17): error TS1206: Decorators are not valid here. +useBeforeDeclaration_classDecorators.2.ts(46,22): error TS2449: Class 'C5' used before its declaration. useBeforeDeclaration_classDecorators.2.ts(47,20): error TS1206: Decorators are not valid here. +useBeforeDeclaration_classDecorators.2.ts(47,25): error TS2449: Class 'C5' used before its declaration. useBeforeDeclaration_classDecorators.2.ts(48,13): error TS1206: Decorators are not valid here. +useBeforeDeclaration_classDecorators.2.ts(48,18): error TS2449: Class 'C5' used before its declaration. useBeforeDeclaration_classDecorators.2.ts(53,17): error TS2449: Class 'C6' used before its declaration. useBeforeDeclaration_classDecorators.2.ts(54,17): error TS2449: Class 'C6' used before its declaration. useBeforeDeclaration_classDecorators.2.ts(55,17): error TS2449: Class 'C6' used before its declaration. @@ -27,11 +30,14 @@ useBeforeDeclaration_classDecorators.2.ts(61,17): error TS2449: Class 'C6' used useBeforeDeclaration_classDecorators.2.ts(62,17): error TS2449: Class 'C6' used before its declaration. useBeforeDeclaration_classDecorators.2.ts(63,17): error TS2449: Class 'C6' used before its declaration. useBeforeDeclaration_classDecorators.2.ts(66,17): error TS1206: Decorators are not valid here. +useBeforeDeclaration_classDecorators.2.ts(66,29): error TS2449: Class 'C6' used before its declaration. useBeforeDeclaration_classDecorators.2.ts(67,20): error TS1206: Decorators are not valid here. +useBeforeDeclaration_classDecorators.2.ts(67,32): error TS2449: Class 'C6' used before its declaration. useBeforeDeclaration_classDecorators.2.ts(68,13): error TS1206: Decorators are not valid here. +useBeforeDeclaration_classDecorators.2.ts(68,25): error TS2449: Class 'C6' used before its declaration. -==== useBeforeDeclaration_classDecorators.2.ts (31 errors) ==== +==== useBeforeDeclaration_classDecorators.2.ts (37 errors) ==== declare const dec: any; // ok @@ -122,12 +128,21 @@ useBeforeDeclaration_classDecorators.2.ts(68,13): error TS1206: Decorators are n constructor(@dec(C5) a: any) {} ~ !!! error TS1206: Decorators are not valid here. + ~~ +!!! error TS2449: Class 'C5' used before its declaration. +!!! related TS2728 useBeforeDeclaration_classDecorators.2.ts:32:7: 'C5' is declared here. static method2(@dec(C5) a: any) {} ~ !!! error TS1206: Decorators are not valid here. + ~~ +!!! error TS2449: Class 'C5' used before its declaration. +!!! related TS2728 useBeforeDeclaration_classDecorators.2.ts:32:7: 'C5' is declared here. method2(@dec(C5) a: any) {} ~ !!! error TS1206: Decorators are not valid here. + ~~ +!!! error TS2449: Class 'C5' used before its declaration. +!!! related TS2728 useBeforeDeclaration_classDecorators.2.ts:32:7: 'C5' is declared here. } // error @@ -178,11 +193,20 @@ useBeforeDeclaration_classDecorators.2.ts(68,13): error TS1206: Decorators are n constructor(@dec((() => C6)()) a: any) {} ~ !!! error TS1206: Decorators are not valid here. + ~~ +!!! error TS2449: Class 'C6' used before its declaration. +!!! related TS2728 useBeforeDeclaration_classDecorators.2.ts:52:7: 'C6' is declared here. static method2(@dec((() => C6)()) a: any) {} ~ !!! error TS1206: Decorators are not valid here. + ~~ +!!! error TS2449: Class 'C6' used before its declaration. +!!! related TS2728 useBeforeDeclaration_classDecorators.2.ts:52:7: 'C6' is declared here. method2(@dec((() => C6)()) a: any) {} ~ !!! error TS1206: Decorators are not valid here. + ~~ +!!! error TS2449: Class 'C6' used before its declaration. +!!! related TS2728 useBeforeDeclaration_classDecorators.2.ts:52:7: 'C6' is declared here. } \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/conformance/parser519458.errors.txt b/tsc/testdata/baselines/reference/conformance/parser519458.errors.txt index 4534e059f31e9..18f6e68c68b55 100644 --- a/tsc/testdata/baselines/reference/conformance/parser519458.errors.txt +++ b/tsc/testdata/baselines/reference/conformance/parser519458.errors.txt @@ -1,14 +1,11 @@ parser519458.ts(1,15): error TS2503: Cannot find namespace 'module'. -parser519458.ts(1,15): error TS2591: Cannot find name 'module'. Do you need to install type definitions for node? Try `npm i --save-dev @types/node` and then add 'node' to the types field in your tsconfig. parser519458.ts(1,21): error TS1005: ';' expected. -==== parser519458.ts (3 errors) ==== +==== parser519458.ts (2 errors) ==== import rect = module("rect"); var bar = new rect.Rect(); ~~~~~~ !!! error TS2503: Cannot find namespace 'module'. - ~~~~~~ -!!! error TS2591: Cannot find name 'module'. Do you need to install type definitions for node? Try `npm i --save-dev @types/node` and then add 'node' to the types field in your tsconfig. ~ !!! error TS1005: ';' expected. \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/conformance/thisTypeInFunctionsNegative.errors.txt b/tsc/testdata/baselines/reference/conformance/thisTypeInFunctionsNegative.errors.txt index c0edb81a0dde9..f3f7dedc9700c 100644 --- a/tsc/testdata/baselines/reference/conformance/thisTypeInFunctionsNegative.errors.txt +++ b/tsc/testdata/baselines/reference/conformance/thisTypeInFunctionsNegative.errors.txt @@ -79,6 +79,7 @@ thisTypeInFunctionsNegative.ts(169,23): error TS1359: Identifier expected. 'this thisTypeInFunctionsNegative.ts(169,23): error TS2680: A 'this' parameter must be the first parameter. thisTypeInFunctionsNegative.ts(170,23): error TS1005: ',' expected. thisTypeInFunctionsNegative.ts(171,20): error TS1433: Neither decorators nor modifiers may be applied to 'this' parameters. +thisTypeInFunctionsNegative.ts(171,21): error TS2304: Cannot find name 'deco'. thisTypeInFunctionsNegative.ts(172,30): error TS1005: ',' expected. thisTypeInFunctionsNegative.ts(172,32): error TS1359: Identifier expected. 'new' is a reserved word that cannot be used here. thisTypeInFunctionsNegative.ts(172,37): error TS1005: ',' expected. @@ -93,7 +94,7 @@ thisTypeInFunctionsNegative.ts(177,19): error TS2730: An arrow function cannot h thisTypeInFunctionsNegative.ts(178,22): error TS2730: An arrow function cannot have a 'this' parameter. -==== thisTypeInFunctionsNegative.ts (63 errors) ==== +==== thisTypeInFunctionsNegative.ts (64 errors) ==== class C { n: number; explicitThis(this: this, m: number): number { @@ -407,6 +408,8 @@ thisTypeInFunctionsNegative.ts(178,22): error TS2730: An arrow function cannot h function decorated(@deco() this: C): number { return this.n; } ~~~~~~~ !!! error TS1433: Neither decorators nor modifiers may be applied to 'this' parameters. + ~~~~ +!!! error TS2304: Cannot find name 'deco'. function initializer(this: C = new C()): number { return this.n; } ~ !!! error TS1005: ',' expected. diff --git a/tsc/testdata/tests/cases/compiler/unusedLocalsReferencedInCycleDuringCheck.ts b/tsc/testdata/tests/cases/compiler/unusedLocalsReferencedInCycleDuringCheck.ts new file mode 100644 index 0000000000000..c946a4bdadd7b --- /dev/null +++ b/tsc/testdata/tests/cases/compiler/unusedLocalsReferencedInCycleDuringCheck.ts @@ -0,0 +1,22 @@ +// @strict: true +// @noUnusedLocals: true +// @target: es2022 +// @noEmit: true + +// Checking the call resolves it within a cycle of flow analysis, during which +// what checking computes is recorded, yet its references are still uses. + +declare const assert: { deepStrictEqual(actual: unknown, expected: T): asserts actual is T }; +declare function make(): { width: number }; +export function test() { + const first = make(); + let baseline: number[][] | undefined; + const geometry = () => [first].map(e => [e.width]); + for (const themeType of ['a', 'b']) { + baseline ??= geometry(); + for (const active of [true, false]) { + const border = active ? themeType : 'x'; + assert.deepStrictEqual({ geometry: geometry(), w: first.width, border }, { geometry: baseline, w: 0, border: '' }); + } + } +} From 5f613a101838c74e970ccaa081f403fa9940bcb2 Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Sat, 7 Nov 2026 10:22:03 -0800 Subject: [PATCH 47/60] Clear a call's resolving marker when discarding its preemptive result When no overload applies, call resolution caches its result before reporting errors, so that a circular request for the call while they are reported finds it. Discarding that result in a cycle restored the marker put in place when resolution began, leaving the call marked as being resolved. Caching it like the final result clears the marker instead. --- tsc/internal/checker/checker.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tsc/internal/checker/checker.go b/tsc/internal/checker/checker.go index 164010d9c8355..46d379c5d7ec9 100644 --- a/tsc/internal/checker/checker.go +++ b/tsc/internal/checker/checker.go @@ -9619,7 +9619,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.set(c, result) + c.setResolvedSignature(c.signatureLinks.Get(node), result) // No signatures were applicable. Now report errors based on the last applicable signature with // no arguments excluded from assignability checks. // If candidate is undefined, it means that no candidates had a suitable arity. In that case, From 17246a560640200daa7f04d9d71ce5d5eaa2f501 Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Sat, 7 Nov 2026 10:22:03 -0800 Subject: [PATCH 48/60] Discard results cached by signature help Signature help resolves a call from the arguments typed so far, without reporting errors, and string literal completions resolve it with inference from the argument being typed blocked. The results those requests cache depend on that state, which is not part of their keys, so checking that reuses them could infer other types or miss errors. Nothing such a request caches is kept: it runs in a cycle headed below every computation, which ends with the request. The state of such a request, the number of arguments typed so far and the nodes inference is blocked from, is held in a request that exists only while it runs, rather than in fields of the checker that any computation could read. --- tsc/internal/checker/checker.go | 10 +-- tsc/internal/checker/inference.go | 2 +- tsc/internal/checker/services.go | 83 ++++++++++++------- ...ryOrder(checkorder=editorfirst).errors.txt | 16 ++++ ...ceQueryOrder(checkorder=editorfirst).types | 4 +- 5 files changed, 78 insertions(+), 37 deletions(-) create mode 100644 tsc/testdata/baselines/reference/compiler/signatureHelpInferenceQueryOrder(checkorder=editorfirst).errors.txt diff --git a/tsc/internal/checker/checker.go b/tsc/internal/checker/checker.go index 46d379c5d7ec9..427a109666bad 100644 --- a/tsc/internal/checker/checker.go +++ b/tsc/internal/checker/checker.go @@ -659,7 +659,6 @@ type Checker struct { // members of one parent are often looked up together. lastLateBindableParent *ast.Symbol lastLateBindableKinds uint8 - isInferencePartiallyBlocked bool wasCanceled bool evaluate evaluator.Evaluator resolveName func(location *ast.Node, name string, meaning ast.SymbolFlags, nameNotFoundMessage *diagnostics.Message, isUse bool, excludeGlobals bool) *ast.Symbol @@ -723,7 +722,7 @@ type Checker struct { resumeBuf []int deferredAttach []deferredAttachment // See attachState recordingFromCheck bool // A query begun in a check is in progress; see recordFromCheck - apparentArgumentCount *int + request *editorRequest // The editor request being answered, if any; see runEditorRequest lastGetCombinedNodeFlagsNode *ast.Node lastGetCombinedNodeFlagsResult ast.NodeFlags lastGetCombinedModifierFlagsNode *ast.Node @@ -809,7 +808,6 @@ type Checker struct { isStringIndexSignatureOnlyType func(*Type) bool markNodeAssignments func(*ast.Node) bool compareTypesAssignable TypeComparer - skipDirectInferenceNodes collections.Set[*ast.Node] ctx context.Context activeMappers []*TypeMapper activeTypeMappersCaches []clearableMap[activeMapperCacheEntry] @@ -9521,7 +9519,7 @@ func (c *Checker) resolveCall(node *ast.Node, signatures []*Signature, candidate isDecorator := node.Kind == ast.KindDecorator isJsxOpeningOrSelfClosingElement := ast.IsJsxOpeningLikeElement(node) isInstanceof := node.Kind == ast.KindBinaryExpression - reportErrors := !c.isInferencePartiallyBlocked && candidatesOutArray == nil + reportErrors := (c.request == nil || !c.request.inferencePartiallyBlocked) && candidatesOutArray == nil var s CallState s.node = node if !isDecorator && !isInstanceof && !isSuperCall(node) && !ast.IsJsxOpeningFragment(node) { @@ -10204,8 +10202,8 @@ func (c *Checker) pickLongestCandidateSignature(node *ast.Node, candidates []*Si // declare function f(k: keyof T); // f(" argCount := len(args) - if c.apparentArgumentCount != nil { - argCount = *c.apparentArgumentCount + if c.request != nil && c.request.argumentCount != nil { + argCount = *c.request.argumentCount } bestIndex := c.getLongestCandidateIndex(candidates, argCount) candidate := candidates[bestIndex] diff --git a/tsc/internal/checker/inference.go b/tsc/internal/checker/inference.go index 0dfcaa5a849d6..2784d8bafc219 100644 --- a/tsc/internal/checker/inference.go +++ b/tsc/internal/checker/inference.go @@ -1648,7 +1648,7 @@ func (c *Checker) isFromInferenceBlockedSource(t *Type) bool { } func (c *Checker) isSkipDirectInferenceNode(node *ast.Node) bool { - return c.skipDirectInferenceNodes.Has(node) + return c.request != nil && c.request.skipDirectInferenceNodes.Has(node) } func newInferenceInfo(typeParameter *Type) *InferenceInfo { diff --git a/tsc/internal/checker/services.go b/tsc/internal/checker/services.go index 8d45e1292699c..9bca7bb9dc200 100644 --- a/tsc/internal/checker/services.go +++ b/tsc/internal/checker/services.go @@ -322,30 +322,37 @@ func (c *Checker) shouldTreatPropertiesOfExternalModuleAsExports(resolvedExterna func (c *Checker) GetContextualType(node *ast.Expression, contextFlags ContextFlags) *Type { if contextFlags&ContextFlagsIgnoreNodeInferences != 0 { - return c.runWithInferenceBlockedFromSourceNode(node, func() *Type { return c.getContextualType(node, contextFlags) }) + return runEditorRequest(c, node, c.inferenceBlockedFrom(node), func() *Type { return c.getContextualType(node, contextFlags) }) } return c.getContextualType(node, contextFlags) } -func (c *Checker) runWithInferenceBlockedFromSourceNode[T any](node *ast.Node, fn func() T) T { - containingCall := ast.FindAncestor(node, ast.IsCallLikeExpression) - if containingCall != nil { - toMarkSkip := node - for { - c.skipDirectInferenceNodes.Add(toMarkSkip) - toMarkSkip = toMarkSkip.Parent - if toMarkSkip == nil || toMarkSkip == containingCall { +// An editorRequest is state of an editor request that what the checker +// computes for it depends on, but is not cached under, such as the number of +// arguments typed so far. It exists only while runEditorRequest runs the +// request, discarding whatever the request caches. +type editorRequest struct { + argumentCount *int // The number of arguments to resolve a call with, if not those it has + // Inference from these nodes, the one being edited and its ancestors up + // to the call, is skipped, and call resolution reports no errors. + skipDirectInferenceNodes collections.Set[*ast.Node] + inferencePartiallyBlocked bool +} + +// inferenceBlockedFrom returns a request that blocks inference from node, an +// argument being edited, and its ancestors up to the call. +func (c *Checker) inferenceBlockedFrom(node *ast.Node) *editorRequest { + request := &editorRequest{inferencePartiallyBlocked: true} + if containingCall := ast.FindAncestor(node, ast.IsCallLikeExpression); containingCall != nil { + for n := node; ; { + request.skipDirectInferenceNodes.Add(n) + n = n.Parent + if n == nil || n == containingCall { break } } } - - c.isInferencePartiallyBlocked = true - result := c.runWithoutResolvedSignatureCaching(node, fn) - c.isInferencePartiallyBlocked = false - - c.skipDirectInferenceNodes.Clear() - return result + return request } func GetResolvedSignatureForSignatureHelp(node *ast.Node, argumentCount int, c *Checker) (*Signature, []*Signature) { @@ -353,14 +360,17 @@ func GetResolvedSignatureForSignatureHelp(node *ast.Node, argumentCount int, c * signature *Signature candidates []*Signature } - res := c.runWithoutResolvedSignatureCaching(node, func() result { - signature, candidates := c.getResolvedSignatureWorker(node, CheckModeIsForSignatureHelp, argumentCount) + res := runEditorRequest(c, node, &editorRequest{argumentCount: &argumentCount}, func() result { + signature, candidates := c.getResolvedSignatureWithCandidates(node, CheckModeIsForSignatureHelp) return result{signature, candidates} }) return res.signature, res.candidates } -func (c *Checker) runWithoutResolvedSignatureCaching[T any](node *ast.Node, fn func() T) T { +// runEditorRequest runs fn, which answers an editor request at node in the +// state of request. The calls and functions enclosing node are resolved +// again in that state, and whatever fn caches is discarded once it returns. +func runEditorRequest[T any](c *Checker, node *ast.Node, request *editorRequest, fn func() T) T { ancestorNode := ast.FindAncestor(node, ast.IsCallLikeOrFunctionLikeExpression) if ancestorNode != nil { cachedResolvedSignatures := make(map[*SignatureLinks]*Signature) @@ -374,7 +384,7 @@ func (c *Checker) runWithoutResolvedSignatureCaching[T any](node *ast.Node, fn f } ancestorNode = ast.FindAncestor(ancestorNode.Parent, ast.IsCallLikeOrFunctionLikeExpression) } - result := fn() + result := runDiscardingCaches(c, request, fn) for signatureLinks, resolvedSignature := range cachedResolvedSignatures { signatureLinks.resolvedSignature.swap(resolvedSignature) } @@ -383,7 +393,23 @@ func (c *Checker) runWithoutResolvedSignatureCaching[T any](node *ast.Node, fn f } return result } - return fn() + return runDiscardingCaches(c, request, fn) +} + +// runDiscardingCaches runs fn in the state of request, and discards whatever +// it caches: it all happens in a cycle headed below every computation, which +// ends with the request. +func runDiscardingCaches[T any](c *Checker, request *editorRequest, fn func() T) T { + debug.Assert(len(c.resolutions) == 1 && c.circularityStart == 0 && c.request == nil, "editor request inside a computation") + c.markCircular(0) + c.request = request + result := fn() + c.request = nil + // Not even the results of the participants of cycles inside the request + // are kept. + c.cycleParticipants = nil + c.endCyclesAt(0) + return result } func (c *Checker) SkipAlias(symbol *ast.Symbol) *ast.Symbol { @@ -837,28 +863,29 @@ func (c *Checker) GetConstantValue(node *ast.Node) any { return nil } -func (c *Checker) getResolvedSignatureWorker(node *ast.Node, checkMode CheckMode, argumentCount int) (*Signature, []*Signature) { - c.apparentArgumentCount = &argumentCount +func (c *Checker) getResolvedSignatureWithCandidates(node *ast.Node, checkMode CheckMode) (*Signature, []*Signature) { candidatesOutArray := &[]*Signature{} var res *Signature if node != nil && ast.IsParseTreeNode(node) { res = c.getResolvedSignature(node, candidatesOutArray, checkMode) } - c.apparentArgumentCount = nil return res, *candidatesOutArray } func (c *Checker) GetCandidateSignaturesForStringLiteralCompletions(call *ast.CallLikeExpression, editingArgument *ast.Node) []*Signature { // first, get candidates when inference is blocked from the source node. - candidates := c.runWithInferenceBlockedFromSourceNode(editingArgument, func() []*Signature { - _, blockedInferenceCandidates := c.getResolvedSignatureWorker(call, CheckModeNormal, 0) + noArguments := 0 + blocked := c.inferenceBlockedFrom(editingArgument) + blocked.argumentCount = &noArguments + candidates := runEditorRequest(c, editingArgument, blocked, func() []*Signature { + _, blockedInferenceCandidates := c.getResolvedSignatureWithCandidates(call, CheckModeNormal) return blockedInferenceCandidates }) candidatesSet := collections.NewSetFromItems(candidates...) // next, get candidates where the source node is considered for inference. - otherCandidates := c.runWithoutResolvedSignatureCaching(editingArgument, func() []*Signature { - _, inferenceCandidates := c.getResolvedSignatureWorker(call, CheckModeNormal, 0) + otherCandidates := runEditorRequest(c, editingArgument, &editorRequest{argumentCount: &noArguments}, func() []*Signature { + _, inferenceCandidates := c.getResolvedSignatureWithCandidates(call, CheckModeNormal) return inferenceCandidates }) diff --git a/tsc/testdata/baselines/reference/compiler/signatureHelpInferenceQueryOrder(checkorder=editorfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/signatureHelpInferenceQueryOrder(checkorder=editorfirst).errors.txt new file mode 100644 index 0000000000000..1509944c6c1ec --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/signatureHelpInferenceQueryOrder(checkorder=editorfirst).errors.txt @@ -0,0 +1,16 @@ +signatureHelpInferenceQueryOrder.ts(7,30): error TS2741: Property 'b' is missing in type 'A' but required in type 'B'. + + +==== signatureHelpInferenceQueryOrder.ts (1 errors) ==== + function f(y: T, y1: U, p: (z: U) => T, p1: (x: T) => U): [T, U] { return [y, p1(y)]; } + interface A { a: A; } + interface B extends A { b; } + + declare var a: A, b: B; + + var d = f(a, b, x => x, x => x); + ~ +!!! error TS2741: Property 'b' is missing in type 'A' but required in type 'B'. +!!! related TS2728 signatureHelpInferenceQueryOrder.ts:3:25: 'b' is declared here. +!!! related TS6502 signatureHelpInferenceQueryOrder.ts:1:51: The expected type comes from the return type of this signature. + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/signatureHelpInferenceQueryOrder(checkorder=editorfirst).types b/tsc/testdata/baselines/reference/compiler/signatureHelpInferenceQueryOrder(checkorder=editorfirst).types index a4d785ae4e6cd..ece3363ee1b85 100644 --- a/tsc/testdata/baselines/reference/compiler/signatureHelpInferenceQueryOrder(checkorder=editorfirst).types +++ b/tsc/testdata/baselines/reference/compiler/signatureHelpInferenceQueryOrder(checkorder=editorfirst).types @@ -26,8 +26,8 @@ declare var a: A, b: B; >b : B var d = f(a, b, x => x, x => x); ->d : [A, A] ->f(a, b, x => x, x => x) : [A, A] +>d : [A, B] +>f(a, b, x => x, x => x) : [A, B] >f : (y: T, y1: U, p: (z: U) => T, p1: (x: T) => U) => [T, U] >a : A >b : B From a1625bc18464cffc70fba10a45cd15e148ddfb00 Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Sun, 8 Nov 2026 14:30:13 -0800 Subject: [PATCH 49/60] Check that checkers are at rest between requests A checker's memos are not its only state: it also holds the state of the computations in progress, such as the contextual types pushed for the nodes being checked, the resolutions on the stack, and the cycles being resolved. The next request reads anything a request leaves there, so none of it may outlast the request that set it. Every field of Checker is now either listed as the state of the computations in progress, which the test harness checks is at rest after every request it makes, or listed with the reason it is not, as the fields of the memo store and links already are. A few fields kept indices or flags after the computation using them finished, which nothing read: the lowest cycle head observed, the cycle flag of errors collected at the current node, the start of a circularity, of a reverse mapping and of a depth limit. They are now left at rest too. --- tsc/internal/checker/checker.go | 18 +++- tsc/internal/checker/checker_test.go | 98 ++++++++++++++++- tsc/internal/checker/checkerstate.go | 100 ++++++++++++++++++ tsc/internal/checker/inference.go | 3 + tsc/internal/checker/memo.go | 5 +- .../testutil/harnessutil/checkorderfuzz.go | 10 ++ .../testutil/harnessutil/checkorderfuzz_ls.go | 4 +- .../testutil/harnessutil/harnessutil.go | 1 + 8 files changed, 231 insertions(+), 8 deletions(-) create mode 100644 tsc/internal/checker/checkerstate.go diff --git a/tsc/internal/checker/checker.go b/tsc/internal/checker/checker.go index 427a109666bad..ff784b8c04e07 100644 --- a/tsc/internal/checker/checker.go +++ b/tsc/internal/checker/checker.go @@ -21136,7 +21136,9 @@ func minObservedHead(a int32, b int32) int32 { // 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 + if c.currentNodeErrorCollectors != 0 { + c.currentNodeErrorsCyclic = true + } c.extendCircularity(start + 1) } @@ -21172,8 +21174,11 @@ func (c *Checker) enterDepthLimit(l *depthLimit) { // does instead. func (c *Checker) exitDepthLimit(l *depthLimit) { l.depth-- - if l.depth == 0 && l.start == 0 { - c.endCyclesAt(0) + if l.depth == 0 { + if l.start == 0 { + c.endCyclesAt(0) + } + l.start = 0 } } @@ -21187,7 +21192,12 @@ func (c *Checker) popTypeResolution() bool { f := &c.resolutions[n] result := f.typeResolution.result observed := c.observedHead - c.observedHead = minObservedHead(f.prevObservedHead, observed) + if f.prevTypeResolution != 0 { + c.observedHead = minObservedHead(f.prevObservedHead, observed) + } else { + // Only an enclosing type resolution reads the cycle heads observed. + c.observedHead = 0 + } if r := &f.typeResolution; result && !r.participant && r.memo != nil && c.circularityStart != 0 && c.keepsResultInCycle(n, f, observed) { r.participant = true c.cycleParticipants = append(c.cycleParticipants, r.memo) diff --git a/tsc/internal/checker/checker_test.go b/tsc/internal/checker/checker_test.go index 14fa6fd60831c..996dc71e2aede 100644 --- a/tsc/internal/checker/checker_test.go +++ b/tsc/internal/checker/checker_test.go @@ -291,6 +291,8 @@ func TestCachedStateIsMemoized(t *testing.T) { files, err := filepath.Glob("*.go") assert.NilError(t, err) seen := make(map[string]bool) + // The state of computations in progress, which Checker.AssertAtRest checks. + progress := make(map[string]bool) var parsed []*goast.File // Entries interned by pointer own the results cached in them. interned := make(map[string]bool) @@ -302,6 +304,11 @@ func TestCachedStateIsMemoized(t *testing.T) { assert.NilError(t, err) parsed = append(parsed, file) goast.Inspect(file, func(n goast.Node) bool { + if vs, ok := n.(*goast.ValueSpec); ok && len(vs.Names) == 1 && vs.Names[0].Name == "checkerProgressFields" { + for _, elt := range vs.Values[0].(*goast.CompositeLit).Elts { + progress[strings.Trim(elt.(*goast.BasicLit).Value, `"`)] = true + } + } if e, ok := n.(*goast.IndexListExpr); ok { if ident, ok := e.X.(*goast.Ident); ok && ident.Name == "internMap" && len(e.Indices) == 2 { if star, ok := e.Indices[1].(*goast.StarExpr); ok { @@ -322,17 +329,32 @@ func TestCachedStateIsMemoized(t *testing.T) { 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] { + isChecker := spec.Name.Name == "Checker" + if !ok || slices.Contains(notCacheOwners, spec.Name.Name) || name != "types.go" && !strings.HasSuffix(spec.Name.Name, "Links") && spec.Name.Name != "memoStore" && !isChecker && !interned[spec.Name.Name] { return true } for _, field := range st.Fields.List { if isMemoType(field.Type) { continue } + if isChecker && isCheckerCreated(field.Type) { + continue + } for _, fieldName := range field.Names { key := spec.Name.Name + "." + fieldName.Name + if isChecker && progress[fieldName.Name] { + if _, ok := unmemoizedCheckerFields[key]; ok { + t.Errorf("%s: %s is listed both in checkerProgressFields and in unmemoizedCheckerFields", fset.Position(fieldName.Pos()), key) + } + delete(progress, fieldName.Name) + continue + } seen[key] = true - if _, ok := unmemoizedCacheFields[key]; !ok { + if isChecker { + if _, ok := unmemoizedCheckerFields[key]; !ok { + t.Errorf("%s: %s is not a memo; list it in checkerProgressFields or unmemoizedCheckerFields", fset.Position(fieldName.Pos()), key) + } + } else if _, ok := unmemoizedCacheFields[key]; !ok { t.Errorf("%s: %s is not a memo; make it one or list it in unmemoizedCacheFields", fset.Position(fieldName.Pos()), key) } } @@ -345,6 +367,35 @@ func TestCachedStateIsMemoized(t *testing.T) { t.Errorf("unmemoizedCacheFields lists %s, which is not an unmemoized field", key) } } + for key := range unmemoizedCheckerFields { + if !seen[key] { + t.Errorf("unmemoizedCheckerFields lists %s, which is not an unmemoized field", key) + } + } + for name := range progress { + t.Errorf("checkerProgressFields lists %s, which is not an unmemoized field of Checker", name) + } +} + +// isCheckerCreated reports whether a field of Checker of type expr is +// created with the checker: a closure, or an allocator for the entities it +// creates. +func isCheckerCreated(expr goast.Expr) bool { + switch e := expr.(type) { + case *goast.IndexExpr: + expr = e.X + case *goast.IndexListExpr: + expr = e.X + } + switch e := expr.(type) { + case *goast.FuncType: + return true + case *goast.SelectorExpr: + return strings.HasSuffix(e.Sel.Name, "Arena") + case *goast.Ident: + return strings.HasSuffix(e.Name, "Arena") + } + return false } func isMemoType(expr goast.Expr) bool { @@ -363,6 +414,8 @@ func isMemoType(expr goast.Expr) bool { const ( unmemoizedImmutable = "Set when the store is created" + unmemoizedCheckerSetup = "Set when the checker is created" + unmemoizedScratch = "Reused buffer or free list, whose contents nothing reads before writing" unmemoizedContainer = "Holds links, whose fields are checked separately" unmemoizedCounter = "Allocation counter for IDs and statistics" unmemoizedInterned = "Interned type whose creation has no effects" @@ -386,6 +439,47 @@ const ( // rather than entities owning cached state. var notCacheOwners = []string{"LanguageFeatureMinimumTargetMap", "accessibleChainCacheKey", "computedName", "TupleElementInfo", "MemberInfo", "RelationCacheSizes"} +// unmemoizedCheckerFields lists the fields of Checker, other than those in +// checkerProgressFields, like unmemoizedCacheFields. +var unmemoizedCheckerFields = map[string]string{ + "Checker.awaitedTypeErrors": "Counter compared only within one computation", + "Checker.flowInvocationCount": "Counter compared only within one computation", + "Checker.resolutionSerials": unmemoizedCounter, + "Checker.instantiationCount": "Counts within a statement or outermost computation, and starts again for each; see \"Instantiation limits\"", + "Checker.wasCanceled": "Set when a check is canceled, after which the checker is not used", + "Checker.evaluate": unmemoizedCheckerSetup, + "Checker.factory": unmemoizedCheckerSetup, + "Checker.uniqueLiteralMapper": unmemoizedCheckerSetup, + "Checker.reportUnreliableMapper": unmemoizedCheckerSetup, + "Checker.reportUnmeasurableMapper": unmemoizedCheckerSetup, + "Checker.restrictiveMapper": unmemoizedCheckerSetup, + "Checker.permissiveMapper": unmemoizedCheckerSetup, + "Checker.syncIterationTypesResolver": unmemoizedCheckerSetup, + "Checker.asyncIterationTypesResolver": unmemoizedCheckerSetup, + "Checker.compareTypesAssignable": unmemoizedCheckerSetup, + "Checker.tracer": unmemoizedCheckerSetup, + "Checker.layoutMembers": unmemoizedScratch, + "Checker.layoutBaseIndices": unmemoizedScratch, + "Checker.freeTypeSets": unmemoizedScratch, + "Checker.freePropertyCounts": unmemoizedScratch, + "Checker.freeinferenceState": unmemoizedScratch, + "Checker.freeFlowState": unmemoizedScratch, + "Checker.freeRelater": unmemoizedScratch, + "Checker.flushBuf": unmemoizedScratch, + "Checker.resumeBuf": unmemoizedScratch, + "Checker.regExpScanner": unmemoizedScratch, + "Checker.typeToStringNodebuilder": unmemoizedScratch, + "Checker.lastGetCombinedNodeFlagsNode": unmemoizedSyntax, + "Checker.lastGetCombinedNodeFlagsResult": unmemoizedSyntax, + "Checker.lastGetCombinedModifierFlagsNode": unmemoizedSyntax, + "Checker.lastGetCombinedModifierFlagsResult": unmemoizedSyntax, + "Checker.lastLateBindableParent": "Derived from syntax and the merges made before checking", + "Checker.lastLateBindableKinds": "Derived from syntax and the merges made before checking", + "Checker.lastFlowNode": "Reused only when no memo observes the reachability it caches", + "Checker.lastFlowNodeReachable": "Reused only when no memo observes the reachability it caches", + "Checker.flowDepthFailures": "A walk from a node that fails within a depth budget fails within any smaller one, regardless of earlier walks", +} + var unmemoizedCacheFields = map[string]string{ "valueSymbolExtra.nameType": unmemoizedCreated, "valueSymbolExtra.containingType": unmemoizedCreated, diff --git a/tsc/internal/checker/checkerstate.go b/tsc/internal/checker/checkerstate.go new file mode 100644 index 0000000000000..c93ede756ec9c --- /dev/null +++ b/tsc/internal/checker/checkerstate.go @@ -0,0 +1,100 @@ +package checker + +import ( + "fmt" + "reflect" +) + +// checkerProgressFields are the fields of Checker holding the state of the +// computations in progress. Between requests it is at rest, as the next +// request would read anything one request left there. See +// TestCachedStateIsMemoized for the other fields of Checker. +var checkerProgressFields = []string{ + "activeMappers", + "activeTypeMappersCaches", + "antecedentTypes", + "baseConstraintWalk", + "checking", + "circularityMark", + "circularityStart", + "conditionalConstraintDepth", + "contextualInfos", + "contextualParameterAssignments", + "ctx", + "currentNode", + "currentNodeErrorCollectors", + "currentNodeErrors", + "currentNodeErrorsCyclic", + "currentNodeResolution", + "cycleParticipants", + "cycleYields", + "deferredAttach", + "discardLog", + "discardLogFloor", + "effectsMarkDepth", + "flowLoopStack", + "flowTypeCache", + "inferenceContextInfos", + "inlineLevel", + "innerCycles", + "instantiationStack", + "markingForEmit", + "memoTop", + "observedHead", + "observingMemos", + "parametersAssigning", + "queryRoot", + "querySave", + "recordingFromCheck", + "reliabilityFlags", + "request", + "resolutionStart", + "resolutions", + "resolving", + "resolvingObjectTypeStack", + "reverseExpandingFlags", + "reverseMappedSourceStack", + "reverseMappedStart", + "reverseMappedTargetStack", + "serializationLevel", + "sharedFlows", + "signaturesResolving", + "typeResolutionTop", + "varianceCycleRoot", + "varianceProvisional", + "varianceStack", + "varianceSuperseded", + "varianceTypeParameter", + "visibleSignatures", + "visibleStart", + "withinUnreachableCode", +} + +// AssertAtRest panics if the state of the computations in progress is not at +// rest, as it must be between requests. +func (c *Checker) AssertAtRest() { + v := reflect.ValueOf(c).Elem() + for _, name := range checkerProgressFields { + f := v.FieldByName(name) + var rest bool + switch name { + case "resolutions": + // The root resolution, for work outside any computation. + rest = f.Len() == 1 + case "resolving": + rest = c.resolving.count == 0 + case "observingMemos": + rest = f.Bool() == (!c.checking || c.memoPendingCount != 0) + default: + switch f.Kind() { + case reflect.Slice, reflect.Map: + rest = f.Len() == 0 + default: + rest = f.IsZero() + } + } + if !rest { + panic(fmt.Sprintf("checker state %s is not at rest between requests", name)) + } + } +} diff --git a/tsc/internal/checker/inference.go b/tsc/internal/checker/inference.go index 2784d8bafc219..cd10d3e3c469e 100644 --- a/tsc/internal/checker/inference.go +++ b/tsc/internal/checker/inference.go @@ -1104,6 +1104,9 @@ func (c *Checker) inferReverseMappedType(source *Type, target *Type, constraint } c.reverseMappedSourceStack = c.reverseMappedSourceStack[:len(c.reverseMappedSourceStack)-1] c.reverseMappedTargetStack = c.reverseMappedTargetStack[:len(c.reverseMappedTargetStack)-1] + if len(c.reverseMappedSourceStack) == 0 { + c.reverseMappedStart = 0 + } c.reverseExpandingFlags = saveExpandingFlags c.reverseMappedCache.set(c, key, t) c.endMemo() diff --git a/tsc/internal/checker/memo.go b/tsc/internal/checker/memo.go index 4ef884c0097bc..fe4bec91167ac 100644 --- a/tsc/internal/checker/memo.go +++ b/tsc/internal/checker/memo.go @@ -1866,6 +1866,7 @@ func (c *Checker) setFlagMemoValue[T any](key memoKey, p *T, v T) { func (c *Checker) endCircularity() { mark := min(c.circularityMark, len(c.discardLog)) c.circularityStart = 0 + c.circularityMark = 0 c.innerCycles = c.innerCycles[:0] c.discardCycle(mark, false) c.cycleParticipants = nil @@ -1920,7 +1921,9 @@ func (c *Checker) discardCycle(mark int, retain bool) { // 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.typeResolutionTop != 0 { + c.observedHead = minObservedHead(c.observedHead, int32(head)) + } c.recordFromCheck() switch { case c.circularityStart == 0: diff --git a/tsc/internal/testutil/harnessutil/checkorderfuzz.go b/tsc/internal/testutil/harnessutil/checkorderfuzz.go index e33977195e1cd..23d61d912179b 100644 --- a/tsc/internal/testutil/harnessutil/checkorderfuzz.go +++ b/tsc/internal/testutil/harnessutil/checkorderfuzz.go @@ -316,6 +316,7 @@ func fuzzRun(t *testing.T, ctx context.Context, host compiler.CompilerHost, conf lang = fuzzLanguageService(program.Program()) } for _, q := range queries { + assertCheckersAtRest(program.Program()) file := program.GetSourceFile(q.file.FileName()) switch q.kind { case fuzzQueryDiagnostics: @@ -338,6 +339,7 @@ func fuzzRun(t *testing.T, ctx context.Context, host compiler.CompilerHost, conf done() } + assertCheckersAtRest(program.Program()) var diags []*ast.Diagnostic diags = append(diags, program.GetSyntacticDiagnostics(ctx, nil)...) diags = append(diags, program.GetSemanticDiagnostics(ctx, nil)...) @@ -435,3 +437,11 @@ func fuzzDiff(expected, actual fuzzResult) string { } return b.String() } + +// assertCheckersAtRest asserts that the checkers of program hold nothing of a +// request between requests; see Checker.AssertAtRest. +func assertCheckersAtRest(program *compiler.Program) { + program.ForEachCheckerParallel(func(_ int, c *checker.Checker) { + c.AssertAtRest() + }) +} diff --git a/tsc/internal/testutil/harnessutil/checkorderfuzz_ls.go b/tsc/internal/testutil/harnessutil/checkorderfuzz_ls.go index d949355a9d07b..0d994f368a6e4 100644 --- a/tsc/internal/testutil/harnessutil/checkorderfuzz_ls.go +++ b/tsc/internal/testutil/harnessutil/checkorderfuzz_ls.go @@ -69,12 +69,13 @@ func fuzzLanguageService(program *compiler.Program) *fuzzLSService { lineMaps[fileName] = lineMap return lineMap }) - return &fuzzLSService{ls.NewLanguageService(fuzzProjectID{}, program, host, ""), host.converters} + return &fuzzLSService{ls.NewLanguageService(fuzzProjectID{}, program, host, ""), host.converters, program} } type fuzzLSService struct { *ls.LanguageService converters *lsconv.Converters + program *compiler.Program } // fuzzLSResult makes the language service request of kind at node, or for @@ -92,6 +93,7 @@ func fuzzLSResult(ctx context.Context, lang *fuzzLSService, file *ast.SourceFile } var result any var err error + defer assertCheckersAtRest(lang.program) switch kind { case fuzzQueryHover: result, err = lang.ProvideHover(ctx, &lsproto.HoverParams{ diff --git a/tsc/internal/testutil/harnessutil/harnessutil.go b/tsc/internal/testutil/harnessutil/harnessutil.go index eaec6c7286621..2a155be6a9796 100644 --- a/tsc/internal/testutil/harnessutil/harnessutil.go +++ b/tsc/internal/testutil/harnessutil/harnessutil.go @@ -732,6 +732,7 @@ func compileFilesWithHost( errors = append(errors, diag) } + assertCheckersAtRest(postProgram.Program()) return newCompilationResult(host, harnessOptions.CurrentDirectory, config.CompilerOptions(), postProgram, emitResult, errors, harnessOptions) } From f9a988d3b1ded5ebd43785ac0a1218c823f8f5d5 Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Mon, 9 Nov 2026 16:56:47 -0800 Subject: [PATCH 50/60] Hold a check's effects during variance cycles instead of recording them When a variance measurement reaches a type whose measurement is in progress, the results cached until the outermost measurement finishes may be discarded, in case the measurement did not start at the canonical entry of its circularity. Until then, checking switched to recording: storing the effects of each result to apply later, and accounting for them on every read of a cached result. Few measurements are ever discarded, a handful per project, but recording roughly doubles the cost of the work done in the meantime, and each checker measures the shared types again, so with several checkers it accounts for most of the extra time these changes cost on xstate. So checking keeps applying effects during a variance cycle, except those that discarding the measurement would have to take back: errors, suggestions and deferred diagnostics are held until nothing can discard them, and dropped with the results if the measurement is. --- tsc/internal/checker/checker.go | 28 ++++++++++-- tsc/internal/checker/checkerstate.go | 2 + tsc/internal/checker/memo.go | 64 ++++++++++++++++++++++++--- tsc/internal/checker/memopeek_test.go | 1 + tsc/internal/checker/relater.go | 10 ++--- 5 files changed, 92 insertions(+), 13 deletions(-) diff --git a/tsc/internal/checker/checker.go b/tsc/internal/checker/checker.go index ff784b8c04e07..2b7f3eb1f5355 100644 --- a/tsc/internal/checker/checker.go +++ b/tsc/internal/checker/checker.go @@ -715,9 +715,11 @@ type Checker struct { cycleParticipants []*memoHeader // Computations that observed a cycle in progress effectsMarkDepth int // 1 + resolution index of the innermost effects mark that may be discarded, or 0 varianceStack []VarianceStackEntry - varianceCycleRoot int // 1 + index in varianceStack of the outermost measurement re-entered in progress, or 0; see getRecursiveVariances - varianceSuperseded bool // The measurement at the bottom of varianceStack is certain to be discarded; see getRecursiveVariances - varianceProvisional []*ast.Symbol // Types measured in a circularity with a measurement in progress; see isGuessedVariance + varianceCycleRoot int // 1 + index in varianceStack of the outermost measurement re-entered in progress, or 0; see getRecursiveVariances + heldEffects []func(c *Checker) // See holdEffect + heldEffectsFloor int // Number of held effects kept for measurements hidden by a canonical variance remeasurement; see trimDiscardLog + varianceSuperseded bool // The measurement at the bottom of varianceStack is certain to be discarded; see getRecursiveVariances + varianceProvisional []*ast.Symbol // Types measured in a circularity with a measurement in progress; see isGuessedVariance flushBuf []*memoState resumeBuf []int deferredAttach []deferredAttachment // See attachState @@ -12372,6 +12374,10 @@ func (c *Checker) reportNonexistentProperty(propNode *ast.Node, containingType * c.recordEffect(func(c *Checker) { c.reportNonexistentProperty(propNode, containingType, isUncheckedJS) }) return } + if c.holdingEffects() { + c.holdEffect(func(c *Checker) { c.reportNonexistentProperty(propNode, containingType, isUncheckedJS) }) + return + } // The diagnostic would never be reported, and building it prints types, // which in unchecked code can infer return types that report more of // them. @@ -15044,6 +15050,10 @@ func (c *Checker) addDeferredDiagnostic(callback func(c *Checker)) { c.recordEffect(func(c *Checker) { c.addDeferredDiagnostic(callback) }) return } + if c.holdingEffects() { + c.holdEffect(func(c *Checker) { c.addDeferredDiagnostic(callback) }) + return + } c.deferredDiagnosticCallbacks = append(c.deferredDiagnosticCallbacks, callback) } @@ -15064,6 +15074,10 @@ func (c *Checker) addDiagnostic(diagnostic *ast.Diagnostic) *ast.Diagnostic { c.recordEffect(func(c *Checker) { c.diagnostics.Add(diagnostic) }) return diagnostic } + if c.holdingEffects() { + c.holdEffect(func(c *Checker) { c.diagnostics.Add(diagnostic) }) + return diagnostic + } return c.diagnostics.Add(diagnostic) } return diagnostic @@ -15076,6 +15090,10 @@ func (c *Checker) addSuggestionDiagnostic(diagnostic *ast.Diagnostic) *ast.Diagn c.recordEffect(func(c *Checker) { c.suggestionDiagnostics.Add(diagnostic) }) return diagnostic } + if c.holdingEffects() { + c.holdEffect(func(c *Checker) { c.suggestionDiagnostics.Add(diagnostic) }) + return diagnostic + } return c.suggestionDiagnostics.Add(diagnostic) } return diagnostic @@ -32065,6 +32083,10 @@ func (c *Checker) checkExternalEmitHelpers(location *ast.Node, helpers ExternalE c.recordEffect(func(c *Checker) { c.checkExternalEmitHelpers(location, helpers) }) return } + if c.holdingEffects() { + c.holdEffect(func(c *Checker) { c.checkExternalEmitHelpers(location, helpers) }) + return + } links := c.sourceFileLinks.Get(sourceFile) if links.typeChecked { // Checking the helpers computes, so it waits for the end of the check diff --git a/tsc/internal/checker/checkerstate.go b/tsc/internal/checker/checkerstate.go index c93ede756ec9c..9ff8b1366b5af 100644 --- a/tsc/internal/checker/checkerstate.go +++ b/tsc/internal/checker/checkerstate.go @@ -34,6 +34,8 @@ var checkerProgressFields = []string{ "effectsMarkDepth", "flowLoopStack", "flowTypeCache", + "heldEffects", + "heldEffectsFloor", "inferenceContextInfos", "inlineLevel", "innerCycles", diff --git a/tsc/internal/checker/memo.go b/tsc/internal/checker/memo.go index fe4bec91167ac..bd2339e334b08 100644 --- a/tsc/internal/checker/memo.go +++ b/tsc/internal/checker/memo.go @@ -628,7 +628,7 @@ func (m *memoMap[K, V]) begin(c *Checker, k K) { side.countAllResolving() } c.beginResolution(m, len(side.resolvingKeys)-1) - if c.checking && c.memoPendingCount == 0 && c.memoTop|c.currentNodeResolution != 0 && !c.logEffects() { + if c.checking && c.memoPendingCount == 0 && c.memoTop|c.currentNodeResolution != 0 && !c.checkingRecords() { // beginCheckedMemo for the common case, without the calls. The memo // state of the result is looked up only if needed; see // resolutionState. @@ -835,7 +835,7 @@ func (c *Checker) beginMemo(key memoKey) { 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() { + if c.checking && c.memoPendingCount == 0 && c.memoTop|c.currentNodeResolution != 0 && !c.checkingRecords() { // beginCheckedMemo for the common case, without the calls. The memo // state of the result is looked up only if needed; see // resolutionState. @@ -1211,6 +1211,9 @@ func (c *Checker) replayCurrentNodeErrors(reports []*currentNodeError) { func (c *Checker) replayPending(state *memoState) { if state != nil && state.pending != nil { + if c.holdingEffects() { + c.logPendingDiscard(state) + } f := state.pending state.pending = nil c.memoPendingCount-- @@ -1435,11 +1438,55 @@ func (c *Checker) recordMark(mark func(c *Checker)) { // so a computation starting while one is in progress records them. func (c *Checker) beginCheckedMemo(state *memoState) { c.startEffects(state) - if c.logEffects() { + if c.checkingRecords() { c.recordFromCheck() } } +// checkingRecords reports whether a check records the effects of what it +// computes rather than applying them, because a cycle or a discard mark in +// progress may discard it. A variance measurement that may be discarded +// does not make it record; see holdEffect. +func (c *Checker) checkingRecords() bool { + return c.circularityStart != 0 || c.effectsMarkDepth != 0 +} + +// holdingEffects reports whether a check holds the effects it applies; see +// holdEffect. +func (c *Checker) holdingEffects() bool { + return c.varianceCycleRoot != 0 +} + +// holdEffect holds an effect a check applies while a variance measurement in +// progress may still be discarded (see getRecursiveVariances), to apply it +// once nothing can discard it, unless what produced it is discarded first. +// Few measurements are discarded, so a check holds their effects rather +// than recording them with every result, which costs far more. +func (c *Checker) holdEffect(effect func(c *Checker)) { + n := len(c.heldEffects) + c.heldEffects = append(c.heldEffects, effect) + c.logRestore(func() { + clear(c.heldEffects[n:]) + c.heldEffects = c.heldEffects[:n] + }) +} + +// applyHeldEffects applies the effects held by holdEffect above the floor +// (see trimDiscardLog), as the check that produced them would have. +func (c *Checker) applyHeldEffects() { + effects := slices.Clone(c.heldEffects[c.heldEffectsFloor:]) + clear(c.heldEffects[c.heldEffectsFloor:]) + c.heldEffects = c.heldEffects[:c.heldEffectsFloor] + saveChecking := c.checking + c.checking = true + c.syncObserving() + for _, e := range effects { + e(c) + } + c.checking = saveChecking + c.syncObserving() +} + // recordFromCheck makes the outermost computation in progress in a check, if // any, a query from here on, because a cycle or a discard mark begins, after which // results and their effects may be discarded. Effects are then recorded with @@ -1483,6 +1530,9 @@ func (c *Checker) endQueryFromCheck() { func (c *Checker) replayFlushed(states []*memoState) { for _, state := range states { if state.pending != nil { + if c.holdingEffects() { + c.logPendingDiscard(state) + } f := state.pending state.pending = nil c.memoPendingCount-- @@ -1499,7 +1549,7 @@ func (c *Checker) replayFlushed(states []*memoState) { // query recorded applies now, as it would have in the check, including what // the computations in progress recorded, which continue as in a check. func (c *Checker) resumeChecking() { - if c.checking || !c.recordingFromCheck || c.logEffects() || len(c.innerCycles) != 0 || len(c.discardLog) != 0 { + if c.checking || !c.recordingFromCheck || c.checkingRecords() || len(c.innerCycles) != 0 || len(c.discardLog) != 0 && !c.holdingEffects() { return } chain := c.resumeBuf[:0] @@ -1765,7 +1815,8 @@ func (c *Checker) discardLogSince(start int) { // While a variance measurement is measured again from the canonical entry of // its circularity, the measurements in progress are hidden, but may still be // discarded once it finishes, so the part of the log logged for them before -// it began is kept; see getVariancesWorker. +// it began is kept, with the effects a check held for them; see +// getVariancesWorker. func (c *Checker) trimDiscardLog() { if !c.logEffects() && len(c.discardLog) > c.discardLogFloor { for i := range c.varianceStack { @@ -1773,6 +1824,9 @@ func (c *Checker) trimDiscardLog() { } clear(c.discardLog[c.discardLogFloor:]) c.discardLog = c.discardLog[:c.discardLogFloor] + if len(c.heldEffects) > c.heldEffectsFloor { + c.applyHeldEffects() + } } } diff --git a/tsc/internal/checker/memopeek_test.go b/tsc/internal/checker/memopeek_test.go index e707418680e09..a04771b16f693 100644 --- a/tsc/internal/checker/memopeek_test.go +++ b/tsc/internal/checker/memopeek_test.go @@ -362,6 +362,7 @@ func TestDeferredEffectsOnlyApply(t *testing.T) { // that a query applies later than checking does. var deferringCalls = map[string]bool{ "recordEffect": true, "recordMark": true, "reportAtCurrentNode": true, "reportAtCurrentNodeOnce": true, + "holdEffect": true, } // recordsEffect reports whether stmt is the part of a method recording an diff --git a/tsc/internal/checker/relater.go b/tsc/internal/checker/relater.go index f53f01f78e8fd..3dfb42f047da4 100644 --- a/tsc/internal/checker/relater.go +++ b/tsc/internal/checker/relater.go @@ -1571,12 +1571,12 @@ func (c *Checker) getVariancesWorker(symbol *ast.Symbol, typeParameters []*Type) // entry, as if that type had been measured first, with nothing in // progress visible. That measures this type as it reaches it. c.discardVariancesSince(e) - saveVarianceStack, saveCycleRoot, saveProvisional, saveFloor := c.varianceStack, c.varianceCycleRoot, c.varianceProvisional, c.discardLogFloor - c.varianceStack, c.varianceCycleRoot, c.varianceProvisional, c.discardLogFloor = nil, 0, nil, len(c.discardLog) + saveVarianceStack, saveCycleRoot, saveProvisional, saveFloor, saveHeldFloor := c.varianceStack, c.varianceCycleRoot, c.varianceProvisional, c.discardLogFloor, c.heldEffectsFloor + c.varianceStack, c.varianceCycleRoot, c.varianceProvisional, c.discardLogFloor, c.heldEffectsFloor = nil, 0, nil, len(c.discardLog), len(c.heldEffects) c.beginCycleYield(e.min, TypeSystemPropertyNameVariances, -1, len(c.resolutions)) c.getVariancesWorker(e.min, e.minTypeParameters) c.endCycleYield() - c.varianceStack, c.varianceCycleRoot, c.varianceProvisional, c.discardLogFloor = saveVarianceStack, saveCycleRoot, saveProvisional, saveFloor + c.varianceStack, c.varianceCycleRoot, c.varianceProvisional, c.discardLogFloor, c.heldEffectsFloor = saveVarianceStack, saveCycleRoot, saveProvisional, saveFloor, saveHeldFloor variances = links.variances.cached(c) if len(variances) == 0 { c.varianceStack[index].remeasuring = true @@ -1635,9 +1635,9 @@ func (c *Checker) getRecursiveVariances(stackIndex int) []VarianceFlags { // first from scratch reaches the measurement and computes it again // inside, the same way. What is cached from now on until the // measurement re-entered finishes is logged, so that it can be discarded - // if the measurement is. + // if the measurement is, and a check holds the effects it applies until + // then (see holdEffect). if c.varianceCycleRoot == 0 { - c.recordFromCheck() c.varianceCycleRoot = stackIndex + 1 } else { c.varianceCycleRoot = min(c.varianceCycleRoot, stackIndex+1) From 8a40fe52652ba52c56dd56289cf4c8e4ae8c2eb7 Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Tue, 10 Nov 2026 10:37:21 -0800 Subject: [PATCH 51/60] Count computations in progress instead of indexing them Every memoized computation records its key as in progress and removes it when it finishes, so that re-entering it is caught as a cycle. Nearly every lookup finds nothing, yet the hash table made each computation pay for an insertion and a deletion that shifts probe sequences. Counting keys per slot makes the common case one load and one increment; the rare hit searches the resolution stack, which already holds the keys. --- tsc/internal/checker/checker.go | 10 +- tsc/internal/checker/memo.go | 7 +- tsc/internal/checker/resolutions.go | 150 +++++++++------------------- tsc/internal/checker/types_test.go | 29 ------ 4 files changed, 55 insertions(+), 141 deletions(-) diff --git a/tsc/internal/checker/checker.go b/tsc/internal/checker/checker.go index 2b7f3eb1f5355..11fc1419eb5b9 100644 --- a/tsc/internal/checker/checker.go +++ b/tsc/internal/checker/checker.go @@ -10849,7 +10849,7 @@ func (c *Checker) contextuallyCheckFunctionExpressionOrObjectLiteralMethod(node key := memoKeyOf(node, memoContextChecked) // A check in progress below a cycle yield is hidden, so the function is // checked again as if it were not, as computing from scratch would. - i, ok := c.resolving.get(key) + i, ok := c.resolvingGet(key) hidden := ok && int(i) < c.visibleStart c.beginMemo(key) c.contextuallyCheckFunctionExpressionOrObjectLiteralMethodUncached(node, checkMode, hidden) @@ -17409,7 +17409,7 @@ func (c *Checker) getResolvedMembersOrExportsOfSymbol(symbol *ast.Symbol, resolu // 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) + i, ok := c.resolvingGet(key) if !ok || int(i) < c.visibleStart || c.isYieldingTo(key, TypeSystemPropertyNameStructuredMembers) { return -1 } @@ -20876,7 +20876,7 @@ func (c *Checker) endCycleYield() { 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.resolutions[sh.index].shadowed = false } c.cycleYields[len(c.cycleYields)-1] = cycleYield{} c.cycleYields = c.cycleYields[:len(c.cycleYields)-1] @@ -21601,7 +21601,7 @@ func (c *Checker) resolveStructuredTypeMembersSlow(t *Type) *StructuredType { } else { c.isResolutionInProgress(t, TypeSystemPropertyNameStructuredMembers) } - if j, ok := c.resolving.get(key); ok && int(j) < c.visibleStart { + if j, ok := c.resolvingGet(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 @@ -21736,7 +21736,7 @@ func (c *Checker) resolveModuleTableMembers(t *Type) { } c.clearStructuredMembers(t) key := memoKeyOf(t, memoStructuredMembers) - i, _ := c.resolving.get(key) + i, _ := c.resolvingGet(key) c.resolutions[i].membersPublished = false if canonical != nil { c.resolveStructuredTypeMembers(canonical.(*Type)) diff --git a/tsc/internal/checker/memo.go b/tsc/internal/checker/memo.go index bd2339e334b08..3affb06ba746c 100644 --- a/tsc/internal/checker/memo.go +++ b/tsc/internal/checker/memo.go @@ -328,7 +328,7 @@ func (m *memo[T]) logDiscard(c *Checker) { // inProgress returns the result of a computation in progress, which a // computation re-entering it may have cached before it finishes. func (m *memo[T]) inProgress(c *Checker) T { - _, ok := c.resolving.get(m.key()) + _, ok := c.resolvingGet(m.key()) debug.Assert(ok, "the computation of the result is not in progress") return m.cached(c) } @@ -820,7 +820,7 @@ func (c *Checker) readsWithoutMemo(key memoKey) bool { if c.observing() { return false } - _, resolving := c.resolving.get(key) + _, resolving := c.resolvingGet(key) return !resolving } @@ -1232,7 +1232,8 @@ func (c *Checker) endMemo() { // calls. c.memoTop = int(f.prevMemo) if f.resolving { - c.resolving.delete(f.key) + c.resolving.counts[resolvingHome(f.key)]-- + c.resolving.count-- } if int(f.attachStart) != len(c.deferredAttach) { clear(c.deferredAttach[f.attachStart:]) diff --git a/tsc/internal/checker/resolutions.go b/tsc/internal/checker/resolutions.go index 942409ed43660..a7e155e4ce709 100644 --- a/tsc/internal/checker/resolutions.go +++ b/tsc/internal/checker/resolutions.go @@ -25,7 +25,10 @@ type resolution struct { // A query records the effects of a memoized computation, for replay by // reuse of its result; see memo.go. memo bool - resolving bool // The resolution is the one in Checker.resolving for key + resolving bool // The resolution is counted in Checker.resolving as computing key + // The resolution is hidden by a cycle yield and shadowed by one + // re-entering it, until the yield ends; see beginResolving. + shadowed bool fromCheck bool // The query began in a check; see recordFromCheck // The computation read the incomplete result of a computation in // progress, or was started by one that did; see effectsToDrop. @@ -147,111 +150,47 @@ func (c *Checker) forgetResult() { // 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 { + if i, ok := c.resolvingGet(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. +// resolvingTable counts the computations of memo cells in progress whose +// keys hash to each of its slots, so that finding none, which is nearly +// always the case, is one load. A computation in progress is a resolution +// with resolving set, which is found by searching the resolution stack only +// when its slot is not empty. The keys of the computations in progress are +// few, so the slots are rarely shared. type resolvingTable struct { - slots []resolvingSlot - count int + counts [1 << resolvingTableBits]uint16 + count int } -type resolvingSlot struct { - key memoKey - index int32 -} +const resolvingTableBits = 12 -func (t *resolvingTable) home(key memoKey) int { - return int(uint64(key) * 0x9E3779B97F4A7C15 >> 32 & uint64(len(t.slots)-1)) +func resolvingHome(key memoKey) uint64 { + return uint64(key) * 0x9E3779B97F4A7C15 >> (64 - resolvingTableBits) } -func (t *resolvingTable) get(key memoKey) (int32, bool) { - if t.count == 0 { +// resolvingGet returns the index in resolutions of the computation of key +// recorded as in progress: the outermost, unless a cycle yield hides it and +// a computation re-entering it shadows it (see beginResolving). +func (c *Checker) resolvingGet(key memoKey) (int32, bool) { + if c.resolving.count == 0 || c.resolving.counts[resolvingHome(key)] == 0 { return 0, false } - 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 - } - } + return c.resolvingFind(key) } -// 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) +//go:noinline +func (c *Checker) resolvingFind(key memoKey) (int32, bool) { + for i := range c.resolutions { + if f := &c.resolutions[i]; f.resolving && f.key == key && !f.shadowed { + return int32(i), true } } + return 0, false } // beginResolving records that the resolution about to be pushed computes key, @@ -259,20 +198,22 @@ func (t *resolvingTable) grow() { // one re-enters it as memoReentry says for its kind. 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 { - c.reenter(int(i), memoReentry[key.field()]) - return false + h := resolvingHome(key) + if c.resolving.counts[h] != 0 { + if i, ok := c.resolvingFind(key); ok { + if int(i) >= c.visibleStart { + c.reenter(int(i), memoReentry[key.field()]) + return false + } + // A cycle yield hides the computation in progress, so this one + // shadows it until the yield ends. + y := &c.cycleYields[len(c.cycleYields)-1] + y.shadowed = append(y.shadowed, shadowedResolving{key, i}) + c.resolutions[i].shadowed = true + } } - y := &c.cycleYields[len(c.cycleYields)-1] - y.shadowed = append(y.shadowed, shadowedResolving{key, i}) - slot.index = int32(len(c.resolutions)) + c.resolving.counts[h]++ + c.resolving.count++ return true } @@ -281,7 +222,7 @@ func (c *Checker) beginResolving(key memoKey) bool { // 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 { + if i, ok := c.resolvingGet(key); ok { return int(i), true } for _, y := range slices.Backward(c.cycleYields) { @@ -299,7 +240,8 @@ func (c *Checker) resolvingAnyIndex(key memoKey) (int, bool) { // 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) + c.resolving.counts[resolvingHome(f.key)]-- + c.resolving.count-- f.resolving = false } } diff --git a/tsc/internal/checker/types_test.go b/tsc/internal/checker/types_test.go index 1b376f5e44e0b..976846c4df460 100644 --- a/tsc/internal/checker/types_test.go +++ b/tsc/internal/checker/types_test.go @@ -2,7 +2,6 @@ package checker import ( "encoding/binary" - "math/rand/v2" "runtime" "slices" "strconv" @@ -713,31 +712,3 @@ func TestSignatureExtra(t *testing.T) { 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) - } -} From eb9fe00150cf6698560249bc654506aff0dfb5f0 Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Tue, 10 Nov 2026 15:16:39 -0800 Subject: [PATCH 52/60] Track memo map entries in progress with the other computations Each memo map kept its own record of the entries being computed: their keys, where on the resolution stack each was, and, once there were many, a count of each key. The checker already counts every other computation in progress and finds it on the resolution stack, so map entries are now counted with the rest by a hash of the map and key, and found on the resolution stack when the count says one may be in progress. A map keeps only the keys themselves, which a resolution has no room for. --- tsc/internal/checker/memo.go | 115 ++++++++-------------------- tsc/internal/checker/resolutions.go | 2 +- 2 files changed, 33 insertions(+), 84 deletions(-) diff --git a/tsc/internal/checker/memo.go b/tsc/internal/checker/memo.go index 3affb06ba746c..3e78c1cd81787 100644 --- a/tsc/internal/checker/memo.go +++ b/tsc/internal/checker/memo.go @@ -1,6 +1,7 @@ package checker import ( + "hash/maphash" "iter" "maps" "math/bits" @@ -63,6 +64,7 @@ const ( memoUnknownLikeUnion memoNeverIntersection memoDiscriminant + memoMapEntry // An entry of a memoMap; see memoMap.entryKey memoResolvedMembers // followed by one field per MembersOrExportsResolutionKind memoSymbolExports = memoResolvedMembers + memoField(MembersOrExportsResolutionKindResolvedExports) memoSymbolMembers = memoResolvedMembers + memoField(MembersOrExportsResolutionKindResolvedMembers) @@ -432,12 +434,10 @@ type memoMap[K comparable, V any] struct { } 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 + memoStates map[K]*memoState + // The keys of the computations of entries in progress, which their + // resolutions index, as a resolution cannot hold a key of any type. + resolvingKeys []K // If set, keyBits returns well-mixed bits of a key, with which stateKeys // filters the keys that may have a memo state, since few do and looking // up one that does not costs as much as one that does. @@ -613,21 +613,16 @@ func (m *memoMap[K, V]) compute(c *Checker, k K, fn func() V) V { // begin starts the computation of the result for k; see beginMemo. func (m *memoMap[K, V]) begin(c *Checker, k K) { side := m.sideTable() - outer := 0 - if len(side.resolvingKeys) != 0 { - outer = m.resolvingIndex(c, k) - } + key := m.entryKey(k) + outer := m.resolvingIndexOf(c, k, key) if outer != 0 { c.reenter(outer-1, side.reentry) } side.resolvingKeys = append(side.resolvingKeys, k) - 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) + c.resolving.counts[resolvingHome(key)]++ + c.resolving.count++ + c.appendResolution(key, m, len(side.resolvingKeys)-1, int32(len(c.instantiationStack))) + c.currentResolution().resolving = true if c.checking && c.memoPendingCount == 0 && c.memoTop|c.currentNodeResolution != 0 && !c.checkingRecords() { // beginCheckedMemo for the common case, without the calls. The memo // state of the result is looked up only if needed; see @@ -653,36 +648,32 @@ func (m *memoMap[K, V]) begin(c *Checker, k K) { c.beginState(state, outer) } +// entryKey returns the key under which Checker.resolving counts the +// computation of the entry for k in progress. Keys of different entries may +// collide, so a computation is found by its entry; see resolvingIndexOf. +func (m *memoMap[K, V]) entryKey(k K) memoKey { + // SAFETY: Only the address of the map is kept, as an identity; it is + // never turned back into a pointer. + h := maphash.Comparable(memoMapSeed, k) ^ uint64(uintptr(unsafe.Pointer(m)))*0x9E3779B97F4A7C15 + return memoKey(h&^0xff | uint64(memoMapEntry)) +} + +var memoMapSeed = maphash.MakeSeed() + // resolvingIndex returns 1 + the index in resolutions of the computation of // the entry for k in progress, or 0. func (m *memoMap[K, V]) resolvingIndex(c *Checker, k K) int { - if m.side == nil { + return m.resolvingIndexOf(c, k, m.entryKey(k)) +} + +func (m *memoMap[K, V]) resolvingIndexOf(c *Checker, k K, key memoKey) int { + if c.resolving.counts[resolvingHome(key)] == 0 { return 0 } - 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 + for i := c.visibleStart; i < len(c.resolutions); i++ { + if f := &c.resolutions[i]; f.resolving && f.key == key && f.source == memoStateSource(m) && m.side.resolvingKeys[f.index] == k { + return i + 1 } - // Hidden; see yieldCycle. } return 0 } @@ -703,50 +694,8 @@ func (m *memoMap[K, V]) peekStateAt(i int) *memoState { } 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 { diff --git a/tsc/internal/checker/resolutions.go b/tsc/internal/checker/resolutions.go index a7e155e4ce709..3b32f8ae6db02 100644 --- a/tsc/internal/checker/resolutions.go +++ b/tsc/internal/checker/resolutions.go @@ -186,7 +186,7 @@ func (c *Checker) resolvingGet(key memoKey) (int32, bool) { //go:noinline func (c *Checker) resolvingFind(key memoKey) (int32, bool) { for i := range c.resolutions { - if f := &c.resolutions[i]; f.resolving && f.key == key && !f.shadowed { + if f := &c.resolutions[i]; f.resolving && f.key == key && f.source == nil && !f.shadowed { return int32(i), true } } From 936558d917f62b8d2119de74e7f9a51eb35e2d8e Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Tue, 10 Nov 2026 16:22:50 -0800 Subject: [PATCH 53/60] Remove an unused memo map accessor --- tsc/internal/checker/memo.go | 8 -------- 1 file changed, 8 deletions(-) diff --git a/tsc/internal/checker/memo.go b/tsc/internal/checker/memo.go index 3e78c1cd81787..7c26ce6fd0c8c 100644 --- a/tsc/internal/checker/memo.go +++ b/tsc/internal/checker/memo.go @@ -466,14 +466,6 @@ 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 -} - // stateOf returns the memo state of the entry for k, or nil. func (m *memoMap[K, V]) stateOf(k K) *memoState { s := m.side From 8f3273bdde15a64dc19c807776a59b2fcaf88e7c Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Wed, 11 Nov 2026 16:43:47 -0800 Subject: [PATCH 54/60] Keep finding and marking computations in progress cheap when deeply nested Finding a computation in progress searched the whole resolution stack whenever its slot of the resolving table was taken, and marking the computations that read an incomplete result walked the stack above it. With thousands of computations in progress, as in an instantiation that runs away, nearly every slot is taken, so both cost time proportional to the depth on every step, and nesting deeply took quadratic time. --- tsc/internal/checker/checker.go | 1 + tsc/internal/checker/checkerstate.go | 1 + tsc/internal/checker/memo.go | 13 ++++++-- tsc/internal/checker/resolutions.go | 47 ++++++++++++++++++++++------ 4 files changed, 49 insertions(+), 13 deletions(-) diff --git a/tsc/internal/checker/checker.go b/tsc/internal/checker/checker.go index 11fc1419eb5b9..a6d9a2526fdfc 100644 --- a/tsc/internal/checker/checker.go +++ b/tsc/internal/checker/checker.go @@ -646,6 +646,7 @@ type Checker struct { resolutionSerials uint32 resolutions []resolution instantiationStack []*Type + readIncompleteFloor int32 // See markReadIncomplete conditionalConstraintDepth depthLimit baseConstraintWalk baseConstraintWalk inlineLevel depthLimit diff --git a/tsc/internal/checker/checkerstate.go b/tsc/internal/checker/checkerstate.go index 9ff8b1366b5af..64797f4e664a5 100644 --- a/tsc/internal/checker/checkerstate.go +++ b/tsc/internal/checker/checkerstate.go @@ -47,6 +47,7 @@ var checkerProgressFields = []string{ "parametersAssigning", "queryRoot", "querySave", + "readIncompleteFloor", "recordingFromCheck", "reliabilityFlags", "request", diff --git a/tsc/internal/checker/memo.go b/tsc/internal/checker/memo.go index 7c26ce6fd0c8c..d03e93b4bcad9 100644 --- a/tsc/internal/checker/memo.go +++ b/tsc/internal/checker/memo.go @@ -1198,8 +1198,10 @@ func (c *Checker) endMemo() { // result published so far. What they compute from here on may be derived // from it; see logResultDiscard. func (c *Checker) markReadIncomplete(i int) { - for j := i + 1; j < len(c.resolutions); j++ { - c.resolutions[j].readIncomplete = true + // Every resolution from i+1 up is marked by the floor, until the stack + // shrinks below it, so that marking does not walk the stack. + if i+1 < len(c.resolutions) && (c.readIncompleteFloor == 0 || int32(i+1) < c.readIncompleteFloor) { + c.readIncompleteFloor = int32(i + 1) } } @@ -1710,7 +1712,7 @@ type discardEntry struct { func (c *Checker) logResultDiscard(own bool, memo *memoHeader, restore func()) { var drop *memoEffects if own { - if f := &c.resolutions[c.memoTop-1]; f.readIncomplete && !f.reportsAtCurrentNode { + if f := &c.resolutions[c.memoTop-1]; c.readIncompleteAt(c.memoTop-1) && !f.reportsAtCurrentNode { drop = f.effects } } @@ -1950,8 +1952,13 @@ func (c *Checker) addInnerCycle(head int, mark int) { // dropResolution removes the resolution at index n, the top of the stack, and // ends the cycles it was the head of. func (c *Checker) dropResolution(n int) { + debug.Assert(n == len(c.resolutions)-1, "resolution dropped below the top") + c.unlinkResolution(&c.resolutions[n]) c.resolutions[n] = resolution{} c.resolutions = c.resolutions[:n] + if int(c.readIncompleteFloor) >= n { + c.readIncompleteFloor = 0 + } c.endCyclesAt(n) } diff --git a/tsc/internal/checker/resolutions.go b/tsc/internal/checker/resolutions.go index 3b32f8ae6db02..f1ba18fb950b3 100644 --- a/tsc/internal/checker/resolutions.go +++ b/tsc/internal/checker/resolutions.go @@ -21,6 +21,9 @@ type resolution struct { // for a node. depthStart int32 serial uint32 // Identifies the resolution among all entered + // One more than the index of the resolution below with a key in the same + // slot of the resolving table, or 0; see resolvingTable. + belowInSlot int32 // A query records the effects of a memoized computation, for replay by // reuse of its result; see memo.go. @@ -31,7 +34,8 @@ type resolution struct { shadowed bool fromCheck bool // The query began in a check; see recordFromCheck // The computation read the incomplete result of a computation in - // progress, or was started by one that did; see effectsToDrop. + // progress, or was started by one that did; see effectsToDrop and + // readIncompleteAt. readIncomplete bool // The computation reported an error located at the current node; see // effectsToDrop. @@ -92,10 +96,16 @@ func (c *Checker) pushResolution() *resolution { f := &c.resolutions[n] // What a computation started by one that read an incomplete result // computes may be derived from it too. - f.readIncomplete = n != 0 && c.resolutions[n-1].readIncomplete + f.readIncomplete = n != 0 && c.readIncompleteAt(n-1) return f } +// readIncompleteAt reports whether the resolution at index i read an +// incomplete result; see markReadIncomplete. +func (c *Checker) readIncompleteAt(i int) bool { + return c.resolutions[i].readIncomplete || c.readIncompleteFloor != 0 && i >= int(c.readIncompleteFloor) +} + func (c *Checker) currentResolution() *resolution { return &c.resolutions[len(c.resolutions)-1] } @@ -110,6 +120,11 @@ func (c *Checker) appendResolution(key memoKey, source memoStateSource, index in c.resolutionSerials++ f := c.pushResolution() f.key = key + if key != 0 { + h := resolvingHome(key) + f.belowInSlot = c.resolving.innermost[h] + c.resolving.innermost[h] = int32(len(c.resolutions)) + } f.source = source f.index = int32(index) f.depthStart = depthBase @@ -144,9 +159,18 @@ func (c *Checker) forgetResult() { f.source.popState(int(f.index)) } c.endResolving(f) + c.unlinkResolution(f) f.key, f.source = 0, nil } +// unlinkResolution removes f, the innermost resolution with its key in its +// slot of the resolving table, from the resolutions linked from the slot. +func (c *Checker) unlinkResolution(f *resolution) { + if f.key != 0 { + c.resolving.innermost[resolvingHome(f.key)] = f.belowInSlot + } +} + // resolvingIndex returns 1 + the index in resolutions of the outermost // computation of key in progress, or 0. func (c *Checker) resolvingIndex(key memoKey) int { @@ -159,12 +183,14 @@ func (c *Checker) resolvingIndex(key memoKey) int { // resolvingTable counts the computations of memo cells in progress whose // keys hash to each of its slots, so that finding none, which is nearly // always the case, is one load. A computation in progress is a resolution -// with resolving set, which is found by searching the resolution stack only -// when its slot is not empty. The keys of the computations in progress are -// few, so the slots are rarely shared. +// with resolving set, which is found by searching the resolutions with a key +// in its slot only when its slot is not empty. Those are linked from the +// innermost, so that a search stays short however deep the computations in +// progress nest. type resolvingTable struct { - counts [1 << resolvingTableBits]uint16 - count int + counts [1 << resolvingTableBits]uint16 + innermost [1 << resolvingTableBits]int32 // One more than the index of the innermost resolution with a key in each slot, or 0 + count int } const resolvingTableBits = 12 @@ -185,12 +211,13 @@ func (c *Checker) resolvingGet(key memoKey) (int32, bool) { //go:noinline func (c *Checker) resolvingFind(key memoKey) (int32, bool) { - for i := range c.resolutions { + found := int32(-1) + for i := c.resolving.innermost[resolvingHome(key)] - 1; i >= 0; i = c.resolutions[i].belowInSlot - 1 { if f := &c.resolutions[i]; f.resolving && f.key == key && f.source == nil && !f.shadowed { - return int32(i), true + found = i } } - return 0, false + return max(found, 0), found >= 0 } // beginResolving records that the resolution about to be pushed computes key, From 67374cdfab3eed0d34ba2823e30e3ad73d44ea58 Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Wed, 11 Nov 2026 16:45:36 -0800 Subject: [PATCH 55/60] Stop only runaway instantiations at the limit on the instantiation stack The limit on the depth of the whole instantiation stack failed an instantiation at whatever depth the stack reached, which depends on how much of what it needed was cached before, so whether a finite but deep instantiation failed depended on the order types were checked in. Caching only ever shortens the stack, so an instantiation that would stay below a limit computed from scratch stays below it in any order. The limit is now a guard against runaway instantiations, far above any finite one in real code (the deepest measured, in arktype's tests, nests 189 instantiations computed from scratch), while the limit on each computation still reports deep ones. An instantiation reaching the guard fails as a whole wherever it is computed or reused, so an infinite one fails the same way in any order. --- tsc/internal/checker/checker.go | 64 ++++++---- tsc/internal/checker/checker_test.go | 1 + tsc/internal/checker/checkerstate.go | 2 + tsc/internal/checker/memo.go | 116 ++++++++++++++++-- tsc/internal/checker/resolutions.go | 5 +- ...larIndexedPropertyInstantiation.errors.txt | 8 +- ...eckOrder(checkorder=typesfirst).errors.txt | 26 ---- ...redCheckOrder(checkorder=typesfirst).types | 8 +- ...tCheckOrder(checkorder=default).errors.txt | 12 +- ...kLimitCheckOrder(checkorder=default).types | 6 +- ...eckOrder(checkorder=typesfirst).errors.txt | 12 +- ...mitCheckOrder(checkorder=typesfirst).types | 4 +- ...enericExtendingClassDoubleLayer.errors.txt | 15 ++- ...tantiations(checkorder=default).errors.txt | 8 +- ...tiations(checkorder=typesfirst).errors.txt | 8 +- .../recursiveConditionalCrash4.errors.txt | 8 +- .../recursiveMappedTypes.errors.txt | 12 +- 17 files changed, 205 insertions(+), 110 deletions(-) delete mode 100644 tsc/testdata/baselines/reference/compiler/instantiationDepthSharedCheckOrder(checkorder=typesfirst).errors.txt diff --git a/tsc/internal/checker/checker.go b/tsc/internal/checker/checker.go index a6d9a2526fdfc..c57b4e709e90e 100644 --- a/tsc/internal/checker/checker.go +++ b/tsc/internal/checker/checker.go @@ -646,6 +646,8 @@ type Checker struct { resolutionSerials uint32 resolutions []resolution instantiationStack []*Type + instantiationAborted bool // See "Instantiation limits" + instantiationAbortLog int // Length of discardLog when instantiationAborted was set readIncompleteFloor int32 // See markReadIncomplete conditionalConstraintDepth depthLimit baseConstraintWalk baseConstraintWalk @@ -839,6 +841,7 @@ type memoStore struct { SymbolCount uint32 SignatureCount uint32 TotalInstantiationCount uint32 + tooDeepInstantiations map[memoKey]struct{} // See "Instantiation limits" languageVersion core.ScriptTarget moduleKind core.ModuleKind moduleResolutionKind core.ModuleResolutionKind @@ -25120,6 +25123,10 @@ func (c *Checker) instantiateTypeWithAlias(t *Type, m *TypeMapper, alias *TypeAl return t } // See "Instantiation limits" in memo.go. + if len(c.instantiationStack) == instantiationStackLimit || c.instantiationAborted { + c.abortInstantiation() + return c.errorType + } depthLimitReached := c.instantiationDepthLimitReached() if depthLimitReached || c.instantiationCount >= instantiationCountLimit { // We have reached 100 recursive type instantiations in one computation, or 5M type instantiations caused by @@ -25174,6 +25181,10 @@ func (c *Checker) instantiateTypeWithAlias(t *Type, m *TypeMapper, alias *TypeAl } c.instantiationStack[len(c.instantiationStack)-1] = nil c.instantiationStack = c.instantiationStack[:len(c.instantiationStack)-1] + if len(c.instantiationStack) == 0 && c.instantiationAborted { + c.endInstantiationAbort() + return c.errorType + } return result } @@ -25200,12 +25211,7 @@ func (c *Checker) getCircularTypeNames() []string { // 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 { + for _, t := range c.instantiationStack[c.currentResolution().depthStart:] { typeCounts[t] = typeCounts[t] + 1 if typeCounts[t] == 3 { symbol := t.symbol @@ -25217,18 +25223,6 @@ func (c *Checker) getCircularTypeNames() []string { } } } - 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) { @@ -25484,7 +25478,14 @@ func (c *Checker) getObjectTypeInstantiation(t *Type, m *TypeMapper, alias *Type if result == nil { reports := c.startCurrentNodeErrors() data.instantiations.begin(c, key) - result = instantiate(newTypeMapper(typeParameters, typeArguments)) + if c.beginInstantiation() { + result = c.errorType + } else { + result = instantiate(newTypeMapper(typeParameters, typeArguments)) + } + if !c.endInstantiation(reports) { + return c.errorType + } data.instantiations.setReported(c, key, result, c.endCurrentNodeErrors(reports)) c.endMemo() if result.flags&TypeFlagsObjectFlagsType != 0 && result.objectFlags&ObjectFlagsCouldContainTypeVariablesComputed == 0 { @@ -25605,6 +25606,11 @@ func (c *Checker) getConditionalTypeInstantiation(t *Type, mapper *TypeMapper, f if result == nil { reports := c.startCurrentNodeErrors() root.instantiations.begin(c, key) + if c.beginInstantiation() { + root.instantiations.setReported(c, key, c.errorType, c.endCurrentNodeErrors(reports)) + c.endMemo() + return c.errorType + } newMapper := newTypeMapper(root.outerTypeParameters, typeArguments) checkType := root.checkType var distributionType *Type @@ -25621,6 +25627,9 @@ func (c *Checker) getConditionalTypeInstantiation(t *Type, mapper *TypeMapper, f } else { result = c.getConditionalType(root, newMapper, forConstraint, alias) } + if !c.endInstantiation(reports) { + return c.errorType + } root.instantiations.setReported(c, key, result, c.endCurrentNodeErrors(reports)) c.endMemo() } @@ -26872,10 +26881,21 @@ func (c *Checker) getTypeAliasInstantiation(symbol *ast.Symbol, typeArguments [] if instantiation, _ := links.instantiations.cached(c, key); instantiation != nil { return instantiation } - return links.instantiations.compute(c, key, func() *Type { + // The instantiation may fail with an error that reusing it must replay; + // see "Instantiation limits". + reports := c.startCurrentNodeErrors() + links.instantiations.begin(c, key) + result := c.errorType + if !c.beginInstantiation() { mapper := newTypeMapper(typeParameters, c.fillMissingTypeArguments(typeArguments, typeParameters, c.getMinTypeArgumentCount(typeParameters), ast.IsInJSFile(symbol.ValueDeclaration()))) - return c.instantiateTypeWithAlias(t, mapper, alias) - }) + result = c.instantiateTypeWithAlias(t, mapper, alias) + } + if !c.endInstantiation(reports) { + return c.errorType + } + links.instantiations.setReported(c, key, result, c.endCurrentNodeErrors(reports)) + c.endMemo() + return result } func isLocalTypeAlias(symbol *ast.Symbol) bool { diff --git a/tsc/internal/checker/checker_test.go b/tsc/internal/checker/checker_test.go index 996dc71e2aede..0a31eaa06c8f9 100644 --- a/tsc/internal/checker/checker_test.go +++ b/tsc/internal/checker/checker_test.go @@ -491,6 +491,7 @@ var unmemoizedCacheFields = map[string]string{ "Type.id": unmemoizedCounter, "Type.kind": unmemoizedCreated, "Type.generation": unmemoizedDerived, + "memoStore.tooDeepInstantiations": "Instantiations known to reach the limit on the instantiation stack, whichever order computes them; see \"Instantiation limits\"", "Type.baseConstraintHeight": "Set with the resolved base constraint whose walk it describes; see \"Base constraint walks\"", "Type.symbol": unmemoizedCreated, "Type.alias": unmemoizedCreated, diff --git a/tsc/internal/checker/checkerstate.go b/tsc/internal/checker/checkerstate.go index 64797f4e664a5..aa48254463da5 100644 --- a/tsc/internal/checker/checkerstate.go +++ b/tsc/internal/checker/checkerstate.go @@ -39,6 +39,8 @@ var checkerProgressFields = []string{ "inferenceContextInfos", "inlineLevel", "innerCycles", + "instantiationAbortLog", + "instantiationAborted", "instantiationStack", "markingForEmit", "memoTop", diff --git a/tsc/internal/checker/memo.go b/tsc/internal/checker/memo.go index d03e93b4bcad9..c001fdc08e209 100644 --- a/tsc/internal/checker/memo.go +++ b/tsc/internal/checker/memo.go @@ -11,6 +11,7 @@ import ( "github.com/microsoft/TypeScript/tsc/internal/ast" "github.com/microsoft/TypeScript/tsc/internal/debug" + "github.com/microsoft/TypeScript/tsc/internal/diagnostics" ) // Checker side effects and memoization @@ -1146,6 +1147,12 @@ func (s *memoState) setErrors(c *Checker, reports []*currentNodeError) { //go:noinline func (c *Checker) replayCurrentNodeErrors(reports []*currentNodeError) { for _, r := range reports { + if r == instantiationTooDeep && len(c.instantiationStack) != 0 { + // Computing the result here would fail the instantiation in + // progress; see "Instantiation limits". + c.abortInstantiation() + continue + } c.reportNode(r) } } @@ -1726,13 +1733,13 @@ func (c *Checker) logMemoDiscard(memo *memoHeader, key memoKey, restore func()) // 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 + return c.circularityStart != 0 || c.varianceCycleRoot != 0 || c.instantiationAborted } // logEffects reports whether changing the effects of a result must be logged // in the discard log. func (c *Checker) logEffects() bool { - return c.circularityStart != 0 || c.effectsMarkDepth != 0 || c.varianceCycleRoot != 0 + return c.circularityStart != 0 || c.effectsMarkDepth != 0 || c.varianceCycleRoot != 0 || c.instantiationAborted } // discardLogSince restores everything logged in the discard log since @@ -2109,13 +2116,25 @@ func (c *Checker) logPendingDiscard(state *memoState) { // 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. +// reused result adds no depth. // -// The limit on the number of instantiations is likewise only reached by -// runaway instantiations, and depends on what was cached before: it counts +// Chains that start a new memoized computation at every level are only +// stopped by a limit on the depth of the whole instantiation stack, which +// is there to stop infinite instantiations rather than to judge finite +// ones: caching only ever shortens the stack, so an instantiation that +// would stay below it if computed from scratch stays below it in any order. +// An instantiation reaching it fails as a whole, with all instantiations in +// progress, and the results cached since are discarded, so no part of an +// infinite instantiation is cached as though it were complete. The error +// reported for it is carried by the results computed with it, and replaying +// it in an instantiation in progress fails that instantiation the same way, +// as computing those results again would. Each cached instantiation in +// progress when one fails would fail too if computed from scratch, so it is +// recorded as failing, rather than computed again to the limit wherever it +// is reached. +// +// The limit on the number of instantiations is only reached by runaway +// instantiations, and depends on what was cached before: it counts // the instantiations performed since the start of the current statement or // expression, or of the outermost computation in progress, and reused // results add none. Making it independent would mean @@ -2123,14 +2142,85 @@ func (c *Checker) logPendingDiscard(state *memoState) { // scratch, which costs far more than the limit is worth. const ( - instantiationDepthLimit = 100 - instantiationTotalDepthLimit = 200 - instantiationCountLimit = 5_000_000 + instantiationDepthLimit = 100 + instantiationStackLimit = 1000 + instantiationCountLimit = 5_000_000 ) func (c *Checker) instantiationDepthLimitReached() bool { - depth := len(c.instantiationStack) - return depth-int(c.currentResolution().depthStart) == instantiationDepthLimit || depth == instantiationTotalDepthLimit + return len(c.instantiationStack)-int(c.currentResolution().depthStart) == instantiationDepthLimit +} + +// instantiationTooDeep is the error reported for an instantiation that +// reached instantiationStackLimit. +var instantiationTooDeep = ¤tNodeError{func(c *Checker, node *ast.Node) { + c.error(node, diagnostics.Type_instantiation_is_excessively_deep_and_possibly_infinite) +}} + +// abortInstantiation fails every instantiation in progress; see +// "Instantiation limits". +func (c *Checker) abortInstantiation() { + if c.instantiationAborted { + return + } + c.instantiationAborted = true + c.instantiationAbortLog = len(c.discardLog) + // Each cached instantiation in progress reached the limit, and would + // again if computed from scratch, so it is known to fail without + // computing it again. + for i := range c.resolutions { + if f := &c.resolutions[i]; f.instantiation { + if c.tooDeepInstantiations == nil { + c.tooDeepInstantiations = make(map[memoKey]struct{}) + } + c.tooDeepInstantiations[f.key] = struct{}{} + } + } +} + +// beginInstantiation is called after beginning the computation of a cached +// instantiation, and reports whether it is known to fail, in which case it +// fails as computing it would. +func (c *Checker) beginInstantiation() bool { + f := c.currentResolution() + f.instantiation = true + if len(c.tooDeepInstantiations) == 0 { + return false + } + if _, ok := c.tooDeepInstantiations[f.key]; !ok { + return false + } + if len(c.instantiationStack) != 0 { + c.abortInstantiation() + } else { + c.reportNode(instantiationTooDeep) + } + return true +} + +// endInstantiation is called when the computation of a cached instantiation +// finishes, and reports whether to cache its result. An instantiation +// finishing while instantiations in progress are failing is part of the +// failure, and is not cached, since the instantiation caches keep the +// identity of what they cache and so are not discarded with the results +// cached since the failure. It then ends the computation itself. +func (c *Checker) endInstantiation(reports currentNodeErrorsMark) bool { + if !c.instantiationAborted { + return true + } + c.endCurrentNodeErrors(reports) + c.endMemoUncached() + return false +} + +// endInstantiationAbort finishes failing the outermost instantiation, once +// it has unwound. +func (c *Checker) endInstantiationAbort() { + c.instantiationAborted = false + c.discardLogSince(c.instantiationAbortLog) + c.instantiationAbortLog = 0 + c.trimDiscardLog() + c.reportNode(instantiationTooDeep) } // A Relation caches the results of comparisons. diff --git a/tsc/internal/checker/resolutions.go b/tsc/internal/checker/resolutions.go index f1ba18fb950b3..04dbd59177add 100644 --- a/tsc/internal/checker/resolutions.go +++ b/tsc/internal/checker/resolutions.go @@ -43,7 +43,10 @@ type resolution struct { // The structured members the outermost resolution of key computes are // available before it completes; see resolveStructuredTypeMembersUncached. membersPublished bool - prevMemo int32 // Checker.memoTop on entry + // The computation is of an instantiation cached in an instantiation + // cache; see "Instantiation limits". + instantiation bool + prevMemo int32 // Checker.memoTop on entry // Index in Checker.deferredAttach of the first result cached by the // computation before it had effects; see attachState. attachStart int32 diff --git a/tsc/testdata/baselines/reference/compiler/circularIndexedPropertyInstantiation.errors.txt b/tsc/testdata/baselines/reference/compiler/circularIndexedPropertyInstantiation.errors.txt index 1d225438007a0..8d26d18d8fb2f 100644 --- a/tsc/testdata/baselines/reference/compiler/circularIndexedPropertyInstantiation.errors.txt +++ b/tsc/testdata/baselines/reference/compiler/circularIndexedPropertyInstantiation.errors.txt @@ -1,5 +1,5 @@ -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(4,5): error TS2589: Type instantiation is excessively deep and possibly infinite. +circularIndexedPropertyInstantiation.ts(4,9): error TS2589: Type instantiation is excessively deep and possibly infinite. circularIndexedPropertyInstantiation.ts(5,13): error TS2344: Type '"false"' does not satisfy the constraint '"true"'. @@ -9,9 +9,9 @@ circularIndexedPropertyInstantiation.ts(5,13): error TS2344: Type '"false"' does type Foo = { "true": Foo> }[T]; let f1: Foo<"true", {}>; ~~ -!!! error TS5114: Instantiations of type 'Foo' appear infinitely circular. +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. ~~~~~~~~~~~~~~~ -!!! error TS5114: Instantiations of type 'Foo' appear infinitely circular. +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. let f2: Foo<"false", {}>; ~~~~~~~ !!! error TS2344: Type '"false"' does not satisfy the constraint '"true"'. \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/instantiationDepthSharedCheckOrder(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/instantiationDepthSharedCheckOrder(checkorder=typesfirst).errors.txt deleted file mode 100644 index 848c226ea7dbd..0000000000000 --- a/tsc/testdata/baselines/reference/compiler/instantiationDepthSharedCheckOrder(checkorder=typesfirst).errors.txt +++ /dev/null @@ -1,26 +0,0 @@ -instantiationDepthSharedCheckOrder.ts(7,15): error TS5114: Instantiations of type 'Deep' appear infinitely circular. -instantiationDepthSharedCheckOrder.ts(8,15): error TS5114: Instantiations of type 'Deep' appear infinitely circular. -instantiationDepthSharedCheckOrder.ts(9,15): error TS5114: Instantiations of type 'Deep' appear infinitely circular. -instantiationDepthSharedCheckOrder.ts(10,16): error TS5114: Instantiations of type 'Deep' appear infinitely circular. - - -==== instantiationDepthSharedCheckOrder.ts (4 errors) ==== - // Instantiating Deep<[]> fresh nests 100 instantiations of Deep, which is - // too deep. In program order each declaration finds the rest of the chain - // already instantiated by the one before it, so none of them nests more - // than 25. Whether DeepAll is too deep must not depend on which comes first. - - type Deep = N["length"] extends 100 ? never : Deep<[...N, 0]> | N["length"]; - type Deep75 = Deep<[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]>; - ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS5114: Instantiations of type 'Deep' appear infinitely circular. - type Deep50 = Deep<[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]>; - ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS5114: Instantiations of type 'Deep' appear infinitely circular. - type Deep25 = Deep<[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]>; - ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS5114: Instantiations of type 'Deep' appear infinitely circular. - type DeepAll = Deep<[]>; - ~~~~~~~~ -!!! error TS5114: Instantiations of type 'Deep' appear infinitely circular. - \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/instantiationDepthSharedCheckOrder(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/instantiationDepthSharedCheckOrder(checkorder=typesfirst).types index 9edac22f5cd4e..19ec88f95d195 100644 --- a/tsc/testdata/baselines/reference/compiler/instantiationDepthSharedCheckOrder(checkorder=typesfirst).types +++ b/tsc/testdata/baselines/reference/compiler/instantiationDepthSharedCheckOrder(checkorder=typesfirst).types @@ -10,14 +10,14 @@ type Deep = N["length"] extends 100 ? never : Deep<[...N, 0]> | N >Deep : Deep type Deep75 = Deep<[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]>; ->Deep75 : any +>Deep75 : 75 | 76 | 77 | 78 | 79 | 80 | 81 | 82 | 83 | 84 | 85 | 86 | 87 | 88 | 89 | 90 | 91 | 92 | 93 | 94 | 95 | 96 | 97 | 98 | 99 type Deep50 = Deep<[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]>; ->Deep50 : any +>Deep50 : 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | 75 | 76 | 77 | 78 | 79 | 80 | 81 | 82 | 83 | 84 | 85 | 86 | 87 | 88 | 89 | 90 | 91 | 92 | 93 | 94 | 95 | 96 | 97 | 98 | 99 type Deep25 = Deep<[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]>; ->Deep25 : any +>Deep25 : 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | 75 | 76 | 77 | 78 | 79 | 80 | 81 | 82 | 83 | 84 | 85 | 86 | 87 | 88 | 89 | 90 | 91 | 92 | 93 | 94 | 95 | 96 | 97 | 98 | 99 type DeepAll = Deep<[]>; ->DeepAll : any +>DeepAll : 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | 75 | 76 | 77 | 78 | 79 | 80 | 81 | 82 | 83 | 84 | 85 | 86 | 87 | 88 | 89 | 90 | 91 | 92 | 93 | 94 | 95 | 96 | 97 | 98 | 99 diff --git a/tsc/testdata/baselines/reference/compiler/instantiationStackLimitCheckOrder(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/instantiationStackLimitCheckOrder(checkorder=default).errors.txt index 469631d6d5bdf..0206551fbf855 100644 --- a/tsc/testdata/baselines/reference/compiler/instantiationStackLimitCheckOrder(checkorder=default).errors.txt +++ b/tsc/testdata/baselines/reference/compiler/instantiationStackLimitCheckOrder(checkorder=default).errors.txt @@ -1,6 +1,6 @@ -instantiationStackLimitCheckOrder.ts(6,48): error TS5114: Instantiations of type 'F' appear infinitely circular. -instantiationStackLimitCheckOrder.ts(7,10): error TS5114: Instantiations of type 'F' appear infinitely circular. -instantiationStackLimitCheckOrder.ts(14,11): error TS5114: Instantiations of type 'FlatArray' appear infinitely circular. +instantiationStackLimitCheckOrder.ts(6,48): error TS2589: Type instantiation is excessively deep and possibly infinite. +instantiationStackLimitCheckOrder.ts(7,10): error TS2589: Type instantiation is excessively deep and possibly infinite. +instantiationStackLimitCheckOrder.ts(14,11): error TS2589: Type instantiation is excessively deep and possibly infinite. ==== instantiationStackLimitCheckOrder.ts (3 errors) ==== @@ -11,10 +11,10 @@ instantiationStackLimitCheckOrder.ts(14,11): error TS5114: Instantiations of typ type F = T extends [unknown?, ...infer R] ? [0, ...F] : []; ~~~~~~~~~~~~ -!!! error TS5114: Instantiations of type 'F' appear infinitely circular. +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. type X = F<[]>; ~~~~~ -!!! error TS5114: Instantiations of type 'F' appear infinitely circular. +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. // The element type of A[] is resolved whenever first needed, inside the // instantiation of the return type of flat or not. Reaching the limit while @@ -23,5 +23,5 @@ instantiationStackLimitCheckOrder.ts(14,11): error TS5114: Instantiations of typ type A = A[]; const r = ([] as A).flat(Infinity); ~~~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS5114: Instantiations of type 'FlatArray' appear infinitely circular. +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/instantiationStackLimitCheckOrder(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/instantiationStackLimitCheckOrder(checkorder=default).types index 0731d655cd19a..25dbb75282678 100644 --- a/tsc/testdata/baselines/reference/compiler/instantiationStackLimitCheckOrder(checkorder=default).types +++ b/tsc/testdata/baselines/reference/compiler/instantiationStackLimitCheckOrder(checkorder=default).types @@ -10,7 +10,7 @@ type F = T extends [unknown?, ...infer R] ? [0, ...F] : []; >F : F type X = F<[]>; ->X : [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ...any[]] +>X : any // The element type of A[] is resolved whenever first needed, inside the // instantiation of the return type of flat or not. Reaching the limit while @@ -20,8 +20,8 @@ type A = A[]; >A : A const r = ([] as A).flat(Infinity); ->r : any[] ->([] as A).flat(Infinity) : any[] +>r : any +>([] as A).flat(Infinity) : any >([] as A).flat : (this: A, depth?: D | undefined) => FlatArray[] >([] as A) : A >[] as A : A diff --git a/tsc/testdata/baselines/reference/compiler/instantiationStackLimitCheckOrder(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/instantiationStackLimitCheckOrder(checkorder=typesfirst).errors.txt index 469631d6d5bdf..0206551fbf855 100644 --- a/tsc/testdata/baselines/reference/compiler/instantiationStackLimitCheckOrder(checkorder=typesfirst).errors.txt +++ b/tsc/testdata/baselines/reference/compiler/instantiationStackLimitCheckOrder(checkorder=typesfirst).errors.txt @@ -1,6 +1,6 @@ -instantiationStackLimitCheckOrder.ts(6,48): error TS5114: Instantiations of type 'F' appear infinitely circular. -instantiationStackLimitCheckOrder.ts(7,10): error TS5114: Instantiations of type 'F' appear infinitely circular. -instantiationStackLimitCheckOrder.ts(14,11): error TS5114: Instantiations of type 'FlatArray' appear infinitely circular. +instantiationStackLimitCheckOrder.ts(6,48): error TS2589: Type instantiation is excessively deep and possibly infinite. +instantiationStackLimitCheckOrder.ts(7,10): error TS2589: Type instantiation is excessively deep and possibly infinite. +instantiationStackLimitCheckOrder.ts(14,11): error TS2589: Type instantiation is excessively deep and possibly infinite. ==== instantiationStackLimitCheckOrder.ts (3 errors) ==== @@ -11,10 +11,10 @@ instantiationStackLimitCheckOrder.ts(14,11): error TS5114: Instantiations of typ type F = T extends [unknown?, ...infer R] ? [0, ...F] : []; ~~~~~~~~~~~~ -!!! error TS5114: Instantiations of type 'F' appear infinitely circular. +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. type X = F<[]>; ~~~~~ -!!! error TS5114: Instantiations of type 'F' appear infinitely circular. +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. // The element type of A[] is resolved whenever first needed, inside the // instantiation of the return type of flat or not. Reaching the limit while @@ -23,5 +23,5 @@ instantiationStackLimitCheckOrder.ts(14,11): error TS5114: Instantiations of typ type A = A[]; const r = ([] as A).flat(Infinity); ~~~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS5114: Instantiations of type 'FlatArray' appear infinitely circular. +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/instantiationStackLimitCheckOrder(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/instantiationStackLimitCheckOrder(checkorder=typesfirst).types index 0731d655cd19a..ad899bd00df1c 100644 --- a/tsc/testdata/baselines/reference/compiler/instantiationStackLimitCheckOrder(checkorder=typesfirst).types +++ b/tsc/testdata/baselines/reference/compiler/instantiationStackLimitCheckOrder(checkorder=typesfirst).types @@ -10,7 +10,7 @@ type F = T extends [unknown?, ...infer R] ? [0, ...F] : []; >F : F type X = F<[]>; ->X : [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ...any[]] +>X : any // The element type of A[] is resolved whenever first needed, inside the // instantiation of the return type of flat or not. Reaching the limit while @@ -21,7 +21,7 @@ type A = A[]; const r = ([] as A).flat(Infinity); >r : any[] ->([] as A).flat(Infinity) : any[] +>([] as A).flat(Infinity) : any >([] as A).flat : (this: A, depth?: D | undefined) => FlatArray[] >([] as A) : A >[] as A : A diff --git a/tsc/testdata/baselines/reference/compiler/keyofGenericExtendingClassDoubleLayer.errors.txt b/tsc/testdata/baselines/reference/compiler/keyofGenericExtendingClassDoubleLayer.errors.txt index 8c8a4f0003e86..78ca4d5e576e6 100644 --- a/tsc/testdata/baselines/reference/compiler/keyofGenericExtendingClassDoubleLayer.errors.txt +++ b/tsc/testdata/baselines/reference/compiler/keyofGenericExtendingClassDoubleLayer.errors.txt @@ -1,10 +1,12 @@ 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: 'Exclude', 'Model', 'ModelAttributes'. +keyofGenericExtendingClassDoubleLayer.ts(9,7): error TS2589: Type instantiation is excessively deep and possibly infinite. keyofGenericExtendingClassDoubleLayer.ts(10,12): error TS2564: Property 'age' has no initializer and is not definitely assigned in the constructor. -keyofGenericExtendingClassDoubleLayer.ts(13,13): error TS5115: Instantiations of the following types appear infinitely circular: 'Exclude', 'Model', 'ModelAttributes'. +keyofGenericExtendingClassDoubleLayer.ts(13,13): error TS2322: Type 'string' is not assignable to type 'keyof this'. + Type '"createdAt"' is not assignable to type '"age" | "toJson"'. +keyofGenericExtendingClassDoubleLayer.ts(13,13): error TS2589: Type instantiation is excessively deep and possibly infinite. -==== keyofGenericExtendingClassDoubleLayer.ts (4 errors) ==== +==== keyofGenericExtendingClassDoubleLayer.ts (5 errors) ==== class Model { public createdAt: Date; ~~~~~~~~~ @@ -17,7 +19,7 @@ keyofGenericExtendingClassDoubleLayer.ts(13,13): error TS5115: Instantiations of class PersonModel extends AutoModel { ~~~~~~~~~~~ -!!! error TS5115: Instantiations of the following types appear infinitely circular: 'Exclude', 'Model', 'ModelAttributes'. +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. public age: number; ~~~ !!! error TS2564: Property 'age' has no initializer and is not definitely assigned in the constructor. @@ -25,7 +27,10 @@ keyofGenericExtendingClassDoubleLayer.ts(13,13): error TS5115: Instantiations of toJson() { let x: keyof this = 'createdAt'; ~ -!!! error TS5115: Instantiations of the following types appear infinitely circular: 'Exclude', 'Model', 'ModelAttributes'. +!!! error TS2322: Type 'string' is not assignable to type 'keyof this'. +!!! error TS2322: Type '"createdAt"' is not assignable to type '"age" | "toJson"'. + ~ +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. } } \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/limitDeepInstantiations(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/limitDeepInstantiations(checkorder=default).errors.txt index b908bb32df049..a11d3142ac85e 100644 --- a/tsc/testdata/baselines/reference/compiler/limitDeepInstantiations(checkorder=default).errors.txt +++ b/tsc/testdata/baselines/reference/compiler/limitDeepInstantiations(checkorder=default).errors.txt @@ -1,5 +1,5 @@ -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(4,5): error TS2589: Type instantiation is excessively deep and possibly infinite. +limitDeepInstantiations.ts(4,9): error TS2589: Type instantiation is excessively deep and possibly infinite. limitDeepInstantiations.ts(5,13): error TS2344: Type '"false"' does not satisfy the constraint '"true"'. @@ -9,9 +9,9 @@ limitDeepInstantiations.ts(5,13): error TS2344: Type '"false"' does not satisfy type Foo = { "true": Foo> }[T]; let f1: Foo<"true", {}>; ~~ -!!! error TS5114: Instantiations of type 'Foo' appear infinitely circular. +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. ~~~~~~~~~~~~~~~ -!!! error TS5114: Instantiations of type 'Foo' appear infinitely circular. +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. let f2: Foo<"false", {}>; ~~~~~~~ !!! error TS2344: Type '"false"' does not satisfy the constraint '"true"'. diff --git a/tsc/testdata/baselines/reference/compiler/limitDeepInstantiations(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/limitDeepInstantiations(checkorder=typesfirst).errors.txt index b908bb32df049..a11d3142ac85e 100644 --- a/tsc/testdata/baselines/reference/compiler/limitDeepInstantiations(checkorder=typesfirst).errors.txt +++ b/tsc/testdata/baselines/reference/compiler/limitDeepInstantiations(checkorder=typesfirst).errors.txt @@ -1,5 +1,5 @@ -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(4,5): error TS2589: Type instantiation is excessively deep and possibly infinite. +limitDeepInstantiations.ts(4,9): error TS2589: Type instantiation is excessively deep and possibly infinite. limitDeepInstantiations.ts(5,13): error TS2344: Type '"false"' does not satisfy the constraint '"true"'. @@ -9,9 +9,9 @@ limitDeepInstantiations.ts(5,13): error TS2344: Type '"false"' does not satisfy type Foo = { "true": Foo> }[T]; let f1: Foo<"true", {}>; ~~ -!!! error TS5114: Instantiations of type 'Foo' appear infinitely circular. +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. ~~~~~~~~~~~~~~~ -!!! error TS5114: Instantiations of type 'Foo' appear infinitely circular. +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. let f2: Foo<"false", {}>; ~~~~~~~ !!! error TS2344: Type '"false"' does not satisfy the constraint '"true"'. diff --git a/tsc/testdata/baselines/reference/compiler/recursiveConditionalCrash4.errors.txt b/tsc/testdata/baselines/reference/compiler/recursiveConditionalCrash4.errors.txt index b119a342d2de9..9a55044866b75 100644 --- a/tsc/testdata/baselines/reference/compiler/recursiveConditionalCrash4.errors.txt +++ b/tsc/testdata/baselines/reference/compiler/recursiveConditionalCrash4.errors.txt @@ -2,9 +2,9 @@ recursiveConditionalCrash4.ts(7,16): error TS2503: Cannot find namespace 'StrIte recursiveConditionalCrash4.ts(8,5): error TS2503: Cannot find namespace 'StrIter'. recursiveConditionalCrash4.ts(9,25): error TS2304: Cannot find name 'Add'. recursiveConditionalCrash4.ts(9,37): error TS2503: Cannot find namespace 'StrIter'. -recursiveConditionalCrash4.ts(10,7): error TS5114: Instantiations of type 'LengthDown' appear infinitely circular. +recursiveConditionalCrash4.ts(10,7): error TS2589: Type instantiation is excessively deep and possibly infinite. recursiveConditionalCrash4.ts(10,31): error TS2503: Cannot find namespace 'StrIter'. -recursiveConditionalCrash4.ts(16,7): error TS5114: Instantiations of type 'Foo' appear infinitely circular. +recursiveConditionalCrash4.ts(16,7): error TS2589: Type instantiation is excessively deep and possibly infinite. ==== recursiveConditionalCrash4.ts (7 errors) ==== @@ -27,7 +27,7 @@ recursiveConditionalCrash4.ts(16,7): error TS5114: Instantiations of type 'Foo' !!! error TS2503: Cannot find namespace 'StrIter'. : LengthDown> ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS5114: Instantiations of type 'LengthDown' appear infinitely circular. +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. ~~~~~~~ !!! error TS2503: Cannot find namespace 'StrIter'. : Length; @@ -37,6 +37,6 @@ recursiveConditionalCrash4.ts(16,7): error TS5114: Instantiations of type 'Foo' ? Foo : Foo ~~~~~~~~~~~~ -!!! error TS5114: Instantiations of type 'Foo' appear infinitely circular. +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. : unknown; \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/conformance/recursiveMappedTypes.errors.txt b/tsc/testdata/baselines/reference/conformance/recursiveMappedTypes.errors.txt index 9d4e77b1bfb1f..802cc83bd228b 100644 --- a/tsc/testdata/baselines/reference/conformance/recursiveMappedTypes.errors.txt +++ b/tsc/testdata/baselines/reference/conformance/recursiveMappedTypes.errors.txt @@ -4,9 +4,9 @@ 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(20,14): error TS2589: Type instantiation is excessively deep and possibly infinite. +recursiveMappedTypes.ts(20,19): error TS2589: Type instantiation is excessively deep and possibly infinite. +recursiveMappedTypes.ts(21,10): error TS2589: Type instantiation is excessively deep and possibly infinite. recursiveMappedTypes.ts(73,5): error TS2502: '"each"' is referenced directly or indirectly in its own type annotation. recursiveMappedTypes.ts(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; }'. @@ -45,12 +45,12 @@ recursiveMappedTypes.ts(73,13): error TS2615: Type of property '"each"' circular function foo(arg: Circular): tup { ~~~~~~~~~~~~~~~~~~ -!!! error TS5114: Instantiations of type 'Circular' appear infinitely circular. +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. ~~~~~~~~~~~~~ -!!! error TS5114: Instantiations of type 'Circular' appear infinitely circular. +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. return arg; ~~~ -!!! error TS5114: Instantiations of type 'Circular' appear infinitely circular. +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. } // Repro from #29442 From 218b174bc23c1488b709c3dac85ec0f391580296 Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Wed, 11 Nov 2026 20:13:08 -0800 Subject: [PATCH 56/60] Let a cycle yielding to a member table see the table's computation A cycle that passes through a member table in progress is computed again as if the table had been entered first, with everything below the table hidden. The table's own memoized computation sits just below its type resolution, so it was hidden too, and reading the table then failed the recomputation instead of reading the table. Which member of such a cycle failed then depended on where the cycle was entered: a type alias read through an index signature was circular when queried first, and a parameter typed through a class's base was circular when its class was checked first. Fixes 64998 For 61721 --- tsc/internal/checker/checker.go | 8 +++++++- ...structorCycleCheckOrder(checkorder=default).errors.txt | 5 +---- ...seConstructorCycleCheckOrder(checkorder=default).types | 2 +- ...atureCycleCheckOrder(checkorder=typesfirst).errors.txt | 6 +++--- ...xSignatureCycleCheckOrder(checkorder=typesfirst).types | 4 ++-- 5 files changed, 14 insertions(+), 11 deletions(-) diff --git a/tsc/internal/checker/checker.go b/tsc/internal/checker/checker.go index c57b4e709e90e..1e65764b159b2 100644 --- a/tsc/internal/checker/checker.go +++ b/tsc/internal/checker/checker.go @@ -20813,7 +20813,13 @@ func (c *Checker) yieldCycleToMembers(start int) bool { c.markResolutionCycle(m) return false } - c.beginCycleYield(r.target, r.propertyName, len(c.resolutions), m) + floor := m + if t := &c.resolutions[m].typeResolution; t.propertyName == TypeSystemPropertyNameStructuredMembers && m > start+1 && c.resolutions[m-1].key == memoKeyOf(t.target.(*Type), memoStructuredMembers) { + // The table's own computation, below its type resolution, must be + // visible too, so that reading the table finds it in progress. + floor = m - 1 + } + c.beginCycleYield(r.target, r.propertyName, len(c.resolutions), floor) return true } if !c.yieldCycle(start) { diff --git a/tsc/testdata/baselines/reference/compiler/intersectionBaseConstructorCycleCheckOrder(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/intersectionBaseConstructorCycleCheckOrder(checkorder=default).errors.txt index 96858d411691e..999b86cd14552 100644 --- a/tsc/testdata/baselines/reference/compiler/intersectionBaseConstructorCycleCheckOrder(checkorder=default).errors.txt +++ b/tsc/testdata/baselines/reference/compiler/intersectionBaseConstructorCycleCheckOrder(checkorder=default).errors.txt @@ -1,16 +1,13 @@ -intersectionBaseConstructorCycleCheckOrder.ts(5,24): error TS2502: 'x' is referenced directly or indirectly in its own type annotation. intersectionBaseConstructorCycleCheckOrder.ts(6,15): error TS2310: Type 'C' recursively references itself as a base type. intersectionBaseConstructorCycleCheckOrder.ts(6,15): error TS2506: 'C' is referenced directly or indirectly in its own base expression. -==== intersectionBaseConstructorCycleCheckOrder.ts (3 errors) ==== +==== intersectionBaseConstructorCycleCheckOrder.ts (2 errors) ==== // The type of x depends on the members of C, which depend on its base B, // whose members depend on the type of x. Whichever is resolved first, the // cycle must be resolved the same way. declare const B: (new (x: C["p"]) => {}) & (new () => {}); - ~~~~~~~~~ -!!! error TS2502: 'x' is referenced directly or indirectly in its own type annotation. declare class C extends B { p: number; } ~ !!! error TS2310: Type 'C' recursively references itself as a base type. diff --git a/tsc/testdata/baselines/reference/compiler/intersectionBaseConstructorCycleCheckOrder(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/intersectionBaseConstructorCycleCheckOrder(checkorder=default).types index 334afbb4eb4f5..3a18ead789620 100644 --- a/tsc/testdata/baselines/reference/compiler/intersectionBaseConstructorCycleCheckOrder(checkorder=default).types +++ b/tsc/testdata/baselines/reference/compiler/intersectionBaseConstructorCycleCheckOrder(checkorder=default).types @@ -7,7 +7,7 @@ declare const B: (new (x: C["p"]) => {}) & (new () => {}); >B : (new (x: C["p"]) => {}) & (new () => {}) ->x : any +>x : number declare class C extends B { p: number; } >C : C diff --git a/tsc/testdata/baselines/reference/compiler/keyofIndexSignatureCycleCheckOrder(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/keyofIndexSignatureCycleCheckOrder(checkorder=typesfirst).errors.txt index 4b322a738aee9..44b9fe50fa70d 100644 --- a/tsc/testdata/baselines/reference/compiler/keyofIndexSignatureCycleCheckOrder(checkorder=typesfirst).errors.txt +++ b/tsc/testdata/baselines/reference/compiler/keyofIndexSignatureCycleCheckOrder(checkorder=typesfirst).errors.txt @@ -1,4 +1,4 @@ -keyofIndexSignatureCycleCheckOrder.ts(6,6): error TS2456: Type alias 'S' circularly references itself. +keyofIndexSignatureCycleCheckOrder.ts(7,7): error TS2322: Type '123' is not assignable to type 'never'. ==== keyofIndexSignatureCycleCheckOrder.ts (1 errors) ==== @@ -8,7 +8,7 @@ keyofIndexSignatureCycleCheckOrder.ts(6,6): error TS2456: Type alias 'S' circula interface C { [k: string]: S; } type S = keyof C; - ~ -!!! error TS2456: Type alias 'S' circularly references itself. const k: S = 123; + ~ +!!! error TS2322: Type '123' is not assignable to type 'never'. \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/keyofIndexSignatureCycleCheckOrder(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/keyofIndexSignatureCycleCheckOrder(checkorder=typesfirst).types index 812f122e35cc6..d43b1450f3a46 100644 --- a/tsc/testdata/baselines/reference/compiler/keyofIndexSignatureCycleCheckOrder(checkorder=typesfirst).types +++ b/tsc/testdata/baselines/reference/compiler/keyofIndexSignatureCycleCheckOrder(checkorder=typesfirst).types @@ -9,9 +9,9 @@ interface C { [k: string]: S; } >k : string type S = keyof C; ->S : any +>S : never const k: S = 123; ->k : any +>k : never >123 : 123 From bcacd2e7a73efcac58ab9df679254d118ddaf634 Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Wed, 11 Nov 2026 20:13:08 -0800 Subject: [PATCH 57/60] Only fail a cycle yield on reading a published member table A cycle yield recomputes a member of the cycle with the computations in progress hidden. Reading a member table being resolved below the yield failed the recomputation, since the table it would see is whatever part of it has been published. A table that has published nothing is instead resolved again from scratch inside the yield, so there is nothing incomplete to read, and failing there reported a circularity for a property only when its class was checked before its type was queried. Fixes 61711 --- tsc/internal/checker/checker.go | 7 ++++--- ...eCheckOrder(checkorder=default).errors.txt | 21 ------------------- 2 files changed, 4 insertions(+), 24 deletions(-) delete mode 100644 tsc/testdata/baselines/reference/compiler/cycleYieldThroughVarianceCheckOrder(checkorder=default).errors.txt diff --git a/tsc/internal/checker/checker.go b/tsc/internal/checker/checker.go index 1e65764b159b2..8afe78a4eaae1 100644 --- a/tsc/internal/checker/checker.go +++ b/tsc/internal/checker/checker.go @@ -21611,14 +21611,15 @@ func (c *Checker) resolveStructuredTypeMembersSlow(t *Type) *StructuredType { } else { c.isResolutionInProgress(t, TypeSystemPropertyNameStructuredMembers) } - if j, ok := c.resolvingGet(key); ok && int(j) < c.visibleStart { + published = c.resolutions[enclosing].membersPublished + if j, ok := c.resolvingGet(key); published && ok && int(j) < c.visibleStart { // The members are being resolved below the cycle yield in // progress, which then sees whatever part of them that // resolution has published, rather than compute them from - // scratch, so the yield fails. + // scratch, so the yield fails. If none are published, the + // nested resolution below computes them from scratch instead. c.markResolutionCycle(c.visibleStart) } - published = c.resolutions[enclosing].membersPublished } c.beginMemo(key) if !published { diff --git a/tsc/testdata/baselines/reference/compiler/cycleYieldThroughVarianceCheckOrder(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/cycleYieldThroughVarianceCheckOrder(checkorder=default).errors.txt deleted file mode 100644 index e4b5adb3ee604..0000000000000 --- a/tsc/testdata/baselines/reference/compiler/cycleYieldThroughVarianceCheckOrder(checkorder=default).errors.txt +++ /dev/null @@ -1,21 +0,0 @@ -cycleYieldThroughVarianceCheckOrder.ts(6,5): error TS2502: 'p' is referenced directly or indirectly in its own type annotation. - - -==== cycleYieldThroughVarianceCheckOrder.ts (1 errors) ==== - // Resolving the base of E measures the variances of B, which needs the type - // of p, which needs the members of E. Whether p is circular must not depend - // on whether B is checked before the type of arg is queried. - - declare class B { - p: E["p"]; - ~ -!!! error TS2502: 'p' is referenced directly or indirectly in its own type annotation. - } - declare class E extends mix(Base) { - p: number; - } - declare function mix object>(x: T): T; - declare class Base { - constructor(arg?: InstanceType); - } - \ No newline at end of file From 403c69a846a92f9c96f3529fdaa066ac11637383 Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Thu, 12 Nov 2026 10:03:20 -0800 Subject: [PATCH 58/60] Do not suggest typeof for a name used in its own value's declaration When a qualified name used as a type does not resolve, the error suggests typeof if the name resolves as a value, which needs the type of the value its first identifier refers to. In declare const n: n.T; declare namespace n {} that type is the annotation being resolved. Checking the annotation first made it the head of the cycle, and the missing member it reports was dropped along with the other results computed from the incomplete annotation, so it was reported only when the type of n was queried first. The type of a value used within its own declaration can depend on the name being resolved, so no suggestion is made there, and the missing member is reported in every order, without a circularity error. For 18163 --- tsc/internal/checker/checker.go | 4 +++- ...dNameCycleErrorCheckOrder(checkorder=default).errors.txt | 6 +++--- ...lifiedNameCycleErrorCheckOrder(checkorder=default).types | 2 +- ...meCycleErrorCheckOrder(checkorder=typesfirst).errors.txt | 5 +---- ...iedNameCycleErrorCheckOrder(checkorder=typesfirst).types | 2 +- 5 files changed, 9 insertions(+), 10 deletions(-) diff --git a/tsc/internal/checker/checker.go b/tsc/internal/checker/checker.go index 8afe78a4eaae1..6d5ba56c31d29 100644 --- a/tsc/internal/checker/checker.go +++ b/tsc/internal/checker/checker.go @@ -17354,7 +17354,9 @@ func (c *Checker) resolveQualifiedName(name *ast.Node, left *ast.Node, right *as func (c *Checker) tryGetQualifiedNameAsValue(node *ast.Node) *ast.Symbol { id := ast.GetFirstIdentifier(node) symbol := c.resolveName(id, id.Text(), ast.SymbolFlagsValue, nil /*nameNotFoundMessage*/, true /*isUse*/, false /*excludeGlobals*/) - if symbol == nil { + if symbol == nil || isSameScopeDescendentOf(node, symbol.ValueDeclaration(), nil) { + // The type of a value used in its own declaration, which the + // suggestion would need, can need the name being resolved. return nil } n := id diff --git a/tsc/testdata/baselines/reference/compiler/qualifiedNameCycleErrorCheckOrder(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/qualifiedNameCycleErrorCheckOrder(checkorder=default).errors.txt index ee473361b43a4..c8d33c7ef3504 100644 --- a/tsc/testdata/baselines/reference/compiler/qualifiedNameCycleErrorCheckOrder(checkorder=default).errors.txt +++ b/tsc/testdata/baselines/reference/compiler/qualifiedNameCycleErrorCheckOrder(checkorder=default).errors.txt @@ -1,4 +1,4 @@ -qualifiedNameCycleErrorCheckOrder.ts(5,15): error TS2502: 'n' is referenced directly or indirectly in its own type annotation. +qualifiedNameCycleErrorCheckOrder.ts(5,20): error TS2694: Namespace 'n' has no exported member 'T'. ==== qualifiedNameCycleErrorCheckOrder.ts (1 errors) ==== @@ -7,7 +7,7 @@ qualifiedNameCycleErrorCheckOrder.ts(5,15): error TS2502: 'n' is referenced dire // resolved first. declare const n: n.T; - ~ -!!! error TS2502: 'n' is referenced directly or indirectly in its own type annotation. + ~ +!!! error TS2694: Namespace 'n' has no exported member 'T'. declare namespace n {} \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/qualifiedNameCycleErrorCheckOrder(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/qualifiedNameCycleErrorCheckOrder(checkorder=default).types index 0aaabb289b6a6..3fab9ef68e510 100644 --- a/tsc/testdata/baselines/reference/compiler/qualifiedNameCycleErrorCheckOrder(checkorder=default).types +++ b/tsc/testdata/baselines/reference/compiler/qualifiedNameCycleErrorCheckOrder(checkorder=default).types @@ -6,7 +6,7 @@ // resolved first. declare const n: n.T; ->n : any +>n : n.T >n : any declare namespace n {} diff --git a/tsc/testdata/baselines/reference/compiler/qualifiedNameCycleErrorCheckOrder(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/qualifiedNameCycleErrorCheckOrder(checkorder=typesfirst).errors.txt index 9377a11b042da..c8d33c7ef3504 100644 --- a/tsc/testdata/baselines/reference/compiler/qualifiedNameCycleErrorCheckOrder(checkorder=typesfirst).errors.txt +++ b/tsc/testdata/baselines/reference/compiler/qualifiedNameCycleErrorCheckOrder(checkorder=typesfirst).errors.txt @@ -1,15 +1,12 @@ -qualifiedNameCycleErrorCheckOrder.ts(5,15): error TS2502: 'n' is referenced directly or indirectly in its own type annotation. qualifiedNameCycleErrorCheckOrder.ts(5,20): error TS2694: Namespace 'n' has no exported member 'T'. -==== qualifiedNameCycleErrorCheckOrder.ts (2 errors) ==== +==== qualifiedNameCycleErrorCheckOrder.ts (1 errors) ==== // Resolving n.T looks for a value n to suggest typeof, which needs the type of // n, which is n.T. The missing member must be reported whichever is // resolved first. declare const n: n.T; - ~ -!!! error TS2502: 'n' is referenced directly or indirectly in its own type annotation. ~ !!! error TS2694: Namespace 'n' has no exported member 'T'. declare namespace n {} diff --git a/tsc/testdata/baselines/reference/compiler/qualifiedNameCycleErrorCheckOrder(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/qualifiedNameCycleErrorCheckOrder(checkorder=typesfirst).types index 0aaabb289b6a6..3fab9ef68e510 100644 --- a/tsc/testdata/baselines/reference/compiler/qualifiedNameCycleErrorCheckOrder(checkorder=typesfirst).types +++ b/tsc/testdata/baselines/reference/compiler/qualifiedNameCycleErrorCheckOrder(checkorder=typesfirst).types @@ -6,7 +6,7 @@ // resolved first. declare const n: n.T; ->n : any +>n : n.T >n : any declare namespace n {} From 595cff4501c991b5ecabba4c4c6e1b3938fab0d7 Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Thu, 12 Nov 2026 23:44:21 -0800 Subject: [PATCH 59/60] Fail only one computation's instantiations at the stack limit Reaching the limit on the instantiation stack failed every instantiation in progress. A computation that resolves part of a type whenever it is first needed, like the element type of a deferred array type, is reached inside an instantiation or not depending on who needs it first, so whether the instantiation needing it failed as a whole depended on order. In type A = A[]; const r = ([] as A).flat(Infinity); r was any[] when the element type of A was resolved first, but any when the call was checked first. Reaching the limit now fails only the instantiations in progress in the innermost computation other than of a cached instantiation, which fail the same way wherever the computation is reached, so r is any[] in every order, as in TypeScript 6. A result carrying the error no longer fails an instantiation reading it, as computing it there would fail only within it. For 49280 --- tsc/internal/checker/checker.go | 3 +- tsc/internal/checker/checkerstate.go | 1 + tsc/internal/checker/memo.go | 67 ++++++++++++------- ...kLimitCheckOrder(checkorder=default).types | 4 +- ...mitCheckOrder(checkorder=typesfirst).types | 2 +- ...enericExtendingClassDoubleLayer.errors.txt | 7 +- 6 files changed, 49 insertions(+), 35 deletions(-) diff --git a/tsc/internal/checker/checker.go b/tsc/internal/checker/checker.go index 6d5ba56c31d29..9309fd79c5eaf 100644 --- a/tsc/internal/checker/checker.go +++ b/tsc/internal/checker/checker.go @@ -648,6 +648,7 @@ type Checker struct { instantiationStack []*Type instantiationAborted bool // See "Instantiation limits" instantiationAbortLog int // Length of discardLog when instantiationAborted was set + instantiationAbortRoot int // Length of instantiationStack to which a failing instantiation unwinds readIncompleteFloor int32 // See markReadIncomplete conditionalConstraintDepth depthLimit baseConstraintWalk baseConstraintWalk @@ -25190,7 +25191,7 @@ func (c *Checker) instantiateTypeWithAlias(t *Type, m *TypeMapper, alias *TypeAl } c.instantiationStack[len(c.instantiationStack)-1] = nil c.instantiationStack = c.instantiationStack[:len(c.instantiationStack)-1] - if len(c.instantiationStack) == 0 && c.instantiationAborted { + if c.instantiationAborted && len(c.instantiationStack) == c.instantiationAbortRoot { c.endInstantiationAbort() return c.errorType } diff --git a/tsc/internal/checker/checkerstate.go b/tsc/internal/checker/checkerstate.go index aa48254463da5..bf0150558747c 100644 --- a/tsc/internal/checker/checkerstate.go +++ b/tsc/internal/checker/checkerstate.go @@ -40,6 +40,7 @@ var checkerProgressFields = []string{ "inlineLevel", "innerCycles", "instantiationAbortLog", + "instantiationAbortRoot", "instantiationAborted", "instantiationStack", "markingForEmit", diff --git a/tsc/internal/checker/memo.go b/tsc/internal/checker/memo.go index c001fdc08e209..8ce64ad4a9dc7 100644 --- a/tsc/internal/checker/memo.go +++ b/tsc/internal/checker/memo.go @@ -1147,12 +1147,6 @@ func (s *memoState) setErrors(c *Checker, reports []*currentNodeError) { //go:noinline func (c *Checker) replayCurrentNodeErrors(reports []*currentNodeError) { for _, r := range reports { - if r == instantiationTooDeep && len(c.instantiationStack) != 0 { - // Computing the result here would fail the instantiation in - // progress; see "Instantiation limits". - c.abortInstantiation() - continue - } c.reportNode(r) } } @@ -2123,15 +2117,19 @@ func (c *Checker) logPendingDiscard(state *memoState) { // is there to stop infinite instantiations rather than to judge finite // ones: caching only ever shortens the stack, so an instantiation that // would stay below it if computed from scratch stays below it in any order. -// An instantiation reaching it fails as a whole, with all instantiations in -// progress, and the results cached since are discarded, so no part of an -// infinite instantiation is cached as though it were complete. The error -// reported for it is carried by the results computed with it, and replaying -// it in an instantiation in progress fails that instantiation the same way, -// as computing those results again would. Each cached instantiation in -// progress when one fails would fail too if computed from scratch, so it is -// recorded as failing, rather than computed again to the limit wherever it -// is reached. +// An instantiation reaching it fails as a whole, with the instantiations in +// progress in the innermost computation other than of a cached +// instantiation, and the results cached since are discarded, so no part of +// an infinite instantiation is cached as though it were complete. Such a +// computation, like resolving the type arguments of a deferred type +// reference, is computed whenever first needed, inside an instantiation or +// not, so failing only its own instantiations makes the failure the same +// wherever it is reached. The error reported for it is carried by the +// results computed with it, and replaying it fails nothing, as computing +// those results again would fail only within them. Each cached +// instantiation in progress when one fails would fail too if computed from +// scratch, so it is recorded as failing, rather than computed again to the +// limit wherever it is reached. // // The limit on the number of instantiations is only reached by runaway // instantiations, and depends on what was cached before: it counts @@ -2157,18 +2155,26 @@ var instantiationTooDeep = ¤tNodeError{func(c *Checker, node *ast.Node) { c.error(node, diagnostics.Type_instantiation_is_excessively_deep_and_possibly_infinite) }} -// abortInstantiation fails every instantiation in progress; see -// "Instantiation limits". +// abortInstantiation fails the instantiations in progress in the innermost +// computation other than of a cached instantiation; see "Instantiation +// limits". func (c *Checker) abortInstantiation() { if c.instantiationAborted { return } + root := c.instantiationRoot() + if int(c.resolutions[root].depthStart) == len(c.instantiationStack) { + // No instantiation of the root is in progress. + c.reportNode(instantiationTooDeep) + return + } c.instantiationAborted = true + c.instantiationAbortRoot = int(c.resolutions[root].depthStart) c.instantiationAbortLog = len(c.discardLog) // Each cached instantiation in progress reached the limit, and would // again if computed from scratch, so it is known to fail without // computing it again. - for i := range c.resolutions { + for i := root + 1; i < len(c.resolutions); i++ { if f := &c.resolutions[i]; f.instantiation { if c.tooDeepInstantiations == nil { c.tooDeepInstantiations = make(map[memoKey]struct{}) @@ -2190,14 +2196,24 @@ func (c *Checker) beginInstantiation() bool { if _, ok := c.tooDeepInstantiations[f.key]; !ok { return false } - if len(c.instantiationStack) != 0 { - c.abortInstantiation() - } else { - c.reportNode(instantiationTooDeep) - } + c.abortInstantiation() return true } +// instantiationRoot returns the index in resolutions of the innermost +// computation in progress other than of a cached instantiation, whose +// instantiations fail together when one reaches instantiationStackLimit; see +// "Instantiation limits". A type or node resolution is part of the +// computation below it, with the same serial. +func (c *Checker) instantiationRoot() int { + for i := len(c.resolutions) - 1; i > 0; i-- { + if f := &c.resolutions[i]; !f.instantiation && f.serial != c.resolutions[i-1].serial { + return i + } + } + return 0 +} + // endInstantiation is called when the computation of a cached instantiation // finishes, and reports whether to cache its result. An instantiation // finishing while instantiations in progress are failing is part of the @@ -2213,10 +2229,11 @@ func (c *Checker) endInstantiation(reports currentNodeErrorsMark) bool { return false } -// endInstantiationAbort finishes failing the outermost instantiation, once -// it has unwound. +// endInstantiationAbort finishes failing the instantiations of the innermost +// computation, once they have unwound. func (c *Checker) endInstantiationAbort() { c.instantiationAborted = false + c.instantiationAbortRoot = 0 c.discardLogSince(c.instantiationAbortLog) c.instantiationAbortLog = 0 c.trimDiscardLog() diff --git a/tsc/testdata/baselines/reference/compiler/instantiationStackLimitCheckOrder(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/instantiationStackLimitCheckOrder(checkorder=default).types index 25dbb75282678..f9ab2f388174d 100644 --- a/tsc/testdata/baselines/reference/compiler/instantiationStackLimitCheckOrder(checkorder=default).types +++ b/tsc/testdata/baselines/reference/compiler/instantiationStackLimitCheckOrder(checkorder=default).types @@ -20,8 +20,8 @@ type A = A[]; >A : A const r = ([] as A).flat(Infinity); ->r : any ->([] as A).flat(Infinity) : any +>r : any[] +>([] as A).flat(Infinity) : any[] >([] as A).flat : (this: A, depth?: D | undefined) => FlatArray[] >([] as A) : A >[] as A : A diff --git a/tsc/testdata/baselines/reference/compiler/instantiationStackLimitCheckOrder(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/instantiationStackLimitCheckOrder(checkorder=typesfirst).types index ad899bd00df1c..f9ab2f388174d 100644 --- a/tsc/testdata/baselines/reference/compiler/instantiationStackLimitCheckOrder(checkorder=typesfirst).types +++ b/tsc/testdata/baselines/reference/compiler/instantiationStackLimitCheckOrder(checkorder=typesfirst).types @@ -21,7 +21,7 @@ type A = A[]; const r = ([] as A).flat(Infinity); >r : any[] ->([] as A).flat(Infinity) : any +>([] as A).flat(Infinity) : any[] >([] as A).flat : (this: A, depth?: D | undefined) => FlatArray[] >([] as A) : A >[] as A : A diff --git a/tsc/testdata/baselines/reference/compiler/keyofGenericExtendingClassDoubleLayer.errors.txt b/tsc/testdata/baselines/reference/compiler/keyofGenericExtendingClassDoubleLayer.errors.txt index 78ca4d5e576e6..d86789c55c7e6 100644 --- a/tsc/testdata/baselines/reference/compiler/keyofGenericExtendingClassDoubleLayer.errors.txt +++ b/tsc/testdata/baselines/reference/compiler/keyofGenericExtendingClassDoubleLayer.errors.txt @@ -1,12 +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 TS2589: Type instantiation is excessively deep and possibly infinite. keyofGenericExtendingClassDoubleLayer.ts(10,12): error TS2564: Property 'age' has no initializer and is not definitely assigned in the constructor. -keyofGenericExtendingClassDoubleLayer.ts(13,13): error TS2322: Type 'string' is not assignable to type 'keyof this'. - Type '"createdAt"' is not assignable to type '"age" | "toJson"'. keyofGenericExtendingClassDoubleLayer.ts(13,13): error TS2589: Type instantiation is excessively deep and possibly infinite. -==== keyofGenericExtendingClassDoubleLayer.ts (5 errors) ==== +==== keyofGenericExtendingClassDoubleLayer.ts (4 errors) ==== class Model { public createdAt: Date; ~~~~~~~~~ @@ -27,9 +25,6 @@ keyofGenericExtendingClassDoubleLayer.ts(13,13): error TS2589: Type instantiatio toJson() { let x: keyof this = 'createdAt'; ~ -!!! error TS2322: Type 'string' is not assignable to type 'keyof this'. -!!! error TS2322: Type '"createdAt"' is not assignable to type '"age" | "toJson"'. - ~ !!! error TS2589: Type instantiation is excessively deep and possibly infinite. } } From 9a2e42360a49689d7b773fd32a87ce75e301274a Mon Sep 17 00:00:00 2001 From: Jake Bailey <5341706+jakebailey@users.noreply.github.com> Date: Fri, 13 Nov 2026 13:48:26 -0800 Subject: [PATCH 60/60] Share heights and key hashing between memoized computations A base constraint keeps how deep its own walk went, so that a walk reusing it can tell whether computing it again there would give up. Comparisons are about to keep the same kind of record for their cached failures, so the record becomes a type of its own, a height, with the checks both need. The multiplication spreading the bits of a key over the high bits, which several tables and filters index by, is likewise written once. --- tsc/internal/checker/checker.go | 9 +++--- tsc/internal/checker/memo.go | 46 +++++++++++++++++++++++++++-- tsc/internal/checker/resolutions.go | 2 +- tsc/internal/checker/types.go | 4 +-- 4 files changed, 50 insertions(+), 11 deletions(-) diff --git a/tsc/internal/checker/checker.go b/tsc/internal/checker/checker.go index 9309fd79c5eaf..787cc5833aff2 100644 --- a/tsc/internal/checker/checker.go +++ b/tsc/internal/checker/checker.go @@ -30863,12 +30863,11 @@ 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. if len(stack) != 0 { - depth := int32(len(stack)) + int32(t.baseConstraintHeight) - if depth >= baseConstraintFreeDepth { + if t.baseConstraintHeight.reaches(len(stack), baseConstraintFreeDepth) { constraint, _, _ := c.resolveBaseConstraint(t, stack, TypeSystemPropertyNameBaseConstraintInWalk, nil) return constraint } - c.baseConstraintWalk.depth = max(c.baseConstraintWalk.depth, depth) + c.baseConstraintWalk.depth = max(c.baseConstraintWalk.depth, int32(len(stack))+int32(t.baseConstraintHeight)) } return constrained.resolvedBaseConstraint.cached(c) } @@ -30921,13 +30920,13 @@ func (c *Checker) getResolvedBaseConstraintUncached(t *Type, stack []RecursionId if constrained.resolvedBaseConstraint.cached(c) != nil { return constrained.resolvedBaseConstraint.cached(c) } - constraint, height, gaveUp := c.resolveBaseConstraint(t, stack, TypeSystemPropertyNameResolvedBaseConstraint, &constrained.resolvedBaseConstraint.memoHeader) + constraint, walkHeight, gaveUp := c.resolveBaseConstraint(t, stack, TypeSystemPropertyNameResolvedBaseConstraint, &constrained.resolvedBaseConstraint.memoHeader) if gaveUp && len(stack) != 0 { // Depends on the walk it was computed in. return constraint } if constrained.resolvedBaseConstraint.cached(c) == nil { - t.baseConstraintHeight = uint8(min(height, math.MaxUint8)) + t.baseConstraintHeight = heightOf(walkHeight) constrained.resolvedBaseConstraint.set(c, constraint) } return constraint diff --git a/tsc/internal/checker/memo.go b/tsc/internal/checker/memo.go index 8ce64ad4a9dc7..debda5aebc60c 100644 --- a/tsc/internal/checker/memo.go +++ b/tsc/internal/checker/memo.go @@ -4,6 +4,7 @@ import ( "hash/maphash" "iter" "maps" + "math" "math/bits" "slices" "unsafe" @@ -647,7 +648,7 @@ func (m *memoMap[K, V]) begin(c *Checker, k K) { func (m *memoMap[K, V]) entryKey(k K) memoKey { // SAFETY: Only the address of the map is kept, as an identity; it is // never turned back into a pointer. - h := maphash.Comparable(memoMapSeed, k) ^ uint64(uintptr(unsafe.Pointer(m)))*0x9E3779B97F4A7C15 + h := maphash.Comparable(memoMapSeed, k) ^ spreadBits(uint64(uintptr(unsafe.Pointer(m)))) return memoKey(h&^0xff | uint64(memoMapEntry)) } @@ -881,8 +882,14 @@ type stateKeyFilter struct { // to a few percent. const stateFilterBitsPerState = 16 +// spreadBits spreads the bits of x over the high bits of the result, from +// which hash tables and filters take their indexes. +func spreadBits(x uint64) uint64 { + return x * 0x9E3779B97F4A7C15 +} + func memoKeyBits(key memoKey) uint64 { - return uint64(key) * 0x9E3779B97F4A7C15 + return spreadBits(uint64(key)) } func (f *stateKeyFilter) mayContain(h uint64) bool { @@ -918,7 +925,7 @@ const errorFilterBits = 12 type errorKeyFilter [1 << errorFilterBits / 64]uint64 func errorFilterIndex(key memoKey) uint64 { - return uint64(key) * 0x9E3779B97F4A7C15 >> (64 - errorFilterBits) + return spreadBits(uint64(key)) >> (64 - errorFilterBits) } // peekMemoState returns the memo state of the result identified by key, or @@ -2139,6 +2146,39 @@ func (c *Checker) logPendingDiscard(state *memoState) { // keeping, for every cached result, the work needed to compute it from // scratch, which costs far more than the limit is worth. +// Heights +// +// Some computations give up beyond a limit on how deeply they nest, counted +// from the outermost one in progress, so a result computed inside another +// computation can differ from the same result computed on its own. A height +// is the number of levels a computation went below its own, kept with a +// cached result so that a computation reusing the result can tell whether +// computing it again there would reach the limit; see "Base constraint +// walks" and "Reusing failures". + +// height saturates at its maximum, which is above every limit it is +// compared with. +type height uint8 + +func heightOf[T ~int | ~int32](levels T) height { + return height(min(levels, math.MaxUint8)) +} + +// below returns the height of a computation with a computation of height h +// one level below it. +func (h height) below() height { + if h == math.MaxUint8 { + return h + } + return h + 1 +} + +// reaches reports whether a computation of height h, started at depth, +// reaches limit. +func (h height) reaches(depth int, limit int) bool { + return depth+int(h) >= limit +} + const ( instantiationDepthLimit = 100 instantiationStackLimit = 1000 diff --git a/tsc/internal/checker/resolutions.go b/tsc/internal/checker/resolutions.go index 04dbd59177add..4f68d33f31c83 100644 --- a/tsc/internal/checker/resolutions.go +++ b/tsc/internal/checker/resolutions.go @@ -199,7 +199,7 @@ type resolvingTable struct { const resolvingTableBits = 12 func resolvingHome(key memoKey) uint64 { - return uint64(key) * 0x9E3779B97F4A7C15 >> (64 - resolvingTableBits) + return spreadBits(uint64(key)) >> (64 - resolvingTableBits) } // resolvingGet returns the index in resolutions of the computation of key diff --git a/tsc/internal/checker/types.go b/tsc/internal/checker/types.go index 5fd105bf14cf9..c142ab9cba9b6 100644 --- a/tsc/internal/checker/types.go +++ b/tsc/internal/checker/types.go @@ -823,8 +823,8 @@ type Type struct { objectFlags ObjectFlags id TypeId kind typeKind `customlint:"protected"` - // Depth of the walk for the cached base constraint; see "Base constraint walks" - baseConstraintHeight uint8 + // Height of the walk for the cached base constraint; see "Base constraint walks" + baseConstraintHeight height generation uint16 // see Checker.typeGeneration; zero until computed symbol *ast.Symbol alias *TypeAlias

+ +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..d3c1fd53cc93f --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/deleteExpressionMustBeOptional(checkorder=typesfirst,strict=true).errors.txt @@ -0,0 +1,59 @@ +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(36,8): error TS2790: The operand of a 'delete' operator must be optional. +deleteExpressionMustBeOptional.ts(37,8): error TS2790: The operand of a 'delete' operator must be optional. + + +==== deleteExpressionMustBeOptional.ts (5 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 + ~~~ +!!! error TS2790: The operand of a 'delete' operator must be optional. + delete a.b + ~~~ +!!! error TS2790: The operand of a 'delete' operator must be optional. + + 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..265e9b075cacf --- /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 : any +>kind === "a" ? payload.toFixed() : payload.toUpperCase() : any +>kind === "a" : boolean +>kind : "a" | "b" +>"a" : "a" +>payload.toFixed() : string +>payload.toFixed : (fractionDigits?: number) => string +>payload : number +>toFixed : (fractionDigits?: number) => string +>payload.toUpperCase() : string +>payload.toUpperCase : () => string +>payload : string +>toUpperCase : () => string + +} = u; +>u : U + +function f({ +>f : ({ kind, payload, extra, }: U) => void + + kind, +>kind : "a" | "b" + + payload, +>payload : string | number + + extra = kind === "a" ? payload.toFixed() : payload.toUpperCase(), +>extra : unknown +>kind === "a" ? payload.toFixed() : payload.toUpperCase() : string +>kind === "a" : boolean +>kind : "a" | "b" +>"a" : "a" +>payload.toFixed() : string +>payload.toFixed : (fractionDigits?: number) => string +>payload : number +>toFixed : (fractionDigits?: number) => string +>payload.toUpperCase() : string +>payload.toUpperCase : () => string +>payload : string +>toUpperCase : () => string + +}: U) {} + diff --git a/tsc/testdata/baselines/reference/compiler/distributiveConstraintOfCircularCheckType.symbols b/tsc/testdata/baselines/reference/compiler/distributiveConstraintOfCircularCheckType.symbols new file mode 100644 index 0000000000000..06df0f2a50571 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/distributiveConstraintOfCircularCheckType.symbols @@ -0,0 +1,45 @@ +//// [tests/cases/compiler/distributiveConstraintOfCircularCheckType.ts] //// + +=== distributiveConstraintOfCircularCheckType.ts === +// The base constraint of Collect is circular, since its +// constraint includes Collect, whose constraint includes itself. +// Distributing Parameters over that constraint leads back into the +// circularity, so Parameters> must instead have the +// constraint of its branches, unknown[], and be spreadable. + +type Collect = +>Collect : Symbol(Collect, Decl(distributiveConstraintOfCircularCheckType.ts, 0, 0)) +>F : Symbol(F, Decl(distributiveConstraintOfCircularCheckType.ts, 6, 13)) +>Result : Symbol(Result, Decl(distributiveConstraintOfCircularCheckType.ts, 6, 15)) + + Result & F extends (arg: infer A) => infer R +>Result : Symbol(Result, Decl(distributiveConstraintOfCircularCheckType.ts, 6, 15)) +>F : Symbol(F, Decl(distributiveConstraintOfCircularCheckType.ts, 6, 13)) +>arg : Symbol(arg, Decl(distributiveConstraintOfCircularCheckType.ts, 7, 24)) +>A : Symbol(A, Decl(distributiveConstraintOfCircularCheckType.ts, 7, 34)) +>R : Symbol(R, Decl(distributiveConstraintOfCircularCheckType.ts, 7, 46)) + + ? Collect | (() => R) +>Collect : Symbol(Collect, Decl(distributiveConstraintOfCircularCheckType.ts, 0, 0)) +>F : Symbol(F, Decl(distributiveConstraintOfCircularCheckType.ts, 6, 13)) +>F : Symbol(F, Decl(distributiveConstraintOfCircularCheckType.ts, 6, 13)) +>R : Symbol(R, Decl(distributiveConstraintOfCircularCheckType.ts, 7, 46)) + + : never; + +function pipe unknown>(args: Parameters>, f: F) { +>pipe : Symbol(pipe, Decl(distributiveConstraintOfCircularCheckType.ts, 9, 16)) +>F : Symbol(F, Decl(distributiveConstraintOfCircularCheckType.ts, 11, 14)) +>args : Symbol(args, Decl(distributiveConstraintOfCircularCheckType.ts, 11, 25)) +>args : Symbol(args, Decl(distributiveConstraintOfCircularCheckType.ts, 11, 51)) +>Parameters : Symbol(Parameters, Decl(lib.es5.d.ts, --, --)) +>Collect : Symbol(Collect, Decl(distributiveConstraintOfCircularCheckType.ts, 0, 0)) +>F : Symbol(F, Decl(distributiveConstraintOfCircularCheckType.ts, 11, 14)) +>f : Symbol(f, Decl(distributiveConstraintOfCircularCheckType.ts, 11, 89)) +>F : Symbol(F, Decl(distributiveConstraintOfCircularCheckType.ts, 11, 14)) + + f(...args); +>f : Symbol(f, Decl(distributiveConstraintOfCircularCheckType.ts, 11, 89)) +>args : Symbol(args, Decl(distributiveConstraintOfCircularCheckType.ts, 11, 51)) +} + diff --git a/tsc/testdata/baselines/reference/compiler/distributiveConstraintOfCircularCheckType.types b/tsc/testdata/baselines/reference/compiler/distributiveConstraintOfCircularCheckType.types new file mode 100644 index 0000000000000..5a0f4a282fbac --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/distributiveConstraintOfCircularCheckType.types @@ -0,0 +1,31 @@ +//// [tests/cases/compiler/distributiveConstraintOfCircularCheckType.ts] //// + +=== distributiveConstraintOfCircularCheckType.ts === +// The base constraint of Collect is circular, since its +// constraint includes Collect, whose constraint includes itself. +// Distributing Parameters over that constraint leads back into the +// circularity, so Parameters> must instead have the +// constraint of its branches, unknown[], and be spreadable. + +type Collect = +>Collect : Collect + + Result & F extends (arg: infer A) => infer R +>arg : A + + ? Collect | (() => R) + : never; + +function pipe unknown>(args: Parameters>, f: F) { +>pipe : unknown>(args: Parameters>, f: F) => void +>args : any +>args : Parameters> +>f : F + + f(...args); +>f(...args) : unknown +>f : F +>...args : unknown +>args : Parameters> +} + diff --git a/tsc/testdata/baselines/reference/compiler/enumMemberTypeCacheConsistency.js b/tsc/testdata/baselines/reference/compiler/enumMemberTypeCacheConsistency.js new file mode 100644 index 0000000000000..774af8292c6a9 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/enumMemberTypeCacheConsistency.js @@ -0,0 +1,29 @@ +//// [tests/cases/compiler/enumMemberTypeCacheConsistency.ts] //// + +//// [enumMemberTypeCacheConsistency.ts] +enum E { + A = 0, + B = E.A.valueOf(), + C = 1, +} + +const member: Extract = E.C; + +//// [enumMemberTypeCacheConsistency.js] +"use strict"; +var E; +(function (E) { + E[E["A"] = 0] = "A"; + E[E["B"] = E.A.valueOf()] = "B"; + E[E["C"] = 1] = "C"; +})(E || (E = {})); +const member = E.C; + + +//// [enumMemberTypeCacheConsistency.d.ts] +declare enum E { + A = 0, + B, + C = 1 +} +declare const member: Extract; diff --git a/tsc/testdata/baselines/reference/compiler/enumMemberTypeCacheConsistency.symbols b/tsc/testdata/baselines/reference/compiler/enumMemberTypeCacheConsistency.symbols new file mode 100644 index 0000000000000..d527b2792f38e --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/enumMemberTypeCacheConsistency.symbols @@ -0,0 +1,29 @@ +//// [tests/cases/compiler/enumMemberTypeCacheConsistency.ts] //// + +=== enumMemberTypeCacheConsistency.ts === +enum E { +>E : Symbol(E, Decl(enumMemberTypeCacheConsistency.ts, 0, 0)) + + A = 0, +>A : Symbol(E.A, Decl(enumMemberTypeCacheConsistency.ts, 0, 8)) + + B = E.A.valueOf(), +>B : Symbol(E.B, Decl(enumMemberTypeCacheConsistency.ts, 1, 10)) +>E.A.valueOf : Symbol(Number.valueOf, Decl(lib.es5.d.ts, --, --)) +>E.A : Symbol(E.A, Decl(enumMemberTypeCacheConsistency.ts, 0, 8)) +>E : Symbol(E, Decl(enumMemberTypeCacheConsistency.ts, 0, 0)) +>A : Symbol(E.A, Decl(enumMemberTypeCacheConsistency.ts, 0, 8)) +>valueOf : Symbol(Number.valueOf, Decl(lib.es5.d.ts, --, --)) + + C = 1, +>C : Symbol(E.C, Decl(enumMemberTypeCacheConsistency.ts, 2, 22)) +} + +const member: Extract = E.C; +>member : Symbol(member, Decl(enumMemberTypeCacheConsistency.ts, 6, 5)) +>Extract : Symbol(Extract, Decl(lib.es5.d.ts, --, --)) +>E : Symbol(E, Decl(enumMemberTypeCacheConsistency.ts, 0, 0)) +>E.C : Symbol(E.C, Decl(enumMemberTypeCacheConsistency.ts, 2, 22)) +>E : Symbol(E, Decl(enumMemberTypeCacheConsistency.ts, 0, 0)) +>C : Symbol(E.C, Decl(enumMemberTypeCacheConsistency.ts, 2, 22)) + diff --git a/tsc/testdata/baselines/reference/compiler/enumMemberTypeCacheConsistency.types b/tsc/testdata/baselines/reference/compiler/enumMemberTypeCacheConsistency.types new file mode 100644 index 0000000000000..118dbac02ec0b --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/enumMemberTypeCacheConsistency.types @@ -0,0 +1,30 @@ +//// [tests/cases/compiler/enumMemberTypeCacheConsistency.ts] //// + +=== enumMemberTypeCacheConsistency.ts === +enum E { +>E : E + + A = 0, +>A : E.A +>0 : 0 + + B = E.A.valueOf(), +>B : E.B +>E.A.valueOf() : number +>E.A.valueOf : () => number +>E.A : E.A +>E : typeof E +>A : E.A +>valueOf : () => number + + C = 1, +>C : E.C +>1 : 1 +} + +const member: Extract = E.C; +>member : E.C +>E.C : E.C +>E : typeof E +>C : E.C + diff --git a/tsc/testdata/baselines/reference/compiler/evolvingArrayReadInLoopCondition.errors.txt b/tsc/testdata/baselines/reference/compiler/evolvingArrayReadInLoopCondition.errors.txt new file mode 100644 index 0000000000000..74a594964208d --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/evolvingArrayReadInLoopCondition.errors.txt @@ -0,0 +1,23 @@ +evolvingArrayReadInLoopCondition.ts(7,7): error TS7034: Variable 'seen' implicitly has type 'any[]' in some locations where its type cannot be determined. +evolvingArrayReadInLoopCondition.ts(9,10): error TS7005: Variable 'seen' implicitly has an 'any[]' type. + + +==== evolvingArrayReadInLoopCondition.ts (2 errors) ==== + // Narrowing by the condition needs the type of `seen` at the call, which + // depends on the analysis of the loop in progress for that same read. Once + // the loop is analyzed, `seen` is number[] there, so no error should say that + // its type cannot be determined. + + declare const x: number; + const seen = []; + ~~~~ +!!! error TS7034: Variable 'seen' implicitly has type 'any[]' in some locations where its type cannot be determined. + for (let i = 0; i < 3; i++) { + if (!seen.some(s => true)) { + ~~~~ +!!! error TS7005: Variable 'seen' implicitly has an 'any[]' type. + seen.push(x); + } + } + const result = seen; + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/evolvingArrayReadInLoopCondition.symbols b/tsc/testdata/baselines/reference/compiler/evolvingArrayReadInLoopCondition.symbols new file mode 100644 index 0000000000000..f78b71ec020dd --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/evolvingArrayReadInLoopCondition.symbols @@ -0,0 +1,36 @@ +//// [tests/cases/compiler/evolvingArrayReadInLoopCondition.ts] //// + +=== evolvingArrayReadInLoopCondition.ts === +// Narrowing by the condition needs the type of `seen` at the call, which +// depends on the analysis of the loop in progress for that same read. Once +// the loop is analyzed, `seen` is number[] there, so no error should say that +// its type cannot be determined. + +declare const x: number; +>x : Symbol(x, Decl(evolvingArrayReadInLoopCondition.ts, 5, 13)) + +const seen = []; +>seen : Symbol(seen, Decl(evolvingArrayReadInLoopCondition.ts, 6, 5)) + +for (let i = 0; i < 3; i++) { +>i : Symbol(i, Decl(evolvingArrayReadInLoopCondition.ts, 7, 8)) +>i : Symbol(i, Decl(evolvingArrayReadInLoopCondition.ts, 7, 8)) +>i : Symbol(i, Decl(evolvingArrayReadInLoopCondition.ts, 7, 8)) + + if (!seen.some(s => true)) { +>seen.some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --)) +>seen : Symbol(seen, Decl(evolvingArrayReadInLoopCondition.ts, 6, 5)) +>some : Symbol(Array.some, Decl(lib.es5.d.ts, --, --)) +>s : Symbol(s, Decl(evolvingArrayReadInLoopCondition.ts, 8, 19)) + + seen.push(x); +>seen.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --)) +>seen : Symbol(seen, Decl(evolvingArrayReadInLoopCondition.ts, 6, 5)) +>push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --)) +>x : Symbol(x, Decl(evolvingArrayReadInLoopCondition.ts, 5, 13)) + } +} +const result = seen; +>result : Symbol(result, Decl(evolvingArrayReadInLoopCondition.ts, 12, 5)) +>seen : Symbol(seen, Decl(evolvingArrayReadInLoopCondition.ts, 6, 5)) + diff --git a/tsc/testdata/baselines/reference/compiler/evolvingArrayReadInLoopCondition.types b/tsc/testdata/baselines/reference/compiler/evolvingArrayReadInLoopCondition.types new file mode 100644 index 0000000000000..6b413578e01e5 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/evolvingArrayReadInLoopCondition.types @@ -0,0 +1,46 @@ +//// [tests/cases/compiler/evolvingArrayReadInLoopCondition.ts] //// + +=== evolvingArrayReadInLoopCondition.ts === +// Narrowing by the condition needs the type of `seen` at the call, which +// depends on the analysis of the loop in progress for that same read. Once +// the loop is analyzed, `seen` is number[] there, so no error should say that +// its type cannot be determined. + +declare const x: number; +>x : number + +const seen = []; +>seen : any[] +>[] : never[] + +for (let i = 0; i < 3; i++) { +>i : number +>0 : 0 +>i < 3 : boolean +>i : number +>3 : 3 +>i++ : number +>i : number + + if (!seen.some(s => true)) { +>!seen.some(s => true) : boolean +>seen.some(s => true) : boolean +>seen.some : (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any) => boolean +>seen : number[] +>some : (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any) => boolean +>s => true : (s: number) => boolean +>s : number +>true : true + + seen.push(x); +>seen.push(x) : number +>seen.push : (...items: any[]) => number +>seen : any[] +>push : (...items: any[]) => number +>x : number + } +} +const result = seen; +>result : number[] +>seen : number[] + diff --git a/tsc/testdata/baselines/reference/compiler/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..651cd4a45a647 --- /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 : never + + break; + } + } +} + +// Repro from #51688 + +declare function functionB(key: string): string; +>functionB : (key: string) => string +>key : string + +function functionC(): void { +>functionC : () => void + + let unionVal: "A" | "B" = "A"; +>unionVal : "A" | "B" +>"A" : "A" + + while (true) { +>true : true + + let key: string; +>key : string + + switch (unionVal) { +>unionVal : "A" + + case "A": { +>"A" : "A" + + key = "AA"; +>key = "AA" : "AA" +>key : string +>"AA" : "AA" + + break; + } + } + functionB(key); +>functionB(key) : string +>functionB : (key: string) => string +>key : string + } +} + diff --git a/tsc/testdata/baselines/reference/compiler/exportAssignmentNestedVisibilityQueryOrder(checkorder=default).js b/tsc/testdata/baselines/reference/compiler/exportAssignmentNestedVisibilityQueryOrder(checkorder=default).js new file mode 100644 index 0000000000000..7f22b20127d74 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/exportAssignmentNestedVisibilityQueryOrder(checkorder=default).js @@ -0,0 +1,35 @@ +//// [tests/cases/compiler/exportAssignmentNestedVisibilityQueryOrder.ts] //// + +//// [exportAssignmentNestedVisibilityQueryOrder.ts] +namespace m { + export interface Inner { + x: number; + } + export interface Outer { + use: (inner: Inner) => Outer; + } +} +declare var m: { + (): m.Outer; +}; +export = m; + + +//// [exportAssignmentNestedVisibilityQueryOrder.js] +"use strict"; +module.exports = m; + + +//// [exportAssignmentNestedVisibilityQueryOrder.d.ts] +declare namespace m { + interface Inner { + x: number; + } + interface Outer { + use: (inner: Inner) => Outer; + } +} +declare var m: { + (): m.Outer; +}; +export = m; diff --git a/tsc/testdata/baselines/reference/compiler/exportAssignmentNestedVisibilityQueryOrder(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/exportAssignmentNestedVisibilityQueryOrder(checkorder=default).symbols new file mode 100644 index 0000000000000..37c52594b538a --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/exportAssignmentNestedVisibilityQueryOrder(checkorder=default).symbols @@ -0,0 +1,33 @@ +//// [tests/cases/compiler/exportAssignmentNestedVisibilityQueryOrder.ts] //// + +=== exportAssignmentNestedVisibilityQueryOrder.ts === +namespace m { +>m : Symbol(m, Decl(exportAssignmentNestedVisibilityQueryOrder.ts, 0, 0), Decl(exportAssignmentNestedVisibilityQueryOrder.ts, 8, 11)) + + export interface Inner { +>Inner : Symbol(Inner, Decl(exportAssignmentNestedVisibilityQueryOrder.ts, 0, 13)) + + x: number; +>x : Symbol(Inner.x, Decl(exportAssignmentNestedVisibilityQueryOrder.ts, 1, 28)) + } + export interface Outer { +>Outer : Symbol(Outer, Decl(exportAssignmentNestedVisibilityQueryOrder.ts, 3, 5)) + + use: (inner: Inner) => Outer; +>use : Symbol(Outer.use, Decl(exportAssignmentNestedVisibilityQueryOrder.ts, 4, 28)) +>inner : Symbol(inner, Decl(exportAssignmentNestedVisibilityQueryOrder.ts, 5, 14)) +>Inner : Symbol(Inner, Decl(exportAssignmentNestedVisibilityQueryOrder.ts, 0, 13)) +>Outer : Symbol(Outer, Decl(exportAssignmentNestedVisibilityQueryOrder.ts, 3, 5)) + } +} +declare var m: { +>m : Symbol(m, Decl(exportAssignmentNestedVisibilityQueryOrder.ts, 0, 0), Decl(exportAssignmentNestedVisibilityQueryOrder.ts, 8, 11)) + + (): m.Outer; +>m : Symbol(m, Decl(exportAssignmentNestedVisibilityQueryOrder.ts, 0, 0), Decl(exportAssignmentNestedVisibilityQueryOrder.ts, 8, 11)) +>Outer : Symbol(m.Outer, Decl(exportAssignmentNestedVisibilityQueryOrder.ts, 3, 5)) + +}; +export = m; +>m : Symbol(m, Decl(exportAssignmentNestedVisibilityQueryOrder.ts, 0, 0), Decl(exportAssignmentNestedVisibilityQueryOrder.ts, 8, 11)) + diff --git a/tsc/testdata/baselines/reference/compiler/exportAssignmentNestedVisibilityQueryOrder(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/exportAssignmentNestedVisibilityQueryOrder(checkorder=default).types new file mode 100644 index 0000000000000..600dc4ebe4a28 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/exportAssignmentNestedVisibilityQueryOrder(checkorder=default).types @@ -0,0 +1,24 @@ +//// [tests/cases/compiler/exportAssignmentNestedVisibilityQueryOrder.ts] //// + +=== exportAssignmentNestedVisibilityQueryOrder.ts === +namespace m { + export interface Inner { + x: number; +>x : number + } + export interface Outer { + use: (inner: Inner) => Outer; +>use : (inner: Inner) => Outer +>inner : Inner + } +} +declare var m: { +>m : () => m.Outer + + (): m.Outer; +>m : any + +}; +export = m; +>m : () => m.Outer + diff --git a/tsc/testdata/baselines/reference/compiler/exportAssignmentNestedVisibilityQueryOrder(checkorder=editorfirst).js b/tsc/testdata/baselines/reference/compiler/exportAssignmentNestedVisibilityQueryOrder(checkorder=editorfirst).js new file mode 100644 index 0000000000000..405c0f22e5b40 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/exportAssignmentNestedVisibilityQueryOrder(checkorder=editorfirst).js @@ -0,0 +1,63 @@ +//// [tests/cases/compiler/exportAssignmentNestedVisibilityQueryOrder.ts] //// + +//// [exportAssignmentNestedVisibilityQueryOrder.ts] +namespace m { + export interface Inner { + x: number; + } + export interface Outer { + use: (inner: Inner) => Outer; + } +} +declare var m: { + (): m.Outer; +}; +export = m; + + +//// [exportAssignmentNestedVisibilityQueryOrder.js] +"use strict"; +module.exports = m; + + +//// [exportAssignmentNestedVisibilityQueryOrder.d.ts] +declare namespace m { +} +declare var m: { + (): m.Outer; +}; +export = m; + + +//// [DtsFileErrors] + + +exportAssignmentNestedVisibilityQueryOrder.d.ts(4,11): error TS2694: Namespace 'm' has no exported member 'Outer'. + + +==== exportAssignmentNestedVisibilityQueryOrder.d.ts (1 errors) ==== + declare namespace m { + } + declare var m: { + (): m.Outer; + ~~~~~ +!!! error TS2694: Namespace 'm' has no exported member 'Outer'. + }; + export = m; + + +!!!! File exportAssignmentNestedVisibilityQueryOrder.d.ts differs from original emit in noCheck emit +//// [exportAssignmentNestedVisibilityQueryOrder.d.ts] +--- Expected The full check baseline ++++ Actual with noCheck set +@@ -1,4 +1,10 @@ + declare namespace m { ++ interface Inner { ++ x: number; ++ } ++ interface Outer { ++ use: (inner: Inner) => Outer; ++ } + } + declare var m: { + (): m.Outer; \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/exportAssignmentNestedVisibilityQueryOrder(checkorder=editorfirst).symbols b/tsc/testdata/baselines/reference/compiler/exportAssignmentNestedVisibilityQueryOrder(checkorder=editorfirst).symbols new file mode 100644 index 0000000000000..37c52594b538a --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/exportAssignmentNestedVisibilityQueryOrder(checkorder=editorfirst).symbols @@ -0,0 +1,33 @@ +//// [tests/cases/compiler/exportAssignmentNestedVisibilityQueryOrder.ts] //// + +=== exportAssignmentNestedVisibilityQueryOrder.ts === +namespace m { +>m : Symbol(m, Decl(exportAssignmentNestedVisibilityQueryOrder.ts, 0, 0), Decl(exportAssignmentNestedVisibilityQueryOrder.ts, 8, 11)) + + export interface Inner { +>Inner : Symbol(Inner, Decl(exportAssignmentNestedVisibilityQueryOrder.ts, 0, 13)) + + x: number; +>x : Symbol(Inner.x, Decl(exportAssignmentNestedVisibilityQueryOrder.ts, 1, 28)) + } + export interface Outer { +>Outer : Symbol(Outer, Decl(exportAssignmentNestedVisibilityQueryOrder.ts, 3, 5)) + + use: (inner: Inner) => Outer; +>use : Symbol(Outer.use, Decl(exportAssignmentNestedVisibilityQueryOrder.ts, 4, 28)) +>inner : Symbol(inner, Decl(exportAssignmentNestedVisibilityQueryOrder.ts, 5, 14)) +>Inner : Symbol(Inner, Decl(exportAssignmentNestedVisibilityQueryOrder.ts, 0, 13)) +>Outer : Symbol(Outer, Decl(exportAssignmentNestedVisibilityQueryOrder.ts, 3, 5)) + } +} +declare var m: { +>m : Symbol(m, Decl(exportAssignmentNestedVisibilityQueryOrder.ts, 0, 0), Decl(exportAssignmentNestedVisibilityQueryOrder.ts, 8, 11)) + + (): m.Outer; +>m : Symbol(m, Decl(exportAssignmentNestedVisibilityQueryOrder.ts, 0, 0), Decl(exportAssignmentNestedVisibilityQueryOrder.ts, 8, 11)) +>Outer : Symbol(m.Outer, Decl(exportAssignmentNestedVisibilityQueryOrder.ts, 3, 5)) + +}; +export = m; +>m : Symbol(m, Decl(exportAssignmentNestedVisibilityQueryOrder.ts, 0, 0), Decl(exportAssignmentNestedVisibilityQueryOrder.ts, 8, 11)) + diff --git a/tsc/testdata/baselines/reference/compiler/exportAssignmentNestedVisibilityQueryOrder(checkorder=editorfirst).types b/tsc/testdata/baselines/reference/compiler/exportAssignmentNestedVisibilityQueryOrder(checkorder=editorfirst).types new file mode 100644 index 0000000000000..600dc4ebe4a28 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/exportAssignmentNestedVisibilityQueryOrder(checkorder=editorfirst).types @@ -0,0 +1,24 @@ +//// [tests/cases/compiler/exportAssignmentNestedVisibilityQueryOrder.ts] //// + +=== exportAssignmentNestedVisibilityQueryOrder.ts === +namespace m { + export interface Inner { + x: number; +>x : number + } + export interface Outer { + use: (inner: Inner) => Outer; +>use : (inner: Inner) => Outer +>inner : Inner + } +} +declare var m: { +>m : () => m.Outer + + (): m.Outer; +>m : any + +}; +export = m; +>m : () => m.Outer + diff --git a/tsc/testdata/baselines/reference/compiler/fallbackToBindingPatternForTypeInference(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/fallbackToBindingPatternForTypeInference(checkorder=default).errors.txt new file mode 100644 index 0000000000000..9a04ca00910e5 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/fallbackToBindingPatternForTypeInference(checkorder=default).errors.txt @@ -0,0 +1,45 @@ +fallbackToBindingPatternForTypeInference.ts(2,7): error TS2345: Argument of type '({ a }: { a: any; }) => any' is not assignable to parameter of type '(x: unknown) => string'. + Types of parameters '__0' and 'x' are incompatible. + Type 'unknown' is not assignable to type '{ a: any; }'. +fallbackToBindingPatternForTypeInference.ts(3,7): error TS2345: Argument of type '([b, c]: [any, any]) => string' is not assignable to parameter of type '(x: unknown) => string'. + Types of parameters '__0' and 'x' are incompatible. + Type 'unknown' is not assignable to type '[any, any]'. +fallbackToBindingPatternForTypeInference.ts(4,7): error TS2345: Argument of type '({ d: [e, f] }: { d: [any, any]; }) => string' is not assignable to parameter of type '(x: unknown) => string'. + Types of parameters '__0' and 'x' are incompatible. + Type 'unknown' is not assignable to type '{ d: [any, any]; }'. +fallbackToBindingPatternForTypeInference.ts(5,7): error TS2345: Argument of type '([{ g }, { h }]: [{ g: any; }, { h: any; }]) => string' is not assignable to parameter of type '(x: unknown) => string'. + Types of parameters '__0' and 'x' are incompatible. + Type 'unknown' is not assignable to type '[{ g: any; }, { h: any; }]'. +fallbackToBindingPatternForTypeInference.ts(6,7): error TS2345: Argument of type '({ a, b }: { a: any; b?: number | undefined; }) => any' is not assignable to parameter of type '(x: unknown) => string'. + Types of parameters '__0' and 'x' are incompatible. + Type 'unknown' is not assignable to type '{ a: any; b?: number | undefined; }'. + + +==== fallbackToBindingPatternForTypeInference.ts (5 errors) ==== + declare function trans(f: (x: T) => string): number; + trans(({a}) => a); + ~~~~~~~~~~ +!!! error TS2345: Argument of type '({ a }: { a: any; }) => any' is not assignable to parameter of type '(x: unknown) => string'. +!!! error TS2345: Types of parameters '__0' and 'x' are incompatible. +!!! error TS2345: Type 'unknown' is not assignable to type '{ a: any; }'. + trans(([b,c]) => 'foo'); + ~~~~~~~~~~~~~~~~ +!!! error TS2345: Argument of type '([b, c]: [any, any]) => string' is not assignable to parameter of type '(x: unknown) => string'. +!!! error TS2345: Types of parameters '__0' and 'x' are incompatible. +!!! error TS2345: Type 'unknown' is not assignable to type '[any, any]'. + trans(({d: [e,f]}) => 'foo'); + ~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2345: Argument of type '({ d: [e, f] }: { d: [any, any]; }) => string' is not assignable to parameter of type '(x: unknown) => string'. +!!! error TS2345: Types of parameters '__0' and 'x' are incompatible. +!!! error TS2345: Type 'unknown' is not assignable to type '{ d: [any, any]; }'. + trans(([{g},{h}]) => 'foo'); + ~~~~~~~~~~~~~~~~~~~~ +!!! error TS2345: Argument of type '([{ g }, { h }]: [{ g: any; }, { h: any; }]) => string' is not assignable to parameter of type '(x: unknown) => string'. +!!! error TS2345: Types of parameters '__0' and 'x' are incompatible. +!!! error TS2345: Type 'unknown' is not assignable to type '[{ g: any; }, { h: any; }]'. + trans(({a, b = 10}) => a); + ~~~~~~~~~~~~~~~~~~ +!!! error TS2345: Argument of type '({ a, b }: { a: any; b?: number | undefined; }) => any' is not assignable to parameter of type '(x: unknown) => string'. +!!! error TS2345: Types of parameters '__0' and 'x' are incompatible. +!!! error TS2345: Type 'unknown' is not assignable to type '{ a: any; b?: number | undefined; }'. + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/fallbackToBindingPatternForTypeInference(checkorder=default).js b/tsc/testdata/baselines/reference/compiler/fallbackToBindingPatternForTypeInference(checkorder=default).js new file mode 100644 index 0000000000000..60378832d9d6a --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/fallbackToBindingPatternForTypeInference(checkorder=default).js @@ -0,0 +1,18 @@ +//// [tests/cases/compiler/fallbackToBindingPatternForTypeInference.ts] //// + +//// [fallbackToBindingPatternForTypeInference.ts] +declare function trans(f: (x: T) => string): number; +trans(({a}) => a); +trans(([b,c]) => 'foo'); +trans(({d: [e,f]}) => 'foo'); +trans(([{g},{h}]) => 'foo'); +trans(({a, b = 10}) => a); + + +//// [fallbackToBindingPatternForTypeInference.js] +"use strict"; +trans(({ a }) => a); +trans(([b, c]) => 'foo'); +trans(({ d: [e, f] }) => 'foo'); +trans(([{ g }, { h }]) => 'foo'); +trans(({ a, b = 10 }) => a); diff --git a/tsc/testdata/baselines/reference/compiler/fallbackToBindingPatternForTypeInference(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/fallbackToBindingPatternForTypeInference(checkorder=default).symbols new file mode 100644 index 0000000000000..7e6456be8db3c --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/fallbackToBindingPatternForTypeInference(checkorder=default).symbols @@ -0,0 +1,36 @@ +//// [tests/cases/compiler/fallbackToBindingPatternForTypeInference.ts] //// + +=== fallbackToBindingPatternForTypeInference.ts === +declare function trans(f: (x: T) => string): number; +>trans : Symbol(trans, Decl(fallbackToBindingPatternForTypeInference.ts, 0, 0)) +>T : Symbol(T, Decl(fallbackToBindingPatternForTypeInference.ts, 0, 23)) +>f : Symbol(f, Decl(fallbackToBindingPatternForTypeInference.ts, 0, 26)) +>x : Symbol(x, Decl(fallbackToBindingPatternForTypeInference.ts, 0, 30)) +>T : Symbol(T, Decl(fallbackToBindingPatternForTypeInference.ts, 0, 23)) + +trans(({a}) => a); +>trans : Symbol(trans, Decl(fallbackToBindingPatternForTypeInference.ts, 0, 0)) +>a : Symbol(a, Decl(fallbackToBindingPatternForTypeInference.ts, 1, 8)) +>a : Symbol(a, Decl(fallbackToBindingPatternForTypeInference.ts, 1, 8)) + +trans(([b,c]) => 'foo'); +>trans : Symbol(trans, Decl(fallbackToBindingPatternForTypeInference.ts, 0, 0)) +>b : Symbol(b, Decl(fallbackToBindingPatternForTypeInference.ts, 2, 8)) +>c : Symbol(c, Decl(fallbackToBindingPatternForTypeInference.ts, 2, 10)) + +trans(({d: [e,f]}) => 'foo'); +>trans : Symbol(trans, Decl(fallbackToBindingPatternForTypeInference.ts, 0, 0)) +>e : Symbol(e, Decl(fallbackToBindingPatternForTypeInference.ts, 3, 12)) +>f : Symbol(f, Decl(fallbackToBindingPatternForTypeInference.ts, 3, 14)) + +trans(([{g},{h}]) => 'foo'); +>trans : Symbol(trans, Decl(fallbackToBindingPatternForTypeInference.ts, 0, 0)) +>g : Symbol(g, Decl(fallbackToBindingPatternForTypeInference.ts, 4, 9)) +>h : Symbol(h, Decl(fallbackToBindingPatternForTypeInference.ts, 4, 13)) + +trans(({a, b = 10}) => a); +>trans : Symbol(trans, Decl(fallbackToBindingPatternForTypeInference.ts, 0, 0)) +>a : Symbol(a, Decl(fallbackToBindingPatternForTypeInference.ts, 5, 8)) +>b : Symbol(b, Decl(fallbackToBindingPatternForTypeInference.ts, 5, 10)) +>a : Symbol(a, Decl(fallbackToBindingPatternForTypeInference.ts, 5, 8)) + diff --git a/tsc/testdata/baselines/reference/compiler/fallbackToBindingPatternForTypeInference(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/fallbackToBindingPatternForTypeInference(checkorder=default).types new file mode 100644 index 0000000000000..be3950ad98131 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/fallbackToBindingPatternForTypeInference(checkorder=default).types @@ -0,0 +1,49 @@ +//// [tests/cases/compiler/fallbackToBindingPatternForTypeInference.ts] //// + +=== fallbackToBindingPatternForTypeInference.ts === +declare function trans(f: (x: T) => string): number; +>trans : (f: (x: T) => string) => number +>f : (x: T) => string +>x : T + +trans(({a}) => a); +>trans(({a}) => a) : number +>trans : (f: (x: T) => string) => number +>({a}) => a : ({ a }: { a: any; }) => any +>a : any +>a : any + +trans(([b,c]) => 'foo'); +>trans(([b,c]) => 'foo') : number +>trans : (f: (x: T) => string) => number +>([b,c]) => 'foo' : ([b, c]: [any, any]) => string +>b : any +>c : any +>'foo' : "foo" + +trans(({d: [e,f]}) => 'foo'); +>trans(({d: [e,f]}) => 'foo') : number +>trans : (f: (x: T) => string) => number +>({d: [e,f]}) => 'foo' : ({ d: [e, f] }: { d: [any, any]; }) => string +>d : any +>e : any +>f : any +>'foo' : "foo" + +trans(([{g},{h}]) => 'foo'); +>trans(([{g},{h}]) => 'foo') : number +>trans : (f: (x: T) => string) => number +>([{g},{h}]) => 'foo' : ([{ g }, { h }]: [{ g: any; }, { h: any; }]) => string +>g : any +>h : any +>'foo' : "foo" + +trans(({a, b = 10}) => a); +>trans(({a, b = 10}) => a) : number +>trans : (f: (x: T) => string) => number +>({a, b = 10}) => a : ({ a, b }: { a: any; b?: number | undefined; }) => any +>a : any +>b : number +>10 : 10 +>a : any + diff --git a/tsc/testdata/baselines/reference/compiler/fallbackToBindingPatternForTypeInference(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/fallbackToBindingPatternForTypeInference(checkorder=typesfirst).errors.txt new file mode 100644 index 0000000000000..37a59b2d11dea --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/fallbackToBindingPatternForTypeInference(checkorder=typesfirst).errors.txt @@ -0,0 +1,51 @@ +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(2,9): error TS2339: Property 'a' does not exist on type 'unknown'. +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(6,9): error TS2339: Property 'a' does not exist on type 'unknown'. + + +==== fallbackToBindingPatternForTypeInference.ts (7 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; }'. + ~ +!!! error TS2339: Property 'a' does not exist on type 'unknown'. + 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; }'. + ~ +!!! error TS2339: Property 'a' does not exist on type 'unknown'. + \ 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..eaf9da009a413 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/fixingTypeParametersRepeatedly2(checkorder=typesfirst).errors.txt @@ -0,0 +1,32 @@ +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(17,34): error TS2339: Property 'toBase' does not exist on type 'Base'. + + +==== fixingTypeParametersRepeatedly2.ts (3 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. + ~~~~~~ +!!! error TS2339: Property 'toBase' does not exist on type 'Base'. \ 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..a94614635d95a --- /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 : any +>d : Derived +>toBase : any + diff --git a/tsc/testdata/baselines/reference/compiler/flowLoopDepthCheckOrder(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/flowLoopDepthCheckOrder(checkorder=default).symbols new file mode 100644 index 0000000000000..6e19f55994980 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/flowLoopDepthCheckOrder(checkorder=default).symbols @@ -0,0 +1,3060 @@ +//// [tests/cases/compiler/flowLoopDepthCheckOrder.ts] //// + +=== flowLoopDepthCheckOrder.ts === +// A loop is analyzed once for all references to the same name and the +// result is cached, so its analysis must not depend on the reference that +// reached it first. 'deep' reaches the loop with little depth left. +// Analyzing the loop from there must not make 'x' inside it give up when +// 'deep' is queried first. + +declare function cond(): boolean; +>cond : Symbol(cond, Decl(flowLoopDepthCheckOrder.ts, 0, 0)) + +declare let b: boolean; +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +let x: string | number = 0; +>x : Symbol(x, Decl(flowLoopDepthCheckOrder.ts, 9, 3)) + +while (cond()) { +>cond : Symbol(cond, Decl(flowLoopDepthCheckOrder.ts, 0, 0)) + + if (typeof x === "string") { x = 1; } else { x = "a"; } +>x : Symbol(x, Decl(flowLoopDepthCheckOrder.ts, 9, 3)) +>x : Symbol(x, Decl(flowLoopDepthCheckOrder.ts, 9, 3)) +>x : Symbol(x, Decl(flowLoopDepthCheckOrder.ts, 9, 3)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) +} +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +const deep = x; +>deep : Symbol(deep, Decl(flowLoopDepthCheckOrder.ts, 1023, 5)) +>x : Symbol(x, Decl(flowLoopDepthCheckOrder.ts, 9, 3)) + diff --git a/tsc/testdata/baselines/reference/compiler/flowLoopDepthCheckOrder(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/flowLoopDepthCheckOrder(checkorder=default).types new file mode 100644 index 0000000000000..efbb9a68a52ad --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/flowLoopDepthCheckOrder(checkorder=default).types @@ -0,0 +1,3069 @@ +//// [tests/cases/compiler/flowLoopDepthCheckOrder.ts] //// + +=== flowLoopDepthCheckOrder.ts === +// A loop is analyzed once for all references to the same name and the +// result is cached, so its analysis must not depend on the reference that +// reached it first. 'deep' reaches the loop with little depth left. +// Analyzing the loop from there must not make 'x' inside it give up when +// 'deep' is queried first. + +declare function cond(): boolean; +>cond : () => boolean + +declare let b: boolean; +>b : boolean + +let x: string | number = 0; +>x : string | number +>0 : 0 + +while (cond()) { +>cond() : boolean +>cond : () => boolean + + if (typeof x === "string") { x = 1; } else { x = "a"; } +>typeof x === "string" : boolean +>typeof x : "bigint" | "boolean" | "function" | "number" | "object" | "string" | "symbol" | "undefined" +>x : string | number +>"string" : "string" +>x = 1 : 1 +>x : string | number +>1 : 1 +>x = "a" : "a" +>x : string | number +>"a" : "a" + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean + + if (b) {} +>b : boolean +} +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +if (b) {} +>b : boolean + +const deep = x; +>deep : string | number +>x : string | number + diff --git a/tsc/testdata/baselines/reference/compiler/flowLoopDepthCheckOrder(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/flowLoopDepthCheckOrder(checkorder=typesfirst).errors.txt new file mode 100644 index 0000000000000..2e4675292eeb0 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/flowLoopDepthCheckOrder(checkorder=typesfirst).errors.txt @@ -0,0 +1,1031 @@ +flowLoopDepthCheckOrder.ts(7,1): error TS2563: The containing function or module body is too large for control flow analysis. + + +==== flowLoopDepthCheckOrder.ts (1 errors) ==== + // A loop is analyzed once for all references to the same name and the + // result is cached, so its analysis must not depend on the reference that + // reached it first. 'deep' reaches the loop with little depth left. + // Analyzing the loop from there must not make 'x' inside it give up when + // 'deep' is queried first. + + declare function cond(): boolean; + ~~~~~~~ +!!! error TS2563: The containing function or module body is too large for control flow analysis. + declare let b: boolean; + + let x: string | number = 0; + while (cond()) { + if (typeof x === "string") { x = 1; } else { x = "a"; } + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + } + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + const deep = x; + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/flowLoopDepthCheckOrder(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/flowLoopDepthCheckOrder(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..6e19f55994980 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/flowLoopDepthCheckOrder(checkorder=typesfirst).symbols @@ -0,0 +1,3060 @@ +//// [tests/cases/compiler/flowLoopDepthCheckOrder.ts] //// + +=== flowLoopDepthCheckOrder.ts === +// A loop is analyzed once for all references to the same name and the +// result is cached, so its analysis must not depend on the reference that +// reached it first. 'deep' reaches the loop with little depth left. +// Analyzing the loop from there must not make 'x' inside it give up when +// 'deep' is queried first. + +declare function cond(): boolean; +>cond : Symbol(cond, Decl(flowLoopDepthCheckOrder.ts, 0, 0)) + +declare let b: boolean; +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +let x: string | number = 0; +>x : Symbol(x, Decl(flowLoopDepthCheckOrder.ts, 9, 3)) + +while (cond()) { +>cond : Symbol(cond, Decl(flowLoopDepthCheckOrder.ts, 0, 0)) + + if (typeof x === "string") { x = 1; } else { x = "a"; } +>x : Symbol(x, Decl(flowLoopDepthCheckOrder.ts, 9, 3)) +>x : Symbol(x, Decl(flowLoopDepthCheckOrder.ts, 9, 3)) +>x : Symbol(x, Decl(flowLoopDepthCheckOrder.ts, 9, 3)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) +} +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +if (b) {} +>b : Symbol(b, Decl(flowLoopDepthCheckOrder.ts, 7, 11)) + +const deep = x; +>deep : Symbol(deep, Decl(flowLoopDepthCheckOrder.ts, 1023, 5)) +>x : Symbol(x, Decl(flowLoopDepthCheckOrder.ts, 9, 3)) + diff --git a/tsc/testdata/baselines/reference/compiler/flowLoopDepthCheckOrder(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/flowLoopDepthCheckOrder(checkorder=typesfirst).types new file mode 100644 index 0000000000000..99b5a33596d2c --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/flowLoopDepthCheckOrder(checkorder=typesfirst).types @@ -0,0 +1,3069 @@ +//// [tests/cases/compiler/flowLoopDepthCheckOrder.ts] //// + +=== flowLoopDepthCheckOrder.ts === +// A loop is analyzed once for all references to the same name and the +// result is cached, so its analysis must not depend on the reference that +// reached it first. 'deep' reaches the loop with little depth left. +// Analyzing the loop from there must not make 'x' inside it give up when +// 'deep' is queried first. + +declare function cond(): boolean; +>cond : () => boolean + +declare let b: boolean; +>b : boolean + +let x: string | number = 0; +>x : string | number +>0 : 0 + +while (cond()) { +>cond() : boolean +>cond : () => boolean + + if (typeof x === "string") { x = 1; } else { x = "a"; } +>typeof x === "string" : boolean +>typeof x : "bigint" | "boolean" | "function" | "number" | "object" | "string" | "symbol" | "undefined" +>x : any +>"string" : "string" +>x = 1 : 1 +>x : string | number +>1 : 1 +>x = "a" : "a" +>x : string | number +>"a" : "a" + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any +} +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +if (b) {} +>b : any + +const deep = x; +>deep : any +>x : any + diff --git a/tsc/testdata/baselines/reference/compiler/flowLoopTooDeepCheckOrder(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/flowLoopTooDeepCheckOrder(checkorder=default).errors.txt new file mode 100644 index 0000000000000..b43190520aaab --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/flowLoopTooDeepCheckOrder(checkorder=default).errors.txt @@ -0,0 +1,1126 @@ +flowLoopTooDeepCheckOrder.ts(4,1): error TS2563: The containing function or module body is too large for control flow analysis. + + +==== flowLoopTooDeepCheckOrder.ts (1 errors) ==== + // The loop is too deep to analyze from any reference, so 'narrowed' gives + // up whether or not the reference in the loop analyzed the loop first. + + declare function cond(): boolean; + ~~~~~~~ +!!! error TS2563: The containing function or module body is too large for control flow analysis. + declare function isString(value: unknown): value is string; + declare let b: boolean; + + let w: string | number = 0; + while (cond()) { + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (typeof w === "string") { w = 1; } else { w = "a"; } + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + } + if (isString(w)) { + const narrowed = w; + } + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/flowLoopTooDeepCheckOrder(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/flowLoopTooDeepCheckOrder(checkorder=default).symbols new file mode 100644 index 0000000000000..42c2e0915139d --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/flowLoopTooDeepCheckOrder(checkorder=default).symbols @@ -0,0 +1,3352 @@ +//// [tests/cases/compiler/flowLoopTooDeepCheckOrder.ts] //// + +=== flowLoopTooDeepCheckOrder.ts === +// The loop is too deep to analyze from any reference, so 'narrowed' gives +// up whether or not the reference in the loop analyzed the loop first. + +declare function cond(): boolean; +>cond : Symbol(cond, Decl(flowLoopTooDeepCheckOrder.ts, 0, 0)) + +declare function isString(value: unknown): value is string; +>isString : Symbol(isString, Decl(flowLoopTooDeepCheckOrder.ts, 3, 33)) +>value : Symbol(value, Decl(flowLoopTooDeepCheckOrder.ts, 4, 26)) +>value : Symbol(value, Decl(flowLoopTooDeepCheckOrder.ts, 4, 26)) + +declare let b: boolean; +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + +let w: string | number = 0; +>w : Symbol(w, Decl(flowLoopTooDeepCheckOrder.ts, 7, 3)) + +while (cond()) { +>cond : Symbol(cond, Decl(flowLoopTooDeepCheckOrder.ts, 0, 0)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (typeof w === "string") { w = 1; } else { w = "a"; } +>w : Symbol(w, Decl(flowLoopTooDeepCheckOrder.ts, 7, 3)) +>w : Symbol(w, Decl(flowLoopTooDeepCheckOrder.ts, 7, 3)) +>w : Symbol(w, Decl(flowLoopTooDeepCheckOrder.ts, 7, 3)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) +} +if (isString(w)) { +>isString : Symbol(isString, Decl(flowLoopTooDeepCheckOrder.ts, 3, 33)) +>w : Symbol(w, Decl(flowLoopTooDeepCheckOrder.ts, 7, 3)) + + const narrowed = w; +>narrowed : Symbol(narrowed, Decl(flowLoopTooDeepCheckOrder.ts, 1117, 9)) +>w : Symbol(w, Decl(flowLoopTooDeepCheckOrder.ts, 7, 3)) +} + diff --git a/tsc/testdata/baselines/reference/compiler/flowLoopTooDeepCheckOrder(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/flowLoopTooDeepCheckOrder(checkorder=default).types new file mode 100644 index 0000000000000..2a0727e493817 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/flowLoopTooDeepCheckOrder(checkorder=default).types @@ -0,0 +1,3361 @@ +//// [tests/cases/compiler/flowLoopTooDeepCheckOrder.ts] //// + +=== flowLoopTooDeepCheckOrder.ts === +// The loop is too deep to analyze from any reference, so 'narrowed' gives +// up whether or not the reference in the loop analyzed the loop first. + +declare function cond(): boolean; +>cond : () => boolean + +declare function isString(value: unknown): value is string; +>isString : (value: unknown) => value is string +>value : unknown + +declare let b: boolean; +>b : boolean + +let w: string | number = 0; +>w : string | number +>0 : 0 + +while (cond()) { +>cond() : boolean +>cond : () => boolean + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (typeof w === "string") { w = 1; } else { w = "a"; } +>typeof w === "string" : boolean +>typeof w : "bigint" | "boolean" | "function" | "number" | "object" | "string" | "symbol" | "undefined" +>w : any +>"string" : "string" +>w = 1 : 1 +>w : string | number +>1 : 1 +>w = "a" : "a" +>w : string | number +>"a" : "a" + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any +} +if (isString(w)) { +>isString(w) : boolean +>isString : (value: unknown) => value is string +>w : any + + const narrowed = w; +>narrowed : any +>w : any +} + diff --git a/tsc/testdata/baselines/reference/compiler/flowLoopTooDeepCheckOrder(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/flowLoopTooDeepCheckOrder(checkorder=typesfirst).errors.txt new file mode 100644 index 0000000000000..b43190520aaab --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/flowLoopTooDeepCheckOrder(checkorder=typesfirst).errors.txt @@ -0,0 +1,1126 @@ +flowLoopTooDeepCheckOrder.ts(4,1): error TS2563: The containing function or module body is too large for control flow analysis. + + +==== flowLoopTooDeepCheckOrder.ts (1 errors) ==== + // The loop is too deep to analyze from any reference, so 'narrowed' gives + // up whether or not the reference in the loop analyzed the loop first. + + declare function cond(): boolean; + ~~~~~~~ +!!! error TS2563: The containing function or module body is too large for control flow analysis. + declare function isString(value: unknown): value is string; + declare let b: boolean; + + let w: string | number = 0; + while (cond()) { + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (typeof w === "string") { w = 1; } else { w = "a"; } + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + if (b) {} + } + if (isString(w)) { + const narrowed = w; + } + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/flowLoopTooDeepCheckOrder(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/flowLoopTooDeepCheckOrder(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..42c2e0915139d --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/flowLoopTooDeepCheckOrder(checkorder=typesfirst).symbols @@ -0,0 +1,3352 @@ +//// [tests/cases/compiler/flowLoopTooDeepCheckOrder.ts] //// + +=== flowLoopTooDeepCheckOrder.ts === +// The loop is too deep to analyze from any reference, so 'narrowed' gives +// up whether or not the reference in the loop analyzed the loop first. + +declare function cond(): boolean; +>cond : Symbol(cond, Decl(flowLoopTooDeepCheckOrder.ts, 0, 0)) + +declare function isString(value: unknown): value is string; +>isString : Symbol(isString, Decl(flowLoopTooDeepCheckOrder.ts, 3, 33)) +>value : Symbol(value, Decl(flowLoopTooDeepCheckOrder.ts, 4, 26)) +>value : Symbol(value, Decl(flowLoopTooDeepCheckOrder.ts, 4, 26)) + +declare let b: boolean; +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + +let w: string | number = 0; +>w : Symbol(w, Decl(flowLoopTooDeepCheckOrder.ts, 7, 3)) + +while (cond()) { +>cond : Symbol(cond, Decl(flowLoopTooDeepCheckOrder.ts, 0, 0)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (typeof w === "string") { w = 1; } else { w = "a"; } +>w : Symbol(w, Decl(flowLoopTooDeepCheckOrder.ts, 7, 3)) +>w : Symbol(w, Decl(flowLoopTooDeepCheckOrder.ts, 7, 3)) +>w : Symbol(w, Decl(flowLoopTooDeepCheckOrder.ts, 7, 3)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) + + if (b) {} +>b : Symbol(b, Decl(flowLoopTooDeepCheckOrder.ts, 5, 11)) +} +if (isString(w)) { +>isString : Symbol(isString, Decl(flowLoopTooDeepCheckOrder.ts, 3, 33)) +>w : Symbol(w, Decl(flowLoopTooDeepCheckOrder.ts, 7, 3)) + + const narrowed = w; +>narrowed : Symbol(narrowed, Decl(flowLoopTooDeepCheckOrder.ts, 1117, 9)) +>w : Symbol(w, Decl(flowLoopTooDeepCheckOrder.ts, 7, 3)) +} + diff --git a/tsc/testdata/baselines/reference/compiler/flowLoopTooDeepCheckOrder(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/flowLoopTooDeepCheckOrder(checkorder=typesfirst).types new file mode 100644 index 0000000000000..5bb07088ede1b --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/flowLoopTooDeepCheckOrder(checkorder=typesfirst).types @@ -0,0 +1,3361 @@ +//// [tests/cases/compiler/flowLoopTooDeepCheckOrder.ts] //// + +=== flowLoopTooDeepCheckOrder.ts === +// The loop is too deep to analyze from any reference, so 'narrowed' gives +// up whether or not the reference in the loop analyzed the loop first. + +declare function cond(): boolean; +>cond : () => boolean + +declare function isString(value: unknown): value is string; +>isString : (value: unknown) => value is string +>value : unknown + +declare let b: boolean; +>b : boolean + +let w: string | number = 0; +>w : string | number +>0 : 0 + +while (cond()) { +>cond() : boolean +>cond : () => boolean + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (typeof w === "string") { w = 1; } else { w = "a"; } +>typeof w === "string" : boolean +>typeof w : "bigint" | "boolean" | "function" | "number" | "object" | "string" | "symbol" | "undefined" +>w : any +>"string" : "string" +>w = 1 : 1 +>w : string | number +>1 : 1 +>w = "a" : "a" +>w : string | number +>"a" : "a" + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any + + if (b) {} +>b : any +} +if (isString(w)) { +>isString(w) : boolean +>isString : (value: unknown) => value is string +>w : any + + const narrowed = w; +>narrowed : any +>w : string +} + diff --git a/tsc/testdata/baselines/reference/compiler/genericCallReturnedFunctionParameterDefault(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/genericCallReturnedFunctionParameterDefault(checkorder=default).errors.txt new file mode 100644 index 0000000000000..adfc91cadd7fc --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/genericCallReturnedFunctionParameterDefault(checkorder=default).errors.txt @@ -0,0 +1,31 @@ +genericCallReturnedFunctionParameterDefault.ts(24,5): error TS2345: Argument of type 'string' is not assignable to parameter of type 'number'. + + +==== genericCallReturnedFunctionParameterDefault.ts (1 errors) ==== + // The function returned from the callback of a generic call has a parameter + // with a default and no annotation. Once T is inferred, the contextual + // signature of the returned function is its own signature, but the parameter + // already has its type (boolean) from the initializer, computed while T was + // being inferred, so there is no circularity: no TS7022, and 'r()(1)' is an + // error. (Reduced from open-design ProjectView.tsx, useCallback returning + // '{ release: (recoverable = false) => ... }'.) + + declare function id(callback: T): T; + + id(() => { + return (x = false) => {}; + }); + + id(() => (y = false) => y); + + id(() => { + return { m(z = false) {} }; + }); + + const r = id(() => { + return (w = 0) => {}; + }); + r()(""); + ~~ +!!! error TS2345: Argument of type 'string' is not assignable to parameter of type 'number'. + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/genericCallReturnedFunctionParameterDefault(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/genericCallReturnedFunctionParameterDefault(checkorder=default).symbols new file mode 100644 index 0000000000000..ee8aa11e466f0 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/genericCallReturnedFunctionParameterDefault(checkorder=default).symbols @@ -0,0 +1,51 @@ +//// [tests/cases/compiler/genericCallReturnedFunctionParameterDefault.ts] //// + +=== genericCallReturnedFunctionParameterDefault.ts === +// The function returned from the callback of a generic call has a parameter +// with a default and no annotation. Once T is inferred, the contextual +// signature of the returned function is its own signature, but the parameter +// already has its type (boolean) from the initializer, computed while T was +// being inferred, so there is no circularity: no TS7022, and 'r()(1)' is an +// error. (Reduced from open-design ProjectView.tsx, useCallback returning +// '{ release: (recoverable = false) => ... }'.) + +declare function id(callback: T): T; +>id : Symbol(id, Decl(genericCallReturnedFunctionParameterDefault.ts, 0, 0)) +>T : Symbol(T, Decl(genericCallReturnedFunctionParameterDefault.ts, 8, 20)) +>callback : Symbol(callback, Decl(genericCallReturnedFunctionParameterDefault.ts, 8, 23)) +>T : Symbol(T, Decl(genericCallReturnedFunctionParameterDefault.ts, 8, 20)) +>T : Symbol(T, Decl(genericCallReturnedFunctionParameterDefault.ts, 8, 20)) + +id(() => { +>id : Symbol(id, Decl(genericCallReturnedFunctionParameterDefault.ts, 0, 0)) + + return (x = false) => {}; +>x : Symbol(x, Decl(genericCallReturnedFunctionParameterDefault.ts, 11, 12)) + +}); + +id(() => (y = false) => y); +>id : Symbol(id, Decl(genericCallReturnedFunctionParameterDefault.ts, 0, 0)) +>y : Symbol(y, Decl(genericCallReturnedFunctionParameterDefault.ts, 14, 10)) +>y : Symbol(y, Decl(genericCallReturnedFunctionParameterDefault.ts, 14, 10)) + +id(() => { +>id : Symbol(id, Decl(genericCallReturnedFunctionParameterDefault.ts, 0, 0)) + + return { m(z = false) {} }; +>m : Symbol(m, Decl(genericCallReturnedFunctionParameterDefault.ts, 17, 12)) +>z : Symbol(z, Decl(genericCallReturnedFunctionParameterDefault.ts, 17, 15)) + +}); + +const r = id(() => { +>r : Symbol(r, Decl(genericCallReturnedFunctionParameterDefault.ts, 20, 5)) +>id : Symbol(id, Decl(genericCallReturnedFunctionParameterDefault.ts, 0, 0)) + + return (w = 0) => {}; +>w : Symbol(w, Decl(genericCallReturnedFunctionParameterDefault.ts, 21, 12)) + +}); +r()(""); +>r : Symbol(r, Decl(genericCallReturnedFunctionParameterDefault.ts, 20, 5)) + diff --git a/tsc/testdata/baselines/reference/compiler/genericCallReturnedFunctionParameterDefault(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/genericCallReturnedFunctionParameterDefault(checkorder=default).types new file mode 100644 index 0000000000000..a8c98c3242e89 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/genericCallReturnedFunctionParameterDefault(checkorder=default).types @@ -0,0 +1,67 @@ +//// [tests/cases/compiler/genericCallReturnedFunctionParameterDefault.ts] //// + +=== genericCallReturnedFunctionParameterDefault.ts === +// The function returned from the callback of a generic call has a parameter +// with a default and no annotation. Once T is inferred, the contextual +// signature of the returned function is its own signature, but the parameter +// already has its type (boolean) from the initializer, computed while T was +// being inferred, so there is no circularity: no TS7022, and 'r()(1)' is an +// error. (Reduced from open-design ProjectView.tsx, useCallback returning +// '{ release: (recoverable = false) => ... }'.) + +declare function id(callback: T): T; +>id : (callback: T) => T +>callback : T + +id(() => { +>id(() => { return (x = false) => {};}) : () => (x?: boolean) => void +>id : (callback: T) => T +>() => { return (x = false) => {};} : () => (x?: boolean) => void + + return (x = false) => {}; +>(x = false) => {} : (x?: boolean) => void +>x : boolean +>false : false + +}); + +id(() => (y = false) => y); +>id(() => (y = false) => y) : () => (y?: boolean) => boolean +>id : (callback: T) => T +>() => (y = false) => y : () => (y?: boolean) => boolean +>(y = false) => y : (y?: boolean) => boolean +>y : boolean +>false : false +>y : boolean + +id(() => { +>id(() => { return { m(z = false) {} };}) : () => { m(z?: boolean): void; } +>id : (callback: T) => T +>() => { return { m(z = false) {} };} : () => { m(z?: boolean): void; } + + return { m(z = false) {} }; +>{ m(z = false) {} } : { m(z?: boolean): void; } +>m : (z?: boolean) => void +>z : boolean +>false : false + +}); + +const r = id(() => { +>r : () => (w?: number) => void +>id(() => { return (w = 0) => {};}) : () => (w?: number) => void +>id : (callback: T) => T +>() => { return (w = 0) => {};} : () => (w?: number) => void + + return (w = 0) => {}; +>(w = 0) => {} : (w?: number) => void +>w : number +>0 : 0 + +}); +r()(""); +>r()("") : void +>r() : (w?: number) => void +>r : () => (w?: number) => void +>"" : "" + diff --git a/tsc/testdata/baselines/reference/compiler/genericCallReturnedFunctionParameterDefault(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/genericCallReturnedFunctionParameterDefault(checkorder=typesfirst).errors.txt new file mode 100644 index 0000000000000..adfc91cadd7fc --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/genericCallReturnedFunctionParameterDefault(checkorder=typesfirst).errors.txt @@ -0,0 +1,31 @@ +genericCallReturnedFunctionParameterDefault.ts(24,5): error TS2345: Argument of type 'string' is not assignable to parameter of type 'number'. + + +==== genericCallReturnedFunctionParameterDefault.ts (1 errors) ==== + // The function returned from the callback of a generic call has a parameter + // with a default and no annotation. Once T is inferred, the contextual + // signature of the returned function is its own signature, but the parameter + // already has its type (boolean) from the initializer, computed while T was + // being inferred, so there is no circularity: no TS7022, and 'r()(1)' is an + // error. (Reduced from open-design ProjectView.tsx, useCallback returning + // '{ release: (recoverable = false) => ... }'.) + + declare function id(callback: T): T; + + id(() => { + return (x = false) => {}; + }); + + id(() => (y = false) => y); + + id(() => { + return { m(z = false) {} }; + }); + + const r = id(() => { + return (w = 0) => {}; + }); + r()(""); + ~~ +!!! error TS2345: Argument of type 'string' is not assignable to parameter of type 'number'. + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/genericCallReturnedFunctionParameterDefault(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/genericCallReturnedFunctionParameterDefault(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..ee8aa11e466f0 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/genericCallReturnedFunctionParameterDefault(checkorder=typesfirst).symbols @@ -0,0 +1,51 @@ +//// [tests/cases/compiler/genericCallReturnedFunctionParameterDefault.ts] //// + +=== genericCallReturnedFunctionParameterDefault.ts === +// The function returned from the callback of a generic call has a parameter +// with a default and no annotation. Once T is inferred, the contextual +// signature of the returned function is its own signature, but the parameter +// already has its type (boolean) from the initializer, computed while T was +// being inferred, so there is no circularity: no TS7022, and 'r()(1)' is an +// error. (Reduced from open-design ProjectView.tsx, useCallback returning +// '{ release: (recoverable = false) => ... }'.) + +declare function id(callback: T): T; +>id : Symbol(id, Decl(genericCallReturnedFunctionParameterDefault.ts, 0, 0)) +>T : Symbol(T, Decl(genericCallReturnedFunctionParameterDefault.ts, 8, 20)) +>callback : Symbol(callback, Decl(genericCallReturnedFunctionParameterDefault.ts, 8, 23)) +>T : Symbol(T, Decl(genericCallReturnedFunctionParameterDefault.ts, 8, 20)) +>T : Symbol(T, Decl(genericCallReturnedFunctionParameterDefault.ts, 8, 20)) + +id(() => { +>id : Symbol(id, Decl(genericCallReturnedFunctionParameterDefault.ts, 0, 0)) + + return (x = false) => {}; +>x : Symbol(x, Decl(genericCallReturnedFunctionParameterDefault.ts, 11, 12)) + +}); + +id(() => (y = false) => y); +>id : Symbol(id, Decl(genericCallReturnedFunctionParameterDefault.ts, 0, 0)) +>y : Symbol(y, Decl(genericCallReturnedFunctionParameterDefault.ts, 14, 10)) +>y : Symbol(y, Decl(genericCallReturnedFunctionParameterDefault.ts, 14, 10)) + +id(() => { +>id : Symbol(id, Decl(genericCallReturnedFunctionParameterDefault.ts, 0, 0)) + + return { m(z = false) {} }; +>m : Symbol(m, Decl(genericCallReturnedFunctionParameterDefault.ts, 17, 12)) +>z : Symbol(z, Decl(genericCallReturnedFunctionParameterDefault.ts, 17, 15)) + +}); + +const r = id(() => { +>r : Symbol(r, Decl(genericCallReturnedFunctionParameterDefault.ts, 20, 5)) +>id : Symbol(id, Decl(genericCallReturnedFunctionParameterDefault.ts, 0, 0)) + + return (w = 0) => {}; +>w : Symbol(w, Decl(genericCallReturnedFunctionParameterDefault.ts, 21, 12)) + +}); +r()(""); +>r : Symbol(r, Decl(genericCallReturnedFunctionParameterDefault.ts, 20, 5)) + diff --git a/tsc/testdata/baselines/reference/compiler/genericCallReturnedFunctionParameterDefault(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/genericCallReturnedFunctionParameterDefault(checkorder=typesfirst).types new file mode 100644 index 0000000000000..a8c98c3242e89 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/genericCallReturnedFunctionParameterDefault(checkorder=typesfirst).types @@ -0,0 +1,67 @@ +//// [tests/cases/compiler/genericCallReturnedFunctionParameterDefault.ts] //// + +=== genericCallReturnedFunctionParameterDefault.ts === +// The function returned from the callback of a generic call has a parameter +// with a default and no annotation. Once T is inferred, the contextual +// signature of the returned function is its own signature, but the parameter +// already has its type (boolean) from the initializer, computed while T was +// being inferred, so there is no circularity: no TS7022, and 'r()(1)' is an +// error. (Reduced from open-design ProjectView.tsx, useCallback returning +// '{ release: (recoverable = false) => ... }'.) + +declare function id(callback: T): T; +>id : (callback: T) => T +>callback : T + +id(() => { +>id(() => { return (x = false) => {};}) : () => (x?: boolean) => void +>id : (callback: T) => T +>() => { return (x = false) => {};} : () => (x?: boolean) => void + + return (x = false) => {}; +>(x = false) => {} : (x?: boolean) => void +>x : boolean +>false : false + +}); + +id(() => (y = false) => y); +>id(() => (y = false) => y) : () => (y?: boolean) => boolean +>id : (callback: T) => T +>() => (y = false) => y : () => (y?: boolean) => boolean +>(y = false) => y : (y?: boolean) => boolean +>y : boolean +>false : false +>y : boolean + +id(() => { +>id(() => { return { m(z = false) {} };}) : () => { m(z?: boolean): void; } +>id : (callback: T) => T +>() => { return { m(z = false) {} };} : () => { m(z?: boolean): void; } + + return { m(z = false) {} }; +>{ m(z = false) {} } : { m(z?: boolean): void; } +>m : (z?: boolean) => void +>z : boolean +>false : false + +}); + +const r = id(() => { +>r : () => (w?: number) => void +>id(() => { return (w = 0) => {};}) : () => (w?: number) => void +>id : (callback: T) => T +>() => { return (w = 0) => {};} : () => (w?: number) => void + + return (w = 0) => {}; +>(w = 0) => {} : (w?: number) => void +>w : number +>0 : 0 + +}); +r()(""); +>r()("") : void +>r() : (w?: number) => void +>r : () => (w?: number) => void +>"" : "" + diff --git a/tsc/testdata/baselines/reference/compiler/getterCircularityDiagnostics.errors.txt b/tsc/testdata/baselines/reference/compiler/getterCircularityDiagnostics.errors.txt new file mode 100644 index 0000000000000..ada42d0527e20 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/getterCircularityDiagnostics.errors.txt @@ -0,0 +1,17 @@ +getterCircularityDiagnostics.ts(4,9): error TS7023: 'options' implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions. + + +==== getterCircularityDiagnostics.ts (1 errors) ==== + declare const props: Options; + + class Container { + get options() { + ~~~~~~~ +!!! error TS7023: 'options' implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions. + return { container: this, ...props } as Options; + } + } + + interface Options { + container?: Container; + } \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/getterCircularityDiagnostics.js b/tsc/testdata/baselines/reference/compiler/getterCircularityDiagnostics.js new file mode 100644 index 0000000000000..e7507ff16bec4 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/getterCircularityDiagnostics.js @@ -0,0 +1,22 @@ +//// [tests/cases/compiler/getterCircularityDiagnostics.ts] //// + +//// [getterCircularityDiagnostics.ts] +declare const props: Options; + +class Container { + get options() { + return { container: this, ...props } as Options; + } +} + +interface Options { + container?: Container; +} + +//// [getterCircularityDiagnostics.js] +"use strict"; +class Container { + get options() { + return Object.assign({ container: this }, props); + } +} diff --git a/tsc/testdata/baselines/reference/compiler/getterCircularityDiagnostics.symbols b/tsc/testdata/baselines/reference/compiler/getterCircularityDiagnostics.symbols new file mode 100644 index 0000000000000..7ef53202b8061 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/getterCircularityDiagnostics.symbols @@ -0,0 +1,28 @@ +//// [tests/cases/compiler/getterCircularityDiagnostics.ts] //// + +=== getterCircularityDiagnostics.ts === +declare const props: Options; +>props : Symbol(props, Decl(getterCircularityDiagnostics.ts, 0, 13)) +>Options : Symbol(Options, Decl(getterCircularityDiagnostics.ts, 6, 1)) + +class Container { +>Container : Symbol(Container, Decl(getterCircularityDiagnostics.ts, 0, 29)) + + get options() { +>options : Symbol(Container.options, Decl(getterCircularityDiagnostics.ts, 2, 17)) + + return { container: this, ...props } as Options; +>container : Symbol(container, Decl(getterCircularityDiagnostics.ts, 4, 16)) +>this : Symbol(Container, Decl(getterCircularityDiagnostics.ts, 0, 29)) +>props : Symbol(props, Decl(getterCircularityDiagnostics.ts, 0, 13)) +>Options : Symbol(Options, Decl(getterCircularityDiagnostics.ts, 6, 1)) + } +} + +interface Options { +>Options : Symbol(Options, Decl(getterCircularityDiagnostics.ts, 6, 1)) + + container?: Container; +>container : Symbol(Options.container, Decl(getterCircularityDiagnostics.ts, 8, 19)) +>Container : Symbol(Container, Decl(getterCircularityDiagnostics.ts, 0, 29)) +} diff --git a/tsc/testdata/baselines/reference/compiler/getterCircularityDiagnostics.types b/tsc/testdata/baselines/reference/compiler/getterCircularityDiagnostics.types new file mode 100644 index 0000000000000..03f8b125b218d --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/getterCircularityDiagnostics.types @@ -0,0 +1,25 @@ +//// [tests/cases/compiler/getterCircularityDiagnostics.ts] //// + +=== getterCircularityDiagnostics.ts === +declare const props: Options; +>props : Options + +class Container { +>Container : Container + + get options() { +>options : any + + return { container: this, ...props } as Options; +>{ container: this, ...props } as Options : Options +>{ container: this, ...props } : { container: Container; } +>container : this +>this : this +>props : Options + } +} + +interface Options { + container?: Container; +>container : Container | undefined +} diff --git a/tsc/testdata/baselines/reference/compiler/getterReturnTypeQueryOrder(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/getterReturnTypeQueryOrder(checkorder=default).errors.txt new file mode 100644 index 0000000000000..4f28621217936 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/getterReturnTypeQueryOrder(checkorder=default).errors.txt @@ -0,0 +1,18 @@ +getterReturnTypeQueryOrder.ts(4,9): error TS7023: 'options' implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions. + + +==== getterReturnTypeQueryOrder.ts (1 errors) ==== + declare const props: Options; + + class Container { + get options() { + ~~~~~~~ +!!! error TS7023: 'options' implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions. + return { container: this, ...props } as Options; + } + } + + interface Options { + container?: Container; + } + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/getterReturnTypeQueryOrder(checkorder=default).js b/tsc/testdata/baselines/reference/compiler/getterReturnTypeQueryOrder(checkorder=default).js new file mode 100644 index 0000000000000..86ae054a9e244 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/getterReturnTypeQueryOrder(checkorder=default).js @@ -0,0 +1,23 @@ +//// [tests/cases/compiler/getterReturnTypeQueryOrder.ts] //// + +//// [getterReturnTypeQueryOrder.ts] +declare const props: Options; + +class Container { + get options() { + return { container: this, ...props } as Options; + } +} + +interface Options { + container?: Container; +} + + +//// [getterReturnTypeQueryOrder.js] +"use strict"; +class Container { + get options() { + return Object.assign({ container: this }, props); + } +} diff --git a/tsc/testdata/baselines/reference/compiler/getterReturnTypeQueryOrder(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/getterReturnTypeQueryOrder(checkorder=default).symbols new file mode 100644 index 0000000000000..0425451cdc246 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/getterReturnTypeQueryOrder(checkorder=default).symbols @@ -0,0 +1,29 @@ +//// [tests/cases/compiler/getterReturnTypeQueryOrder.ts] //// + +=== getterReturnTypeQueryOrder.ts === +declare const props: Options; +>props : Symbol(props, Decl(getterReturnTypeQueryOrder.ts, 0, 13)) +>Options : Symbol(Options, Decl(getterReturnTypeQueryOrder.ts, 6, 1)) + +class Container { +>Container : Symbol(Container, Decl(getterReturnTypeQueryOrder.ts, 0, 29)) + + get options() { +>options : Symbol(Container.options, Decl(getterReturnTypeQueryOrder.ts, 2, 17)) + + return { container: this, ...props } as Options; +>container : Symbol(container, Decl(getterReturnTypeQueryOrder.ts, 4, 16)) +>this : Symbol(Container, Decl(getterReturnTypeQueryOrder.ts, 0, 29)) +>props : Symbol(props, Decl(getterReturnTypeQueryOrder.ts, 0, 13)) +>Options : Symbol(Options, Decl(getterReturnTypeQueryOrder.ts, 6, 1)) + } +} + +interface Options { +>Options : Symbol(Options, Decl(getterReturnTypeQueryOrder.ts, 6, 1)) + + container?: Container; +>container : Symbol(Options.container, Decl(getterReturnTypeQueryOrder.ts, 8, 19)) +>Container : Symbol(Container, Decl(getterReturnTypeQueryOrder.ts, 0, 29)) +} + diff --git a/tsc/testdata/baselines/reference/compiler/getterReturnTypeQueryOrder(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/getterReturnTypeQueryOrder(checkorder=default).types new file mode 100644 index 0000000000000..df84cc21241ea --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/getterReturnTypeQueryOrder(checkorder=default).types @@ -0,0 +1,26 @@ +//// [tests/cases/compiler/getterReturnTypeQueryOrder.ts] //// + +=== getterReturnTypeQueryOrder.ts === +declare const props: Options; +>props : Options + +class Container { +>Container : Container + + get options() { +>options : any + + return { container: this, ...props } as Options; +>{ container: this, ...props } as Options : Options +>{ container: this, ...props } : { container: Container; } +>container : this +>this : this +>props : Options + } +} + +interface Options { + container?: Container; +>container : Container | undefined +} + diff --git a/tsc/testdata/baselines/reference/compiler/getterReturnTypeQueryOrder(checkorder=editorfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/getterReturnTypeQueryOrder(checkorder=editorfirst).errors.txt new file mode 100644 index 0000000000000..4f28621217936 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/getterReturnTypeQueryOrder(checkorder=editorfirst).errors.txt @@ -0,0 +1,18 @@ +getterReturnTypeQueryOrder.ts(4,9): error TS7023: 'options' implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions. + + +==== getterReturnTypeQueryOrder.ts (1 errors) ==== + declare const props: Options; + + class Container { + get options() { + ~~~~~~~ +!!! error TS7023: 'options' implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions. + return { container: this, ...props } as Options; + } + } + + interface Options { + container?: Container; + } + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/getterReturnTypeQueryOrder(checkorder=editorfirst).js b/tsc/testdata/baselines/reference/compiler/getterReturnTypeQueryOrder(checkorder=editorfirst).js new file mode 100644 index 0000000000000..86ae054a9e244 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/getterReturnTypeQueryOrder(checkorder=editorfirst).js @@ -0,0 +1,23 @@ +//// [tests/cases/compiler/getterReturnTypeQueryOrder.ts] //// + +//// [getterReturnTypeQueryOrder.ts] +declare const props: Options; + +class Container { + get options() { + return { container: this, ...props } as Options; + } +} + +interface Options { + container?: Container; +} + + +//// [getterReturnTypeQueryOrder.js] +"use strict"; +class Container { + get options() { + return Object.assign({ container: this }, props); + } +} diff --git a/tsc/testdata/baselines/reference/compiler/getterReturnTypeQueryOrder(checkorder=editorfirst).symbols b/tsc/testdata/baselines/reference/compiler/getterReturnTypeQueryOrder(checkorder=editorfirst).symbols new file mode 100644 index 0000000000000..0425451cdc246 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/getterReturnTypeQueryOrder(checkorder=editorfirst).symbols @@ -0,0 +1,29 @@ +//// [tests/cases/compiler/getterReturnTypeQueryOrder.ts] //// + +=== getterReturnTypeQueryOrder.ts === +declare const props: Options; +>props : Symbol(props, Decl(getterReturnTypeQueryOrder.ts, 0, 13)) +>Options : Symbol(Options, Decl(getterReturnTypeQueryOrder.ts, 6, 1)) + +class Container { +>Container : Symbol(Container, Decl(getterReturnTypeQueryOrder.ts, 0, 29)) + + get options() { +>options : Symbol(Container.options, Decl(getterReturnTypeQueryOrder.ts, 2, 17)) + + return { container: this, ...props } as Options; +>container : Symbol(container, Decl(getterReturnTypeQueryOrder.ts, 4, 16)) +>this : Symbol(Container, Decl(getterReturnTypeQueryOrder.ts, 0, 29)) +>props : Symbol(props, Decl(getterReturnTypeQueryOrder.ts, 0, 13)) +>Options : Symbol(Options, Decl(getterReturnTypeQueryOrder.ts, 6, 1)) + } +} + +interface Options { +>Options : Symbol(Options, Decl(getterReturnTypeQueryOrder.ts, 6, 1)) + + container?: Container; +>container : Symbol(Options.container, Decl(getterReturnTypeQueryOrder.ts, 8, 19)) +>Container : Symbol(Container, Decl(getterReturnTypeQueryOrder.ts, 0, 29)) +} + diff --git a/tsc/testdata/baselines/reference/compiler/getterReturnTypeQueryOrder(checkorder=editorfirst).types b/tsc/testdata/baselines/reference/compiler/getterReturnTypeQueryOrder(checkorder=editorfirst).types new file mode 100644 index 0000000000000..df84cc21241ea --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/getterReturnTypeQueryOrder(checkorder=editorfirst).types @@ -0,0 +1,26 @@ +//// [tests/cases/compiler/getterReturnTypeQueryOrder.ts] //// + +=== getterReturnTypeQueryOrder.ts === +declare const props: Options; +>props : Options + +class Container { +>Container : Container + + get options() { +>options : any + + return { container: this, ...props } as Options; +>{ container: this, ...props } as Options : Options +>{ container: this, ...props } : { container: Container; } +>container : this +>this : this +>props : Options + } +} + +interface Options { + container?: Container; +>container : Container | undefined +} + diff --git a/tsc/testdata/baselines/reference/compiler/importAttributeValueCheckOrder(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/importAttributeValueCheckOrder(checkorder=default).errors.txt new file mode 100644 index 0000000000000..d95e6caed1e54 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/importAttributeValueCheckOrder(checkorder=default).errors.txt @@ -0,0 +1,19 @@ +importAttributeValueCheckOrder.ts(5,19): error TS2322: Type '{ a: 0; }' is not assignable to type 'ImportAttributes'. + Property 'a' is incompatible with index signature. + Type 'number' is not assignable to type 'string'. +importAttributeValueCheckOrder.ts(5,29): error TS2858: Import attribute values must be string literal expressions. + + +==== importAttributeValueCheckOrder.ts (2 errors) ==== + // The attribute value is invalid, which does not affect the module. Its + // missing module must be reported whether or not the type of x is queried + // before the import is checked. + + import x from "x" with { a: 0 }; + ~~~~~~~~~~~~~ +!!! error TS2322: Type '{ a: 0; }' is not assignable to type 'ImportAttributes'. +!!! error TS2322: Property 'a' is incompatible with index signature. +!!! error TS2322: Type 'number' is not assignable to type 'string'. + ~ +!!! error TS2858: Import attribute values must be string literal expressions. + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/importAttributeValueCheckOrder(checkorder=default).js b/tsc/testdata/baselines/reference/compiler/importAttributeValueCheckOrder(checkorder=default).js new file mode 100644 index 0000000000000..97e58214a9ea0 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/importAttributeValueCheckOrder(checkorder=default).js @@ -0,0 +1,15 @@ +//// [tests/cases/compiler/importAttributeValueCheckOrder.ts] //// + +//// [importAttributeValueCheckOrder.ts] +// The attribute value is invalid, which does not affect the module. Its +// missing module must be reported whether or not the type of x is queried +// before the import is checked. + +import x from "x" with { a: 0 }; + + +//// [importAttributeValueCheckOrder.js] +// The attribute value is invalid, which does not affect the module. Its +// missing module must be reported whether or not the type of x is queried +// before the import is checked. +export {}; diff --git a/tsc/testdata/baselines/reference/compiler/importAttributeValueCheckOrder(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/importAttributeValueCheckOrder(checkorder=default).symbols new file mode 100644 index 0000000000000..3af978ee9fe99 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/importAttributeValueCheckOrder(checkorder=default).symbols @@ -0,0 +1,10 @@ +//// [tests/cases/compiler/importAttributeValueCheckOrder.ts] //// + +=== importAttributeValueCheckOrder.ts === +// The attribute value is invalid, which does not affect the module. Its +// missing module must be reported whether or not the type of x is queried +// before the import is checked. + +import x from "x" with { a: 0 }; +>x : Symbol(x, Decl(importAttributeValueCheckOrder.ts, 4, 6)) + diff --git a/tsc/testdata/baselines/reference/compiler/importAttributeValueCheckOrder(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/importAttributeValueCheckOrder(checkorder=default).types new file mode 100644 index 0000000000000..d0a03be7dfcaf --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/importAttributeValueCheckOrder(checkorder=default).types @@ -0,0 +1,11 @@ +//// [tests/cases/compiler/importAttributeValueCheckOrder.ts] //// + +=== importAttributeValueCheckOrder.ts === +// The attribute value is invalid, which does not affect the module. Its +// missing module must be reported whether or not the type of x is queried +// before the import is checked. + +import x from "x" with { a: 0 }; +>x : any +>a : any + diff --git a/tsc/testdata/baselines/reference/compiler/importAttributeValueCheckOrder(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/importAttributeValueCheckOrder(checkorder=typesfirst).errors.txt new file mode 100644 index 0000000000000..ebb125845b45c --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/importAttributeValueCheckOrder(checkorder=typesfirst).errors.txt @@ -0,0 +1,22 @@ +importAttributeValueCheckOrder.ts(5,15): error TS2307: Cannot find module 'x' or its corresponding type declarations. +importAttributeValueCheckOrder.ts(5,19): error TS2322: Type '{ a: 0; }' is not assignable to type 'ImportAttributes'. + Property 'a' is incompatible with index signature. + Type 'number' is not assignable to type 'string'. +importAttributeValueCheckOrder.ts(5,29): error TS2858: Import attribute values must be string literal expressions. + + +==== importAttributeValueCheckOrder.ts (3 errors) ==== + // The attribute value is invalid, which does not affect the module. Its + // missing module must be reported whether or not the type of x is queried + // before the import is checked. + + import x from "x" with { a: 0 }; + ~~~ +!!! error TS2307: Cannot find module 'x' or its corresponding type declarations. + ~~~~~~~~~~~~~ +!!! error TS2322: Type '{ a: 0; }' is not assignable to type 'ImportAttributes'. +!!! error TS2322: Property 'a' is incompatible with index signature. +!!! error TS2322: Type 'number' is not assignable to type 'string'. + ~ +!!! error TS2858: Import attribute values must be string literal expressions. + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/importAttributeValueCheckOrder(checkorder=typesfirst).js b/tsc/testdata/baselines/reference/compiler/importAttributeValueCheckOrder(checkorder=typesfirst).js new file mode 100644 index 0000000000000..97e58214a9ea0 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/importAttributeValueCheckOrder(checkorder=typesfirst).js @@ -0,0 +1,15 @@ +//// [tests/cases/compiler/importAttributeValueCheckOrder.ts] //// + +//// [importAttributeValueCheckOrder.ts] +// The attribute value is invalid, which does not affect the module. Its +// missing module must be reported whether or not the type of x is queried +// before the import is checked. + +import x from "x" with { a: 0 }; + + +//// [importAttributeValueCheckOrder.js] +// The attribute value is invalid, which does not affect the module. Its +// missing module must be reported whether or not the type of x is queried +// before the import is checked. +export {}; diff --git a/tsc/testdata/baselines/reference/compiler/importAttributeValueCheckOrder(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/importAttributeValueCheckOrder(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..3af978ee9fe99 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/importAttributeValueCheckOrder(checkorder=typesfirst).symbols @@ -0,0 +1,10 @@ +//// [tests/cases/compiler/importAttributeValueCheckOrder.ts] //// + +=== importAttributeValueCheckOrder.ts === +// The attribute value is invalid, which does not affect the module. Its +// missing module must be reported whether or not the type of x is queried +// before the import is checked. + +import x from "x" with { a: 0 }; +>x : Symbol(x, Decl(importAttributeValueCheckOrder.ts, 4, 6)) + diff --git a/tsc/testdata/baselines/reference/compiler/importAttributeValueCheckOrder(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/importAttributeValueCheckOrder(checkorder=typesfirst).types new file mode 100644 index 0000000000000..d0a03be7dfcaf --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/importAttributeValueCheckOrder(checkorder=typesfirst).types @@ -0,0 +1,11 @@ +//// [tests/cases/compiler/importAttributeValueCheckOrder.ts] //// + +=== importAttributeValueCheckOrder.ts === +// The attribute value is invalid, which does not affect the module. Its +// missing module must be reported whether or not the type of x is queried +// before the import is checked. + +import x from "x" with { a: 0 }; +>x : any +>a : any + diff --git a/tsc/testdata/baselines/reference/compiler/indexSignatureWithIndexedAccessOfDerivedInterface.errors.txt b/tsc/testdata/baselines/reference/compiler/indexSignatureWithIndexedAccessOfDerivedInterface.errors.txt new file mode 100644 index 0000000000000..b66f2e95879ca --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/indexSignatureWithIndexedAccessOfDerivedInterface.errors.txt @@ -0,0 +1,28 @@ +indexSignatureWithIndexedAccessOfDerivedInterface.ts(9,11): error TS2430: Interface 'TokenNode' incorrectly extends interface 'BaseNode'. + Index signature for type 'string' is missing in type 'TokenNode'. + + +==== indexSignatureWithIndexedAccessOfDerivedInterface.ts (1 errors) ==== + // The type of data in TokenNode is assignable to its inherited index + // signature, which mentions it through an indexed access. + + interface BaseNode { + kind: string; + [key: string]: string | TokenNode["data"]; + } + + interface TokenNode extends BaseNode { + ~~~~~~~~~ +!!! error TS2430: Interface 'TokenNode' incorrectly extends interface 'BaseNode'. +!!! error TS2430: Index signature for type 'string' is missing in type 'TokenNode'. + kind: 'token'; + data: TokenData; + } + + interface TokenData { + offset: number; + width: number; + leading_width: number; + trailing_width: number; + } + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/indexSignatureWithIndexedAccessOfDerivedInterface.symbols b/tsc/testdata/baselines/reference/compiler/indexSignatureWithIndexedAccessOfDerivedInterface.symbols new file mode 100644 index 0000000000000..da0c2151df68c --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/indexSignatureWithIndexedAccessOfDerivedInterface.symbols @@ -0,0 +1,45 @@ +//// [tests/cases/compiler/indexSignatureWithIndexedAccessOfDerivedInterface.ts] //// + +=== indexSignatureWithIndexedAccessOfDerivedInterface.ts === +// The type of data in TokenNode is assignable to its inherited index +// signature, which mentions it through an indexed access. + +interface BaseNode { +>BaseNode : Symbol(BaseNode, Decl(indexSignatureWithIndexedAccessOfDerivedInterface.ts, 0, 0)) + + kind: string; +>kind : Symbol(BaseNode.kind, Decl(indexSignatureWithIndexedAccessOfDerivedInterface.ts, 3, 20)) + + [key: string]: string | TokenNode["data"]; +>key : Symbol(key, Decl(indexSignatureWithIndexedAccessOfDerivedInterface.ts, 5, 3)) +>TokenNode : Symbol(TokenNode, Decl(indexSignatureWithIndexedAccessOfDerivedInterface.ts, 6, 1)) +} + +interface TokenNode extends BaseNode { +>TokenNode : Symbol(TokenNode, Decl(indexSignatureWithIndexedAccessOfDerivedInterface.ts, 6, 1)) +>BaseNode : Symbol(BaseNode, Decl(indexSignatureWithIndexedAccessOfDerivedInterface.ts, 0, 0)) + + kind: 'token'; +>kind : Symbol(TokenNode.kind, Decl(indexSignatureWithIndexedAccessOfDerivedInterface.ts, 8, 38)) + + data: TokenData; +>data : Symbol(TokenNode.data, Decl(indexSignatureWithIndexedAccessOfDerivedInterface.ts, 9, 16)) +>TokenData : Symbol(TokenData, Decl(indexSignatureWithIndexedAccessOfDerivedInterface.ts, 11, 1)) +} + +interface TokenData { +>TokenData : Symbol(TokenData, Decl(indexSignatureWithIndexedAccessOfDerivedInterface.ts, 11, 1)) + + offset: number; +>offset : Symbol(TokenData.offset, Decl(indexSignatureWithIndexedAccessOfDerivedInterface.ts, 13, 21)) + + width: number; +>width : Symbol(TokenData.width, Decl(indexSignatureWithIndexedAccessOfDerivedInterface.ts, 14, 17)) + + leading_width: number; +>leading_width : Symbol(TokenData.leading_width, Decl(indexSignatureWithIndexedAccessOfDerivedInterface.ts, 15, 16)) + + trailing_width: number; +>trailing_width : Symbol(TokenData.trailing_width, Decl(indexSignatureWithIndexedAccessOfDerivedInterface.ts, 16, 24)) +} + diff --git a/tsc/testdata/baselines/reference/compiler/indexSignatureWithIndexedAccessOfDerivedInterface.types b/tsc/testdata/baselines/reference/compiler/indexSignatureWithIndexedAccessOfDerivedInterface.types new file mode 100644 index 0000000000000..8dfc18dcb19e8 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/indexSignatureWithIndexedAccessOfDerivedInterface.types @@ -0,0 +1,36 @@ +//// [tests/cases/compiler/indexSignatureWithIndexedAccessOfDerivedInterface.ts] //// + +=== indexSignatureWithIndexedAccessOfDerivedInterface.ts === +// The type of data in TokenNode is assignable to its inherited index +// signature, which mentions it through an indexed access. + +interface BaseNode { + kind: string; +>kind : string + + [key: string]: string | TokenNode["data"]; +>key : string +} + +interface TokenNode extends BaseNode { + kind: 'token'; +>kind : "token" + + data: TokenData; +>data : TokenData +} + +interface TokenData { + offset: number; +>offset : number + + width: number; +>width : number + + leading_width: number; +>leading_width : number + + trailing_width: number; +>trailing_width : number +} + diff --git a/tsc/testdata/baselines/reference/compiler/indexedAccessAccessFlagsUnionOrder(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/indexedAccessAccessFlagsUnionOrder(checkorder=default).errors.txt new file mode 100644 index 0000000000000..b1e49290327ec --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/indexedAccessAccessFlagsUnionOrder(checkorder=default).errors.txt @@ -0,0 +1,22 @@ +indexedAccessAccessFlagsUnionOrder.ts(3,11): error TS2322: Type 'string | undefined' is not assignable to type 'string'. + Type 'undefined' is not assignable to type 'string'. +indexedAccessAccessFlagsUnionOrder.ts(5,11): error TS2322: Type 'string | undefined' is not assignable to type 'string'. + Type 'undefined' is not assignable to type 'string'. + + +==== indexedAccessAccessFlagsUnionOrder.ts (2 errors) ==== + function f, K extends keyof T>(obj: T, k: K, b: boolean) { + const x = b ? obj[k] : g(); + const s1: string = x; + ~~ +!!! error TS2322: Type 'string | undefined' is not assignable to type 'string'. +!!! error TS2322: Type 'undefined' is not assignable to type 'string'. + const y = b ? g() : obj[k]; + const s2: string = y; + ~~ +!!! error TS2322: Type 'string | undefined' is not assignable to type 'string'. +!!! error TS2322: Type 'undefined' is not assignable to type 'string'. + } + + declare function g(): T[K]; + \ No newline at end of file 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..5f8f696fbf930 --- /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 : string | undefined + + 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 : string | undefined +} + +declare function g(): T[K]; +>g : () => T[K] + diff --git a/tsc/testdata/baselines/reference/compiler/indexedAccessAccessFlagsUnionOrder(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/indexedAccessAccessFlagsUnionOrder(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..1c03287916ff1 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/indexedAccessAccessFlagsUnionOrder(checkorder=typesfirst).symbols @@ -0,0 +1,50 @@ +//// [tests/cases/compiler/indexedAccessAccessFlagsUnionOrder.ts] //// + +=== indexedAccessAccessFlagsUnionOrder.ts === +function f, K extends keyof T>(obj: T, k: K, b: boolean) { +>f : Symbol(f, Decl(indexedAccessAccessFlagsUnionOrder.ts, 0, 0)) +>T : Symbol(T, Decl(indexedAccessAccessFlagsUnionOrder.ts, 0, 11)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) +>K : Symbol(K, Decl(indexedAccessAccessFlagsUnionOrder.ts, 0, 44)) +>T : Symbol(T, Decl(indexedAccessAccessFlagsUnionOrder.ts, 0, 11)) +>obj : Symbol(obj, Decl(indexedAccessAccessFlagsUnionOrder.ts, 0, 64)) +>T : Symbol(T, Decl(indexedAccessAccessFlagsUnionOrder.ts, 0, 11)) +>k : Symbol(k, Decl(indexedAccessAccessFlagsUnionOrder.ts, 0, 71)) +>K : Symbol(K, Decl(indexedAccessAccessFlagsUnionOrder.ts, 0, 44)) +>b : Symbol(b, Decl(indexedAccessAccessFlagsUnionOrder.ts, 0, 77)) + + const x = b ? obj[k] : g(); +>x : Symbol(x, Decl(indexedAccessAccessFlagsUnionOrder.ts, 1, 9)) +>b : Symbol(b, Decl(indexedAccessAccessFlagsUnionOrder.ts, 0, 77)) +>obj : Symbol(obj, Decl(indexedAccessAccessFlagsUnionOrder.ts, 0, 64)) +>k : Symbol(k, Decl(indexedAccessAccessFlagsUnionOrder.ts, 0, 71)) +>g : Symbol(g, Decl(indexedAccessAccessFlagsUnionOrder.ts, 5, 1)) +>T : Symbol(T, Decl(indexedAccessAccessFlagsUnionOrder.ts, 0, 11)) +>K : Symbol(K, Decl(indexedAccessAccessFlagsUnionOrder.ts, 0, 44)) + + const s1: string = x; +>s1 : Symbol(s1, Decl(indexedAccessAccessFlagsUnionOrder.ts, 2, 9)) +>x : Symbol(x, Decl(indexedAccessAccessFlagsUnionOrder.ts, 1, 9)) + + const y = b ? g() : obj[k]; +>y : Symbol(y, Decl(indexedAccessAccessFlagsUnionOrder.ts, 3, 9)) +>b : Symbol(b, Decl(indexedAccessAccessFlagsUnionOrder.ts, 0, 77)) +>g : Symbol(g, Decl(indexedAccessAccessFlagsUnionOrder.ts, 5, 1)) +>T : Symbol(T, Decl(indexedAccessAccessFlagsUnionOrder.ts, 0, 11)) +>K : Symbol(K, Decl(indexedAccessAccessFlagsUnionOrder.ts, 0, 44)) +>obj : Symbol(obj, Decl(indexedAccessAccessFlagsUnionOrder.ts, 0, 64)) +>k : Symbol(k, Decl(indexedAccessAccessFlagsUnionOrder.ts, 0, 71)) + + const s2: string = y; +>s2 : Symbol(s2, Decl(indexedAccessAccessFlagsUnionOrder.ts, 4, 9)) +>y : Symbol(y, Decl(indexedAccessAccessFlagsUnionOrder.ts, 3, 9)) +} + +declare function g(): T[K]; +>g : Symbol(g, Decl(indexedAccessAccessFlagsUnionOrder.ts, 5, 1)) +>T : Symbol(T, Decl(indexedAccessAccessFlagsUnionOrder.ts, 7, 19)) +>K : Symbol(K, Decl(indexedAccessAccessFlagsUnionOrder.ts, 7, 21)) +>T : Symbol(T, Decl(indexedAccessAccessFlagsUnionOrder.ts, 7, 19)) +>T : Symbol(T, Decl(indexedAccessAccessFlagsUnionOrder.ts, 7, 19)) +>K : Symbol(K, Decl(indexedAccessAccessFlagsUnionOrder.ts, 7, 21)) + diff --git a/tsc/testdata/baselines/reference/compiler/indexedAccessAccessFlagsUnionOrder(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/indexedAccessAccessFlagsUnionOrder(checkorder=typesfirst).types new file mode 100644 index 0000000000000..3842ea2cb6352 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/indexedAccessAccessFlagsUnionOrder(checkorder=typesfirst).types @@ -0,0 +1,41 @@ +//// [tests/cases/compiler/indexedAccessAccessFlagsUnionOrder.ts] //// + +=== indexedAccessAccessFlagsUnionOrder.ts === +function f, K extends keyof T>(obj: T, k: K, b: boolean) { +>f : , K extends keyof T>(obj: T, k: K, b: boolean) => void +>obj : T +>k : K +>b : boolean + + const x = b ? obj[k] : g(); +>x : T[K] +>b ? obj[k] : g() : T[K] +>b : boolean +>obj[k] : T[K] +>obj : T +>k : K +>g() : T[K] +>g : () => T_1[K_1] + + const s1: string = x; +>s1 : string +>x : T[K] + + const y = b ? g() : obj[k]; +>y : T[K] +>b ? g() : obj[k] : T[K] +>b : boolean +>g() : T[K] +>g : () => T_1[K_1] +>obj[k] : T[K] +>obj : T +>k : K + + const s2: string = y; +>s2 : string +>y : T[K] +} + +declare function g(): T[K]; +>g : () => T[K] + diff --git a/tsc/testdata/baselines/reference/compiler/inferTypeParameterConstraintFromMappedIntersectionCheckOrder(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/inferTypeParameterConstraintFromMappedIntersectionCheckOrder(checkorder=default).errors.txt new file mode 100644 index 0000000000000..451dbe9e554a3 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/inferTypeParameterConstraintFromMappedIntersectionCheckOrder(checkorder=default).errors.txt @@ -0,0 +1,16 @@ +inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts(8,23): error TS2344: Type 'U' does not satisfy the constraint 'object'. + + +==== inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts (1 errors) ==== + // The constraint of U is inferred from the constraint of the type parameter + // of S. Instantiating S with U needs the constraint of U, so whether U + // satisfies object must not depend on whether I is queried before its type + // arguments are checked. + + type Copy = { [K in keyof T]: T[K] }; + type S = Copy<{ x: 0 } & T>; + type I = {} extends S ? U : never; + ~~~~~~~ +!!! error TS2344: Type 'U' does not satisfy the constraint 'object'. +!!! related TS2208 inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts:8:29: This type parameter might need an `extends object` constraint. + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/inferTypeParameterConstraintFromMappedIntersectionCheckOrder(checkorder=default).js b/tsc/testdata/baselines/reference/compiler/inferTypeParameterConstraintFromMappedIntersectionCheckOrder(checkorder=default).js new file mode 100644 index 0000000000000..1267ee1cbc4a6 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/inferTypeParameterConstraintFromMappedIntersectionCheckOrder(checkorder=default).js @@ -0,0 +1,19 @@ +//// [tests/cases/compiler/inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts] //// + +//// [inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts] +// The constraint of U is inferred from the constraint of the type parameter +// of S. Instantiating S with U needs the constraint of U, so whether U +// satisfies object must not depend on whether I is queried before its type +// arguments are checked. + +type Copy = { [K in keyof T]: T[K] }; +type S = Copy<{ x: 0 } & T>; +type I = {} extends S ? U : never; + + +//// [inferTypeParameterConstraintFromMappedIntersectionCheckOrder.js] +"use strict"; +// The constraint of U is inferred from the constraint of the type parameter +// of S. Instantiating S with U needs the constraint of U, so whether U +// satisfies object must not depend on whether I is queried before its type +// arguments are checked. diff --git a/tsc/testdata/baselines/reference/compiler/inferTypeParameterConstraintFromMappedIntersectionCheckOrder(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/inferTypeParameterConstraintFromMappedIntersectionCheckOrder(checkorder=default).symbols new file mode 100644 index 0000000000000..20615918e8733 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/inferTypeParameterConstraintFromMappedIntersectionCheckOrder(checkorder=default).symbols @@ -0,0 +1,29 @@ +//// [tests/cases/compiler/inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts] //// + +=== inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts === +// The constraint of U is inferred from the constraint of the type parameter +// of S. Instantiating S with U needs the constraint of U, so whether U +// satisfies object must not depend on whether I is queried before its type +// arguments are checked. + +type Copy = { [K in keyof T]: T[K] }; +>Copy : Symbol(Copy, Decl(inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts, 0, 0)) +>T : Symbol(T, Decl(inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts, 5, 10)) +>K : Symbol(K, Decl(inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts, 5, 18)) +>T : Symbol(T, Decl(inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts, 5, 10)) +>T : Symbol(T, Decl(inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts, 5, 10)) +>K : Symbol(K, Decl(inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts, 5, 18)) + +type S = Copy<{ x: 0 } & T>; +>S : Symbol(S, Decl(inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts, 5, 40)) +>T : Symbol(T, Decl(inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts, 6, 7)) +>Copy : Symbol(Copy, Decl(inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts, 0, 0)) +>x : Symbol(x, Decl(inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts, 6, 33)) +>T : Symbol(T, Decl(inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts, 6, 7)) + +type I = {} extends S ? U : never; +>I : Symbol(I, Decl(inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts, 6, 46)) +>S : Symbol(S, Decl(inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts, 5, 40)) +>U : Symbol(U, Decl(inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts, 7, 27)) +>U : Symbol(U, Decl(inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts, 7, 27)) + diff --git a/tsc/testdata/baselines/reference/compiler/inferTypeParameterConstraintFromMappedIntersectionCheckOrder(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/inferTypeParameterConstraintFromMappedIntersectionCheckOrder(checkorder=default).types new file mode 100644 index 0000000000000..f7d45d2ef1677 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/inferTypeParameterConstraintFromMappedIntersectionCheckOrder(checkorder=default).types @@ -0,0 +1,18 @@ +//// [tests/cases/compiler/inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts] //// + +=== inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts === +// The constraint of U is inferred from the constraint of the type parameter +// of S. Instantiating S with U needs the constraint of U, so whether U +// satisfies object must not depend on whether I is queried before its type +// arguments are checked. + +type Copy = { [K in keyof T]: T[K] }; +>Copy : Copy + +type S = Copy<{ x: 0 } & T>; +>S : Copy<{ x: 0; } & T> +>x : 0 + +type I = {} extends S ? U : never; +>I : never + diff --git a/tsc/testdata/baselines/reference/compiler/inferTypeParameterConstraintFromMappedIntersectionCheckOrder(checkorder=typesfirst).js b/tsc/testdata/baselines/reference/compiler/inferTypeParameterConstraintFromMappedIntersectionCheckOrder(checkorder=typesfirst).js new file mode 100644 index 0000000000000..1267ee1cbc4a6 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/inferTypeParameterConstraintFromMappedIntersectionCheckOrder(checkorder=typesfirst).js @@ -0,0 +1,19 @@ +//// [tests/cases/compiler/inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts] //// + +//// [inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts] +// The constraint of U is inferred from the constraint of the type parameter +// of S. Instantiating S with U needs the constraint of U, so whether U +// satisfies object must not depend on whether I is queried before its type +// arguments are checked. + +type Copy = { [K in keyof T]: T[K] }; +type S = Copy<{ x: 0 } & T>; +type I = {} extends S ? U : never; + + +//// [inferTypeParameterConstraintFromMappedIntersectionCheckOrder.js] +"use strict"; +// The constraint of U is inferred from the constraint of the type parameter +// of S. Instantiating S with U needs the constraint of U, so whether U +// satisfies object must not depend on whether I is queried before its type +// arguments are checked. diff --git a/tsc/testdata/baselines/reference/compiler/inferTypeParameterConstraintFromMappedIntersectionCheckOrder(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/inferTypeParameterConstraintFromMappedIntersectionCheckOrder(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..20615918e8733 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/inferTypeParameterConstraintFromMappedIntersectionCheckOrder(checkorder=typesfirst).symbols @@ -0,0 +1,29 @@ +//// [tests/cases/compiler/inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts] //// + +=== inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts === +// The constraint of U is inferred from the constraint of the type parameter +// of S. Instantiating S with U needs the constraint of U, so whether U +// satisfies object must not depend on whether I is queried before its type +// arguments are checked. + +type Copy = { [K in keyof T]: T[K] }; +>Copy : Symbol(Copy, Decl(inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts, 0, 0)) +>T : Symbol(T, Decl(inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts, 5, 10)) +>K : Symbol(K, Decl(inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts, 5, 18)) +>T : Symbol(T, Decl(inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts, 5, 10)) +>T : Symbol(T, Decl(inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts, 5, 10)) +>K : Symbol(K, Decl(inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts, 5, 18)) + +type S = Copy<{ x: 0 } & T>; +>S : Symbol(S, Decl(inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts, 5, 40)) +>T : Symbol(T, Decl(inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts, 6, 7)) +>Copy : Symbol(Copy, Decl(inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts, 0, 0)) +>x : Symbol(x, Decl(inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts, 6, 33)) +>T : Symbol(T, Decl(inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts, 6, 7)) + +type I = {} extends S ? U : never; +>I : Symbol(I, Decl(inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts, 6, 46)) +>S : Symbol(S, Decl(inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts, 5, 40)) +>U : Symbol(U, Decl(inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts, 7, 27)) +>U : Symbol(U, Decl(inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts, 7, 27)) + diff --git a/tsc/testdata/baselines/reference/compiler/inferTypeParameterConstraintFromMappedIntersectionCheckOrder(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/inferTypeParameterConstraintFromMappedIntersectionCheckOrder(checkorder=typesfirst).types new file mode 100644 index 0000000000000..f7d45d2ef1677 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/inferTypeParameterConstraintFromMappedIntersectionCheckOrder(checkorder=typesfirst).types @@ -0,0 +1,18 @@ +//// [tests/cases/compiler/inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts] //// + +=== inferTypeParameterConstraintFromMappedIntersectionCheckOrder.ts === +// The constraint of U is inferred from the constraint of the type parameter +// of S. Instantiating S with U needs the constraint of U, so whether U +// satisfies object must not depend on whether I is queried before its type +// arguments are checked. + +type Copy = { [K in keyof T]: T[K] }; +>Copy : Copy + +type S = Copy<{ x: 0 } & T>; +>S : Copy<{ x: 0; } & T> +>x : 0 + +type I = {} extends S ? U : never; +>I : never + diff --git a/tsc/testdata/baselines/reference/compiler/inferenceDeeplyNestedCheckOrder.errors.txt b/tsc/testdata/baselines/reference/compiler/inferenceDeeplyNestedCheckOrder.errors.txt new file mode 100644 index 0000000000000..32e5d2c00be81 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/inferenceDeeplyNestedCheckOrder.errors.txt @@ -0,0 +1,24 @@ +first.ts(3,7): error TS2322: Type 'unknown[]' 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 'unknown[]' 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..c1fc223370a61 --- /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) : unknown[] +>flatten1 : (iterable: Iterable>) => T[] +>lists1 : string[][] + +declare const items1: string[]; +>items1 : string[] + +for (const item of items1) {} +>item : string +>items1 : string[] + +=== second.ts === +declare const items2: number[]; +>items2 : number[] + +for (const item of items2) {} +>item : number +>items2 : number[] + +declare function flatten2(iterable: Iterable>): T[]; +>flatten2 : (iterable: Iterable>) => T[] +>iterable : Iterable> + +declare const lists2: number[][]; +>lists2 : number[][] + +const flat2: null = flatten2(lists2); +>flat2 : null +>flatten2(lists2) : number[] +>flatten2 : (iterable: Iterable>) => T[] +>lists2 : number[][] + diff --git a/tsc/testdata/baselines/reference/compiler/inferenceFromUnionOfTypeParameterAndPromiseLike.errors.txt b/tsc/testdata/baselines/reference/compiler/inferenceFromUnionOfTypeParameterAndPromiseLike.errors.txt new file mode 100644 index 0000000000000..1810c3d299596 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/inferenceFromUnionOfTypeParameterAndPromiseLike.errors.txt @@ -0,0 +1,17 @@ +inferenceFromUnionOfTypeParameterAndPromiseLike.ts(6,7): error TS2322: Type 'Promise>>' is not assignable to type 'Promise>'. + Type 'Map>' is not assignable to type 'Map'. + Type 'Promise' is not assignable to type 'string'. + + +==== inferenceFromUnionOfTypeParameterAndPromiseLike.ts (1 errors) ==== + // Inferring from Promise to PromiseLike | V must infer V as string, + // whichever order the union's members are in. + + declare function props(x: PromiseLike | V>>): Promise>; + declare const input: Promise>>; + const out: Promise> = props(input); + ~~~ +!!! error TS2322: Type 'Promise>>' is not assignable to type 'Promise>'. +!!! error TS2322: Type 'Map>' is not assignable to type 'Map'. +!!! error TS2322: Type 'Promise' is not assignable to type 'string'. + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/inferenceFromUnionOfTypeParameterAndPromiseLike.symbols b/tsc/testdata/baselines/reference/compiler/inferenceFromUnionOfTypeParameterAndPromiseLike.symbols new file mode 100644 index 0000000000000..981fb64862427 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/inferenceFromUnionOfTypeParameterAndPromiseLike.symbols @@ -0,0 +1,35 @@ +//// [tests/cases/compiler/inferenceFromUnionOfTypeParameterAndPromiseLike.ts] //// + +=== inferenceFromUnionOfTypeParameterAndPromiseLike.ts === +// Inferring from Promise to PromiseLike | V must infer V as string, +// whichever order the union's members are in. + +declare function props(x: PromiseLike | V>>): Promise>; +>props : Symbol(props, Decl(inferenceFromUnionOfTypeParameterAndPromiseLike.ts, 0, 0)) +>K : Symbol(K, Decl(inferenceFromUnionOfTypeParameterAndPromiseLike.ts, 3, 23)) +>V : Symbol(V, Decl(inferenceFromUnionOfTypeParameterAndPromiseLike.ts, 3, 25)) +>x : Symbol(x, Decl(inferenceFromUnionOfTypeParameterAndPromiseLike.ts, 3, 29)) +>PromiseLike : Symbol(PromiseLike, Decl(lib.es5.d.ts, --, --)) +>Map : Symbol(Map, Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2026.collection.d.ts, --, --)) +>K : Symbol(K, Decl(inferenceFromUnionOfTypeParameterAndPromiseLike.ts, 3, 23)) +>PromiseLike : Symbol(PromiseLike, Decl(lib.es5.d.ts, --, --)) +>V : Symbol(V, Decl(inferenceFromUnionOfTypeParameterAndPromiseLike.ts, 3, 25)) +>V : Symbol(V, Decl(inferenceFromUnionOfTypeParameterAndPromiseLike.ts, 3, 25)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2018.promise.d.ts, --, --)) +>Map : Symbol(Map, Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2026.collection.d.ts, --, --)) +>K : Symbol(K, Decl(inferenceFromUnionOfTypeParameterAndPromiseLike.ts, 3, 23)) +>V : Symbol(V, Decl(inferenceFromUnionOfTypeParameterAndPromiseLike.ts, 3, 25)) + +declare const input: Promise>>; +>input : Symbol(input, Decl(inferenceFromUnionOfTypeParameterAndPromiseLike.ts, 4, 13)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2018.promise.d.ts, --, --)) +>Map : Symbol(Map, Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2026.collection.d.ts, --, --)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2018.promise.d.ts, --, --)) + +const out: Promise> = props(input); +>out : Symbol(out, Decl(inferenceFromUnionOfTypeParameterAndPromiseLike.ts, 5, 5)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2018.promise.d.ts, --, --)) +>Map : Symbol(Map, Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2026.collection.d.ts, --, --)) +>props : Symbol(props, Decl(inferenceFromUnionOfTypeParameterAndPromiseLike.ts, 0, 0)) +>input : Symbol(input, Decl(inferenceFromUnionOfTypeParameterAndPromiseLike.ts, 4, 13)) + diff --git a/tsc/testdata/baselines/reference/compiler/inferenceFromUnionOfTypeParameterAndPromiseLike.types b/tsc/testdata/baselines/reference/compiler/inferenceFromUnionOfTypeParameterAndPromiseLike.types new file mode 100644 index 0000000000000..c3d2ece0232d6 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/inferenceFromUnionOfTypeParameterAndPromiseLike.types @@ -0,0 +1,19 @@ +//// [tests/cases/compiler/inferenceFromUnionOfTypeParameterAndPromiseLike.ts] //// + +=== inferenceFromUnionOfTypeParameterAndPromiseLike.ts === +// Inferring from Promise to PromiseLike | V must infer V as string, +// whichever order the union's members are in. + +declare function props(x: PromiseLike | V>>): Promise>; +>props : (x: PromiseLike | V>>) => Promise> +>x : PromiseLike>> + +declare const input: Promise>>; +>input : Promise>> + +const out: Promise> = props(input); +>out : Promise> +>props(input) : Promise>> +>props : (x: PromiseLike | V>>) => Promise> +>input : Promise>> + diff --git a/tsc/testdata/baselines/reference/compiler/inferenceThroughSortOfFlattenedIterable.errors.txt b/tsc/testdata/baselines/reference/compiler/inferenceThroughSortOfFlattenedIterable.errors.txt new file mode 100644 index 0000000000000..a34bbb1f6960b --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/inferenceThroughSortOfFlattenedIterable.errors.txt @@ -0,0 +1,26 @@ +inferenceThroughSortOfFlattenedIterable.ts(10,2): error TS2322: Type 'unknown[]' is not assignable to type 'readonly string[]'. + Type 'unknown' is not assignable to type 'string'. + + +==== inferenceThroughSortOfFlattenedIterable.ts (1 errors) ==== + // Sorting the array made from a flattened iterable must keep its element type. + + function getAllValuesUnsorted(m: ReadonlyArray>): ReadonlyArray { + // OK + return Array.from(flatten(m.values())) + } + + function getAllValuesSorted(m: ReadonlyArray>): ReadonlyArray { + // Type 'unknown[]' is not assignable to type 'readonly string[]'. + return Array.from(flatten(m.values())).sort() + ~~~~~~ +!!! error TS2322: Type 'unknown[]' is not assignable to type 'readonly string[]'. +!!! error TS2322: Type 'unknown' is not assignable to type 'string'. + } + + function* flatten(a: Iterable>): Iterable { + for (const xs of a) + for (const x of xs) + yield x + } + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/inferenceThroughSortOfFlattenedIterable.symbols b/tsc/testdata/baselines/reference/compiler/inferenceThroughSortOfFlattenedIterable.symbols new file mode 100644 index 0000000000000..9e92b4fcae85c --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/inferenceThroughSortOfFlattenedIterable.symbols @@ -0,0 +1,65 @@ +//// [tests/cases/compiler/inferenceThroughSortOfFlattenedIterable.ts] //// + +=== inferenceThroughSortOfFlattenedIterable.ts === +// Sorting the array made from a flattened iterable must keep its element type. + +function getAllValuesUnsorted(m: ReadonlyArray>): ReadonlyArray { +>getAllValuesUnsorted : Symbol(getAllValuesUnsorted, Decl(inferenceThroughSortOfFlattenedIterable.ts, 0, 0)) +>m : Symbol(m, Decl(inferenceThroughSortOfFlattenedIterable.ts, 2, 30)) +>ReadonlyArray : Symbol(ReadonlyArray, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2016.array.include.d.ts, --, --) ... and 3 more) +>ReadonlyArray : Symbol(ReadonlyArray, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2016.array.include.d.ts, --, --) ... and 3 more) +>ReadonlyArray : Symbol(ReadonlyArray, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2016.array.include.d.ts, --, --) ... and 3 more) + + // OK + return Array.from(flatten(m.values())) +>Array.from : Symbol(ArrayConstructor.from, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) +>Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --) ... and 4 more) +>from : Symbol(ArrayConstructor.from, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) +>flatten : Symbol(flatten, Decl(inferenceThroughSortOfFlattenedIterable.ts, 10, 1)) +>m.values : Symbol(ReadonlyArray.values, Decl(lib.es2015.iterable.d.ts, --, --)) +>m : Symbol(m, Decl(inferenceThroughSortOfFlattenedIterable.ts, 2, 30)) +>values : Symbol(ReadonlyArray.values, Decl(lib.es2015.iterable.d.ts, --, --)) +} + +function getAllValuesSorted(m: ReadonlyArray>): ReadonlyArray { +>getAllValuesSorted : Symbol(getAllValuesSorted, Decl(inferenceThroughSortOfFlattenedIterable.ts, 5, 1)) +>m : Symbol(m, Decl(inferenceThroughSortOfFlattenedIterable.ts, 7, 28)) +>ReadonlyArray : Symbol(ReadonlyArray, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2016.array.include.d.ts, --, --) ... and 3 more) +>ReadonlyArray : Symbol(ReadonlyArray, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2016.array.include.d.ts, --, --) ... and 3 more) +>ReadonlyArray : Symbol(ReadonlyArray, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2016.array.include.d.ts, --, --) ... and 3 more) + + // Type 'unknown[]' is not assignable to type 'readonly string[]'. + return Array.from(flatten(m.values())).sort() +>Array.from(flatten(m.values())).sort : Symbol(Array.sort, Decl(lib.es5.d.ts, --, --)) +>Array.from : Symbol(ArrayConstructor.from, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) +>Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --) ... and 4 more) +>from : Symbol(ArrayConstructor.from, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --)) +>flatten : Symbol(flatten, Decl(inferenceThroughSortOfFlattenedIterable.ts, 10, 1)) +>m.values : Symbol(ReadonlyArray.values, Decl(lib.es2015.iterable.d.ts, --, --)) +>m : Symbol(m, Decl(inferenceThroughSortOfFlattenedIterable.ts, 7, 28)) +>values : Symbol(ReadonlyArray.values, Decl(lib.es2015.iterable.d.ts, --, --)) +>sort : Symbol(Array.sort, Decl(lib.es5.d.ts, --, --)) +} + +function* flatten(a: Iterable>): Iterable { +>flatten : Symbol(flatten, Decl(inferenceThroughSortOfFlattenedIterable.ts, 10, 1)) +>T : Symbol(T, Decl(inferenceThroughSortOfFlattenedIterable.ts, 12, 18)) +>a : Symbol(a, Decl(inferenceThroughSortOfFlattenedIterable.ts, 12, 21)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>T : Symbol(T, Decl(inferenceThroughSortOfFlattenedIterable.ts, 12, 18)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>T : Symbol(T, Decl(inferenceThroughSortOfFlattenedIterable.ts, 12, 18)) + + for (const xs of a) +>xs : Symbol(xs, Decl(inferenceThroughSortOfFlattenedIterable.ts, 13, 11)) +>a : Symbol(a, Decl(inferenceThroughSortOfFlattenedIterable.ts, 12, 21)) + + for (const x of xs) +>x : Symbol(x, Decl(inferenceThroughSortOfFlattenedIterable.ts, 14, 12)) +>xs : Symbol(xs, Decl(inferenceThroughSortOfFlattenedIterable.ts, 13, 11)) + + yield x +>x : Symbol(x, Decl(inferenceThroughSortOfFlattenedIterable.ts, 14, 12)) +} + diff --git a/tsc/testdata/baselines/reference/compiler/inferenceThroughSortOfFlattenedIterable.types b/tsc/testdata/baselines/reference/compiler/inferenceThroughSortOfFlattenedIterable.types new file mode 100644 index 0000000000000..fa14743403d39 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/inferenceThroughSortOfFlattenedIterable.types @@ -0,0 +1,61 @@ +//// [tests/cases/compiler/inferenceThroughSortOfFlattenedIterable.ts] //// + +=== inferenceThroughSortOfFlattenedIterable.ts === +// Sorting the array made from a flattened iterable must keep its element type. + +function getAllValuesUnsorted(m: ReadonlyArray>): ReadonlyArray { +>getAllValuesUnsorted : (m: ReadonlyArray>) => ReadonlyArray +>m : readonly (readonly string[])[] + + // OK + return Array.from(flatten(m.values())) +>Array.from(flatten(m.values())) : string[] +>Array.from : { (arrayLike: ArrayLike): T[]; (arrayLike: ArrayLike, mapfn: (v: T, k: number) => U, thisArg?: any): U[]; (iterable: Iterable | ArrayLike): T[]; (iterable: Iterable | ArrayLike, mapfn: (v: T, k: number) => U, thisArg?: any): U[]; } +>Array : ArrayConstructor +>from : { (arrayLike: ArrayLike): T[]; (arrayLike: ArrayLike, mapfn: (v: T, k: number) => U, thisArg?: any): U[]; (iterable: Iterable | ArrayLike): T[]; (iterable: Iterable | ArrayLike, mapfn: (v: T, k: number) => U, thisArg?: any): U[]; } +>flatten(m.values()) : Iterable +>flatten : (a: Iterable>) => Iterable +>m.values() : ArrayIterator +>m.values : () => ArrayIterator +>m : readonly (readonly string[])[] +>values : () => ArrayIterator +} + +function getAllValuesSorted(m: ReadonlyArray>): ReadonlyArray { +>getAllValuesSorted : (m: ReadonlyArray>) => ReadonlyArray +>m : readonly (readonly string[])[] + + // Type 'unknown[]' is not assignable to type 'readonly string[]'. + return Array.from(flatten(m.values())).sort() +>Array.from(flatten(m.values())).sort() : unknown[] +>Array.from(flatten(m.values())).sort : (compareFn?: ((a: unknown, b: unknown) => number) | undefined) => unknown[] +>Array.from(flatten(m.values())) : unknown[] +>Array.from : { (arrayLike: ArrayLike): T[]; (arrayLike: ArrayLike, mapfn: (v: T, k: number) => U, thisArg?: any): U[]; (iterable: Iterable | ArrayLike): T[]; (iterable: Iterable | ArrayLike, mapfn: (v: T, k: number) => U, thisArg?: any): U[]; } +>Array : ArrayConstructor +>from : { (arrayLike: ArrayLike): T[]; (arrayLike: ArrayLike, mapfn: (v: T, k: number) => U, thisArg?: any): U[]; (iterable: Iterable | ArrayLike): T[]; (iterable: Iterable | ArrayLike, mapfn: (v: T, k: number) => U, thisArg?: any): U[]; } +>flatten(m.values()) : Iterable +>flatten : (a: Iterable>) => Iterable +>m.values() : ArrayIterator +>m.values : () => ArrayIterator +>m : readonly (readonly string[])[] +>values : () => ArrayIterator +>sort : (compareFn?: ((a: unknown, b: unknown) => number) | undefined) => unknown[] +} + +function* flatten(a: Iterable>): Iterable { +>flatten : (a: Iterable>) => Iterable +>a : Iterable> + + for (const xs of a) +>xs : Iterable +>a : Iterable> + + for (const x of xs) +>x : T +>xs : Iterable + + yield x +>yield x : any +>x : T +} + diff --git a/tsc/testdata/baselines/reference/compiler/instantiationCouldContainTypeVariablesAfterCycle(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/instantiationCouldContainTypeVariablesAfterCycle(checkorder=default).symbols new file mode 100644 index 0000000000000..0031705ad6203 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/instantiationCouldContainTypeVariablesAfterCycle(checkorder=default).symbols @@ -0,0 +1,69 @@ +//// [tests/cases/compiler/instantiationCouldContainTypeVariablesAfterCycle.ts] //// + +=== instantiationCouldContainTypeVariablesAfterCycle.ts === +// Query is instantiated with only non-generic arguments, so it (and DeepPartial>) +// can't contain type variables, and inference from Meta must not structurally recurse into +// DeepPartial>. That recursion would expand the infinite DeepPartial and report +// TS5114. The carry-forward of the "could contain type variables" flag set at instantiation time +// must survive even when the instantiation is created inside a circularity that is later discarded. + +declare const a: Meta; +>a : Symbol(a, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 6, 13)) +>Meta : Symbol(Meta, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 10, 36)) + +fromMetadata(a); +>fromMetadata : Symbol(fromMetadata, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 16, 33)) +>a : Symbol(a, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 6, 13)) + +type DeepPartial = { [P in keyof T]: DeepPartial }; +>DeepPartial : Symbol(DeepPartial, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 7, 16)) +>T : Symbol(T, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 8, 17)) +>P : Symbol(P, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 8, 25)) +>T : Symbol(T, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 8, 17)) +>DeepPartial : Symbol(DeepPartial, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 7, 16)) +>T : Symbol(T, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 8, 17)) +>P : Symbol(P, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 8, 25)) + +type Nested = Nested[]; +>Nested : Symbol(Nested, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 8, 60)) +>Nested : Symbol(Nested, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 8, 60)) + +interface Prop { owner: Meta } +>Prop : Symbol(Prop, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 9, 23)) +>T : Symbol(T, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 10, 15)) +>owner : Symbol(Prop.owner, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 10, 19)) +>Meta : Symbol(Meta, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 10, 36)) +>T : Symbol(T, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 10, 15)) + +interface Meta { +>Meta : Symbol(Meta, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 10, 36)) +>T : Symbol(T, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 11, 15)) + + prop: Prop; +>prop : Symbol(Meta.prop, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 11, 19)) +>Prop : Symbol(Prop, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 9, 23)) +>T : Symbol(T, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 11, 15)) + + other: any; +>other : Symbol(Meta.other, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 12, 18)) + + query: Query; +>query : Symbol(Meta.query, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 13, 15)) +>Query : Symbol(Query, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 15, 1)) +} +type Query = { cond: Nested }; +>Query : Symbol(Query, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 15, 1)) +>X : Symbol(X, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 16, 11)) +>cond : Symbol(cond, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 16, 17)) +>Nested : Symbol(Nested, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 8, 60)) + +declare function fromMetadata(meta: Meta | DeepPartial>): void; +>fromMetadata : Symbol(fromMetadata, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 16, 33)) +>T : Symbol(T, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 17, 30)) +>meta : Symbol(meta, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 17, 33)) +>Meta : Symbol(Meta, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 10, 36)) +>T : Symbol(T, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 17, 30)) +>DeepPartial : Symbol(DeepPartial, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 7, 16)) +>Meta : Symbol(Meta, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 10, 36)) +>T : Symbol(T, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 17, 30)) + diff --git a/tsc/testdata/baselines/reference/compiler/instantiationCouldContainTypeVariablesAfterCycle(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/instantiationCouldContainTypeVariablesAfterCycle(checkorder=default).types new file mode 100644 index 0000000000000..1541a7890f5e6 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/instantiationCouldContainTypeVariablesAfterCycle(checkorder=default).types @@ -0,0 +1,44 @@ +//// [tests/cases/compiler/instantiationCouldContainTypeVariablesAfterCycle.ts] //// + +=== instantiationCouldContainTypeVariablesAfterCycle.ts === +// Query is instantiated with only non-generic arguments, so it (and DeepPartial>) +// can't contain type variables, and inference from Meta must not structurally recurse into +// DeepPartial>. That recursion would expand the infinite DeepPartial and report +// TS5114. The carry-forward of the "could contain type variables" flag set at instantiation time +// must survive even when the instantiation is created inside a circularity that is later discarded. + +declare const a: Meta; +>a : Meta + +fromMetadata(a); +>fromMetadata(a) : void +>fromMetadata : (meta: Meta | DeepPartial>) => void +>a : Meta + +type DeepPartial = { [P in keyof T]: DeepPartial }; +>DeepPartial : DeepPartial + +type Nested = Nested[]; +>Nested : Nested + +interface Prop { owner: Meta } +>owner : Meta + +interface Meta { + prop: Prop; +>prop : Prop + + other: any; +>other : any + + query: Query; +>query : Query +} +type Query = { cond: Nested }; +>Query : Query +>cond : Nested + +declare function fromMetadata(meta: Meta | DeepPartial>): void; +>fromMetadata : (meta: Meta | DeepPartial>) => void +>meta : DeepPartial> | Meta + diff --git a/tsc/testdata/baselines/reference/compiler/instantiationCouldContainTypeVariablesAfterCycle(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/instantiationCouldContainTypeVariablesAfterCycle(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..0031705ad6203 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/instantiationCouldContainTypeVariablesAfterCycle(checkorder=typesfirst).symbols @@ -0,0 +1,69 @@ +//// [tests/cases/compiler/instantiationCouldContainTypeVariablesAfterCycle.ts] //// + +=== instantiationCouldContainTypeVariablesAfterCycle.ts === +// Query is instantiated with only non-generic arguments, so it (and DeepPartial>) +// can't contain type variables, and inference from Meta must not structurally recurse into +// DeepPartial>. That recursion would expand the infinite DeepPartial and report +// TS5114. The carry-forward of the "could contain type variables" flag set at instantiation time +// must survive even when the instantiation is created inside a circularity that is later discarded. + +declare const a: Meta; +>a : Symbol(a, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 6, 13)) +>Meta : Symbol(Meta, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 10, 36)) + +fromMetadata(a); +>fromMetadata : Symbol(fromMetadata, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 16, 33)) +>a : Symbol(a, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 6, 13)) + +type DeepPartial = { [P in keyof T]: DeepPartial }; +>DeepPartial : Symbol(DeepPartial, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 7, 16)) +>T : Symbol(T, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 8, 17)) +>P : Symbol(P, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 8, 25)) +>T : Symbol(T, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 8, 17)) +>DeepPartial : Symbol(DeepPartial, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 7, 16)) +>T : Symbol(T, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 8, 17)) +>P : Symbol(P, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 8, 25)) + +type Nested = Nested[]; +>Nested : Symbol(Nested, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 8, 60)) +>Nested : Symbol(Nested, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 8, 60)) + +interface Prop { owner: Meta } +>Prop : Symbol(Prop, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 9, 23)) +>T : Symbol(T, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 10, 15)) +>owner : Symbol(Prop.owner, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 10, 19)) +>Meta : Symbol(Meta, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 10, 36)) +>T : Symbol(T, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 10, 15)) + +interface Meta { +>Meta : Symbol(Meta, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 10, 36)) +>T : Symbol(T, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 11, 15)) + + prop: Prop; +>prop : Symbol(Meta.prop, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 11, 19)) +>Prop : Symbol(Prop, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 9, 23)) +>T : Symbol(T, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 11, 15)) + + other: any; +>other : Symbol(Meta.other, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 12, 18)) + + query: Query; +>query : Symbol(Meta.query, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 13, 15)) +>Query : Symbol(Query, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 15, 1)) +} +type Query = { cond: Nested }; +>Query : Symbol(Query, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 15, 1)) +>X : Symbol(X, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 16, 11)) +>cond : Symbol(cond, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 16, 17)) +>Nested : Symbol(Nested, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 8, 60)) + +declare function fromMetadata(meta: Meta | DeepPartial>): void; +>fromMetadata : Symbol(fromMetadata, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 16, 33)) +>T : Symbol(T, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 17, 30)) +>meta : Symbol(meta, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 17, 33)) +>Meta : Symbol(Meta, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 10, 36)) +>T : Symbol(T, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 17, 30)) +>DeepPartial : Symbol(DeepPartial, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 7, 16)) +>Meta : Symbol(Meta, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 10, 36)) +>T : Symbol(T, Decl(instantiationCouldContainTypeVariablesAfterCycle.ts, 17, 30)) + diff --git a/tsc/testdata/baselines/reference/compiler/instantiationCouldContainTypeVariablesAfterCycle(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/instantiationCouldContainTypeVariablesAfterCycle(checkorder=typesfirst).types new file mode 100644 index 0000000000000..1541a7890f5e6 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/instantiationCouldContainTypeVariablesAfterCycle(checkorder=typesfirst).types @@ -0,0 +1,44 @@ +//// [tests/cases/compiler/instantiationCouldContainTypeVariablesAfterCycle.ts] //// + +=== instantiationCouldContainTypeVariablesAfterCycle.ts === +// Query is instantiated with only non-generic arguments, so it (and DeepPartial>) +// can't contain type variables, and inference from Meta must not structurally recurse into +// DeepPartial>. That recursion would expand the infinite DeepPartial and report +// TS5114. The carry-forward of the "could contain type variables" flag set at instantiation time +// must survive even when the instantiation is created inside a circularity that is later discarded. + +declare const a: Meta; +>a : Meta + +fromMetadata(a); +>fromMetadata(a) : void +>fromMetadata : (meta: Meta | DeepPartial>) => void +>a : Meta + +type DeepPartial = { [P in keyof T]: DeepPartial }; +>DeepPartial : DeepPartial + +type Nested = Nested[]; +>Nested : Nested + +interface Prop { owner: Meta } +>owner : Meta + +interface Meta { + prop: Prop; +>prop : Prop + + other: any; +>other : any + + query: Query; +>query : Query +} +type Query = { cond: Nested }; +>Query : Query +>cond : Nested + +declare function fromMetadata(meta: Meta | DeepPartial>): void; +>fromMetadata : (meta: Meta | DeepPartial>) => void +>meta : DeepPartial> | Meta + diff --git a/tsc/testdata/baselines/reference/compiler/instantiationCountSharedCheckOrder(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/instantiationCountSharedCheckOrder(checkorder=default).symbols new file mode 100644 index 0000000000000..e139f88dccad8 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/instantiationCountSharedCheckOrder(checkorder=default).symbols @@ -0,0 +1,41 @@ +//// [tests/cases/compiler/instantiationCountSharedCheckOrder.ts] //// + +=== instantiationCountSharedCheckOrder.ts === +// Instantiating Wide<[], "a"> fresh takes over five million instantiations, +// which is too many. In program order Rest has already done all but about +// two million of them. Whether All takes too many must not depend on which +// comes first. + +type D = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9; +>D : Symbol(D, Decl(instantiationCountSharedCheckOrder.ts, 0, 0)) + +type K = `${D}${D}${D}`; +>K : Symbol(K, Decl(instantiationCountSharedCheckOrder.ts, 5, 47)) +>D : Symbol(D, Decl(instantiationCountSharedCheckOrder.ts, 0, 0)) +>D : Symbol(D, Decl(instantiationCountSharedCheckOrder.ts, 0, 0)) +>D : Symbol(D, Decl(instantiationCountSharedCheckOrder.ts, 0, 0)) + +type Wide = N["length"] extends 6 ? [I, J] : { [J2 in K]: Wide<[...N, 0], I, J2> }[K]; +>Wide : Symbol(Wide, Decl(instantiationCountSharedCheckOrder.ts, 6, 24)) +>N : Symbol(N, Decl(instantiationCountSharedCheckOrder.ts, 7, 10)) +>I : Symbol(I, Decl(instantiationCountSharedCheckOrder.ts, 7, 24)) +>J : Symbol(J, Decl(instantiationCountSharedCheckOrder.ts, 7, 27)) +>N : Symbol(N, Decl(instantiationCountSharedCheckOrder.ts, 7, 10)) +>I : Symbol(I, Decl(instantiationCountSharedCheckOrder.ts, 7, 24)) +>J : Symbol(J, Decl(instantiationCountSharedCheckOrder.ts, 7, 27)) +>J2 : Symbol(J2, Decl(instantiationCountSharedCheckOrder.ts, 7, 77)) +>K : Symbol(K, Decl(instantiationCountSharedCheckOrder.ts, 5, 47)) +>Wide : Symbol(Wide, Decl(instantiationCountSharedCheckOrder.ts, 6, 24)) +>N : Symbol(N, Decl(instantiationCountSharedCheckOrder.ts, 7, 10)) +>I : Symbol(I, Decl(instantiationCountSharedCheckOrder.ts, 7, 24)) +>J2 : Symbol(J2, Decl(instantiationCountSharedCheckOrder.ts, 7, 77)) +>K : Symbol(K, Decl(instantiationCountSharedCheckOrder.ts, 5, 47)) + +type Rest = Wide<[0, 0], "a">; +>Rest : Symbol(Rest, Decl(instantiationCountSharedCheckOrder.ts, 7, 115)) +>Wide : Symbol(Wide, Decl(instantiationCountSharedCheckOrder.ts, 6, 24)) + +type All = Wide<[], "a">; +>All : Symbol(All, Decl(instantiationCountSharedCheckOrder.ts, 8, 30)) +>Wide : Symbol(Wide, Decl(instantiationCountSharedCheckOrder.ts, 6, 24)) + diff --git a/tsc/testdata/baselines/reference/compiler/instantiationCountSharedCheckOrder(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/instantiationCountSharedCheckOrder(checkorder=default).types new file mode 100644 index 0000000000000..7df2d098a6ea2 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/instantiationCountSharedCheckOrder(checkorder=default).types @@ -0,0 +1,23 @@ +//// [tests/cases/compiler/instantiationCountSharedCheckOrder.ts] //// + +=== instantiationCountSharedCheckOrder.ts === +// Instantiating Wide<[], "a"> fresh takes over five million instantiations, +// which is too many. In program order Rest has already done all but about +// two million of them. Whether All takes too many must not depend on which +// comes first. + +type D = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9; +>D : D + +type K = `${D}${D}${D}`; +>K : "000" | "001" | "002" | "003" | "004" | "005" | "006" | "007" | "008" | "009" | "010" | "011" | "012" | "013" | "014" | "015" | "016" | "017" | "018" | "019" | "020" | "021" | "022" | "023" | "024" | "025" | "026" | "027" | "028" | "029" | "030" | "031" | "032" | "033" | "034" | "035" | "036" | "037" | "038" | "039" | "040" | "041" | "042" | "043" | "044" | "045" | "046" | "047" | "048" | "049" | "050" | "051" | "052" | "053" | "054" | "055" | "056" | "057" | "058" | "059" | "060" | "061" | "062" | "063" | "064" | "065" | "066" | "067" | "068" | "069" | "070" | "071" | "072" | "073" | "074" | "075" | "076" | "077" | "078" | "079" | "080" | "081" | "082" | "083" | "084" | "085" | "086" | "087" | "088" | "089" | "090" | "091" | "092" | "093" | "094" | "095" | "096" | "097" | "098" | "099" | "100" | "101" | "102" | "103" | "104" | "105" | "106" | "107" | "108" | "109" | "110" | "111" | "112" | "113" | "114" | "115" | "116" | "117" | "118" | "119" | "120" | "121" | "122" | "123" | "124" | "125" | "126" | "127" | "128" | "129" | "130" | "131" | "132" | "133" | "134" | "135" | "136" | "137" | "138" | "139" | "140" | "141" | "142" | "143" | "144" | "145" | "146" | "147" | "148" | "149" | "150" | "151" | "152" | "153" | "154" | "155" | "156" | "157" | "158" | "159" | "160" | "161" | "162" | "163" | "164" | "165" | "166" | "167" | "168" | "169" | "170" | "171" | "172" | "173" | "174" | "175" | "176" | "177" | "178" | "179" | "180" | "181" | "182" | "183" | "184" | "185" | "186" | "187" | "188" | "189" | "190" | "191" | "192" | "193" | "194" | "195" | "196" | "197" | "198" | "199" | "200" | "201" | "202" | "203" | "204" | "205" | "206" | "207" | "208" | "209" | "210" | "211" | "212" | "213" | "214" | "215" | "216" | "217" | "218" | "219" | "220" | "221" | "222" | "223" | "224" | "225" | "226" | "227" | "228" | "229" | "230" | "231" | "232" | "233" | "234" | "235" | "236" | "237" | "238" | "239" | "240" | "241" | "242" | "243" | "244" | "245" | "246" | "247" | "248" | "249" | "250" | "251" | "252" | "253" | "254" | "255" | "256" | "257" | "258" | "259" | "260" | "261" | "262" | "263" | "264" | "265" | "266" | "267" | "268" | "269" | "270" | "271" | "272" | "273" | "274" | "275" | "276" | "277" | "278" | "279" | "280" | "281" | "282" | "283" | "284" | "285" | "286" | "287" | "288" | "289" | "290" | "291" | "292" | "293" | "294" | "295" | "296" | "297" | "298" | "299" | "300" | "301" | "302" | "303" | "304" | "305" | "306" | "307" | "308" | "309" | "310" | "311" | "312" | "313" | "314" | "315" | "316" | "317" | "318" | "319" | "320" | "321" | "322" | "323" | "324" | "325" | "326" | "327" | "328" | "329" | "330" | "331" | "332" | "333" | "334" | "335" | "336" | "337" | "338" | "339" | "340" | "341" | "342" | "343" | "344" | "345" | "346" | "347" | "348" | "349" | "350" | "351" | "352" | "353" | "354" | "355" | "356" | "357" | "358" | "359" | "360" | "361" | "362" | "363" | "364" | "365" | "366" | "367" | "368" | "369" | "370" | "371" | "372" | "373" | "374" | "375" | "376" | "377" | "378" | "379" | "380" | "381" | "382" | "383" | "384" | "385" | "386" | "387" | "388" | "389" | "390" | "391" | "392" | "393" | "394" | "395" | "396" | "397" | "398" | "399" | "400" | "401" | "402" | "403" | "404" | "405" | "406" | "407" | "408" | "409" | "410" | "411" | "412" | "413" | "414" | "415" | "416" | "417" | "418" | "419" | "420" | "421" | "422" | "423" | "424" | "425" | "426" | "427" | "428" | "429" | "430" | "431" | "432" | "433" | "434" | "435" | "436" | "437" | "438" | "439" | "440" | "441" | "442" | "443" | "444" | "445" | "446" | "447" | "448" | "449" | "450" | "451" | "452" | "453" | "454" | "455" | "456" | "457" | "458" | "459" | "460" | "461" | "462" | "463" | "464" | "465" | "466" | "467" | "468" | "469" | "470" | "471" | "472" | "473" | "474" | "475" | "476" | "477" | "478" | "479" | "480" | "481" | "482" | "483" | "484" | "485" | "486" | "487" | "488" | "489" | "490" | "491" | "492" | "493" | "494" | "495" | "496" | "497" | "498" | "499" | "500" | "501" | "502" | "503" | "504" | "505" | "506" | "507" | "508" | "509" | "510" | "511" | "512" | "513" | "514" | "515" | "516" | "517" | "518" | "519" | "520" | "521" | "522" | "523" | "524" | "525" | "526" | "527" | "528" | "529" | "530" | "531" | "532" | "533" | "534" | "535" | "536" | "537" | "538" | "539" | "540" | "541" | "542" | "543" | "544" | "545" | "546" | "547" | "548" | "549" | "550" | "551" | "552" | "553" | "554" | "555" | "556" | "557" | "558" | "559" | "560" | "561" | "562" | "563" | "564" | "565" | "566" | "567" | "568" | "569" | "570" | "571" | "572" | "573" | "574" | "575" | "576" | "577" | "578" | "579" | "580" | "581" | "582" | "583" | "584" | "585" | "586" | "587" | "588" | "589" | "590" | "591" | "592" | "593" | "594" | "595" | "596" | "597" | "598" | "599" | "600" | "601" | "602" | "603" | "604" | "605" | "606" | "607" | "608" | "609" | "610" | "611" | "612" | "613" | "614" | "615" | "616" | "617" | "618" | "619" | "620" | "621" | "622" | "623" | "624" | "625" | "626" | "627" | "628" | "629" | "630" | "631" | "632" | "633" | "634" | "635" | "636" | "637" | "638" | "639" | "640" | "641" | "642" | "643" | "644" | "645" | "646" | "647" | "648" | "649" | "650" | "651" | "652" | "653" | "654" | "655" | "656" | "657" | "658" | "659" | "660" | "661" | "662" | "663" | "664" | "665" | "666" | "667" | "668" | "669" | "670" | "671" | "672" | "673" | "674" | "675" | "676" | "677" | "678" | "679" | "680" | "681" | "682" | "683" | "684" | "685" | "686" | "687" | "688" | "689" | "690" | "691" | "692" | "693" | "694" | "695" | "696" | "697" | "698" | "699" | "700" | "701" | "702" | "703" | "704" | "705" | "706" | "707" | "708" | "709" | "710" | "711" | "712" | "713" | "714" | "715" | "716" | "717" | "718" | "719" | "720" | "721" | "722" | "723" | "724" | "725" | "726" | "727" | "728" | "729" | "730" | "731" | "732" | "733" | "734" | "735" | "736" | "737" | "738" | "739" | "740" | "741" | "742" | "743" | "744" | "745" | "746" | "747" | "748" | "749" | "750" | "751" | "752" | "753" | "754" | "755" | "756" | "757" | "758" | "759" | "760" | "761" | "762" | "763" | "764" | "765" | "766" | "767" | "768" | "769" | "770" | "771" | "772" | "773" | "774" | "775" | "776" | "777" | "778" | "779" | "780" | "781" | "782" | "783" | "784" | "785" | "786" | "787" | "788" | "789" | "790" | "791" | "792" | "793" | "794" | "795" | "796" | "797" | "798" | "799" | "800" | "801" | "802" | "803" | "804" | "805" | "806" | "807" | "808" | "809" | "810" | "811" | "812" | "813" | "814" | "815" | "816" | "817" | "818" | "819" | "820" | "821" | "822" | "823" | "824" | "825" | "826" | "827" | "828" | "829" | "830" | "831" | "832" | "833" | "834" | "835" | "836" | "837" | "838" | "839" | "840" | "841" | "842" | "843" | "844" | "845" | "846" | "847" | "848" | "849" | "850" | "851" | "852" | "853" | "854" | "855" | "856" | "857" | "858" | "859" | "860" | "861" | "862" | "863" | "864" | "865" | "866" | "867" | "868" | "869" | "870" | "871" | "872" | "873" | "874" | "875" | "876" | "877" | "878" | "879" | "880" | "881" | "882" | "883" | "884" | "885" | "886" | "887" | "888" | "889" | "890" | "891" | "892" | "893" | "894" | "895" | "896" | "897" | "898" | "899" | "900" | "901" | "902" | "903" | "904" | "905" | "906" | "907" | "908" | "909" | "910" | "911" | "912" | "913" | "914" | "915" | "916" | "917" | "918" | "919" | "920" | "921" | "922" | "923" | "924" | "925" | "926" | "927" | "928" | "929" | "930" | "931" | "932" | "933" | "934" | "935" | "936" | "937" | "938" | "939" | "940" | "941" | "942" | "943" | "944" | "945" | "946" | "947" | "948" | "949" | "950" | "951" | "952" | "953" | "954" | "955" | "956" | "957" | "958" | "959" | "960" | "961" | "962" | "963" | "964" | "965" | "966" | "967" | "968" | "969" | "970" | "971" | "972" | "973" | "974" | "975" | "976" | "977" | "978" | "979" | "980" | "981" | "982" | "983" | "984" | "985" | "986" | "987" | "988" | "989" | "990" | "991" | "992" | "993" | "994" | "995" | "996" | "997" | "998" | "999" + +type Wide = N["length"] extends 6 ? [I, J] : { [J2 in K]: Wide<[...N, 0], I, J2> }[K]; +>Wide : Wide + +type Rest = Wide<[0, 0], "a">; +>Rest : ["a", "000"] | ["a", "001"] | ["a", "002"] | ["a", "003"] | ["a", "004"] | ["a", "005"] | ["a", "006"] | ["a", "007"] | ["a", "008"] | ["a", "009"] | ["a", "010"] | ["a", "011"] | ["a", "012"] | ["a", "013"] | ["a", "014"] | ["a", "015"] | ["a", "016"] | ["a", "017"] | ["a", "018"] | ["a", "019"] | ["a", "020"] | ["a", "021"] | ["a", "022"] | ["a", "023"] | ["a", "024"] | ["a", "025"] | ["a", "026"] | ["a", "027"] | ["a", "028"] | ["a", "029"] | ["a", "030"] | ["a", "031"] | ["a", "032"] | ["a", "033"] | ["a", "034"] | ["a", "035"] | ["a", "036"] | ["a", "037"] | ["a", "038"] | ["a", "039"] | ["a", "040"] | ["a", "041"] | ["a", "042"] | ["a", "043"] | ["a", "044"] | ["a", "045"] | ["a", "046"] | ["a", "047"] | ["a", "048"] | ["a", "049"] | ["a", "050"] | ["a", "051"] | ["a", "052"] | ["a", "053"] | ["a", "054"] | ["a", "055"] | ["a", "056"] | ["a", "057"] | ["a", "058"] | ["a", "059"] | ["a", "060"] | ["a", "061"] | ["a", "062"] | ["a", "063"] | ["a", "064"] | ["a", "065"] | ["a", "066"] | ["a", "067"] | ["a", "068"] | ["a", "069"] | ["a", "070"] | ["a", "071"] | ["a", "072"] | ["a", "073"] | ["a", "074"] | ["a", "075"] | ["a", "076"] | ["a", "077"] | ["a", "078"] | ["a", "079"] | ["a", "080"] | ["a", "081"] | ["a", "082"] | ["a", "083"] | ["a", "084"] | ["a", "085"] | ["a", "086"] | ["a", "087"] | ["a", "088"] | ["a", "089"] | ["a", "090"] | ["a", "091"] | ["a", "092"] | ["a", "093"] | ["a", "094"] | ["a", "095"] | ["a", "096"] | ["a", "097"] | ["a", "098"] | ["a", "099"] | ["a", "100"] | ["a", "101"] | ["a", "102"] | ["a", "103"] | ["a", "104"] | ["a", "105"] | ["a", "106"] | ["a", "107"] | ["a", "108"] | ["a", "109"] | ["a", "110"] | ["a", "111"] | ["a", "112"] | ["a", "113"] | ["a", "114"] | ["a", "115"] | ["a", "116"] | ["a", "117"] | ["a", "118"] | ["a", "119"] | ["a", "120"] | ["a", "121"] | ["a", "122"] | ["a", "123"] | ["a", "124"] | ["a", "125"] | ["a", "126"] | ["a", "127"] | ["a", "128"] | ["a", "129"] | ["a", "130"] | ["a", "131"] | ["a", "132"] | ["a", "133"] | ["a", "134"] | ["a", "135"] | ["a", "136"] | ["a", "137"] | ["a", "138"] | ["a", "139"] | ["a", "140"] | ["a", "141"] | ["a", "142"] | ["a", "143"] | ["a", "144"] | ["a", "145"] | ["a", "146"] | ["a", "147"] | ["a", "148"] | ["a", "149"] | ["a", "150"] | ["a", "151"] | ["a", "152"] | ["a", "153"] | ["a", "154"] | ["a", "155"] | ["a", "156"] | ["a", "157"] | ["a", "158"] | ["a", "159"] | ["a", "160"] | ["a", "161"] | ["a", "162"] | ["a", "163"] | ["a", "164"] | ["a", "165"] | ["a", "166"] | ["a", "167"] | ["a", "168"] | ["a", "169"] | ["a", "170"] | ["a", "171"] | ["a", "172"] | ["a", "173"] | ["a", "174"] | ["a", "175"] | ["a", "176"] | ["a", "177"] | ["a", "178"] | ["a", "179"] | ["a", "180"] | ["a", "181"] | ["a", "182"] | ["a", "183"] | ["a", "184"] | ["a", "185"] | ["a", "186"] | ["a", "187"] | ["a", "188"] | ["a", "189"] | ["a", "190"] | ["a", "191"] | ["a", "192"] | ["a", "193"] | ["a", "194"] | ["a", "195"] | ["a", "196"] | ["a", "197"] | ["a", "198"] | ["a", "199"] | ["a", "200"] | ["a", "201"] | ["a", "202"] | ["a", "203"] | ["a", "204"] | ["a", "205"] | ["a", "206"] | ["a", "207"] | ["a", "208"] | ["a", "209"] | ["a", "210"] | ["a", "211"] | ["a", "212"] | ["a", "213"] | ["a", "214"] | ["a", "215"] | ["a", "216"] | ["a", "217"] | ["a", "218"] | ["a", "219"] | ["a", "220"] | ["a", "221"] | ["a", "222"] | ["a", "223"] | ["a", "224"] | ["a", "225"] | ["a", "226"] | ["a", "227"] | ["a", "228"] | ["a", "229"] | ["a", "230"] | ["a", "231"] | ["a", "232"] | ["a", "233"] | ["a", "234"] | ["a", "235"] | ["a", "236"] | ["a", "237"] | ["a", "238"] | ["a", "239"] | ["a", "240"] | ["a", "241"] | ["a", "242"] | ["a", "243"] | ["a", "244"] | ["a", "245"] | ["a", "246"] | ["a", "247"] | ["a", "248"] | ["a", "249"] | ["a", "250"] | ["a", "251"] | ["a", "252"] | ["a", "253"] | ["a", "254"] | ["a", "255"] | ["a", "256"] | ["a", "257"] | ["a", "258"] | ["a", "259"] | ["a", "260"] | ["a", "261"] | ["a", "262"] | ["a", "263"] | ["a", "264"] | ["a", "265"] | ["a", "266"] | ["a", "267"] | ["a", "268"] | ["a", "269"] | ["a", "270"] | ["a", "271"] | ["a", "272"] | ["a", "273"] | ["a", "274"] | ["a", "275"] | ["a", "276"] | ["a", "277"] | ["a", "278"] | ["a", "279"] | ["a", "280"] | ["a", "281"] | ["a", "282"] | ["a", "283"] | ["a", "284"] | ["a", "285"] | ["a", "286"] | ["a", "287"] | ["a", "288"] | ["a", "289"] | ["a", "290"] | ["a", "291"] | ["a", "292"] | ["a", "293"] | ["a", "294"] | ["a", "295"] | ["a", "296"] | ["a", "297"] | ["a", "298"] | ["a", "299"] | ["a", "300"] | ["a", "301"] | ["a", "302"] | ["a", "303"] | ["a", "304"] | ["a", "305"] | ["a", "306"] | ["a", "307"] | ["a", "308"] | ["a", "309"] | ["a", "310"] | ["a", "311"] | ["a", "312"] | ["a", "313"] | ["a", "314"] | ["a", "315"] | ["a", "316"] | ["a", "317"] | ["a", "318"] | ["a", "319"] | ["a", "320"] | ["a", "321"] | ["a", "322"] | ["a", "323"] | ["a", "324"] | ["a", "325"] | ["a", "326"] | ["a", "327"] | ["a", "328"] | ["a", "329"] | ["a", "330"] | ["a", "331"] | ["a", "332"] | ["a", "333"] | ["a", "334"] | ["a", "335"] | ["a", "336"] | ["a", "337"] | ["a", "338"] | ["a", "339"] | ["a", "340"] | ["a", "341"] | ["a", "342"] | ["a", "343"] | ["a", "344"] | ["a", "345"] | ["a", "346"] | ["a", "347"] | ["a", "348"] | ["a", "349"] | ["a", "350"] | ["a", "351"] | ["a", "352"] | ["a", "353"] | ["a", "354"] | ["a", "355"] | ["a", "356"] | ["a", "357"] | ["a", "358"] | ["a", "359"] | ["a", "360"] | ["a", "361"] | ["a", "362"] | ["a", "363"] | ["a", "364"] | ["a", "365"] | ["a", "366"] | ["a", "367"] | ["a", "368"] | ["a", "369"] | ["a", "370"] | ["a", "371"] | ["a", "372"] | ["a", "373"] | ["a", "374"] | ["a", "375"] | ["a", "376"] | ["a", "377"] | ["a", "378"] | ["a", "379"] | ["a", "380"] | ["a", "381"] | ["a", "382"] | ["a", "383"] | ["a", "384"] | ["a", "385"] | ["a", "386"] | ["a", "387"] | ["a", "388"] | ["a", "389"] | ["a", "390"] | ["a", "391"] | ["a", "392"] | ["a", "393"] | ["a", "394"] | ["a", "395"] | ["a", "396"] | ["a", "397"] | ["a", "398"] | ["a", "399"] | ["a", "400"] | ["a", "401"] | ["a", "402"] | ["a", "403"] | ["a", "404"] | ["a", "405"] | ["a", "406"] | ["a", "407"] | ["a", "408"] | ["a", "409"] | ["a", "410"] | ["a", "411"] | ["a", "412"] | ["a", "413"] | ["a", "414"] | ["a", "415"] | ["a", "416"] | ["a", "417"] | ["a", "418"] | ["a", "419"] | ["a", "420"] | ["a", "421"] | ["a", "422"] | ["a", "423"] | ["a", "424"] | ["a", "425"] | ["a", "426"] | ["a", "427"] | ["a", "428"] | ["a", "429"] | ["a", "430"] | ["a", "431"] | ["a", "432"] | ["a", "433"] | ["a", "434"] | ["a", "435"] | ["a", "436"] | ["a", "437"] | ["a", "438"] | ["a", "439"] | ["a", "440"] | ["a", "441"] | ["a", "442"] | ["a", "443"] | ["a", "444"] | ["a", "445"] | ["a", "446"] | ["a", "447"] | ["a", "448"] | ["a", "449"] | ["a", "450"] | ["a", "451"] | ["a", "452"] | ["a", "453"] | ["a", "454"] | ["a", "455"] | ["a", "456"] | ["a", "457"] | ["a", "458"] | ["a", "459"] | ["a", "460"] | ["a", "461"] | ["a", "462"] | ["a", "463"] | ["a", "464"] | ["a", "465"] | ["a", "466"] | ["a", "467"] | ["a", "468"] | ["a", "469"] | ["a", "470"] | ["a", "471"] | ["a", "472"] | ["a", "473"] | ["a", "474"] | ["a", "475"] | ["a", "476"] | ["a", "477"] | ["a", "478"] | ["a", "479"] | ["a", "480"] | ["a", "481"] | ["a", "482"] | ["a", "483"] | ["a", "484"] | ["a", "485"] | ["a", "486"] | ["a", "487"] | ["a", "488"] | ["a", "489"] | ["a", "490"] | ["a", "491"] | ["a", "492"] | ["a", "493"] | ["a", "494"] | ["a", "495"] | ["a", "496"] | ["a", "497"] | ["a", "498"] | ["a", "499"] | ["a", "500"] | ["a", "501"] | ["a", "502"] | ["a", "503"] | ["a", "504"] | ["a", "505"] | ["a", "506"] | ["a", "507"] | ["a", "508"] | ["a", "509"] | ["a", "510"] | ["a", "511"] | ["a", "512"] | ["a", "513"] | ["a", "514"] | ["a", "515"] | ["a", "516"] | ["a", "517"] | ["a", "518"] | ["a", "519"] | ["a", "520"] | ["a", "521"] | ["a", "522"] | ["a", "523"] | ["a", "524"] | ["a", "525"] | ["a", "526"] | ["a", "527"] | ["a", "528"] | ["a", "529"] | ["a", "530"] | ["a", "531"] | ["a", "532"] | ["a", "533"] | ["a", "534"] | ["a", "535"] | ["a", "536"] | ["a", "537"] | ["a", "538"] | ["a", "539"] | ["a", "540"] | ["a", "541"] | ["a", "542"] | ["a", "543"] | ["a", "544"] | ["a", "545"] | ["a", "546"] | ["a", "547"] | ["a", "548"] | ["a", "549"] | ["a", "550"] | ["a", "551"] | ["a", "552"] | ["a", "553"] | ["a", "554"] | ["a", "555"] | ["a", "556"] | ["a", "557"] | ["a", "558"] | ["a", "559"] | ["a", "560"] | ["a", "561"] | ["a", "562"] | ["a", "563"] | ["a", "564"] | ["a", "565"] | ["a", "566"] | ["a", "567"] | ["a", "568"] | ["a", "569"] | ["a", "570"] | ["a", "571"] | ["a", "572"] | ["a", "573"] | ["a", "574"] | ["a", "575"] | ["a", "576"] | ["a", "577"] | ["a", "578"] | ["a", "579"] | ["a", "580"] | ["a", "581"] | ["a", "582"] | ["a", "583"] | ["a", "584"] | ["a", "585"] | ["a", "586"] | ["a", "587"] | ["a", "588"] | ["a", "589"] | ["a", "590"] | ["a", "591"] | ["a", "592"] | ["a", "593"] | ["a", "594"] | ["a", "595"] | ["a", "596"] | ["a", "597"] | ["a", "598"] | ["a", "599"] | ["a", "600"] | ["a", "601"] | ["a", "602"] | ["a", "603"] | ["a", "604"] | ["a", "605"] | ["a", "606"] | ["a", "607"] | ["a", "608"] | ["a", "609"] | ["a", "610"] | ["a", "611"] | ["a", "612"] | ["a", "613"] | ["a", "614"] | ["a", "615"] | ["a", "616"] | ["a", "617"] | ["a", "618"] | ["a", "619"] | ["a", "620"] | ["a", "621"] | ["a", "622"] | ["a", "623"] | ["a", "624"] | ["a", "625"] | ["a", "626"] | ["a", "627"] | ["a", "628"] | ["a", "629"] | ["a", "630"] | ["a", "631"] | ["a", "632"] | ["a", "633"] | ["a", "634"] | ["a", "635"] | ["a", "636"] | ["a", "637"] | ["a", "638"] | ["a", "639"] | ["a", "640"] | ["a", "641"] | ["a", "642"] | ["a", "643"] | ["a", "644"] | ["a", "645"] | ["a", "646"] | ["a", "647"] | ["a", "648"] | ["a", "649"] | ["a", "650"] | ["a", "651"] | ["a", "652"] | ["a", "653"] | ["a", "654"] | ["a", "655"] | ["a", "656"] | ["a", "657"] | ["a", "658"] | ["a", "659"] | ["a", "660"] | ["a", "661"] | ["a", "662"] | ["a", "663"] | ["a", "664"] | ["a", "665"] | ["a", "666"] | ["a", "667"] | ["a", "668"] | ["a", "669"] | ["a", "670"] | ["a", "671"] | ["a", "672"] | ["a", "673"] | ["a", "674"] | ["a", "675"] | ["a", "676"] | ["a", "677"] | ["a", "678"] | ["a", "679"] | ["a", "680"] | ["a", "681"] | ["a", "682"] | ["a", "683"] | ["a", "684"] | ["a", "685"] | ["a", "686"] | ["a", "687"] | ["a", "688"] | ["a", "689"] | ["a", "690"] | ["a", "691"] | ["a", "692"] | ["a", "693"] | ["a", "694"] | ["a", "695"] | ["a", "696"] | ["a", "697"] | ["a", "698"] | ["a", "699"] | ["a", "700"] | ["a", "701"] | ["a", "702"] | ["a", "703"] | ["a", "704"] | ["a", "705"] | ["a", "706"] | ["a", "707"] | ["a", "708"] | ["a", "709"] | ["a", "710"] | ["a", "711"] | ["a", "712"] | ["a", "713"] | ["a", "714"] | ["a", "715"] | ["a", "716"] | ["a", "717"] | ["a", "718"] | ["a", "719"] | ["a", "720"] | ["a", "721"] | ["a", "722"] | ["a", "723"] | ["a", "724"] | ["a", "725"] | ["a", "726"] | ["a", "727"] | ["a", "728"] | ["a", "729"] | ["a", "730"] | ["a", "731"] | ["a", "732"] | ["a", "733"] | ["a", "734"] | ["a", "735"] | ["a", "736"] | ["a", "737"] | ["a", "738"] | ["a", "739"] | ["a", "740"] | ["a", "741"] | ["a", "742"] | ["a", "743"] | ["a", "744"] | ["a", "745"] | ["a", "746"] | ["a", "747"] | ["a", "748"] | ["a", "749"] | ["a", "750"] | ["a", "751"] | ["a", "752"] | ["a", "753"] | ["a", "754"] | ["a", "755"] | ["a", "756"] | ["a", "757"] | ["a", "758"] | ["a", "759"] | ["a", "760"] | ["a", "761"] | ["a", "762"] | ["a", "763"] | ["a", "764"] | ["a", "765"] | ["a", "766"] | ["a", "767"] | ["a", "768"] | ["a", "769"] | ["a", "770"] | ["a", "771"] | ["a", "772"] | ["a", "773"] | ["a", "774"] | ["a", "775"] | ["a", "776"] | ["a", "777"] | ["a", "778"] | ["a", "779"] | ["a", "780"] | ["a", "781"] | ["a", "782"] | ["a", "783"] | ["a", "784"] | ["a", "785"] | ["a", "786"] | ["a", "787"] | ["a", "788"] | ["a", "789"] | ["a", "790"] | ["a", "791"] | ["a", "792"] | ["a", "793"] | ["a", "794"] | ["a", "795"] | ["a", "796"] | ["a", "797"] | ["a", "798"] | ["a", "799"] | ["a", "800"] | ["a", "801"] | ["a", "802"] | ["a", "803"] | ["a", "804"] | ["a", "805"] | ["a", "806"] | ["a", "807"] | ["a", "808"] | ["a", "809"] | ["a", "810"] | ["a", "811"] | ["a", "812"] | ["a", "813"] | ["a", "814"] | ["a", "815"] | ["a", "816"] | ["a", "817"] | ["a", "818"] | ["a", "819"] | ["a", "820"] | ["a", "821"] | ["a", "822"] | ["a", "823"] | ["a", "824"] | ["a", "825"] | ["a", "826"] | ["a", "827"] | ["a", "828"] | ["a", "829"] | ["a", "830"] | ["a", "831"] | ["a", "832"] | ["a", "833"] | ["a", "834"] | ["a", "835"] | ["a", "836"] | ["a", "837"] | ["a", "838"] | ["a", "839"] | ["a", "840"] | ["a", "841"] | ["a", "842"] | ["a", "843"] | ["a", "844"] | ["a", "845"] | ["a", "846"] | ["a", "847"] | ["a", "848"] | ["a", "849"] | ["a", "850"] | ["a", "851"] | ["a", "852"] | ["a", "853"] | ["a", "854"] | ["a", "855"] | ["a", "856"] | ["a", "857"] | ["a", "858"] | ["a", "859"] | ["a", "860"] | ["a", "861"] | ["a", "862"] | ["a", "863"] | ["a", "864"] | ["a", "865"] | ["a", "866"] | ["a", "867"] | ["a", "868"] | ["a", "869"] | ["a", "870"] | ["a", "871"] | ["a", "872"] | ["a", "873"] | ["a", "874"] | ["a", "875"] | ["a", "876"] | ["a", "877"] | ["a", "878"] | ["a", "879"] | ["a", "880"] | ["a", "881"] | ["a", "882"] | ["a", "883"] | ["a", "884"] | ["a", "885"] | ["a", "886"] | ["a", "887"] | ["a", "888"] | ["a", "889"] | ["a", "890"] | ["a", "891"] | ["a", "892"] | ["a", "893"] | ["a", "894"] | ["a", "895"] | ["a", "896"] | ["a", "897"] | ["a", "898"] | ["a", "899"] | ["a", "900"] | ["a", "901"] | ["a", "902"] | ["a", "903"] | ["a", "904"] | ["a", "905"] | ["a", "906"] | ["a", "907"] | ["a", "908"] | ["a", "909"] | ["a", "910"] | ["a", "911"] | ["a", "912"] | ["a", "913"] | ["a", "914"] | ["a", "915"] | ["a", "916"] | ["a", "917"] | ["a", "918"] | ["a", "919"] | ["a", "920"] | ["a", "921"] | ["a", "922"] | ["a", "923"] | ["a", "924"] | ["a", "925"] | ["a", "926"] | ["a", "927"] | ["a", "928"] | ["a", "929"] | ["a", "930"] | ["a", "931"] | ["a", "932"] | ["a", "933"] | ["a", "934"] | ["a", "935"] | ["a", "936"] | ["a", "937"] | ["a", "938"] | ["a", "939"] | ["a", "940"] | ["a", "941"] | ["a", "942"] | ["a", "943"] | ["a", "944"] | ["a", "945"] | ["a", "946"] | ["a", "947"] | ["a", "948"] | ["a", "949"] | ["a", "950"] | ["a", "951"] | ["a", "952"] | ["a", "953"] | ["a", "954"] | ["a", "955"] | ["a", "956"] | ["a", "957"] | ["a", "958"] | ["a", "959"] | ["a", "960"] | ["a", "961"] | ["a", "962"] | ["a", "963"] | ["a", "964"] | ["a", "965"] | ["a", "966"] | ["a", "967"] | ["a", "968"] | ["a", "969"] | ["a", "970"] | ["a", "971"] | ["a", "972"] | ["a", "973"] | ["a", "974"] | ["a", "975"] | ["a", "976"] | ["a", "977"] | ["a", "978"] | ["a", "979"] | ["a", "980"] | ["a", "981"] | ["a", "982"] | ["a", "983"] | ["a", "984"] | ["a", "985"] | ["a", "986"] | ["a", "987"] | ["a", "988"] | ["a", "989"] | ["a", "990"] | ["a", "991"] | ["a", "992"] | ["a", "993"] | ["a", "994"] | ["a", "995"] | ["a", "996"] | ["a", "997"] | ["a", "998"] | ["a", "999"] + +type All = Wide<[], "a">; +>All : ["a", "000"] | ["a", "001"] | ["a", "002"] | ["a", "003"] | ["a", "004"] | ["a", "005"] | ["a", "006"] | ["a", "007"] | ["a", "008"] | ["a", "009"] | ["a", "010"] | ["a", "011"] | ["a", "012"] | ["a", "013"] | ["a", "014"] | ["a", "015"] | ["a", "016"] | ["a", "017"] | ["a", "018"] | ["a", "019"] | ["a", "020"] | ["a", "021"] | ["a", "022"] | ["a", "023"] | ["a", "024"] | ["a", "025"] | ["a", "026"] | ["a", "027"] | ["a", "028"] | ["a", "029"] | ["a", "030"] | ["a", "031"] | ["a", "032"] | ["a", "033"] | ["a", "034"] | ["a", "035"] | ["a", "036"] | ["a", "037"] | ["a", "038"] | ["a", "039"] | ["a", "040"] | ["a", "041"] | ["a", "042"] | ["a", "043"] | ["a", "044"] | ["a", "045"] | ["a", "046"] | ["a", "047"] | ["a", "048"] | ["a", "049"] | ["a", "050"] | ["a", "051"] | ["a", "052"] | ["a", "053"] | ["a", "054"] | ["a", "055"] | ["a", "056"] | ["a", "057"] | ["a", "058"] | ["a", "059"] | ["a", "060"] | ["a", "061"] | ["a", "062"] | ["a", "063"] | ["a", "064"] | ["a", "065"] | ["a", "066"] | ["a", "067"] | ["a", "068"] | ["a", "069"] | ["a", "070"] | ["a", "071"] | ["a", "072"] | ["a", "073"] | ["a", "074"] | ["a", "075"] | ["a", "076"] | ["a", "077"] | ["a", "078"] | ["a", "079"] | ["a", "080"] | ["a", "081"] | ["a", "082"] | ["a", "083"] | ["a", "084"] | ["a", "085"] | ["a", "086"] | ["a", "087"] | ["a", "088"] | ["a", "089"] | ["a", "090"] | ["a", "091"] | ["a", "092"] | ["a", "093"] | ["a", "094"] | ["a", "095"] | ["a", "096"] | ["a", "097"] | ["a", "098"] | ["a", "099"] | ["a", "100"] | ["a", "101"] | ["a", "102"] | ["a", "103"] | ["a", "104"] | ["a", "105"] | ["a", "106"] | ["a", "107"] | ["a", "108"] | ["a", "109"] | ["a", "110"] | ["a", "111"] | ["a", "112"] | ["a", "113"] | ["a", "114"] | ["a", "115"] | ["a", "116"] | ["a", "117"] | ["a", "118"] | ["a", "119"] | ["a", "120"] | ["a", "121"] | ["a", "122"] | ["a", "123"] | ["a", "124"] | ["a", "125"] | ["a", "126"] | ["a", "127"] | ["a", "128"] | ["a", "129"] | ["a", "130"] | ["a", "131"] | ["a", "132"] | ["a", "133"] | ["a", "134"] | ["a", "135"] | ["a", "136"] | ["a", "137"] | ["a", "138"] | ["a", "139"] | ["a", "140"] | ["a", "141"] | ["a", "142"] | ["a", "143"] | ["a", "144"] | ["a", "145"] | ["a", "146"] | ["a", "147"] | ["a", "148"] | ["a", "149"] | ["a", "150"] | ["a", "151"] | ["a", "152"] | ["a", "153"] | ["a", "154"] | ["a", "155"] | ["a", "156"] | ["a", "157"] | ["a", "158"] | ["a", "159"] | ["a", "160"] | ["a", "161"] | ["a", "162"] | ["a", "163"] | ["a", "164"] | ["a", "165"] | ["a", "166"] | ["a", "167"] | ["a", "168"] | ["a", "169"] | ["a", "170"] | ["a", "171"] | ["a", "172"] | ["a", "173"] | ["a", "174"] | ["a", "175"] | ["a", "176"] | ["a", "177"] | ["a", "178"] | ["a", "179"] | ["a", "180"] | ["a", "181"] | ["a", "182"] | ["a", "183"] | ["a", "184"] | ["a", "185"] | ["a", "186"] | ["a", "187"] | ["a", "188"] | ["a", "189"] | ["a", "190"] | ["a", "191"] | ["a", "192"] | ["a", "193"] | ["a", "194"] | ["a", "195"] | ["a", "196"] | ["a", "197"] | ["a", "198"] | ["a", "199"] | ["a", "200"] | ["a", "201"] | ["a", "202"] | ["a", "203"] | ["a", "204"] | ["a", "205"] | ["a", "206"] | ["a", "207"] | ["a", "208"] | ["a", "209"] | ["a", "210"] | ["a", "211"] | ["a", "212"] | ["a", "213"] | ["a", "214"] | ["a", "215"] | ["a", "216"] | ["a", "217"] | ["a", "218"] | ["a", "219"] | ["a", "220"] | ["a", "221"] | ["a", "222"] | ["a", "223"] | ["a", "224"] | ["a", "225"] | ["a", "226"] | ["a", "227"] | ["a", "228"] | ["a", "229"] | ["a", "230"] | ["a", "231"] | ["a", "232"] | ["a", "233"] | ["a", "234"] | ["a", "235"] | ["a", "236"] | ["a", "237"] | ["a", "238"] | ["a", "239"] | ["a", "240"] | ["a", "241"] | ["a", "242"] | ["a", "243"] | ["a", "244"] | ["a", "245"] | ["a", "246"] | ["a", "247"] | ["a", "248"] | ["a", "249"] | ["a", "250"] | ["a", "251"] | ["a", "252"] | ["a", "253"] | ["a", "254"] | ["a", "255"] | ["a", "256"] | ["a", "257"] | ["a", "258"] | ["a", "259"] | ["a", "260"] | ["a", "261"] | ["a", "262"] | ["a", "263"] | ["a", "264"] | ["a", "265"] | ["a", "266"] | ["a", "267"] | ["a", "268"] | ["a", "269"] | ["a", "270"] | ["a", "271"] | ["a", "272"] | ["a", "273"] | ["a", "274"] | ["a", "275"] | ["a", "276"] | ["a", "277"] | ["a", "278"] | ["a", "279"] | ["a", "280"] | ["a", "281"] | ["a", "282"] | ["a", "283"] | ["a", "284"] | ["a", "285"] | ["a", "286"] | ["a", "287"] | ["a", "288"] | ["a", "289"] | ["a", "290"] | ["a", "291"] | ["a", "292"] | ["a", "293"] | ["a", "294"] | ["a", "295"] | ["a", "296"] | ["a", "297"] | ["a", "298"] | ["a", "299"] | ["a", "300"] | ["a", "301"] | ["a", "302"] | ["a", "303"] | ["a", "304"] | ["a", "305"] | ["a", "306"] | ["a", "307"] | ["a", "308"] | ["a", "309"] | ["a", "310"] | ["a", "311"] | ["a", "312"] | ["a", "313"] | ["a", "314"] | ["a", "315"] | ["a", "316"] | ["a", "317"] | ["a", "318"] | ["a", "319"] | ["a", "320"] | ["a", "321"] | ["a", "322"] | ["a", "323"] | ["a", "324"] | ["a", "325"] | ["a", "326"] | ["a", "327"] | ["a", "328"] | ["a", "329"] | ["a", "330"] | ["a", "331"] | ["a", "332"] | ["a", "333"] | ["a", "334"] | ["a", "335"] | ["a", "336"] | ["a", "337"] | ["a", "338"] | ["a", "339"] | ["a", "340"] | ["a", "341"] | ["a", "342"] | ["a", "343"] | ["a", "344"] | ["a", "345"] | ["a", "346"] | ["a", "347"] | ["a", "348"] | ["a", "349"] | ["a", "350"] | ["a", "351"] | ["a", "352"] | ["a", "353"] | ["a", "354"] | ["a", "355"] | ["a", "356"] | ["a", "357"] | ["a", "358"] | ["a", "359"] | ["a", "360"] | ["a", "361"] | ["a", "362"] | ["a", "363"] | ["a", "364"] | ["a", "365"] | ["a", "366"] | ["a", "367"] | ["a", "368"] | ["a", "369"] | ["a", "370"] | ["a", "371"] | ["a", "372"] | ["a", "373"] | ["a", "374"] | ["a", "375"] | ["a", "376"] | ["a", "377"] | ["a", "378"] | ["a", "379"] | ["a", "380"] | ["a", "381"] | ["a", "382"] | ["a", "383"] | ["a", "384"] | ["a", "385"] | ["a", "386"] | ["a", "387"] | ["a", "388"] | ["a", "389"] | ["a", "390"] | ["a", "391"] | ["a", "392"] | ["a", "393"] | ["a", "394"] | ["a", "395"] | ["a", "396"] | ["a", "397"] | ["a", "398"] | ["a", "399"] | ["a", "400"] | ["a", "401"] | ["a", "402"] | ["a", "403"] | ["a", "404"] | ["a", "405"] | ["a", "406"] | ["a", "407"] | ["a", "408"] | ["a", "409"] | ["a", "410"] | ["a", "411"] | ["a", "412"] | ["a", "413"] | ["a", "414"] | ["a", "415"] | ["a", "416"] | ["a", "417"] | ["a", "418"] | ["a", "419"] | ["a", "420"] | ["a", "421"] | ["a", "422"] | ["a", "423"] | ["a", "424"] | ["a", "425"] | ["a", "426"] | ["a", "427"] | ["a", "428"] | ["a", "429"] | ["a", "430"] | ["a", "431"] | ["a", "432"] | ["a", "433"] | ["a", "434"] | ["a", "435"] | ["a", "436"] | ["a", "437"] | ["a", "438"] | ["a", "439"] | ["a", "440"] | ["a", "441"] | ["a", "442"] | ["a", "443"] | ["a", "444"] | ["a", "445"] | ["a", "446"] | ["a", "447"] | ["a", "448"] | ["a", "449"] | ["a", "450"] | ["a", "451"] | ["a", "452"] | ["a", "453"] | ["a", "454"] | ["a", "455"] | ["a", "456"] | ["a", "457"] | ["a", "458"] | ["a", "459"] | ["a", "460"] | ["a", "461"] | ["a", "462"] | ["a", "463"] | ["a", "464"] | ["a", "465"] | ["a", "466"] | ["a", "467"] | ["a", "468"] | ["a", "469"] | ["a", "470"] | ["a", "471"] | ["a", "472"] | ["a", "473"] | ["a", "474"] | ["a", "475"] | ["a", "476"] | ["a", "477"] | ["a", "478"] | ["a", "479"] | ["a", "480"] | ["a", "481"] | ["a", "482"] | ["a", "483"] | ["a", "484"] | ["a", "485"] | ["a", "486"] | ["a", "487"] | ["a", "488"] | ["a", "489"] | ["a", "490"] | ["a", "491"] | ["a", "492"] | ["a", "493"] | ["a", "494"] | ["a", "495"] | ["a", "496"] | ["a", "497"] | ["a", "498"] | ["a", "499"] | ["a", "500"] | ["a", "501"] | ["a", "502"] | ["a", "503"] | ["a", "504"] | ["a", "505"] | ["a", "506"] | ["a", "507"] | ["a", "508"] | ["a", "509"] | ["a", "510"] | ["a", "511"] | ["a", "512"] | ["a", "513"] | ["a", "514"] | ["a", "515"] | ["a", "516"] | ["a", "517"] | ["a", "518"] | ["a", "519"] | ["a", "520"] | ["a", "521"] | ["a", "522"] | ["a", "523"] | ["a", "524"] | ["a", "525"] | ["a", "526"] | ["a", "527"] | ["a", "528"] | ["a", "529"] | ["a", "530"] | ["a", "531"] | ["a", "532"] | ["a", "533"] | ["a", "534"] | ["a", "535"] | ["a", "536"] | ["a", "537"] | ["a", "538"] | ["a", "539"] | ["a", "540"] | ["a", "541"] | ["a", "542"] | ["a", "543"] | ["a", "544"] | ["a", "545"] | ["a", "546"] | ["a", "547"] | ["a", "548"] | ["a", "549"] | ["a", "550"] | ["a", "551"] | ["a", "552"] | ["a", "553"] | ["a", "554"] | ["a", "555"] | ["a", "556"] | ["a", "557"] | ["a", "558"] | ["a", "559"] | ["a", "560"] | ["a", "561"] | ["a", "562"] | ["a", "563"] | ["a", "564"] | ["a", "565"] | ["a", "566"] | ["a", "567"] | ["a", "568"] | ["a", "569"] | ["a", "570"] | ["a", "571"] | ["a", "572"] | ["a", "573"] | ["a", "574"] | ["a", "575"] | ["a", "576"] | ["a", "577"] | ["a", "578"] | ["a", "579"] | ["a", "580"] | ["a", "581"] | ["a", "582"] | ["a", "583"] | ["a", "584"] | ["a", "585"] | ["a", "586"] | ["a", "587"] | ["a", "588"] | ["a", "589"] | ["a", "590"] | ["a", "591"] | ["a", "592"] | ["a", "593"] | ["a", "594"] | ["a", "595"] | ["a", "596"] | ["a", "597"] | ["a", "598"] | ["a", "599"] | ["a", "600"] | ["a", "601"] | ["a", "602"] | ["a", "603"] | ["a", "604"] | ["a", "605"] | ["a", "606"] | ["a", "607"] | ["a", "608"] | ["a", "609"] | ["a", "610"] | ["a", "611"] | ["a", "612"] | ["a", "613"] | ["a", "614"] | ["a", "615"] | ["a", "616"] | ["a", "617"] | ["a", "618"] | ["a", "619"] | ["a", "620"] | ["a", "621"] | ["a", "622"] | ["a", "623"] | ["a", "624"] | ["a", "625"] | ["a", "626"] | ["a", "627"] | ["a", "628"] | ["a", "629"] | ["a", "630"] | ["a", "631"] | ["a", "632"] | ["a", "633"] | ["a", "634"] | ["a", "635"] | ["a", "636"] | ["a", "637"] | ["a", "638"] | ["a", "639"] | ["a", "640"] | ["a", "641"] | ["a", "642"] | ["a", "643"] | ["a", "644"] | ["a", "645"] | ["a", "646"] | ["a", "647"] | ["a", "648"] | ["a", "649"] | ["a", "650"] | ["a", "651"] | ["a", "652"] | ["a", "653"] | ["a", "654"] | ["a", "655"] | ["a", "656"] | ["a", "657"] | ["a", "658"] | ["a", "659"] | ["a", "660"] | ["a", "661"] | ["a", "662"] | ["a", "663"] | ["a", "664"] | ["a", "665"] | ["a", "666"] | ["a", "667"] | ["a", "668"] | ["a", "669"] | ["a", "670"] | ["a", "671"] | ["a", "672"] | ["a", "673"] | ["a", "674"] | ["a", "675"] | ["a", "676"] | ["a", "677"] | ["a", "678"] | ["a", "679"] | ["a", "680"] | ["a", "681"] | ["a", "682"] | ["a", "683"] | ["a", "684"] | ["a", "685"] | ["a", "686"] | ["a", "687"] | ["a", "688"] | ["a", "689"] | ["a", "690"] | ["a", "691"] | ["a", "692"] | ["a", "693"] | ["a", "694"] | ["a", "695"] | ["a", "696"] | ["a", "697"] | ["a", "698"] | ["a", "699"] | ["a", "700"] | ["a", "701"] | ["a", "702"] | ["a", "703"] | ["a", "704"] | ["a", "705"] | ["a", "706"] | ["a", "707"] | ["a", "708"] | ["a", "709"] | ["a", "710"] | ["a", "711"] | ["a", "712"] | ["a", "713"] | ["a", "714"] | ["a", "715"] | ["a", "716"] | ["a", "717"] | ["a", "718"] | ["a", "719"] | ["a", "720"] | ["a", "721"] | ["a", "722"] | ["a", "723"] | ["a", "724"] | ["a", "725"] | ["a", "726"] | ["a", "727"] | ["a", "728"] | ["a", "729"] | ["a", "730"] | ["a", "731"] | ["a", "732"] | ["a", "733"] | ["a", "734"] | ["a", "735"] | ["a", "736"] | ["a", "737"] | ["a", "738"] | ["a", "739"] | ["a", "740"] | ["a", "741"] | ["a", "742"] | ["a", "743"] | ["a", "744"] | ["a", "745"] | ["a", "746"] | ["a", "747"] | ["a", "748"] | ["a", "749"] | ["a", "750"] | ["a", "751"] | ["a", "752"] | ["a", "753"] | ["a", "754"] | ["a", "755"] | ["a", "756"] | ["a", "757"] | ["a", "758"] | ["a", "759"] | ["a", "760"] | ["a", "761"] | ["a", "762"] | ["a", "763"] | ["a", "764"] | ["a", "765"] | ["a", "766"] | ["a", "767"] | ["a", "768"] | ["a", "769"] | ["a", "770"] | ["a", "771"] | ["a", "772"] | ["a", "773"] | ["a", "774"] | ["a", "775"] | ["a", "776"] | ["a", "777"] | ["a", "778"] | ["a", "779"] | ["a", "780"] | ["a", "781"] | ["a", "782"] | ["a", "783"] | ["a", "784"] | ["a", "785"] | ["a", "786"] | ["a", "787"] | ["a", "788"] | ["a", "789"] | ["a", "790"] | ["a", "791"] | ["a", "792"] | ["a", "793"] | ["a", "794"] | ["a", "795"] | ["a", "796"] | ["a", "797"] | ["a", "798"] | ["a", "799"] | ["a", "800"] | ["a", "801"] | ["a", "802"] | ["a", "803"] | ["a", "804"] | ["a", "805"] | ["a", "806"] | ["a", "807"] | ["a", "808"] | ["a", "809"] | ["a", "810"] | ["a", "811"] | ["a", "812"] | ["a", "813"] | ["a", "814"] | ["a", "815"] | ["a", "816"] | ["a", "817"] | ["a", "818"] | ["a", "819"] | ["a", "820"] | ["a", "821"] | ["a", "822"] | ["a", "823"] | ["a", "824"] | ["a", "825"] | ["a", "826"] | ["a", "827"] | ["a", "828"] | ["a", "829"] | ["a", "830"] | ["a", "831"] | ["a", "832"] | ["a", "833"] | ["a", "834"] | ["a", "835"] | ["a", "836"] | ["a", "837"] | ["a", "838"] | ["a", "839"] | ["a", "840"] | ["a", "841"] | ["a", "842"] | ["a", "843"] | ["a", "844"] | ["a", "845"] | ["a", "846"] | ["a", "847"] | ["a", "848"] | ["a", "849"] | ["a", "850"] | ["a", "851"] | ["a", "852"] | ["a", "853"] | ["a", "854"] | ["a", "855"] | ["a", "856"] | ["a", "857"] | ["a", "858"] | ["a", "859"] | ["a", "860"] | ["a", "861"] | ["a", "862"] | ["a", "863"] | ["a", "864"] | ["a", "865"] | ["a", "866"] | ["a", "867"] | ["a", "868"] | ["a", "869"] | ["a", "870"] | ["a", "871"] | ["a", "872"] | ["a", "873"] | ["a", "874"] | ["a", "875"] | ["a", "876"] | ["a", "877"] | ["a", "878"] | ["a", "879"] | ["a", "880"] | ["a", "881"] | ["a", "882"] | ["a", "883"] | ["a", "884"] | ["a", "885"] | ["a", "886"] | ["a", "887"] | ["a", "888"] | ["a", "889"] | ["a", "890"] | ["a", "891"] | ["a", "892"] | ["a", "893"] | ["a", "894"] | ["a", "895"] | ["a", "896"] | ["a", "897"] | ["a", "898"] | ["a", "899"] | ["a", "900"] | ["a", "901"] | ["a", "902"] | ["a", "903"] | ["a", "904"] | ["a", "905"] | ["a", "906"] | ["a", "907"] | ["a", "908"] | ["a", "909"] | ["a", "910"] | ["a", "911"] | ["a", "912"] | ["a", "913"] | ["a", "914"] | ["a", "915"] | ["a", "916"] | ["a", "917"] | ["a", "918"] | ["a", "919"] | ["a", "920"] | ["a", "921"] | ["a", "922"] | ["a", "923"] | ["a", "924"] | ["a", "925"] | ["a", "926"] | ["a", "927"] | ["a", "928"] | ["a", "929"] | ["a", "930"] | ["a", "931"] | ["a", "932"] | ["a", "933"] | ["a", "934"] | ["a", "935"] | ["a", "936"] | ["a", "937"] | ["a", "938"] | ["a", "939"] | ["a", "940"] | ["a", "941"] | ["a", "942"] | ["a", "943"] | ["a", "944"] | ["a", "945"] | ["a", "946"] | ["a", "947"] | ["a", "948"] | ["a", "949"] | ["a", "950"] | ["a", "951"] | ["a", "952"] | ["a", "953"] | ["a", "954"] | ["a", "955"] | ["a", "956"] | ["a", "957"] | ["a", "958"] | ["a", "959"] | ["a", "960"] | ["a", "961"] | ["a", "962"] | ["a", "963"] | ["a", "964"] | ["a", "965"] | ["a", "966"] | ["a", "967"] | ["a", "968"] | ["a", "969"] | ["a", "970"] | ["a", "971"] | ["a", "972"] | ["a", "973"] | ["a", "974"] | ["a", "975"] | ["a", "976"] | ["a", "977"] | ["a", "978"] | ["a", "979"] | ["a", "980"] | ["a", "981"] | ["a", "982"] | ["a", "983"] | ["a", "984"] | ["a", "985"] | ["a", "986"] | ["a", "987"] | ["a", "988"] | ["a", "989"] | ["a", "990"] | ["a", "991"] | ["a", "992"] | ["a", "993"] | ["a", "994"] | ["a", "995"] | ["a", "996"] | ["a", "997"] | ["a", "998"] | ["a", "999"] + diff --git a/tsc/testdata/baselines/reference/compiler/instantiationCountSharedCheckOrder(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/instantiationCountSharedCheckOrder(checkorder=typesfirst).errors.txt new file mode 100644 index 0000000000000..0dcf882bf475c --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/instantiationCountSharedCheckOrder(checkorder=typesfirst).errors.txt @@ -0,0 +1,16 @@ +error TS2589: Type instantiation is excessively deep and possibly infinite. + + +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. +==== instantiationCountSharedCheckOrder.ts (0 errors) ==== + // Instantiating Wide<[], "a"> fresh takes over five million instantiations, + // which is too many. In program order Rest has already done all but about + // two million of them. Whether All takes too many must not depend on which + // comes first. + + type D = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9; + type K = `${D}${D}${D}`; + type Wide = N["length"] extends 6 ? [I, J] : { [J2 in K]: Wide<[...N, 0], I, J2> }[K]; + type Rest = Wide<[0, 0], "a">; + type All = Wide<[], "a">; + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/instantiationCountSharedCheckOrder(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/instantiationCountSharedCheckOrder(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..e139f88dccad8 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/instantiationCountSharedCheckOrder(checkorder=typesfirst).symbols @@ -0,0 +1,41 @@ +//// [tests/cases/compiler/instantiationCountSharedCheckOrder.ts] //// + +=== instantiationCountSharedCheckOrder.ts === +// Instantiating Wide<[], "a"> fresh takes over five million instantiations, +// which is too many. In program order Rest has already done all but about +// two million of them. Whether All takes too many must not depend on which +// comes first. + +type D = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9; +>D : Symbol(D, Decl(instantiationCountSharedCheckOrder.ts, 0, 0)) + +type K = `${D}${D}${D}`; +>K : Symbol(K, Decl(instantiationCountSharedCheckOrder.ts, 5, 47)) +>D : Symbol(D, Decl(instantiationCountSharedCheckOrder.ts, 0, 0)) +>D : Symbol(D, Decl(instantiationCountSharedCheckOrder.ts, 0, 0)) +>D : Symbol(D, Decl(instantiationCountSharedCheckOrder.ts, 0, 0)) + +type Wide = N["length"] extends 6 ? [I, J] : { [J2 in K]: Wide<[...N, 0], I, J2> }[K]; +>Wide : Symbol(Wide, Decl(instantiationCountSharedCheckOrder.ts, 6, 24)) +>N : Symbol(N, Decl(instantiationCountSharedCheckOrder.ts, 7, 10)) +>I : Symbol(I, Decl(instantiationCountSharedCheckOrder.ts, 7, 24)) +>J : Symbol(J, Decl(instantiationCountSharedCheckOrder.ts, 7, 27)) +>N : Symbol(N, Decl(instantiationCountSharedCheckOrder.ts, 7, 10)) +>I : Symbol(I, Decl(instantiationCountSharedCheckOrder.ts, 7, 24)) +>J : Symbol(J, Decl(instantiationCountSharedCheckOrder.ts, 7, 27)) +>J2 : Symbol(J2, Decl(instantiationCountSharedCheckOrder.ts, 7, 77)) +>K : Symbol(K, Decl(instantiationCountSharedCheckOrder.ts, 5, 47)) +>Wide : Symbol(Wide, Decl(instantiationCountSharedCheckOrder.ts, 6, 24)) +>N : Symbol(N, Decl(instantiationCountSharedCheckOrder.ts, 7, 10)) +>I : Symbol(I, Decl(instantiationCountSharedCheckOrder.ts, 7, 24)) +>J2 : Symbol(J2, Decl(instantiationCountSharedCheckOrder.ts, 7, 77)) +>K : Symbol(K, Decl(instantiationCountSharedCheckOrder.ts, 5, 47)) + +type Rest = Wide<[0, 0], "a">; +>Rest : Symbol(Rest, Decl(instantiationCountSharedCheckOrder.ts, 7, 115)) +>Wide : Symbol(Wide, Decl(instantiationCountSharedCheckOrder.ts, 6, 24)) + +type All = Wide<[], "a">; +>All : Symbol(All, Decl(instantiationCountSharedCheckOrder.ts, 8, 30)) +>Wide : Symbol(Wide, Decl(instantiationCountSharedCheckOrder.ts, 6, 24)) + diff --git a/tsc/testdata/baselines/reference/compiler/instantiationCountSharedCheckOrder(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/instantiationCountSharedCheckOrder(checkorder=typesfirst).types new file mode 100644 index 0000000000000..4ed5f89ebfadd --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/instantiationCountSharedCheckOrder(checkorder=typesfirst).types @@ -0,0 +1,23 @@ +//// [tests/cases/compiler/instantiationCountSharedCheckOrder.ts] //// + +=== instantiationCountSharedCheckOrder.ts === +// Instantiating Wide<[], "a"> fresh takes over five million instantiations, +// which is too many. In program order Rest has already done all but about +// two million of them. Whether All takes too many must not depend on which +// comes first. + +type D = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9; +>D : D + +type K = `${D}${D}${D}`; +>K : "000" | "001" | "002" | "003" | "004" | "005" | "006" | "007" | "008" | "009" | "010" | "011" | "012" | "013" | "014" | "015" | "016" | "017" | "018" | "019" | "020" | "021" | "022" | "023" | "024" | "025" | "026" | "027" | "028" | "029" | "030" | "031" | "032" | "033" | "034" | "035" | "036" | "037" | "038" | "039" | "040" | "041" | "042" | "043" | "044" | "045" | "046" | "047" | "048" | "049" | "050" | "051" | "052" | "053" | "054" | "055" | "056" | "057" | "058" | "059" | "060" | "061" | "062" | "063" | "064" | "065" | "066" | "067" | "068" | "069" | "070" | "071" | "072" | "073" | "074" | "075" | "076" | "077" | "078" | "079" | "080" | "081" | "082" | "083" | "084" | "085" | "086" | "087" | "088" | "089" | "090" | "091" | "092" | "093" | "094" | "095" | "096" | "097" | "098" | "099" | "100" | "101" | "102" | "103" | "104" | "105" | "106" | "107" | "108" | "109" | "110" | "111" | "112" | "113" | "114" | "115" | "116" | "117" | "118" | "119" | "120" | "121" | "122" | "123" | "124" | "125" | "126" | "127" | "128" | "129" | "130" | "131" | "132" | "133" | "134" | "135" | "136" | "137" | "138" | "139" | "140" | "141" | "142" | "143" | "144" | "145" | "146" | "147" | "148" | "149" | "150" | "151" | "152" | "153" | "154" | "155" | "156" | "157" | "158" | "159" | "160" | "161" | "162" | "163" | "164" | "165" | "166" | "167" | "168" | "169" | "170" | "171" | "172" | "173" | "174" | "175" | "176" | "177" | "178" | "179" | "180" | "181" | "182" | "183" | "184" | "185" | "186" | "187" | "188" | "189" | "190" | "191" | "192" | "193" | "194" | "195" | "196" | "197" | "198" | "199" | "200" | "201" | "202" | "203" | "204" | "205" | "206" | "207" | "208" | "209" | "210" | "211" | "212" | "213" | "214" | "215" | "216" | "217" | "218" | "219" | "220" | "221" | "222" | "223" | "224" | "225" | "226" | "227" | "228" | "229" | "230" | "231" | "232" | "233" | "234" | "235" | "236" | "237" | "238" | "239" | "240" | "241" | "242" | "243" | "244" | "245" | "246" | "247" | "248" | "249" | "250" | "251" | "252" | "253" | "254" | "255" | "256" | "257" | "258" | "259" | "260" | "261" | "262" | "263" | "264" | "265" | "266" | "267" | "268" | "269" | "270" | "271" | "272" | "273" | "274" | "275" | "276" | "277" | "278" | "279" | "280" | "281" | "282" | "283" | "284" | "285" | "286" | "287" | "288" | "289" | "290" | "291" | "292" | "293" | "294" | "295" | "296" | "297" | "298" | "299" | "300" | "301" | "302" | "303" | "304" | "305" | "306" | "307" | "308" | "309" | "310" | "311" | "312" | "313" | "314" | "315" | "316" | "317" | "318" | "319" | "320" | "321" | "322" | "323" | "324" | "325" | "326" | "327" | "328" | "329" | "330" | "331" | "332" | "333" | "334" | "335" | "336" | "337" | "338" | "339" | "340" | "341" | "342" | "343" | "344" | "345" | "346" | "347" | "348" | "349" | "350" | "351" | "352" | "353" | "354" | "355" | "356" | "357" | "358" | "359" | "360" | "361" | "362" | "363" | "364" | "365" | "366" | "367" | "368" | "369" | "370" | "371" | "372" | "373" | "374" | "375" | "376" | "377" | "378" | "379" | "380" | "381" | "382" | "383" | "384" | "385" | "386" | "387" | "388" | "389" | "390" | "391" | "392" | "393" | "394" | "395" | "396" | "397" | "398" | "399" | "400" | "401" | "402" | "403" | "404" | "405" | "406" | "407" | "408" | "409" | "410" | "411" | "412" | "413" | "414" | "415" | "416" | "417" | "418" | "419" | "420" | "421" | "422" | "423" | "424" | "425" | "426" | "427" | "428" | "429" | "430" | "431" | "432" | "433" | "434" | "435" | "436" | "437" | "438" | "439" | "440" | "441" | "442" | "443" | "444" | "445" | "446" | "447" | "448" | "449" | "450" | "451" | "452" | "453" | "454" | "455" | "456" | "457" | "458" | "459" | "460" | "461" | "462" | "463" | "464" | "465" | "466" | "467" | "468" | "469" | "470" | "471" | "472" | "473" | "474" | "475" | "476" | "477" | "478" | "479" | "480" | "481" | "482" | "483" | "484" | "485" | "486" | "487" | "488" | "489" | "490" | "491" | "492" | "493" | "494" | "495" | "496" | "497" | "498" | "499" | "500" | "501" | "502" | "503" | "504" | "505" | "506" | "507" | "508" | "509" | "510" | "511" | "512" | "513" | "514" | "515" | "516" | "517" | "518" | "519" | "520" | "521" | "522" | "523" | "524" | "525" | "526" | "527" | "528" | "529" | "530" | "531" | "532" | "533" | "534" | "535" | "536" | "537" | "538" | "539" | "540" | "541" | "542" | "543" | "544" | "545" | "546" | "547" | "548" | "549" | "550" | "551" | "552" | "553" | "554" | "555" | "556" | "557" | "558" | "559" | "560" | "561" | "562" | "563" | "564" | "565" | "566" | "567" | "568" | "569" | "570" | "571" | "572" | "573" | "574" | "575" | "576" | "577" | "578" | "579" | "580" | "581" | "582" | "583" | "584" | "585" | "586" | "587" | "588" | "589" | "590" | "591" | "592" | "593" | "594" | "595" | "596" | "597" | "598" | "599" | "600" | "601" | "602" | "603" | "604" | "605" | "606" | "607" | "608" | "609" | "610" | "611" | "612" | "613" | "614" | "615" | "616" | "617" | "618" | "619" | "620" | "621" | "622" | "623" | "624" | "625" | "626" | "627" | "628" | "629" | "630" | "631" | "632" | "633" | "634" | "635" | "636" | "637" | "638" | "639" | "640" | "641" | "642" | "643" | "644" | "645" | "646" | "647" | "648" | "649" | "650" | "651" | "652" | "653" | "654" | "655" | "656" | "657" | "658" | "659" | "660" | "661" | "662" | "663" | "664" | "665" | "666" | "667" | "668" | "669" | "670" | "671" | "672" | "673" | "674" | "675" | "676" | "677" | "678" | "679" | "680" | "681" | "682" | "683" | "684" | "685" | "686" | "687" | "688" | "689" | "690" | "691" | "692" | "693" | "694" | "695" | "696" | "697" | "698" | "699" | "700" | "701" | "702" | "703" | "704" | "705" | "706" | "707" | "708" | "709" | "710" | "711" | "712" | "713" | "714" | "715" | "716" | "717" | "718" | "719" | "720" | "721" | "722" | "723" | "724" | "725" | "726" | "727" | "728" | "729" | "730" | "731" | "732" | "733" | "734" | "735" | "736" | "737" | "738" | "739" | "740" | "741" | "742" | "743" | "744" | "745" | "746" | "747" | "748" | "749" | "750" | "751" | "752" | "753" | "754" | "755" | "756" | "757" | "758" | "759" | "760" | "761" | "762" | "763" | "764" | "765" | "766" | "767" | "768" | "769" | "770" | "771" | "772" | "773" | "774" | "775" | "776" | "777" | "778" | "779" | "780" | "781" | "782" | "783" | "784" | "785" | "786" | "787" | "788" | "789" | "790" | "791" | "792" | "793" | "794" | "795" | "796" | "797" | "798" | "799" | "800" | "801" | "802" | "803" | "804" | "805" | "806" | "807" | "808" | "809" | "810" | "811" | "812" | "813" | "814" | "815" | "816" | "817" | "818" | "819" | "820" | "821" | "822" | "823" | "824" | "825" | "826" | "827" | "828" | "829" | "830" | "831" | "832" | "833" | "834" | "835" | "836" | "837" | "838" | "839" | "840" | "841" | "842" | "843" | "844" | "845" | "846" | "847" | "848" | "849" | "850" | "851" | "852" | "853" | "854" | "855" | "856" | "857" | "858" | "859" | "860" | "861" | "862" | "863" | "864" | "865" | "866" | "867" | "868" | "869" | "870" | "871" | "872" | "873" | "874" | "875" | "876" | "877" | "878" | "879" | "880" | "881" | "882" | "883" | "884" | "885" | "886" | "887" | "888" | "889" | "890" | "891" | "892" | "893" | "894" | "895" | "896" | "897" | "898" | "899" | "900" | "901" | "902" | "903" | "904" | "905" | "906" | "907" | "908" | "909" | "910" | "911" | "912" | "913" | "914" | "915" | "916" | "917" | "918" | "919" | "920" | "921" | "922" | "923" | "924" | "925" | "926" | "927" | "928" | "929" | "930" | "931" | "932" | "933" | "934" | "935" | "936" | "937" | "938" | "939" | "940" | "941" | "942" | "943" | "944" | "945" | "946" | "947" | "948" | "949" | "950" | "951" | "952" | "953" | "954" | "955" | "956" | "957" | "958" | "959" | "960" | "961" | "962" | "963" | "964" | "965" | "966" | "967" | "968" | "969" | "970" | "971" | "972" | "973" | "974" | "975" | "976" | "977" | "978" | "979" | "980" | "981" | "982" | "983" | "984" | "985" | "986" | "987" | "988" | "989" | "990" | "991" | "992" | "993" | "994" | "995" | "996" | "997" | "998" | "999" + +type Wide = N["length"] extends 6 ? [I, J] : { [J2 in K]: Wide<[...N, 0], I, J2> }[K]; +>Wide : Wide + +type Rest = Wide<[0, 0], "a">; +>Rest : ["a", "000"] | ["a", "001"] | ["a", "002"] | ["a", "003"] | ["a", "004"] | ["a", "005"] | ["a", "006"] | ["a", "007"] | ["a", "008"] | ["a", "009"] | ["a", "010"] | ["a", "011"] | ["a", "012"] | ["a", "013"] | ["a", "014"] | ["a", "015"] | ["a", "016"] | ["a", "017"] | ["a", "018"] | ["a", "019"] | ["a", "020"] | ["a", "021"] | ["a", "022"] | ["a", "023"] | ["a", "024"] | ["a", "025"] | ["a", "026"] | ["a", "027"] | ["a", "028"] | ["a", "029"] | ["a", "030"] | ["a", "031"] | ["a", "032"] | ["a", "033"] | ["a", "034"] | ["a", "035"] | ["a", "036"] | ["a", "037"] | ["a", "038"] | ["a", "039"] | ["a", "040"] | ["a", "041"] | ["a", "042"] | ["a", "043"] | ["a", "044"] | ["a", "045"] | ["a", "046"] | ["a", "047"] | ["a", "048"] | ["a", "049"] | ["a", "050"] | ["a", "051"] | ["a", "052"] | ["a", "053"] | ["a", "054"] | ["a", "055"] | ["a", "056"] | ["a", "057"] | ["a", "058"] | ["a", "059"] | ["a", "060"] | ["a", "061"] | ["a", "062"] | ["a", "063"] | ["a", "064"] | ["a", "065"] | ["a", "066"] | ["a", "067"] | ["a", "068"] | ["a", "069"] | ["a", "070"] | ["a", "071"] | ["a", "072"] | ["a", "073"] | ["a", "074"] | ["a", "075"] | ["a", "076"] | ["a", "077"] | ["a", "078"] | ["a", "079"] | ["a", "080"] | ["a", "081"] | ["a", "082"] | ["a", "083"] | ["a", "084"] | ["a", "085"] | ["a", "086"] | ["a", "087"] | ["a", "088"] | ["a", "089"] | ["a", "090"] | ["a", "091"] | ["a", "092"] | ["a", "093"] | ["a", "094"] | ["a", "095"] | ["a", "096"] | ["a", "097"] | ["a", "098"] | ["a", "099"] | ["a", "100"] | ["a", "101"] | ["a", "102"] | ["a", "103"] | ["a", "104"] | ["a", "105"] | ["a", "106"] | ["a", "107"] | ["a", "108"] | ["a", "109"] | ["a", "110"] | ["a", "111"] | ["a", "112"] | ["a", "113"] | ["a", "114"] | ["a", "115"] | ["a", "116"] | ["a", "117"] | ["a", "118"] | ["a", "119"] | ["a", "120"] | ["a", "121"] | ["a", "122"] | ["a", "123"] | ["a", "124"] | ["a", "125"] | ["a", "126"] | ["a", "127"] | ["a", "128"] | ["a", "129"] | ["a", "130"] | ["a", "131"] | ["a", "132"] | ["a", "133"] | ["a", "134"] | ["a", "135"] | ["a", "136"] | ["a", "137"] | ["a", "138"] | ["a", "139"] | ["a", "140"] | ["a", "141"] | ["a", "142"] | ["a", "143"] | ["a", "144"] | ["a", "145"] | ["a", "146"] | ["a", "147"] | ["a", "148"] | ["a", "149"] | ["a", "150"] | ["a", "151"] | ["a", "152"] | ["a", "153"] | ["a", "154"] | ["a", "155"] | ["a", "156"] | ["a", "157"] | ["a", "158"] | ["a", "159"] | ["a", "160"] | ["a", "161"] | ["a", "162"] | ["a", "163"] | ["a", "164"] | ["a", "165"] | ["a", "166"] | ["a", "167"] | ["a", "168"] | ["a", "169"] | ["a", "170"] | ["a", "171"] | ["a", "172"] | ["a", "173"] | ["a", "174"] | ["a", "175"] | ["a", "176"] | ["a", "177"] | ["a", "178"] | ["a", "179"] | ["a", "180"] | ["a", "181"] | ["a", "182"] | ["a", "183"] | ["a", "184"] | ["a", "185"] | ["a", "186"] | ["a", "187"] | ["a", "188"] | ["a", "189"] | ["a", "190"] | ["a", "191"] | ["a", "192"] | ["a", "193"] | ["a", "194"] | ["a", "195"] | ["a", "196"] | ["a", "197"] | ["a", "198"] | ["a", "199"] | ["a", "200"] | ["a", "201"] | ["a", "202"] | ["a", "203"] | ["a", "204"] | ["a", "205"] | ["a", "206"] | ["a", "207"] | ["a", "208"] | ["a", "209"] | ["a", "210"] | ["a", "211"] | ["a", "212"] | ["a", "213"] | ["a", "214"] | ["a", "215"] | ["a", "216"] | ["a", "217"] | ["a", "218"] | ["a", "219"] | ["a", "220"] | ["a", "221"] | ["a", "222"] | ["a", "223"] | ["a", "224"] | ["a", "225"] | ["a", "226"] | ["a", "227"] | ["a", "228"] | ["a", "229"] | ["a", "230"] | ["a", "231"] | ["a", "232"] | ["a", "233"] | ["a", "234"] | ["a", "235"] | ["a", "236"] | ["a", "237"] | ["a", "238"] | ["a", "239"] | ["a", "240"] | ["a", "241"] | ["a", "242"] | ["a", "243"] | ["a", "244"] | ["a", "245"] | ["a", "246"] | ["a", "247"] | ["a", "248"] | ["a", "249"] | ["a", "250"] | ["a", "251"] | ["a", "252"] | ["a", "253"] | ["a", "254"] | ["a", "255"] | ["a", "256"] | ["a", "257"] | ["a", "258"] | ["a", "259"] | ["a", "260"] | ["a", "261"] | ["a", "262"] | ["a", "263"] | ["a", "264"] | ["a", "265"] | ["a", "266"] | ["a", "267"] | ["a", "268"] | ["a", "269"] | ["a", "270"] | ["a", "271"] | ["a", "272"] | ["a", "273"] | ["a", "274"] | ["a", "275"] | ["a", "276"] | ["a", "277"] | ["a", "278"] | ["a", "279"] | ["a", "280"] | ["a", "281"] | ["a", "282"] | ["a", "283"] | ["a", "284"] | ["a", "285"] | ["a", "286"] | ["a", "287"] | ["a", "288"] | ["a", "289"] | ["a", "290"] | ["a", "291"] | ["a", "292"] | ["a", "293"] | ["a", "294"] | ["a", "295"] | ["a", "296"] | ["a", "297"] | ["a", "298"] | ["a", "299"] | ["a", "300"] | ["a", "301"] | ["a", "302"] | ["a", "303"] | ["a", "304"] | ["a", "305"] | ["a", "306"] | ["a", "307"] | ["a", "308"] | ["a", "309"] | ["a", "310"] | ["a", "311"] | ["a", "312"] | ["a", "313"] | ["a", "314"] | ["a", "315"] | ["a", "316"] | ["a", "317"] | ["a", "318"] | ["a", "319"] | ["a", "320"] | ["a", "321"] | ["a", "322"] | ["a", "323"] | ["a", "324"] | ["a", "325"] | ["a", "326"] | ["a", "327"] | ["a", "328"] | ["a", "329"] | ["a", "330"] | ["a", "331"] | ["a", "332"] | ["a", "333"] | ["a", "334"] | ["a", "335"] | ["a", "336"] | ["a", "337"] | ["a", "338"] | ["a", "339"] | ["a", "340"] | ["a", "341"] | ["a", "342"] | ["a", "343"] | ["a", "344"] | ["a", "345"] | ["a", "346"] | ["a", "347"] | ["a", "348"] | ["a", "349"] | ["a", "350"] | ["a", "351"] | ["a", "352"] | ["a", "353"] | ["a", "354"] | ["a", "355"] | ["a", "356"] | ["a", "357"] | ["a", "358"] | ["a", "359"] | ["a", "360"] | ["a", "361"] | ["a", "362"] | ["a", "363"] | ["a", "364"] | ["a", "365"] | ["a", "366"] | ["a", "367"] | ["a", "368"] | ["a", "369"] | ["a", "370"] | ["a", "371"] | ["a", "372"] | ["a", "373"] | ["a", "374"] | ["a", "375"] | ["a", "376"] | ["a", "377"] | ["a", "378"] | ["a", "379"] | ["a", "380"] | ["a", "381"] | ["a", "382"] | ["a", "383"] | ["a", "384"] | ["a", "385"] | ["a", "386"] | ["a", "387"] | ["a", "388"] | ["a", "389"] | ["a", "390"] | ["a", "391"] | ["a", "392"] | ["a", "393"] | ["a", "394"] | ["a", "395"] | ["a", "396"] | ["a", "397"] | ["a", "398"] | ["a", "399"] | ["a", "400"] | ["a", "401"] | ["a", "402"] | ["a", "403"] | ["a", "404"] | ["a", "405"] | ["a", "406"] | ["a", "407"] | ["a", "408"] | ["a", "409"] | ["a", "410"] | ["a", "411"] | ["a", "412"] | ["a", "413"] | ["a", "414"] | ["a", "415"] | ["a", "416"] | ["a", "417"] | ["a", "418"] | ["a", "419"] | ["a", "420"] | ["a", "421"] | ["a", "422"] | ["a", "423"] | ["a", "424"] | ["a", "425"] | ["a", "426"] | ["a", "427"] | ["a", "428"] | ["a", "429"] | ["a", "430"] | ["a", "431"] | ["a", "432"] | ["a", "433"] | ["a", "434"] | ["a", "435"] | ["a", "436"] | ["a", "437"] | ["a", "438"] | ["a", "439"] | ["a", "440"] | ["a", "441"] | ["a", "442"] | ["a", "443"] | ["a", "444"] | ["a", "445"] | ["a", "446"] | ["a", "447"] | ["a", "448"] | ["a", "449"] | ["a", "450"] | ["a", "451"] | ["a", "452"] | ["a", "453"] | ["a", "454"] | ["a", "455"] | ["a", "456"] | ["a", "457"] | ["a", "458"] | ["a", "459"] | ["a", "460"] | ["a", "461"] | ["a", "462"] | ["a", "463"] | ["a", "464"] | ["a", "465"] | ["a", "466"] | ["a", "467"] | ["a", "468"] | ["a", "469"] | ["a", "470"] | ["a", "471"] | ["a", "472"] | ["a", "473"] | ["a", "474"] | ["a", "475"] | ["a", "476"] | ["a", "477"] | ["a", "478"] | ["a", "479"] | ["a", "480"] | ["a", "481"] | ["a", "482"] | ["a", "483"] | ["a", "484"] | ["a", "485"] | ["a", "486"] | ["a", "487"] | ["a", "488"] | ["a", "489"] | ["a", "490"] | ["a", "491"] | ["a", "492"] | ["a", "493"] | ["a", "494"] | ["a", "495"] | ["a", "496"] | ["a", "497"] | ["a", "498"] | ["a", "499"] | ["a", "500"] | ["a", "501"] | ["a", "502"] | ["a", "503"] | ["a", "504"] | ["a", "505"] | ["a", "506"] | ["a", "507"] | ["a", "508"] | ["a", "509"] | ["a", "510"] | ["a", "511"] | ["a", "512"] | ["a", "513"] | ["a", "514"] | ["a", "515"] | ["a", "516"] | ["a", "517"] | ["a", "518"] | ["a", "519"] | ["a", "520"] | ["a", "521"] | ["a", "522"] | ["a", "523"] | ["a", "524"] | ["a", "525"] | ["a", "526"] | ["a", "527"] | ["a", "528"] | ["a", "529"] | ["a", "530"] | ["a", "531"] | ["a", "532"] | ["a", "533"] | ["a", "534"] | ["a", "535"] | ["a", "536"] | ["a", "537"] | ["a", "538"] | ["a", "539"] | ["a", "540"] | ["a", "541"] | ["a", "542"] | ["a", "543"] | ["a", "544"] | ["a", "545"] | ["a", "546"] | ["a", "547"] | ["a", "548"] | ["a", "549"] | ["a", "550"] | ["a", "551"] | ["a", "552"] | ["a", "553"] | ["a", "554"] | ["a", "555"] | ["a", "556"] | ["a", "557"] | ["a", "558"] | ["a", "559"] | ["a", "560"] | ["a", "561"] | ["a", "562"] | ["a", "563"] | ["a", "564"] | ["a", "565"] | ["a", "566"] | ["a", "567"] | ["a", "568"] | ["a", "569"] | ["a", "570"] | ["a", "571"] | ["a", "572"] | ["a", "573"] | ["a", "574"] | ["a", "575"] | ["a", "576"] | ["a", "577"] | ["a", "578"] | ["a", "579"] | ["a", "580"] | ["a", "581"] | ["a", "582"] | ["a", "583"] | ["a", "584"] | ["a", "585"] | ["a", "586"] | ["a", "587"] | ["a", "588"] | ["a", "589"] | ["a", "590"] | ["a", "591"] | ["a", "592"] | ["a", "593"] | ["a", "594"] | ["a", "595"] | ["a", "596"] | ["a", "597"] | ["a", "598"] | ["a", "599"] | ["a", "600"] | ["a", "601"] | ["a", "602"] | ["a", "603"] | ["a", "604"] | ["a", "605"] | ["a", "606"] | ["a", "607"] | ["a", "608"] | ["a", "609"] | ["a", "610"] | ["a", "611"] | ["a", "612"] | ["a", "613"] | ["a", "614"] | ["a", "615"] | ["a", "616"] | ["a", "617"] | ["a", "618"] | ["a", "619"] | ["a", "620"] | ["a", "621"] | ["a", "622"] | ["a", "623"] | ["a", "624"] | ["a", "625"] | ["a", "626"] | ["a", "627"] | ["a", "628"] | ["a", "629"] | ["a", "630"] | ["a", "631"] | ["a", "632"] | ["a", "633"] | ["a", "634"] | ["a", "635"] | ["a", "636"] | ["a", "637"] | ["a", "638"] | ["a", "639"] | ["a", "640"] | ["a", "641"] | ["a", "642"] | ["a", "643"] | ["a", "644"] | ["a", "645"] | ["a", "646"] | ["a", "647"] | ["a", "648"] | ["a", "649"] | ["a", "650"] | ["a", "651"] | ["a", "652"] | ["a", "653"] | ["a", "654"] | ["a", "655"] | ["a", "656"] | ["a", "657"] | ["a", "658"] | ["a", "659"] | ["a", "660"] | ["a", "661"] | ["a", "662"] | ["a", "663"] | ["a", "664"] | ["a", "665"] | ["a", "666"] | ["a", "667"] | ["a", "668"] | ["a", "669"] | ["a", "670"] | ["a", "671"] | ["a", "672"] | ["a", "673"] | ["a", "674"] | ["a", "675"] | ["a", "676"] | ["a", "677"] | ["a", "678"] | ["a", "679"] | ["a", "680"] | ["a", "681"] | ["a", "682"] | ["a", "683"] | ["a", "684"] | ["a", "685"] | ["a", "686"] | ["a", "687"] | ["a", "688"] | ["a", "689"] | ["a", "690"] | ["a", "691"] | ["a", "692"] | ["a", "693"] | ["a", "694"] | ["a", "695"] | ["a", "696"] | ["a", "697"] | ["a", "698"] | ["a", "699"] | ["a", "700"] | ["a", "701"] | ["a", "702"] | ["a", "703"] | ["a", "704"] | ["a", "705"] | ["a", "706"] | ["a", "707"] | ["a", "708"] | ["a", "709"] | ["a", "710"] | ["a", "711"] | ["a", "712"] | ["a", "713"] | ["a", "714"] | ["a", "715"] | ["a", "716"] | ["a", "717"] | ["a", "718"] | ["a", "719"] | ["a", "720"] | ["a", "721"] | ["a", "722"] | ["a", "723"] | ["a", "724"] | ["a", "725"] | ["a", "726"] | ["a", "727"] | ["a", "728"] | ["a", "729"] | ["a", "730"] | ["a", "731"] | ["a", "732"] | ["a", "733"] | ["a", "734"] | ["a", "735"] | ["a", "736"] | ["a", "737"] | ["a", "738"] | ["a", "739"] | ["a", "740"] | ["a", "741"] | ["a", "742"] | ["a", "743"] | ["a", "744"] | ["a", "745"] | ["a", "746"] | ["a", "747"] | ["a", "748"] | ["a", "749"] | ["a", "750"] | ["a", "751"] | ["a", "752"] | ["a", "753"] | ["a", "754"] | ["a", "755"] | ["a", "756"] | ["a", "757"] | ["a", "758"] | ["a", "759"] | ["a", "760"] | ["a", "761"] | ["a", "762"] | ["a", "763"] | ["a", "764"] | ["a", "765"] | ["a", "766"] | ["a", "767"] | ["a", "768"] | ["a", "769"] | ["a", "770"] | ["a", "771"] | ["a", "772"] | ["a", "773"] | ["a", "774"] | ["a", "775"] | ["a", "776"] | ["a", "777"] | ["a", "778"] | ["a", "779"] | ["a", "780"] | ["a", "781"] | ["a", "782"] | ["a", "783"] | ["a", "784"] | ["a", "785"] | ["a", "786"] | ["a", "787"] | ["a", "788"] | ["a", "789"] | ["a", "790"] | ["a", "791"] | ["a", "792"] | ["a", "793"] | ["a", "794"] | ["a", "795"] | ["a", "796"] | ["a", "797"] | ["a", "798"] | ["a", "799"] | ["a", "800"] | ["a", "801"] | ["a", "802"] | ["a", "803"] | ["a", "804"] | ["a", "805"] | ["a", "806"] | ["a", "807"] | ["a", "808"] | ["a", "809"] | ["a", "810"] | ["a", "811"] | ["a", "812"] | ["a", "813"] | ["a", "814"] | ["a", "815"] | ["a", "816"] | ["a", "817"] | ["a", "818"] | ["a", "819"] | ["a", "820"] | ["a", "821"] | ["a", "822"] | ["a", "823"] | ["a", "824"] | ["a", "825"] | ["a", "826"] | ["a", "827"] | ["a", "828"] | ["a", "829"] | ["a", "830"] | ["a", "831"] | ["a", "832"] | ["a", "833"] | ["a", "834"] | ["a", "835"] | ["a", "836"] | ["a", "837"] | ["a", "838"] | ["a", "839"] | ["a", "840"] | ["a", "841"] | ["a", "842"] | ["a", "843"] | ["a", "844"] | ["a", "845"] | ["a", "846"] | ["a", "847"] | ["a", "848"] | ["a", "849"] | ["a", "850"] | ["a", "851"] | ["a", "852"] | ["a", "853"] | ["a", "854"] | ["a", "855"] | ["a", "856"] | ["a", "857"] | ["a", "858"] | ["a", "859"] | ["a", "860"] | ["a", "861"] | ["a", "862"] | ["a", "863"] | ["a", "864"] | ["a", "865"] | ["a", "866"] | ["a", "867"] | ["a", "868"] | ["a", "869"] | ["a", "870"] | ["a", "871"] | ["a", "872"] | ["a", "873"] | ["a", "874"] | ["a", "875"] | ["a", "876"] | ["a", "877"] | ["a", "878"] | ["a", "879"] | ["a", "880"] | ["a", "881"] | ["a", "882"] | ["a", "883"] | ["a", "884"] | ["a", "885"] | ["a", "886"] | ["a", "887"] | ["a", "888"] | ["a", "889"] | ["a", "890"] | ["a", "891"] | ["a", "892"] | ["a", "893"] | ["a", "894"] | ["a", "895"] | ["a", "896"] | ["a", "897"] | ["a", "898"] | ["a", "899"] | ["a", "900"] | ["a", "901"] | ["a", "902"] | ["a", "903"] | ["a", "904"] | ["a", "905"] | ["a", "906"] | ["a", "907"] | ["a", "908"] | ["a", "909"] | ["a", "910"] | ["a", "911"] | ["a", "912"] | ["a", "913"] | ["a", "914"] | ["a", "915"] | ["a", "916"] | ["a", "917"] | ["a", "918"] | ["a", "919"] | ["a", "920"] | ["a", "921"] | ["a", "922"] | ["a", "923"] | ["a", "924"] | ["a", "925"] | ["a", "926"] | ["a", "927"] | ["a", "928"] | ["a", "929"] | ["a", "930"] | ["a", "931"] | ["a", "932"] | ["a", "933"] | ["a", "934"] | ["a", "935"] | ["a", "936"] | ["a", "937"] | ["a", "938"] | ["a", "939"] | ["a", "940"] | ["a", "941"] | ["a", "942"] | ["a", "943"] | ["a", "944"] | ["a", "945"] | ["a", "946"] | ["a", "947"] | ["a", "948"] | ["a", "949"] | ["a", "950"] | ["a", "951"] | ["a", "952"] | ["a", "953"] | ["a", "954"] | ["a", "955"] | ["a", "956"] | ["a", "957"] | ["a", "958"] | ["a", "959"] | ["a", "960"] | ["a", "961"] | ["a", "962"] | ["a", "963"] | ["a", "964"] | ["a", "965"] | ["a", "966"] | ["a", "967"] | ["a", "968"] | ["a", "969"] | ["a", "970"] | ["a", "971"] | ["a", "972"] | ["a", "973"] | ["a", "974"] | ["a", "975"] | ["a", "976"] | ["a", "977"] | ["a", "978"] | ["a", "979"] | ["a", "980"] | ["a", "981"] | ["a", "982"] | ["a", "983"] | ["a", "984"] | ["a", "985"] | ["a", "986"] | ["a", "987"] | ["a", "988"] | ["a", "989"] | ["a", "990"] | ["a", "991"] | ["a", "992"] | ["a", "993"] | ["a", "994"] | ["a", "995"] | ["a", "996"] | ["a", "997"] | ["a", "998"] | ["a", "999"] + +type All = Wide<[], "a">; +>All : any + diff --git a/tsc/testdata/baselines/reference/compiler/instantiationDepthSharedCheckOrder(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/instantiationDepthSharedCheckOrder(checkorder=default).symbols new file mode 100644 index 0000000000000..f884f93457e7e --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/instantiationDepthSharedCheckOrder(checkorder=default).symbols @@ -0,0 +1,32 @@ +//// [tests/cases/compiler/instantiationDepthSharedCheckOrder.ts] //// + +=== instantiationDepthSharedCheckOrder.ts === +// Instantiating Deep<[]> fresh nests 100 instantiations of Deep, which is +// too deep. In program order each declaration finds the rest of the chain +// already instantiated by the one before it, so none of them nests more +// than 25. Whether DeepAll is too deep must not depend on which comes first. + +type Deep = N["length"] extends 100 ? never : Deep<[...N, 0]> | N["length"]; +>Deep : Symbol(Deep, Decl(instantiationDepthSharedCheckOrder.ts, 0, 0)) +>N : Symbol(N, Decl(instantiationDepthSharedCheckOrder.ts, 5, 10)) +>N : Symbol(N, Decl(instantiationDepthSharedCheckOrder.ts, 5, 10)) +>Deep : Symbol(Deep, Decl(instantiationDepthSharedCheckOrder.ts, 0, 0)) +>N : Symbol(N, Decl(instantiationDepthSharedCheckOrder.ts, 5, 10)) +>N : Symbol(N, Decl(instantiationDepthSharedCheckOrder.ts, 5, 10)) + +type Deep75 = Deep<[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]>; +>Deep75 : Symbol(Deep75, Decl(instantiationDepthSharedCheckOrder.ts, 5, 91)) +>Deep : Symbol(Deep, Decl(instantiationDepthSharedCheckOrder.ts, 0, 0)) + +type Deep50 = Deep<[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]>; +>Deep50 : Symbol(Deep50, Decl(instantiationDepthSharedCheckOrder.ts, 6, 246)) +>Deep : Symbol(Deep, Decl(instantiationDepthSharedCheckOrder.ts, 0, 0)) + +type Deep25 = Deep<[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]>; +>Deep25 : Symbol(Deep25, Decl(instantiationDepthSharedCheckOrder.ts, 7, 171)) +>Deep : Symbol(Deep, Decl(instantiationDepthSharedCheckOrder.ts, 0, 0)) + +type DeepAll = Deep<[]>; +>DeepAll : Symbol(DeepAll, Decl(instantiationDepthSharedCheckOrder.ts, 8, 96)) +>Deep : Symbol(Deep, Decl(instantiationDepthSharedCheckOrder.ts, 0, 0)) + diff --git a/tsc/testdata/baselines/reference/compiler/instantiationDepthSharedCheckOrder(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/instantiationDepthSharedCheckOrder(checkorder=default).types new file mode 100644 index 0000000000000..19ec88f95d195 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/instantiationDepthSharedCheckOrder(checkorder=default).types @@ -0,0 +1,23 @@ +//// [tests/cases/compiler/instantiationDepthSharedCheckOrder.ts] //// + +=== instantiationDepthSharedCheckOrder.ts === +// Instantiating Deep<[]> fresh nests 100 instantiations of Deep, which is +// too deep. In program order each declaration finds the rest of the chain +// already instantiated by the one before it, so none of them nests more +// than 25. Whether DeepAll is too deep must not depend on which comes first. + +type Deep = N["length"] extends 100 ? never : Deep<[...N, 0]> | N["length"]; +>Deep : Deep + +type Deep75 = Deep<[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]>; +>Deep75 : 75 | 76 | 77 | 78 | 79 | 80 | 81 | 82 | 83 | 84 | 85 | 86 | 87 | 88 | 89 | 90 | 91 | 92 | 93 | 94 | 95 | 96 | 97 | 98 | 99 + +type Deep50 = Deep<[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]>; +>Deep50 : 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | 75 | 76 | 77 | 78 | 79 | 80 | 81 | 82 | 83 | 84 | 85 | 86 | 87 | 88 | 89 | 90 | 91 | 92 | 93 | 94 | 95 | 96 | 97 | 98 | 99 + +type Deep25 = Deep<[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]>; +>Deep25 : 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | 75 | 76 | 77 | 78 | 79 | 80 | 81 | 82 | 83 | 84 | 85 | 86 | 87 | 88 | 89 | 90 | 91 | 92 | 93 | 94 | 95 | 96 | 97 | 98 | 99 + +type DeepAll = Deep<[]>; +>DeepAll : 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | 75 | 76 | 77 | 78 | 79 | 80 | 81 | 82 | 83 | 84 | 85 | 86 | 87 | 88 | 89 | 90 | 91 | 92 | 93 | 94 | 95 | 96 | 97 | 98 | 99 + diff --git a/tsc/testdata/baselines/reference/compiler/instantiationDepthSharedCheckOrder(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/instantiationDepthSharedCheckOrder(checkorder=typesfirst).errors.txt new file mode 100644 index 0000000000000..083ecdc701b69 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/instantiationDepthSharedCheckOrder(checkorder=typesfirst).errors.txt @@ -0,0 +1,16 @@ +error TS5114: Instantiations of type 'Deep' appear infinitely circular. + + +!!! error TS5114: Instantiations of type 'Deep' appear infinitely circular. +==== instantiationDepthSharedCheckOrder.ts (0 errors) ==== + // Instantiating Deep<[]> fresh nests 100 instantiations of Deep, which is + // too deep. In program order each declaration finds the rest of the chain + // already instantiated by the one before it, so none of them nests more + // than 25. Whether DeepAll is too deep must not depend on which comes first. + + type Deep = N["length"] extends 100 ? never : Deep<[...N, 0]> | N["length"]; + type Deep75 = Deep<[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]>; + type Deep50 = Deep<[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]>; + type Deep25 = Deep<[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]>; + type DeepAll = Deep<[]>; + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/instantiationDepthSharedCheckOrder(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/instantiationDepthSharedCheckOrder(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..f884f93457e7e --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/instantiationDepthSharedCheckOrder(checkorder=typesfirst).symbols @@ -0,0 +1,32 @@ +//// [tests/cases/compiler/instantiationDepthSharedCheckOrder.ts] //// + +=== instantiationDepthSharedCheckOrder.ts === +// Instantiating Deep<[]> fresh nests 100 instantiations of Deep, which is +// too deep. In program order each declaration finds the rest of the chain +// already instantiated by the one before it, so none of them nests more +// than 25. Whether DeepAll is too deep must not depend on which comes first. + +type Deep = N["length"] extends 100 ? never : Deep<[...N, 0]> | N["length"]; +>Deep : Symbol(Deep, Decl(instantiationDepthSharedCheckOrder.ts, 0, 0)) +>N : Symbol(N, Decl(instantiationDepthSharedCheckOrder.ts, 5, 10)) +>N : Symbol(N, Decl(instantiationDepthSharedCheckOrder.ts, 5, 10)) +>Deep : Symbol(Deep, Decl(instantiationDepthSharedCheckOrder.ts, 0, 0)) +>N : Symbol(N, Decl(instantiationDepthSharedCheckOrder.ts, 5, 10)) +>N : Symbol(N, Decl(instantiationDepthSharedCheckOrder.ts, 5, 10)) + +type Deep75 = Deep<[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]>; +>Deep75 : Symbol(Deep75, Decl(instantiationDepthSharedCheckOrder.ts, 5, 91)) +>Deep : Symbol(Deep, Decl(instantiationDepthSharedCheckOrder.ts, 0, 0)) + +type Deep50 = Deep<[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]>; +>Deep50 : Symbol(Deep50, Decl(instantiationDepthSharedCheckOrder.ts, 6, 246)) +>Deep : Symbol(Deep, Decl(instantiationDepthSharedCheckOrder.ts, 0, 0)) + +type Deep25 = Deep<[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]>; +>Deep25 : Symbol(Deep25, Decl(instantiationDepthSharedCheckOrder.ts, 7, 171)) +>Deep : Symbol(Deep, Decl(instantiationDepthSharedCheckOrder.ts, 0, 0)) + +type DeepAll = Deep<[]>; +>DeepAll : Symbol(DeepAll, Decl(instantiationDepthSharedCheckOrder.ts, 8, 96)) +>Deep : Symbol(Deep, Decl(instantiationDepthSharedCheckOrder.ts, 0, 0)) + diff --git a/tsc/testdata/baselines/reference/compiler/instantiationDepthSharedCheckOrder(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/instantiationDepthSharedCheckOrder(checkorder=typesfirst).types new file mode 100644 index 0000000000000..9edac22f5cd4e --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/instantiationDepthSharedCheckOrder(checkorder=typesfirst).types @@ -0,0 +1,23 @@ +//// [tests/cases/compiler/instantiationDepthSharedCheckOrder.ts] //// + +=== instantiationDepthSharedCheckOrder.ts === +// Instantiating Deep<[]> fresh nests 100 instantiations of Deep, which is +// too deep. In program order each declaration finds the rest of the chain +// already instantiated by the one before it, so none of them nests more +// than 25. Whether DeepAll is too deep must not depend on which comes first. + +type Deep = N["length"] extends 100 ? never : Deep<[...N, 0]> | N["length"]; +>Deep : Deep + +type Deep75 = Deep<[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]>; +>Deep75 : any + +type Deep50 = Deep<[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]>; +>Deep50 : any + +type Deep25 = Deep<[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]>; +>Deep25 : any + +type DeepAll = Deep<[]>; +>DeepAll : any + diff --git a/tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintCycleCheckOrder(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintCycleCheckOrder(checkorder=default).errors.txt new file mode 100644 index 0000000000000..a674eea18c3f4 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintCycleCheckOrder(checkorder=default).errors.txt @@ -0,0 +1,32 @@ +instantiationExpressionConstraintCycleCheckOrder.ts(17,41): error TS2344: Type 'A' does not satisfy the constraint 'A'. + Type 'T' is not assignable to type 'number'. + + +==== instantiationExpressionConstraintCycleCheckOrder.ts (1 errors) ==== + // Checking the type arguments of the instantiation expressions against their + // constraints needs the variances of A, which need the type of child. The + // constraint errors and the types of child must not depend on whether child + // is queried before A is checked. + + namespace InterfaceCycle { + declare function b(): U; + interface A { + value: T; + child: typeof b>; + } + } + + namespace ClassCycle { + class A { + value!: T; + child!: InstanceType>>; + ~~~~ +!!! error TS2344: Type 'A' does not satisfy the constraint 'A'. +!!! error TS2344: Type 'T' is not assignable to type 'number'. +!!! related TS2208 instantiationExpressionConstraintCycleCheckOrder.ts:15:13: This type parameter might need an `extends number` constraint. + static B = class B { + parent!: T; + }; + } + } + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintCycleCheckOrder(checkorder=default).js b/tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintCycleCheckOrder(checkorder=default).js new file mode 100644 index 0000000000000..4f198380085a7 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintCycleCheckOrder(checkorder=default).js @@ -0,0 +1,46 @@ +//// [tests/cases/compiler/instantiationExpressionConstraintCycleCheckOrder.ts] //// + +//// [instantiationExpressionConstraintCycleCheckOrder.ts] +// Checking the type arguments of the instantiation expressions against their +// constraints needs the variances of A, which need the type of child. The +// constraint errors and the types of child must not depend on whether child +// is queried before A is checked. + +namespace InterfaceCycle { + declare function b(): U; + interface A { + value: T; + child: typeof b>; + } +} + +namespace ClassCycle { + class A { + value!: T; + child!: InstanceType>>; + static B = class B { + parent!: T; + }; + } +} + + +//// [instantiationExpressionConstraintCycleCheckOrder.js] +"use strict"; +// Checking the type arguments of the instantiation expressions against their +// constraints needs the variances of A, which need the type of child. The +// constraint errors and the types of child must not depend on whether child +// is queried before A is checked. +var InterfaceCycle; +(function (InterfaceCycle) { +})(InterfaceCycle || (InterfaceCycle = {})); +var ClassCycle; +(function (ClassCycle) { + class A { + value; + child; + static B = class B { + parent; + }; + } +})(ClassCycle || (ClassCycle = {})); diff --git a/tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintCycleCheckOrder(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintCycleCheckOrder(checkorder=default).symbols new file mode 100644 index 0000000000000..8651ce4a98d10 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintCycleCheckOrder(checkorder=default).symbols @@ -0,0 +1,68 @@ +//// [tests/cases/compiler/instantiationExpressionConstraintCycleCheckOrder.ts] //// + +=== instantiationExpressionConstraintCycleCheckOrder.ts === +// Checking the type arguments of the instantiation expressions against their +// constraints needs the variances of A, which need the type of child. The +// constraint errors and the types of child must not depend on whether child +// is queried before A is checked. + +namespace InterfaceCycle { +>InterfaceCycle : Symbol(InterfaceCycle, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 0, 0)) + + declare function b(): U; +>b : Symbol(b, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 5, 26)) +>U : Symbol(U, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 6, 23)) +>A : Symbol(A, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 6, 45)) +>A : Symbol(A, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 6, 45)) +>U : Symbol(U, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 6, 23)) + + interface A { +>A : Symbol(A, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 6, 45)) +>T : Symbol(T, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 7, 16)) + + value: T; +>value : Symbol(A.value, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 7, 29)) +>T : Symbol(T, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 7, 16)) + + child: typeof b>; +>child : Symbol(A.child, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 8, 17)) +>b : Symbol(b, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 5, 26)) +>A : Symbol(A, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 6, 45)) +>T : Symbol(T, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 7, 16)) + } +} + +namespace ClassCycle { +>ClassCycle : Symbol(ClassCycle, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 11, 1)) + + class A { +>A : Symbol(A, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 13, 22)) +>T : Symbol(T, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 14, 12)) + + value!: T; +>value : Symbol(A.value, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 14, 25)) +>T : Symbol(T, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 14, 12)) + + child!: InstanceType>>; +>child : Symbol(A.child, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 15, 18)) +>InstanceType : Symbol(InstanceType, Decl(lib.es5.d.ts, --, --)) +>A.B : Symbol(A.B, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 16, 47)) +>A : Symbol(A, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 13, 22)) +>B : Symbol(A.B, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 16, 47)) +>A : Symbol(A, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 13, 22)) +>T : Symbol(T, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 14, 12)) + + static B = class B { +>B : Symbol(A.B, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 16, 47)) +>B : Symbol(B, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 17, 18)) +>T : Symbol(T, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 17, 27)) +>A : Symbol(A, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 13, 22)) + + parent!: T; +>parent : Symbol(B.parent, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 17, 41)) +>T : Symbol(T, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 17, 27)) + + }; + } +} + diff --git a/tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintCycleCheckOrder(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintCycleCheckOrder(checkorder=default).types new file mode 100644 index 0000000000000..21ae95de09035 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintCycleCheckOrder(checkorder=default).types @@ -0,0 +1,51 @@ +//// [tests/cases/compiler/instantiationExpressionConstraintCycleCheckOrder.ts] //// + +=== instantiationExpressionConstraintCycleCheckOrder.ts === +// Checking the type arguments of the instantiation expressions against their +// constraints needs the variances of A, which need the type of child. The +// constraint errors and the types of child must not depend on whether child +// is queried before A is checked. + +namespace InterfaceCycle { +>InterfaceCycle : typeof InterfaceCycle + + declare function b(): U; +>b : >() => U + + interface A { + value: T; +>value : T + + child: typeof b>; +>child : typeof b> +>b : >() => U + } +} + +namespace ClassCycle { +>ClassCycle : typeof ClassCycle + + class A { +>A : A + + value!: T; +>value : T + + child!: InstanceType>>; +>child : B> +>A.B : typeof B +>A : typeof A +>B : typeof B + + static B = class B { +>B : typeof B +>class B { parent!: T; } : typeof B +>B : typeof B + + parent!: T; +>parent : T + + }; + } +} + diff --git a/tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintCycleCheckOrder(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintCycleCheckOrder(checkorder=typesfirst).errors.txt new file mode 100644 index 0000000000000..34b433cab41d3 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintCycleCheckOrder(checkorder=typesfirst).errors.txt @@ -0,0 +1,38 @@ +instantiationExpressionConstraintCycleCheckOrder.ts(10,25): error TS2344: Type 'A' does not satisfy the constraint 'A'. + Type 'T' is not assignable to type 'number'. +instantiationExpressionConstraintCycleCheckOrder.ts(17,41): error TS2344: Type 'A' does not satisfy the constraint 'A'. + Type 'T' is not assignable to type 'number'. + + +==== instantiationExpressionConstraintCycleCheckOrder.ts (2 errors) ==== + // Checking the type arguments of the instantiation expressions against their + // constraints needs the variances of A, which need the type of child. The + // constraint errors and the types of child must not depend on whether child + // is queried before A is checked. + + namespace InterfaceCycle { + declare function b(): U; + interface A { + value: T; + child: typeof b>; + ~~~~ +!!! error TS2344: Type 'A' does not satisfy the constraint 'A'. +!!! error TS2344: Type 'T' is not assignable to type 'number'. +!!! related TS2208 instantiationExpressionConstraintCycleCheckOrder.ts:8:17: This type parameter might need an `extends number` constraint. + } + } + + namespace ClassCycle { + class A { + value!: T; + child!: InstanceType>>; + ~~~~ +!!! error TS2344: Type 'A' does not satisfy the constraint 'A'. +!!! error TS2344: Type 'T' is not assignable to type 'number'. +!!! related TS2208 instantiationExpressionConstraintCycleCheckOrder.ts:15:13: This type parameter might need an `extends number` constraint. + static B = class B { + parent!: T; + }; + } + } + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintCycleCheckOrder(checkorder=typesfirst).js b/tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintCycleCheckOrder(checkorder=typesfirst).js new file mode 100644 index 0000000000000..4f198380085a7 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintCycleCheckOrder(checkorder=typesfirst).js @@ -0,0 +1,46 @@ +//// [tests/cases/compiler/instantiationExpressionConstraintCycleCheckOrder.ts] //// + +//// [instantiationExpressionConstraintCycleCheckOrder.ts] +// Checking the type arguments of the instantiation expressions against their +// constraints needs the variances of A, which need the type of child. The +// constraint errors and the types of child must not depend on whether child +// is queried before A is checked. + +namespace InterfaceCycle { + declare function b(): U; + interface A { + value: T; + child: typeof b>; + } +} + +namespace ClassCycle { + class A { + value!: T; + child!: InstanceType>>; + static B = class B { + parent!: T; + }; + } +} + + +//// [instantiationExpressionConstraintCycleCheckOrder.js] +"use strict"; +// Checking the type arguments of the instantiation expressions against their +// constraints needs the variances of A, which need the type of child. The +// constraint errors and the types of child must not depend on whether child +// is queried before A is checked. +var InterfaceCycle; +(function (InterfaceCycle) { +})(InterfaceCycle || (InterfaceCycle = {})); +var ClassCycle; +(function (ClassCycle) { + class A { + value; + child; + static B = class B { + parent; + }; + } +})(ClassCycle || (ClassCycle = {})); diff --git a/tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintCycleCheckOrder(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintCycleCheckOrder(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..8651ce4a98d10 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintCycleCheckOrder(checkorder=typesfirst).symbols @@ -0,0 +1,68 @@ +//// [tests/cases/compiler/instantiationExpressionConstraintCycleCheckOrder.ts] //// + +=== instantiationExpressionConstraintCycleCheckOrder.ts === +// Checking the type arguments of the instantiation expressions against their +// constraints needs the variances of A, which need the type of child. The +// constraint errors and the types of child must not depend on whether child +// is queried before A is checked. + +namespace InterfaceCycle { +>InterfaceCycle : Symbol(InterfaceCycle, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 0, 0)) + + declare function b(): U; +>b : Symbol(b, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 5, 26)) +>U : Symbol(U, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 6, 23)) +>A : Symbol(A, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 6, 45)) +>A : Symbol(A, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 6, 45)) +>U : Symbol(U, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 6, 23)) + + interface A { +>A : Symbol(A, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 6, 45)) +>T : Symbol(T, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 7, 16)) + + value: T; +>value : Symbol(A.value, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 7, 29)) +>T : Symbol(T, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 7, 16)) + + child: typeof b>; +>child : Symbol(A.child, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 8, 17)) +>b : Symbol(b, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 5, 26)) +>A : Symbol(A, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 6, 45)) +>T : Symbol(T, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 7, 16)) + } +} + +namespace ClassCycle { +>ClassCycle : Symbol(ClassCycle, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 11, 1)) + + class A { +>A : Symbol(A, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 13, 22)) +>T : Symbol(T, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 14, 12)) + + value!: T; +>value : Symbol(A.value, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 14, 25)) +>T : Symbol(T, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 14, 12)) + + child!: InstanceType>>; +>child : Symbol(A.child, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 15, 18)) +>InstanceType : Symbol(InstanceType, Decl(lib.es5.d.ts, --, --)) +>A.B : Symbol(A.B, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 16, 47)) +>A : Symbol(A, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 13, 22)) +>B : Symbol(A.B, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 16, 47)) +>A : Symbol(A, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 13, 22)) +>T : Symbol(T, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 14, 12)) + + static B = class B { +>B : Symbol(A.B, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 16, 47)) +>B : Symbol(B, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 17, 18)) +>T : Symbol(T, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 17, 27)) +>A : Symbol(A, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 13, 22)) + + parent!: T; +>parent : Symbol(B.parent, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 17, 41)) +>T : Symbol(T, Decl(instantiationExpressionConstraintCycleCheckOrder.ts, 17, 27)) + + }; + } +} + diff --git a/tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintCycleCheckOrder(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintCycleCheckOrder(checkorder=typesfirst).types new file mode 100644 index 0000000000000..4b7e7e4ea94e9 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintCycleCheckOrder(checkorder=typesfirst).types @@ -0,0 +1,51 @@ +//// [tests/cases/compiler/instantiationExpressionConstraintCycleCheckOrder.ts] //// + +=== instantiationExpressionConstraintCycleCheckOrder.ts === +// Checking the type arguments of the instantiation expressions against their +// constraints needs the variances of A, which need the type of child. The +// constraint errors and the types of child must not depend on whether child +// is queried before A is checked. + +namespace InterfaceCycle { +>InterfaceCycle : typeof InterfaceCycle + + declare function b(): U; +>b : >() => U + + interface A { + value: T; +>value : T + + child: typeof b>; +>child : () => A +>b : >() => U + } +} + +namespace ClassCycle { +>ClassCycle : typeof ClassCycle + + class A { +>A : A + + value!: T; +>value : T + + child!: InstanceType>>; +>child : B> +>A.B : typeof B +>A : typeof A +>B : typeof B + + static B = class B { +>B : typeof B +>class B { parent!: T; } : typeof B +>B : typeof B + + parent!: T; +>parent : T + + }; + } +} + diff --git a/tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintInStaticClassExpression.symbols b/tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintInStaticClassExpression.symbols new file mode 100644 index 0000000000000..e7a7218e1a855 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintInStaticClassExpression.symbols @@ -0,0 +1,37 @@ +//// [tests/cases/compiler/instantiationExpressionConstraintInStaticClassExpression.ts] //// + +=== instantiationExpressionConstraintInStaticClassExpression.ts === +// A does not satisfy the constraint A of B, as T is not assignable to +// number, which must be reported. + +class A { +>A : Symbol(A, Decl(instantiationExpressionConstraintInStaticClassExpression.ts, 0, 0)) +>T : Symbol(T, Decl(instantiationExpressionConstraintInStaticClassExpression.ts, 3, 8)) + + value!: T; +>value : Symbol(A.value, Decl(instantiationExpressionConstraintInStaticClassExpression.ts, 3, 21)) +>T : Symbol(T, Decl(instantiationExpressionConstraintInStaticClassExpression.ts, 3, 8)) + + child!: InstanceType>>; // this should error +>child : Symbol(A.child, Decl(instantiationExpressionConstraintInStaticClassExpression.ts, 4, 12)) +>InstanceType : Symbol(InstanceType, Decl(lib.es5.d.ts, --, --)) +>A.B : Symbol(A.B, Decl(instantiationExpressionConstraintInStaticClassExpression.ts, 5, 41)) +>A : Symbol(A, Decl(instantiationExpressionConstraintInStaticClassExpression.ts, 0, 0)) +>B : Symbol(A.B, Decl(instantiationExpressionConstraintInStaticClassExpression.ts, 5, 41)) +>A : Symbol(A, Decl(instantiationExpressionConstraintInStaticClassExpression.ts, 0, 0)) +>T : Symbol(T, Decl(instantiationExpressionConstraintInStaticClassExpression.ts, 3, 8)) + + static B = class B { +>B : Symbol(A.B, Decl(instantiationExpressionConstraintInStaticClassExpression.ts, 5, 41)) +>B : Symbol(B, Decl(instantiationExpressionConstraintInStaticClassExpression.ts, 7, 12)) +>T : Symbol(T, Decl(instantiationExpressionConstraintInStaticClassExpression.ts, 7, 21)) +>A : Symbol(A, Decl(instantiationExpressionConstraintInStaticClassExpression.ts, 0, 0)) +>A : Symbol(A, Decl(instantiationExpressionConstraintInStaticClassExpression.ts, 0, 0)) + + parent!: T; +>parent : Symbol(B.parent, Decl(instantiationExpressionConstraintInStaticClassExpression.ts, 7, 39)) +>T : Symbol(T, Decl(instantiationExpressionConstraintInStaticClassExpression.ts, 7, 21)) + + }; +} + diff --git a/tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintInStaticClassExpression.types b/tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintInStaticClassExpression.types new file mode 100644 index 0000000000000..4f1d247f40a86 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/instantiationExpressionConstraintInStaticClassExpression.types @@ -0,0 +1,29 @@ +//// [tests/cases/compiler/instantiationExpressionConstraintInStaticClassExpression.ts] //// + +=== instantiationExpressionConstraintInStaticClassExpression.ts === +// A does not satisfy the constraint A of B, as T is not assignable to +// number, which must be reported. + +class A { +>A : A + + value!: T; +>value : T + + child!: InstanceType>>; // this should error +>child : B> +>A.B : typeof B +>A : typeof A +>B : typeof B + + static B = class B { +>B : typeof B +>class B { parent!: T; } : typeof B +>B : typeof B + + parent!: T; +>parent : T + + }; +} + diff --git a/tsc/testdata/baselines/reference/compiler/instantiationLimitsCheckOrder.errors.txt b/tsc/testdata/baselines/reference/compiler/instantiationLimitsCheckOrder.errors.txt new file mode 100644 index 0000000000000..69dd6c2b622df --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/instantiationLimitsCheckOrder.errors.txt @@ -0,0 +1,24 @@ +instantiationLimitsCheckOrder.ts(11,16): error TS2589: Type instantiation is excessively deep and possibly infinite. + + +==== instantiationLimitsCheckOrder.ts (1 errors) ==== + // The depth limit on instantiations must not depend on what was + // instantiated before. The limit on the number of instantiations does, as + // it only stops runaway instantiations, so it is only tested for a single + // statement whose work nothing else shares. + + type D = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9; + type K = `${D}${D}${D}`; + + // Several million instantiations, well over the limit, for one statement. + type Wide = N["length"] extends 8 ? I : { [J in K]: Wide<[...N, 0], [J, I][0]> }[K]; + type WideAll = Wide<[], "">; + ~~~~~~~~~~~~ +!!! error TS2589: Type instantiation is excessively deep and possibly infinite. + + // Over a hundred nested instantiations, half of which already happened for + // another statement. + type Deep = N["length"] extends 60 ? never : Deep<[...N, 0]> | N["length"]; + type DeepTail = Deep<[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]>; + type DeepAll = Deep<[]>; + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/instantiationLimitsCheckOrder.symbols b/tsc/testdata/baselines/reference/compiler/instantiationLimitsCheckOrder.symbols new file mode 100644 index 0000000000000..c49f0e567e06e --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/instantiationLimitsCheckOrder.symbols @@ -0,0 +1,54 @@ +//// [tests/cases/compiler/instantiationLimitsCheckOrder.ts] //// + +=== instantiationLimitsCheckOrder.ts === +// The depth limit on instantiations must not depend on what was +// instantiated before. The limit on the number of instantiations does, as +// it only stops runaway instantiations, so it is only tested for a single +// statement whose work nothing else shares. + +type D = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9; +>D : Symbol(D, Decl(instantiationLimitsCheckOrder.ts, 0, 0)) + +type K = `${D}${D}${D}`; +>K : Symbol(K, Decl(instantiationLimitsCheckOrder.ts, 5, 47)) +>D : Symbol(D, Decl(instantiationLimitsCheckOrder.ts, 0, 0)) +>D : Symbol(D, Decl(instantiationLimitsCheckOrder.ts, 0, 0)) +>D : Symbol(D, Decl(instantiationLimitsCheckOrder.ts, 0, 0)) + +// Several million instantiations, well over the limit, for one statement. +type Wide = N["length"] extends 8 ? I : { [J in K]: Wide<[...N, 0], [J, I][0]> }[K]; +>Wide : Symbol(Wide, Decl(instantiationLimitsCheckOrder.ts, 6, 24)) +>N : Symbol(N, Decl(instantiationLimitsCheckOrder.ts, 9, 10)) +>I : Symbol(I, Decl(instantiationLimitsCheckOrder.ts, 9, 24)) +>N : Symbol(N, Decl(instantiationLimitsCheckOrder.ts, 9, 10)) +>I : Symbol(I, Decl(instantiationLimitsCheckOrder.ts, 9, 24)) +>J : Symbol(J, Decl(instantiationLimitsCheckOrder.ts, 9, 61)) +>K : Symbol(K, Decl(instantiationLimitsCheckOrder.ts, 5, 47)) +>Wide : Symbol(Wide, Decl(instantiationLimitsCheckOrder.ts, 6, 24)) +>N : Symbol(N, Decl(instantiationLimitsCheckOrder.ts, 9, 10)) +>J : Symbol(J, Decl(instantiationLimitsCheckOrder.ts, 9, 61)) +>I : Symbol(I, Decl(instantiationLimitsCheckOrder.ts, 9, 24)) +>K : Symbol(K, Decl(instantiationLimitsCheckOrder.ts, 5, 47)) + +type WideAll = Wide<[], "">; +>WideAll : Symbol(WideAll, Decl(instantiationLimitsCheckOrder.ts, 9, 102)) +>Wide : Symbol(Wide, Decl(instantiationLimitsCheckOrder.ts, 6, 24)) + +// Over a hundred nested instantiations, half of which already happened for +// another statement. +type Deep = N["length"] extends 60 ? never : Deep<[...N, 0]> | N["length"]; +>Deep : Symbol(Deep, Decl(instantiationLimitsCheckOrder.ts, 10, 28)) +>N : Symbol(N, Decl(instantiationLimitsCheckOrder.ts, 14, 10)) +>N : Symbol(N, Decl(instantiationLimitsCheckOrder.ts, 14, 10)) +>Deep : Symbol(Deep, Decl(instantiationLimitsCheckOrder.ts, 10, 28)) +>N : Symbol(N, Decl(instantiationLimitsCheckOrder.ts, 14, 10)) +>N : Symbol(N, Decl(instantiationLimitsCheckOrder.ts, 14, 10)) + +type DeepTail = Deep<[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]>; +>DeepTail : Symbol(DeepTail, Decl(instantiationLimitsCheckOrder.ts, 14, 90)) +>Deep : Symbol(Deep, Decl(instantiationLimitsCheckOrder.ts, 10, 28)) + +type DeepAll = Deep<[]>; +>DeepAll : Symbol(DeepAll, Decl(instantiationLimitsCheckOrder.ts, 15, 113)) +>Deep : Symbol(Deep, Decl(instantiationLimitsCheckOrder.ts, 10, 28)) + diff --git a/tsc/testdata/baselines/reference/compiler/instantiationLimitsCheckOrder.types b/tsc/testdata/baselines/reference/compiler/instantiationLimitsCheckOrder.types new file mode 100644 index 0000000000000..5227b6c530923 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/instantiationLimitsCheckOrder.types @@ -0,0 +1,32 @@ +//// [tests/cases/compiler/instantiationLimitsCheckOrder.ts] //// + +=== instantiationLimitsCheckOrder.ts === +// The depth limit on instantiations must not depend on what was +// instantiated before. The limit on the number of instantiations does, as +// it only stops runaway instantiations, so it is only tested for a single +// statement whose work nothing else shares. + +type D = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9; +>D : D + +type K = `${D}${D}${D}`; +>K : "000" | "001" | "002" | "003" | "004" | "005" | "006" | "007" | "008" | "009" | "010" | "011" | "012" | "013" | "014" | "015" | "016" | "017" | "018" | "019" | "020" | "021" | "022" | "023" | "024" | "025" | "026" | "027" | "028" | "029" | "030" | "031" | "032" | "033" | "034" | "035" | "036" | "037" | "038" | "039" | "040" | "041" | "042" | "043" | "044" | "045" | "046" | "047" | "048" | "049" | "050" | "051" | "052" | "053" | "054" | "055" | "056" | "057" | "058" | "059" | "060" | "061" | "062" | "063" | "064" | "065" | "066" | "067" | "068" | "069" | "070" | "071" | "072" | "073" | "074" | "075" | "076" | "077" | "078" | "079" | "080" | "081" | "082" | "083" | "084" | "085" | "086" | "087" | "088" | "089" | "090" | "091" | "092" | "093" | "094" | "095" | "096" | "097" | "098" | "099" | "100" | "101" | "102" | "103" | "104" | "105" | "106" | "107" | "108" | "109" | "110" | "111" | "112" | "113" | "114" | "115" | "116" | "117" | "118" | "119" | "120" | "121" | "122" | "123" | "124" | "125" | "126" | "127" | "128" | "129" | "130" | "131" | "132" | "133" | "134" | "135" | "136" | "137" | "138" | "139" | "140" | "141" | "142" | "143" | "144" | "145" | "146" | "147" | "148" | "149" | "150" | "151" | "152" | "153" | "154" | "155" | "156" | "157" | "158" | "159" | "160" | "161" | "162" | "163" | "164" | "165" | "166" | "167" | "168" | "169" | "170" | "171" | "172" | "173" | "174" | "175" | "176" | "177" | "178" | "179" | "180" | "181" | "182" | "183" | "184" | "185" | "186" | "187" | "188" | "189" | "190" | "191" | "192" | "193" | "194" | "195" | "196" | "197" | "198" | "199" | "200" | "201" | "202" | "203" | "204" | "205" | "206" | "207" | "208" | "209" | "210" | "211" | "212" | "213" | "214" | "215" | "216" | "217" | "218" | "219" | "220" | "221" | "222" | "223" | "224" | "225" | "226" | "227" | "228" | "229" | "230" | "231" | "232" | "233" | "234" | "235" | "236" | "237" | "238" | "239" | "240" | "241" | "242" | "243" | "244" | "245" | "246" | "247" | "248" | "249" | "250" | "251" | "252" | "253" | "254" | "255" | "256" | "257" | "258" | "259" | "260" | "261" | "262" | "263" | "264" | "265" | "266" | "267" | "268" | "269" | "270" | "271" | "272" | "273" | "274" | "275" | "276" | "277" | "278" | "279" | "280" | "281" | "282" | "283" | "284" | "285" | "286" | "287" | "288" | "289" | "290" | "291" | "292" | "293" | "294" | "295" | "296" | "297" | "298" | "299" | "300" | "301" | "302" | "303" | "304" | "305" | "306" | "307" | "308" | "309" | "310" | "311" | "312" | "313" | "314" | "315" | "316" | "317" | "318" | "319" | "320" | "321" | "322" | "323" | "324" | "325" | "326" | "327" | "328" | "329" | "330" | "331" | "332" | "333" | "334" | "335" | "336" | "337" | "338" | "339" | "340" | "341" | "342" | "343" | "344" | "345" | "346" | "347" | "348" | "349" | "350" | "351" | "352" | "353" | "354" | "355" | "356" | "357" | "358" | "359" | "360" | "361" | "362" | "363" | "364" | "365" | "366" | "367" | "368" | "369" | "370" | "371" | "372" | "373" | "374" | "375" | "376" | "377" | "378" | "379" | "380" | "381" | "382" | "383" | "384" | "385" | "386" | "387" | "388" | "389" | "390" | "391" | "392" | "393" | "394" | "395" | "396" | "397" | "398" | "399" | "400" | "401" | "402" | "403" | "404" | "405" | "406" | "407" | "408" | "409" | "410" | "411" | "412" | "413" | "414" | "415" | "416" | "417" | "418" | "419" | "420" | "421" | "422" | "423" | "424" | "425" | "426" | "427" | "428" | "429" | "430" | "431" | "432" | "433" | "434" | "435" | "436" | "437" | "438" | "439" | "440" | "441" | "442" | "443" | "444" | "445" | "446" | "447" | "448" | "449" | "450" | "451" | "452" | "453" | "454" | "455" | "456" | "457" | "458" | "459" | "460" | "461" | "462" | "463" | "464" | "465" | "466" | "467" | "468" | "469" | "470" | "471" | "472" | "473" | "474" | "475" | "476" | "477" | "478" | "479" | "480" | "481" | "482" | "483" | "484" | "485" | "486" | "487" | "488" | "489" | "490" | "491" | "492" | "493" | "494" | "495" | "496" | "497" | "498" | "499" | "500" | "501" | "502" | "503" | "504" | "505" | "506" | "507" | "508" | "509" | "510" | "511" | "512" | "513" | "514" | "515" | "516" | "517" | "518" | "519" | "520" | "521" | "522" | "523" | "524" | "525" | "526" | "527" | "528" | "529" | "530" | "531" | "532" | "533" | "534" | "535" | "536" | "537" | "538" | "539" | "540" | "541" | "542" | "543" | "544" | "545" | "546" | "547" | "548" | "549" | "550" | "551" | "552" | "553" | "554" | "555" | "556" | "557" | "558" | "559" | "560" | "561" | "562" | "563" | "564" | "565" | "566" | "567" | "568" | "569" | "570" | "571" | "572" | "573" | "574" | "575" | "576" | "577" | "578" | "579" | "580" | "581" | "582" | "583" | "584" | "585" | "586" | "587" | "588" | "589" | "590" | "591" | "592" | "593" | "594" | "595" | "596" | "597" | "598" | "599" | "600" | "601" | "602" | "603" | "604" | "605" | "606" | "607" | "608" | "609" | "610" | "611" | "612" | "613" | "614" | "615" | "616" | "617" | "618" | "619" | "620" | "621" | "622" | "623" | "624" | "625" | "626" | "627" | "628" | "629" | "630" | "631" | "632" | "633" | "634" | "635" | "636" | "637" | "638" | "639" | "640" | "641" | "642" | "643" | "644" | "645" | "646" | "647" | "648" | "649" | "650" | "651" | "652" | "653" | "654" | "655" | "656" | "657" | "658" | "659" | "660" | "661" | "662" | "663" | "664" | "665" | "666" | "667" | "668" | "669" | "670" | "671" | "672" | "673" | "674" | "675" | "676" | "677" | "678" | "679" | "680" | "681" | "682" | "683" | "684" | "685" | "686" | "687" | "688" | "689" | "690" | "691" | "692" | "693" | "694" | "695" | "696" | "697" | "698" | "699" | "700" | "701" | "702" | "703" | "704" | "705" | "706" | "707" | "708" | "709" | "710" | "711" | "712" | "713" | "714" | "715" | "716" | "717" | "718" | "719" | "720" | "721" | "722" | "723" | "724" | "725" | "726" | "727" | "728" | "729" | "730" | "731" | "732" | "733" | "734" | "735" | "736" | "737" | "738" | "739" | "740" | "741" | "742" | "743" | "744" | "745" | "746" | "747" | "748" | "749" | "750" | "751" | "752" | "753" | "754" | "755" | "756" | "757" | "758" | "759" | "760" | "761" | "762" | "763" | "764" | "765" | "766" | "767" | "768" | "769" | "770" | "771" | "772" | "773" | "774" | "775" | "776" | "777" | "778" | "779" | "780" | "781" | "782" | "783" | "784" | "785" | "786" | "787" | "788" | "789" | "790" | "791" | "792" | "793" | "794" | "795" | "796" | "797" | "798" | "799" | "800" | "801" | "802" | "803" | "804" | "805" | "806" | "807" | "808" | "809" | "810" | "811" | "812" | "813" | "814" | "815" | "816" | "817" | "818" | "819" | "820" | "821" | "822" | "823" | "824" | "825" | "826" | "827" | "828" | "829" | "830" | "831" | "832" | "833" | "834" | "835" | "836" | "837" | "838" | "839" | "840" | "841" | "842" | "843" | "844" | "845" | "846" | "847" | "848" | "849" | "850" | "851" | "852" | "853" | "854" | "855" | "856" | "857" | "858" | "859" | "860" | "861" | "862" | "863" | "864" | "865" | "866" | "867" | "868" | "869" | "870" | "871" | "872" | "873" | "874" | "875" | "876" | "877" | "878" | "879" | "880" | "881" | "882" | "883" | "884" | "885" | "886" | "887" | "888" | "889" | "890" | "891" | "892" | "893" | "894" | "895" | "896" | "897" | "898" | "899" | "900" | "901" | "902" | "903" | "904" | "905" | "906" | "907" | "908" | "909" | "910" | "911" | "912" | "913" | "914" | "915" | "916" | "917" | "918" | "919" | "920" | "921" | "922" | "923" | "924" | "925" | "926" | "927" | "928" | "929" | "930" | "931" | "932" | "933" | "934" | "935" | "936" | "937" | "938" | "939" | "940" | "941" | "942" | "943" | "944" | "945" | "946" | "947" | "948" | "949" | "950" | "951" | "952" | "953" | "954" | "955" | "956" | "957" | "958" | "959" | "960" | "961" | "962" | "963" | "964" | "965" | "966" | "967" | "968" | "969" | "970" | "971" | "972" | "973" | "974" | "975" | "976" | "977" | "978" | "979" | "980" | "981" | "982" | "983" | "984" | "985" | "986" | "987" | "988" | "989" | "990" | "991" | "992" | "993" | "994" | "995" | "996" | "997" | "998" | "999" + +// Several million instantiations, well over the limit, for one statement. +type Wide = N["length"] extends 8 ? I : { [J in K]: Wide<[...N, 0], [J, I][0]> }[K]; +>Wide : Wide + +type WideAll = Wide<[], "">; +>WideAll : any + +// Over a hundred nested instantiations, half of which already happened for +// another statement. +type Deep = N["length"] extends 60 ? never : Deep<[...N, 0]> | N["length"]; +>Deep : Deep + +type DeepTail = Deep<[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]>; +>DeepTail : 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 + +type DeepAll = Deep<[]>; +>DeepAll : 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 + diff --git a/tsc/testdata/baselines/reference/compiler/instantiationStackLimitCheckOrder(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/instantiationStackLimitCheckOrder(checkorder=default).errors.txt new file mode 100644 index 0000000000000..cda46ad3a724f --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/instantiationStackLimitCheckOrder(checkorder=default).errors.txt @@ -0,0 +1,24 @@ +instantiationStackLimitCheckOrder.ts(6,48): error TS5114: Instantiations of type 'F' appear infinitely circular. +instantiationStackLimitCheckOrder.ts(14,11): error TS5114: Instantiations of type 'FlatArray' appear infinitely circular. + + +==== instantiationStackLimitCheckOrder.ts (2 errors) ==== + // F<[]> recurses forever, so instantiating it reaches the limit on the + // instantiation stack, wherever it is first instantiated. The instantiations + // in progress then fail as a whole, and none of them may be cached partly + // built for the other declaration to reuse. + + type F = T extends [unknown?, ...infer R] ? [0, ...F] : []; + ~~~~~~~~~~~~ +!!! error TS5114: Instantiations of type 'F' appear infinitely circular. + type X = F<[]>; + + // The element type of A[] is resolved whenever first needed, inside the + // instantiation of the return type of flat or not. Reaching the limit while + // flattening it must fail the same instantiations either way. + + type A = A[]; + const r = ([] as A).flat(Infinity); + ~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS5114: Instantiations of type 'FlatArray' appear infinitely circular. + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/instantiationStackLimitCheckOrder(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/instantiationStackLimitCheckOrder(checkorder=default).symbols new file mode 100644 index 0000000000000..97100f75a4cf2 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/instantiationStackLimitCheckOrder(checkorder=default).symbols @@ -0,0 +1,35 @@ +//// [tests/cases/compiler/instantiationStackLimitCheckOrder.ts] //// + +=== instantiationStackLimitCheckOrder.ts === +// F<[]> recurses forever, so instantiating it reaches the limit on the +// instantiation stack, wherever it is first instantiated. The instantiations +// in progress then fail as a whole, and none of them may be cached partly +// built for the other declaration to reuse. + +type F = T extends [unknown?, ...infer R] ? [0, ...F] : []; +>F : Symbol(F, Decl(instantiationStackLimitCheckOrder.ts, 0, 0)) +>T : Symbol(T, Decl(instantiationStackLimitCheckOrder.ts, 5, 7)) +>T : Symbol(T, Decl(instantiationStackLimitCheckOrder.ts, 5, 7)) +>R : Symbol(R, Decl(instantiationStackLimitCheckOrder.ts, 5, 41)) +>F : Symbol(F, Decl(instantiationStackLimitCheckOrder.ts, 0, 0)) +>R : Symbol(R, Decl(instantiationStackLimitCheckOrder.ts, 5, 41)) + +type X = F<[]>; +>X : Symbol(X, Decl(instantiationStackLimitCheckOrder.ts, 5, 65)) +>F : Symbol(F, Decl(instantiationStackLimitCheckOrder.ts, 0, 0)) + +// The element type of A[] is resolved whenever first needed, inside the +// instantiation of the return type of flat or not. Reaching the limit while +// flattening it must fail the same instantiations either way. + +type A = A[]; +>A : Symbol(A, Decl(instantiationStackLimitCheckOrder.ts, 6, 15)) +>A : Symbol(A, Decl(instantiationStackLimitCheckOrder.ts, 6, 15)) + +const r = ([] as A).flat(Infinity); +>r : Symbol(r, Decl(instantiationStackLimitCheckOrder.ts, 13, 5)) +>([] as A).flat : Symbol(Array.flat, Decl(lib.es2019.array.d.ts, --, --)) +>A : Symbol(A, Decl(instantiationStackLimitCheckOrder.ts, 6, 15)) +>flat : Symbol(Array.flat, Decl(lib.es2019.array.d.ts, --, --)) +>Infinity : Symbol(Infinity, Decl(lib.es5.d.ts, --, --)) + diff --git a/tsc/testdata/baselines/reference/compiler/instantiationStackLimitCheckOrder(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/instantiationStackLimitCheckOrder(checkorder=default).types new file mode 100644 index 0000000000000..8e3cbd6baf4b9 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/instantiationStackLimitCheckOrder(checkorder=default).types @@ -0,0 +1,31 @@ +//// [tests/cases/compiler/instantiationStackLimitCheckOrder.ts] //// + +=== instantiationStackLimitCheckOrder.ts === +// F<[]> recurses forever, so instantiating it reaches the limit on the +// instantiation stack, wherever it is first instantiated. The instantiations +// in progress then fail as a whole, and none of them may be cached partly +// built for the other declaration to reuse. + +type F = T extends [unknown?, ...infer R] ? [0, ...F] : []; +>F : F + +type X = F<[]>; +>X : [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ...any[]] + +// The element type of A[] is resolved whenever first needed, inside the +// instantiation of the return type of flat or not. Reaching the limit while +// flattening it must fail the same instantiations either way. + +type A = A[]; +>A : A + +const r = ([] as A).flat(Infinity); +>r : any[] +>([] as A).flat(Infinity) : any[] +>([] as A).flat : (this: A, depth?: D | undefined) => FlatArray[] +>([] as A) : A +>[] as A : A +>[] : never[] +>flat : (this: A, depth?: D | undefined) => FlatArray[] +>Infinity : number + diff --git a/tsc/testdata/baselines/reference/compiler/instantiationStackLimitCheckOrder(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/instantiationStackLimitCheckOrder(checkorder=typesfirst).errors.txt new file mode 100644 index 0000000000000..aaa7aed71c5bf --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/instantiationStackLimitCheckOrder(checkorder=typesfirst).errors.txt @@ -0,0 +1,23 @@ +error TS5114: Instantiations of type 'F' appear infinitely circular. +instantiationStackLimitCheckOrder.ts(14,11): error TS5114: Instantiations of type 'FlatArray' appear infinitely circular. + + +!!! error TS5114: Instantiations of type 'F' appear infinitely circular. +==== instantiationStackLimitCheckOrder.ts (1 errors) ==== + // F<[]> recurses forever, so instantiating it reaches the limit on the + // instantiation stack, wherever it is first instantiated. The instantiations + // in progress then fail as a whole, and none of them may be cached partly + // built for the other declaration to reuse. + + type F = T extends [unknown?, ...infer R] ? [0, ...F] : []; + type X = F<[]>; + + // The element type of A[] is resolved whenever first needed, inside the + // instantiation of the return type of flat or not. Reaching the limit while + // flattening it must fail the same instantiations either way. + + type A = A[]; + const r = ([] as A).flat(Infinity); + ~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS5114: Instantiations of type 'FlatArray' appear infinitely circular. + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/instantiationStackLimitCheckOrder(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/instantiationStackLimitCheckOrder(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..97100f75a4cf2 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/instantiationStackLimitCheckOrder(checkorder=typesfirst).symbols @@ -0,0 +1,35 @@ +//// [tests/cases/compiler/instantiationStackLimitCheckOrder.ts] //// + +=== instantiationStackLimitCheckOrder.ts === +// F<[]> recurses forever, so instantiating it reaches the limit on the +// instantiation stack, wherever it is first instantiated. The instantiations +// in progress then fail as a whole, and none of them may be cached partly +// built for the other declaration to reuse. + +type F = T extends [unknown?, ...infer R] ? [0, ...F] : []; +>F : Symbol(F, Decl(instantiationStackLimitCheckOrder.ts, 0, 0)) +>T : Symbol(T, Decl(instantiationStackLimitCheckOrder.ts, 5, 7)) +>T : Symbol(T, Decl(instantiationStackLimitCheckOrder.ts, 5, 7)) +>R : Symbol(R, Decl(instantiationStackLimitCheckOrder.ts, 5, 41)) +>F : Symbol(F, Decl(instantiationStackLimitCheckOrder.ts, 0, 0)) +>R : Symbol(R, Decl(instantiationStackLimitCheckOrder.ts, 5, 41)) + +type X = F<[]>; +>X : Symbol(X, Decl(instantiationStackLimitCheckOrder.ts, 5, 65)) +>F : Symbol(F, Decl(instantiationStackLimitCheckOrder.ts, 0, 0)) + +// The element type of A[] is resolved whenever first needed, inside the +// instantiation of the return type of flat or not. Reaching the limit while +// flattening it must fail the same instantiations either way. + +type A = A[]; +>A : Symbol(A, Decl(instantiationStackLimitCheckOrder.ts, 6, 15)) +>A : Symbol(A, Decl(instantiationStackLimitCheckOrder.ts, 6, 15)) + +const r = ([] as A).flat(Infinity); +>r : Symbol(r, Decl(instantiationStackLimitCheckOrder.ts, 13, 5)) +>([] as A).flat : Symbol(Array.flat, Decl(lib.es2019.array.d.ts, --, --)) +>A : Symbol(A, Decl(instantiationStackLimitCheckOrder.ts, 6, 15)) +>flat : Symbol(Array.flat, Decl(lib.es2019.array.d.ts, --, --)) +>Infinity : Symbol(Infinity, Decl(lib.es5.d.ts, --, --)) + diff --git a/tsc/testdata/baselines/reference/compiler/instantiationStackLimitCheckOrder(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/instantiationStackLimitCheckOrder(checkorder=typesfirst).types new file mode 100644 index 0000000000000..8e3cbd6baf4b9 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/instantiationStackLimitCheckOrder(checkorder=typesfirst).types @@ -0,0 +1,31 @@ +//// [tests/cases/compiler/instantiationStackLimitCheckOrder.ts] //// + +=== instantiationStackLimitCheckOrder.ts === +// F<[]> recurses forever, so instantiating it reaches the limit on the +// instantiation stack, wherever it is first instantiated. The instantiations +// in progress then fail as a whole, and none of them may be cached partly +// built for the other declaration to reuse. + +type F = T extends [unknown?, ...infer R] ? [0, ...F] : []; +>F : F + +type X = F<[]>; +>X : [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ...any[]] + +// The element type of A[] is resolved whenever first needed, inside the +// instantiation of the return type of flat or not. Reaching the limit while +// flattening it must fail the same instantiations either way. + +type A = A[]; +>A : A + +const r = ([] as A).flat(Infinity); +>r : any[] +>([] as A).flat(Infinity) : any[] +>([] as A).flat : (this: A, depth?: D | undefined) => FlatArray[] +>([] as A) : A +>[] as A : A +>[] : never[] +>flat : (this: A, depth?: D | undefined) => FlatArray[] +>Infinity : number + diff --git a/tsc/testdata/baselines/reference/compiler/intersectionBaseConstructorCycleCheckOrder(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/intersectionBaseConstructorCycleCheckOrder(checkorder=default).errors.txt new file mode 100644 index 0000000000000..96858d411691e --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/intersectionBaseConstructorCycleCheckOrder(checkorder=default).errors.txt @@ -0,0 +1,19 @@ +intersectionBaseConstructorCycleCheckOrder.ts(5,24): error TS2502: 'x' is referenced directly or indirectly in its own type annotation. +intersectionBaseConstructorCycleCheckOrder.ts(6,15): error TS2310: Type 'C' recursively references itself as a base type. +intersectionBaseConstructorCycleCheckOrder.ts(6,15): error TS2506: 'C' is referenced directly or indirectly in its own base expression. + + +==== intersectionBaseConstructorCycleCheckOrder.ts (3 errors) ==== + // The type of x depends on the members of C, which depend on its base B, + // whose members depend on the type of x. Whichever is resolved first, the + // cycle must be resolved the same way. + + declare const B: (new (x: C["p"]) => {}) & (new () => {}); + ~~~~~~~~~ +!!! error TS2502: 'x' is referenced directly or indirectly in its own type annotation. + declare class C extends B { p: number; } + ~ +!!! error TS2310: Type 'C' recursively references itself as a base type. + ~ +!!! error TS2506: 'C' is referenced directly or indirectly in its own base expression. + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/intersectionBaseConstructorCycleCheckOrder(checkorder=default).js b/tsc/testdata/baselines/reference/compiler/intersectionBaseConstructorCycleCheckOrder(checkorder=default).js new file mode 100644 index 0000000000000..1110d38181fac --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/intersectionBaseConstructorCycleCheckOrder(checkorder=default).js @@ -0,0 +1,16 @@ +//// [tests/cases/compiler/intersectionBaseConstructorCycleCheckOrder.ts] //// + +//// [intersectionBaseConstructorCycleCheckOrder.ts] +// The type of x depends on the members of C, which depend on its base B, +// whose members depend on the type of x. Whichever is resolved first, the +// cycle must be resolved the same way. + +declare const B: (new (x: C["p"]) => {}) & (new () => {}); +declare class C extends B { p: number; } + + +//// [intersectionBaseConstructorCycleCheckOrder.js] +"use strict"; +// The type of x depends on the members of C, which depend on its base B, +// whose members depend on the type of x. Whichever is resolved first, the +// cycle must be resolved the same way. diff --git a/tsc/testdata/baselines/reference/compiler/intersectionBaseConstructorCycleCheckOrder(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/intersectionBaseConstructorCycleCheckOrder(checkorder=default).symbols new file mode 100644 index 0000000000000..3e614bc639b69 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/intersectionBaseConstructorCycleCheckOrder(checkorder=default).symbols @@ -0,0 +1,17 @@ +//// [tests/cases/compiler/intersectionBaseConstructorCycleCheckOrder.ts] //// + +=== intersectionBaseConstructorCycleCheckOrder.ts === +// The type of x depends on the members of C, which depend on its base B, +// whose members depend on the type of x. Whichever is resolved first, the +// cycle must be resolved the same way. + +declare const B: (new (x: C["p"]) => {}) & (new () => {}); +>B : Symbol(B, Decl(intersectionBaseConstructorCycleCheckOrder.ts, 4, 13)) +>x : Symbol(x, Decl(intersectionBaseConstructorCycleCheckOrder.ts, 4, 23)) +>C : Symbol(C, Decl(intersectionBaseConstructorCycleCheckOrder.ts, 4, 58)) + +declare class C extends B { p: number; } +>C : Symbol(C, Decl(intersectionBaseConstructorCycleCheckOrder.ts, 4, 58)) +>B : Symbol(B, Decl(intersectionBaseConstructorCycleCheckOrder.ts, 4, 13)) +>p : Symbol(C.p, Decl(intersectionBaseConstructorCycleCheckOrder.ts, 5, 27)) + diff --git a/tsc/testdata/baselines/reference/compiler/intersectionBaseConstructorCycleCheckOrder(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/intersectionBaseConstructorCycleCheckOrder(checkorder=default).types new file mode 100644 index 0000000000000..334afbb4eb4f5 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/intersectionBaseConstructorCycleCheckOrder(checkorder=default).types @@ -0,0 +1,16 @@ +//// [tests/cases/compiler/intersectionBaseConstructorCycleCheckOrder.ts] //// + +=== intersectionBaseConstructorCycleCheckOrder.ts === +// The type of x depends on the members of C, which depend on its base B, +// whose members depend on the type of x. Whichever is resolved first, the +// cycle must be resolved the same way. + +declare const B: (new (x: C["p"]) => {}) & (new () => {}); +>B : (new (x: C["p"]) => {}) & (new () => {}) +>x : any + +declare class C extends B { p: number; } +>C : C +>B : (new (x: C["p"]) => {}) & (new () => {}) +>p : number + diff --git a/tsc/testdata/baselines/reference/compiler/intersectionBaseConstructorCycleCheckOrder(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/intersectionBaseConstructorCycleCheckOrder(checkorder=typesfirst).errors.txt new file mode 100644 index 0000000000000..96858d411691e --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/intersectionBaseConstructorCycleCheckOrder(checkorder=typesfirst).errors.txt @@ -0,0 +1,19 @@ +intersectionBaseConstructorCycleCheckOrder.ts(5,24): error TS2502: 'x' is referenced directly or indirectly in its own type annotation. +intersectionBaseConstructorCycleCheckOrder.ts(6,15): error TS2310: Type 'C' recursively references itself as a base type. +intersectionBaseConstructorCycleCheckOrder.ts(6,15): error TS2506: 'C' is referenced directly or indirectly in its own base expression. + + +==== intersectionBaseConstructorCycleCheckOrder.ts (3 errors) ==== + // The type of x depends on the members of C, which depend on its base B, + // whose members depend on the type of x. Whichever is resolved first, the + // cycle must be resolved the same way. + + declare const B: (new (x: C["p"]) => {}) & (new () => {}); + ~~~~~~~~~ +!!! error TS2502: 'x' is referenced directly or indirectly in its own type annotation. + declare class C extends B { p: number; } + ~ +!!! error TS2310: Type 'C' recursively references itself as a base type. + ~ +!!! error TS2506: 'C' is referenced directly or indirectly in its own base expression. + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/intersectionBaseConstructorCycleCheckOrder(checkorder=typesfirst).js b/tsc/testdata/baselines/reference/compiler/intersectionBaseConstructorCycleCheckOrder(checkorder=typesfirst).js new file mode 100644 index 0000000000000..1110d38181fac --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/intersectionBaseConstructorCycleCheckOrder(checkorder=typesfirst).js @@ -0,0 +1,16 @@ +//// [tests/cases/compiler/intersectionBaseConstructorCycleCheckOrder.ts] //// + +//// [intersectionBaseConstructorCycleCheckOrder.ts] +// The type of x depends on the members of C, which depend on its base B, +// whose members depend on the type of x. Whichever is resolved first, the +// cycle must be resolved the same way. + +declare const B: (new (x: C["p"]) => {}) & (new () => {}); +declare class C extends B { p: number; } + + +//// [intersectionBaseConstructorCycleCheckOrder.js] +"use strict"; +// The type of x depends on the members of C, which depend on its base B, +// whose members depend on the type of x. Whichever is resolved first, the +// cycle must be resolved the same way. diff --git a/tsc/testdata/baselines/reference/compiler/intersectionBaseConstructorCycleCheckOrder(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/intersectionBaseConstructorCycleCheckOrder(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..3e614bc639b69 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/intersectionBaseConstructorCycleCheckOrder(checkorder=typesfirst).symbols @@ -0,0 +1,17 @@ +//// [tests/cases/compiler/intersectionBaseConstructorCycleCheckOrder.ts] //// + +=== intersectionBaseConstructorCycleCheckOrder.ts === +// The type of x depends on the members of C, which depend on its base B, +// whose members depend on the type of x. Whichever is resolved first, the +// cycle must be resolved the same way. + +declare const B: (new (x: C["p"]) => {}) & (new () => {}); +>B : Symbol(B, Decl(intersectionBaseConstructorCycleCheckOrder.ts, 4, 13)) +>x : Symbol(x, Decl(intersectionBaseConstructorCycleCheckOrder.ts, 4, 23)) +>C : Symbol(C, Decl(intersectionBaseConstructorCycleCheckOrder.ts, 4, 58)) + +declare class C extends B { p: number; } +>C : Symbol(C, Decl(intersectionBaseConstructorCycleCheckOrder.ts, 4, 58)) +>B : Symbol(B, Decl(intersectionBaseConstructorCycleCheckOrder.ts, 4, 13)) +>p : Symbol(C.p, Decl(intersectionBaseConstructorCycleCheckOrder.ts, 5, 27)) + diff --git a/tsc/testdata/baselines/reference/compiler/intersectionBaseConstructorCycleCheckOrder(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/intersectionBaseConstructorCycleCheckOrder(checkorder=typesfirst).types new file mode 100644 index 0000000000000..334afbb4eb4f5 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/intersectionBaseConstructorCycleCheckOrder(checkorder=typesfirst).types @@ -0,0 +1,16 @@ +//// [tests/cases/compiler/intersectionBaseConstructorCycleCheckOrder.ts] //// + +=== intersectionBaseConstructorCycleCheckOrder.ts === +// The type of x depends on the members of C, which depend on its base B, +// whose members depend on the type of x. Whichever is resolved first, the +// cycle must be resolved the same way. + +declare const B: (new (x: C["p"]) => {}) & (new () => {}); +>B : (new (x: C["p"]) => {}) & (new () => {}) +>x : any + +declare class C extends B { p: number; } +>C : C +>B : (new (x: C["p"]) => {}) & (new () => {}) +>p : number + diff --git a/tsc/testdata/baselines/reference/compiler/jsdocLinkImportElisionQueryOrder(checkorder=default).js b/tsc/testdata/baselines/reference/compiler/jsdocLinkImportElisionQueryOrder(checkorder=default).js new file mode 100644 index 0000000000000..bead869eaeb90 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/jsdocLinkImportElisionQueryOrder(checkorder=default).js @@ -0,0 +1,25 @@ +//// [tests/cases/compiler/jsdocLinkImportElisionQueryOrder.ts] //// + +//// [a.ts] +export interface A {} + +//// [b.ts] +import * as a from "./a"; + +/** + * See {@link a.A}. + */ +export function foo() {} + + +//// [a.js] +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +//// [b.js] +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.foo = foo; +/** + * See {@link a.A}. + */ +function foo() { } diff --git a/tsc/testdata/baselines/reference/compiler/jsdocLinkImportElisionQueryOrder(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/jsdocLinkImportElisionQueryOrder(checkorder=default).symbols new file mode 100644 index 0000000000000..5ac6b40e1c04f --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/jsdocLinkImportElisionQueryOrder(checkorder=default).symbols @@ -0,0 +1,16 @@ +//// [tests/cases/compiler/jsdocLinkImportElisionQueryOrder.ts] //// + +=== /a.ts === +export interface A {} +>A : Symbol(A, Decl(a.ts, 0, 0)) + +=== /b.ts === +import * as a from "./a"; +>a : Symbol(a, Decl(b.ts, 0, 6)) + +/** + * See {@link a.A}. + */ +export function foo() {} +>foo : Symbol(foo, Decl(b.ts, 0, 25)) + diff --git a/tsc/testdata/baselines/reference/compiler/jsdocLinkImportElisionQueryOrder(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/jsdocLinkImportElisionQueryOrder(checkorder=default).types new file mode 100644 index 0000000000000..239eddf0ea7ff --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/jsdocLinkImportElisionQueryOrder(checkorder=default).types @@ -0,0 +1,16 @@ +//// [tests/cases/compiler/jsdocLinkImportElisionQueryOrder.ts] //// + +=== /a.ts === + +export interface A {} + +=== /b.ts === +import * as a from "./a"; +>a : typeof a + +/** + * See {@link a.A}. + */ +export function foo() {} +>foo : () => void + diff --git a/tsc/testdata/baselines/reference/compiler/jsdocLinkImportElisionQueryOrder(checkorder=editorfirst).js b/tsc/testdata/baselines/reference/compiler/jsdocLinkImportElisionQueryOrder(checkorder=editorfirst).js new file mode 100644 index 0000000000000..0da32e96e9494 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/jsdocLinkImportElisionQueryOrder(checkorder=editorfirst).js @@ -0,0 +1,106 @@ +//// [tests/cases/compiler/jsdocLinkImportElisionQueryOrder.ts] //// + +//// [a.ts] +export interface A {} + +//// [b.ts] +import * as a from "./a"; + +/** + * See {@link a.A}. + */ +export function foo() {} + + +//// [a.js] +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +//// [b.js] +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +exports.foo = foo; +const a = __importStar(require("./a")); +/** + * See {@link a.A}. + */ +function foo() { } + + +!!!! File /b.js differs from original emit in noCheck emit +//// [b.js] +--- Expected The full check baseline ++++ Actual with noCheck set +@@ -1,40 +1,6 @@ + "use strict"; +-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { +- if (k2 === undefined) k2 = k; +- var desc = Object.getOwnPropertyDescriptor(m, k); +- if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { +- desc = { enumerable: true, get: function() { return m[k]; } }; +- } +- Object.defineProperty(o, k2, desc); +-}) : (function(o, m, k, k2) { +- if (k2 === undefined) k2 = k; +- o[k2] = m[k]; +-})); +-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { +- Object.defineProperty(o, "default", { enumerable: true, value: v }); +-}) : function(o, v) { +- o["default"] = v; +-}); +-var __importStar = (this && this.__importStar) || (function () { +- var ownKeys = function(o) { +- ownKeys = Object.getOwnPropertyNames || function (o) { +- var ar = []; +- for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; +- return ar; +- }; +- return ownKeys(o); +- }; +- return function (mod) { +- if (mod && mod.__esModule) return mod; +- var result = {}; +- if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); +- __setModuleDefault(result, mod); +- return result; +- }; +-})(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.foo = foo; +-const a = __importStar(require("./a")); + /** + * See {@link a.A}. + */ \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/jsdocLinkImportElisionQueryOrder(checkorder=editorfirst).symbols b/tsc/testdata/baselines/reference/compiler/jsdocLinkImportElisionQueryOrder(checkorder=editorfirst).symbols new file mode 100644 index 0000000000000..5ac6b40e1c04f --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/jsdocLinkImportElisionQueryOrder(checkorder=editorfirst).symbols @@ -0,0 +1,16 @@ +//// [tests/cases/compiler/jsdocLinkImportElisionQueryOrder.ts] //// + +=== /a.ts === +export interface A {} +>A : Symbol(A, Decl(a.ts, 0, 0)) + +=== /b.ts === +import * as a from "./a"; +>a : Symbol(a, Decl(b.ts, 0, 6)) + +/** + * See {@link a.A}. + */ +export function foo() {} +>foo : Symbol(foo, Decl(b.ts, 0, 25)) + diff --git a/tsc/testdata/baselines/reference/compiler/jsdocLinkImportElisionQueryOrder(checkorder=editorfirst).types b/tsc/testdata/baselines/reference/compiler/jsdocLinkImportElisionQueryOrder(checkorder=editorfirst).types new file mode 100644 index 0000000000000..239eddf0ea7ff --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/jsdocLinkImportElisionQueryOrder(checkorder=editorfirst).types @@ -0,0 +1,16 @@ +//// [tests/cases/compiler/jsdocLinkImportElisionQueryOrder.ts] //// + +=== /a.ts === + +export interface A {} + +=== /b.ts === +import * as a from "./a"; +>a : typeof a + +/** + * See {@link a.A}. + */ +export function foo() {} +>foo : () => void + diff --git a/tsc/testdata/baselines/reference/compiler/jsdocTypeTagOnContextuallyTypedFunction.errors.txt b/tsc/testdata/baselines/reference/compiler/jsdocTypeTagOnContextuallyTypedFunction.errors.txt new file mode 100644 index 0000000000000..f9f9a2d8d5885 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/jsdocTypeTagOnContextuallyTypedFunction.errors.txt @@ -0,0 +1,33 @@ +a.js(4,1): error TS2322: Type '(content: string, rest_0?: boolean | undefined) => string' is not assignable to type '(a: string | number, ...rest: unknown[]) => string'. + Types of parameters 'content' and 'a' are incompatible. + Type 'string | number' is not assignable to type 'string'. + Type 'number' is not assignable to type 'string'. +a.js(9,7): error TS2322: Type '(content: string) => string' is not assignable to type '(content: string | number) => string'. + Types of parameters 'content' and 'content' are incompatible. + Type 'string | number' is not assignable to type 'string'. + Type 'number' is not assignable to type 'string'. + + +==== a.js (2 errors) ==== + /** @type {{ f: (a: string | number, ...rest: unknown[]) => string }} */ + const context = { f: (a) => "" }; + + context.f = + ~~~~~~~~~ +!!! error TS2322: Type '(content: string, rest_0?: boolean | undefined) => string' is not assignable to type '(a: string | number, ...rest: unknown[]) => string'. +!!! error TS2322: Types of parameters 'content' and 'a' are incompatible. +!!! error TS2322: Type 'string | number' is not assignable to type 'string'. +!!! error TS2322: Type 'number' is not assignable to type 'string'. + /** @type {(content: string, ...rest: [boolean?]) => string} */ + (content, ...rest) => content.toUpperCase() + rest.length; + + /** @type {(content: string | number) => string} */ + const g = + ~ +!!! error TS2322: Type '(content: string) => string' is not assignable to type '(content: string | number) => string'. +!!! error TS2322: Types of parameters 'content' and 'content' are incompatible. +!!! error TS2322: Type 'string | number' is not assignable to type 'string'. +!!! error TS2322: Type 'number' is not assignable to type 'string'. + /** @type {(content: string) => string} */ + (content) => content.toUpperCase(); + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/jsdocTypeTagOnContextuallyTypedFunction.symbols b/tsc/testdata/baselines/reference/compiler/jsdocTypeTagOnContextuallyTypedFunction.symbols new file mode 100644 index 0000000000000..15ffe15bb65e2 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/jsdocTypeTagOnContextuallyTypedFunction.symbols @@ -0,0 +1,36 @@ +//// [tests/cases/compiler/jsdocTypeTagOnContextuallyTypedFunction.ts] //// + +=== a.js === +/** @type {{ f: (a: string | number, ...rest: unknown[]) => string }} */ +const context = { f: (a) => "" }; +>context : Symbol(context, Decl(a.js, 1, 5)) +>f : Symbol(f, Decl(a.js, 1, 17)) +>a : Symbol(a, Decl(a.js, 1, 22)) + +context.f = +>context.f : Symbol(f, Decl(a.js, 0, 12)) +>context : Symbol(context, Decl(a.js, 1, 5)) +>f : Symbol(f, Decl(a.js, 0, 12)) + + /** @type {(content: string, ...rest: [boolean?]) => string} */ + (content, ...rest) => content.toUpperCase() + rest.length; +>content : Symbol(content, Decl(a.js, 5, 5)) +>rest : Symbol(rest, Decl(a.js, 5, 13)) +>content.toUpperCase : Symbol(String.toUpperCase, Decl(lib.es5.d.ts, --, --)) +>content : Symbol(content, Decl(a.js, 5, 5)) +>toUpperCase : Symbol(String.toUpperCase, Decl(lib.es5.d.ts, --, --)) +>rest.length : Symbol(length) +>rest : Symbol(rest, Decl(a.js, 5, 13)) +>length : Symbol(length) + +/** @type {(content: string | number) => string} */ +const g = +>g : Symbol(g, Decl(a.js, 8, 5)) + + /** @type {(content: string) => string} */ + (content) => content.toUpperCase(); +>content : Symbol(content, Decl(a.js, 10, 5)) +>content.toUpperCase : Symbol(String.toUpperCase, Decl(lib.es5.d.ts, --, --)) +>content : Symbol(content, Decl(a.js, 10, 5)) +>toUpperCase : Symbol(String.toUpperCase, Decl(lib.es5.d.ts, --, --)) + diff --git a/tsc/testdata/baselines/reference/compiler/jsdocTypeTagOnContextuallyTypedFunction.types b/tsc/testdata/baselines/reference/compiler/jsdocTypeTagOnContextuallyTypedFunction.types new file mode 100644 index 0000000000000..6defe743de587 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/jsdocTypeTagOnContextuallyTypedFunction.types @@ -0,0 +1,45 @@ +//// [tests/cases/compiler/jsdocTypeTagOnContextuallyTypedFunction.ts] //// + +=== a.js === +/** @type {{ f: (a: string | number, ...rest: unknown[]) => string }} */ +const context = { f: (a) => "" }; +>context : { f: (a: string | number, ...rest: unknown[]) => string; } +>{ f: (a) => "" } : { f: (a: string | number) => string; } +>f : (a: string | number) => string +>(a) => "" : (a: string | number) => string +>a : string | number +>"" : "" + +context.f = +>context.f = /** @type {(content: string, ...rest: [boolean?]) => string} */ (content, ...rest) => content.toUpperCase() + rest.length : (content: string, rest_0?: boolean | undefined) => string +>context.f : (a: string | number, ...rest: unknown[]) => string +>context : { f: (a: string | number, ...rest: unknown[]) => string; } +>f : (a: string | number, ...rest: unknown[]) => string + + /** @type {(content: string, ...rest: [boolean?]) => string} */ + (content, ...rest) => content.toUpperCase() + rest.length; +>(content, ...rest) => content.toUpperCase() + rest.length : (content: string, rest_0?: boolean | undefined) => string +>content : string +>rest : [(boolean | undefined)?] +>content.toUpperCase() + rest.length : string +>content.toUpperCase() : string +>content.toUpperCase : () => string +>content : string +>toUpperCase : () => string +>rest.length : 0 | 1 +>rest : [(boolean | undefined)?] +>length : 0 | 1 + +/** @type {(content: string | number) => string} */ +const g = +>g : (content: string | number) => string + + /** @type {(content: string) => string} */ + (content) => content.toUpperCase(); +>(content) => content.toUpperCase() : (content: string) => string +>content : string +>content.toUpperCase() : string +>content.toUpperCase : () => string +>content : string +>toUpperCase : () => string + diff --git a/tsc/testdata/baselines/reference/compiler/jsxImportSourceNonPragmaComment(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/jsxImportSourceNonPragmaComment(checkorder=default).errors.txt new file mode 100644 index 0000000000000..191dc50e4166c --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/jsxImportSourceNonPragmaComment(checkorder=default).errors.txt @@ -0,0 +1,33 @@ +jsxImportSourceNonPragmaComment.tsx(3,21): error TS2307: Cannot find module '@emotion/react' or its corresponding type declarations. +jsxImportSourceNonPragmaComment.tsx(7,5): error TS2875: This JSX tag requires the module path '@emotion/react/jsx-runtime' to exist, but none could be found. Make sure you have types for the appropriate package installed. +jsxImportSourceNonPragmaComment.tsx(7,5): error TS7026: JSX element implicitly has type 'any' because no interface 'JSX.IntrinsicElements' exists. + + +==== jsxImportSourceNonPragmaComment.tsx (3 errors) ==== + /* eslint-disable react/react-in-jsx-scope -- Unaware of @jsxImportSource */ + /** @jsxImportSource @emotion/react */ + import { css } from "@emotion/react"; + ~~~~~~~~~~~~~~~~ +!!! error TS2307: Cannot find module '@emotion/react' or its corresponding type declarations. + + export default function Component() { + return ( + + ~~~~~~ +!!! error TS2875: This JSX tag requires the module path '@emotion/react/jsx-runtime' to exist, but none could be found. Make sure you have types for the appropriate package installed. + ~~~~~~ +!!! error TS7026: JSX element implicitly has type 'any' because no interface 'JSX.IntrinsicElements' exists. + ); + } \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/jsxImportSourceNonPragmaComment(checkorder=default).js b/tsc/testdata/baselines/reference/compiler/jsxImportSourceNonPragmaComment(checkorder=default).js new file mode 100644 index 0000000000000..e58934ed59b6b --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/jsxImportSourceNonPragmaComment(checkorder=default).js @@ -0,0 +1,29 @@ +//// [tests/cases/compiler/jsxImportSourceNonPragmaComment.tsx] //// + +//// [jsxImportSourceNonPragmaComment.tsx] +/* eslint-disable react/react-in-jsx-scope -- Unaware of @jsxImportSource */ +/** @jsxImportSource @emotion/react */ +import { css } from "@emotion/react"; + +export default function Component() { + return ( + + ); +} + +//// [jsxImportSourceNonPragmaComment.jsx] +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.default = Component; +/* eslint-disable react/react-in-jsx-scope -- Unaware of @jsxImportSource */ +/** @jsxImportSource @emotion/react */ +const react_1 = require("@emotion/react"); +function Component() { + return (); +} diff --git a/tsc/testdata/baselines/reference/compiler/jsxImportSourceNonPragmaComment(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/jsxImportSourceNonPragmaComment(checkorder=default).symbols new file mode 100644 index 0000000000000..d12b587e7c215 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/jsxImportSourceNonPragmaComment(checkorder=default).symbols @@ -0,0 +1,22 @@ +//// [tests/cases/compiler/jsxImportSourceNonPragmaComment.tsx] //// + +=== jsxImportSourceNonPragmaComment.tsx === +/* eslint-disable react/react-in-jsx-scope -- Unaware of @jsxImportSource */ +/** @jsxImportSource @emotion/react */ +import { css } from "@emotion/react"; +>css : Symbol(css, Decl(jsxImportSourceNonPragmaComment.tsx, 2, 8)) + +export default function Component() { +>Component : Symbol(Component, Decl(jsxImportSourceNonPragmaComment.tsx, 2, 37)) + + return ( + css : Symbol(css, Decl(jsxImportSourceNonPragmaComment.tsx, 6, 10)) +>css : Symbol(css, Decl(jsxImportSourceNonPragmaComment.tsx, 2, 8)) + + color: red; + `} + /> + ); +} diff --git a/tsc/testdata/baselines/reference/compiler/jsxImportSourceNonPragmaComment(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/jsxImportSourceNonPragmaComment(checkorder=default).types new file mode 100644 index 0000000000000..5300452403d62 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/jsxImportSourceNonPragmaComment(checkorder=default).types @@ -0,0 +1,29 @@ +//// [tests/cases/compiler/jsxImportSourceNonPragmaComment.tsx] //// + +=== jsxImportSourceNonPragmaComment.tsx === +/* eslint-disable react/react-in-jsx-scope -- Unaware of @jsxImportSource */ +/** @jsxImportSource @emotion/react */ +import { css } from "@emotion/react"; +>css : any + +export default function Component() { +>Component : () => any + + return ( +>( ) : any + + : any +>input : any + + css={css` +>css : any +>css` color: red; ` : any +>css : any +>` color: red; ` : "\n color: red;\n " + + color: red; + `} + /> + ); +} diff --git a/tsc/testdata/baselines/reference/compiler/jsxImportSourceNonPragmaComment(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/jsxImportSourceNonPragmaComment(checkorder=typesfirst).errors.txt new file mode 100644 index 0000000000000..b45ab387a625b --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/jsxImportSourceNonPragmaComment(checkorder=typesfirst).errors.txt @@ -0,0 +1,37 @@ +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(7,6): error TS2552: Cannot find name 'input'. Did you mean 'oninput'? + + +==== jsxImportSourceNonPragmaComment.tsx (4 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).errors.txt b/tsc/testdata/baselines/reference/compiler/jsxIntrinsicElementsExtendsRecord(checkorder=typesfirst).errors.txt new file mode 100644 index 0000000000000..183a3fdcdd653 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/jsxIntrinsicElementsExtendsRecord(checkorder=typesfirst).errors.txt @@ -0,0 +1,12 @@ +index.tsx(5,2): error TS2304: Cannot find name 'a'. + + +==== index.tsx (1 errors) ==== + declare namespace JSX { + interface IntrinsicElements extends Record {} + } + + ; + ~ +!!! error TS2304: Cannot find name 'a'. + \ No newline at end of file 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..a2a76b6e77eed --- /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 {} +} + +; +> : any +>a : any + diff --git a/tsc/testdata/baselines/reference/compiler/keyofIndexSignatureCycleCheckOrder(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/keyofIndexSignatureCycleCheckOrder(checkorder=default).errors.txt new file mode 100644 index 0000000000000..44b9fe50fa70d --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/keyofIndexSignatureCycleCheckOrder(checkorder=default).errors.txt @@ -0,0 +1,14 @@ +keyofIndexSignatureCycleCheckOrder.ts(7,7): error TS2322: Type '123' is not assignable to type 'never'. + + +==== keyofIndexSignatureCycleCheckOrder.ts (1 errors) ==== + // S and the index signature of C depend on each other. Resolving the members + // of C first gives S from the part of them available so far, and resolving S + // first must give the same result rather than fail it as circular. + + interface C { [k: string]: S; } + type S = keyof C; + const k: S = 123; + ~ +!!! error TS2322: Type '123' is not assignable to type 'never'. + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/keyofIndexSignatureCycleCheckOrder(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/keyofIndexSignatureCycleCheckOrder(checkorder=default).symbols new file mode 100644 index 0000000000000..826be2b914e3b --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/keyofIndexSignatureCycleCheckOrder(checkorder=default).symbols @@ -0,0 +1,20 @@ +//// [tests/cases/compiler/keyofIndexSignatureCycleCheckOrder.ts] //// + +=== keyofIndexSignatureCycleCheckOrder.ts === +// S and the index signature of C depend on each other. Resolving the members +// of C first gives S from the part of them available so far, and resolving S +// first must give the same result rather than fail it as circular. + +interface C { [k: string]: S; } +>C : Symbol(C, Decl(keyofIndexSignatureCycleCheckOrder.ts, 0, 0)) +>k : Symbol(k, Decl(keyofIndexSignatureCycleCheckOrder.ts, 4, 15)) +>S : Symbol(S, Decl(keyofIndexSignatureCycleCheckOrder.ts, 4, 31)) + +type S = keyof C; +>S : Symbol(S, Decl(keyofIndexSignatureCycleCheckOrder.ts, 4, 31)) +>C : Symbol(C, Decl(keyofIndexSignatureCycleCheckOrder.ts, 0, 0)) + +const k: S = 123; +>k : Symbol(k, Decl(keyofIndexSignatureCycleCheckOrder.ts, 6, 5)) +>S : Symbol(S, Decl(keyofIndexSignatureCycleCheckOrder.ts, 4, 31)) + diff --git a/tsc/testdata/baselines/reference/compiler/keyofIndexSignatureCycleCheckOrder(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/keyofIndexSignatureCycleCheckOrder(checkorder=default).types new file mode 100644 index 0000000000000..d43b1450f3a46 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/keyofIndexSignatureCycleCheckOrder(checkorder=default).types @@ -0,0 +1,17 @@ +//// [tests/cases/compiler/keyofIndexSignatureCycleCheckOrder.ts] //// + +=== keyofIndexSignatureCycleCheckOrder.ts === +// S and the index signature of C depend on each other. Resolving the members +// of C first gives S from the part of them available so far, and resolving S +// first must give the same result rather than fail it as circular. + +interface C { [k: string]: S; } +>k : string + +type S = keyof C; +>S : never + +const k: S = 123; +>k : never +>123 : 123 + diff --git a/tsc/testdata/baselines/reference/compiler/keyofIndexSignatureCycleCheckOrder(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/keyofIndexSignatureCycleCheckOrder(checkorder=typesfirst).errors.txt new file mode 100644 index 0000000000000..4b322a738aee9 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/keyofIndexSignatureCycleCheckOrder(checkorder=typesfirst).errors.txt @@ -0,0 +1,14 @@ +keyofIndexSignatureCycleCheckOrder.ts(6,6): error TS2456: Type alias 'S' circularly references itself. + + +==== keyofIndexSignatureCycleCheckOrder.ts (1 errors) ==== + // S and the index signature of C depend on each other. Resolving the members + // of C first gives S from the part of them available so far, and resolving S + // first must give the same result rather than fail it as circular. + + interface C { [k: string]: S; } + type S = keyof C; + ~ +!!! error TS2456: Type alias 'S' circularly references itself. + const k: S = 123; + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/keyofIndexSignatureCycleCheckOrder(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/keyofIndexSignatureCycleCheckOrder(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..826be2b914e3b --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/keyofIndexSignatureCycleCheckOrder(checkorder=typesfirst).symbols @@ -0,0 +1,20 @@ +//// [tests/cases/compiler/keyofIndexSignatureCycleCheckOrder.ts] //// + +=== keyofIndexSignatureCycleCheckOrder.ts === +// S and the index signature of C depend on each other. Resolving the members +// of C first gives S from the part of them available so far, and resolving S +// first must give the same result rather than fail it as circular. + +interface C { [k: string]: S; } +>C : Symbol(C, Decl(keyofIndexSignatureCycleCheckOrder.ts, 0, 0)) +>k : Symbol(k, Decl(keyofIndexSignatureCycleCheckOrder.ts, 4, 15)) +>S : Symbol(S, Decl(keyofIndexSignatureCycleCheckOrder.ts, 4, 31)) + +type S = keyof C; +>S : Symbol(S, Decl(keyofIndexSignatureCycleCheckOrder.ts, 4, 31)) +>C : Symbol(C, Decl(keyofIndexSignatureCycleCheckOrder.ts, 0, 0)) + +const k: S = 123; +>k : Symbol(k, Decl(keyofIndexSignatureCycleCheckOrder.ts, 6, 5)) +>S : Symbol(S, Decl(keyofIndexSignatureCycleCheckOrder.ts, 4, 31)) + diff --git a/tsc/testdata/baselines/reference/compiler/keyofIndexSignatureCycleCheckOrder(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/keyofIndexSignatureCycleCheckOrder(checkorder=typesfirst).types new file mode 100644 index 0000000000000..812f122e35cc6 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/keyofIndexSignatureCycleCheckOrder(checkorder=typesfirst).types @@ -0,0 +1,17 @@ +//// [tests/cases/compiler/keyofIndexSignatureCycleCheckOrder.ts] //// + +=== keyofIndexSignatureCycleCheckOrder.ts === +// S and the index signature of C depend on each other. Resolving the members +// of C first gives S from the part of them available so far, and resolving S +// first must give the same result rather than fail it as circular. + +interface C { [k: string]: S; } +>k : string + +type S = keyof C; +>S : any + +const k: S = 123; +>k : any +>123 : 123 + 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..a1b033edf54ba --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/limitDeepInstantiations(checkorder=default).errors.txt @@ -0,0 +1,15 @@ +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 (2 errors) ==== + // Repro from #14837 + + type Foo = { "true": Foo> }[T]; + let f1: Foo<"true", {}>; + ~~~~~~~~~~~~~~~ +!!! 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..2998e94608985 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/limitDeepInstantiations(checkorder=typesfirst).errors.txt @@ -0,0 +1,14 @@ +error TS5114: Instantiations of type 'Foo' appear infinitely circular. +limitDeepInstantiations.ts(5,13): error TS2344: Type '"false"' does not satisfy the constraint '"true"'. + + +!!! error TS5114: Instantiations of type 'Foo' appear infinitely circular. +==== limitDeepInstantiations.ts (1 errors) ==== + // Repro from #14837 + + type Foo = { "true": Foo> }[T]; + let f1: Foo<"true", {}>; + 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/narrowedNeverAfterLoopWithAndCondition.errors.txt b/tsc/testdata/baselines/reference/compiler/narrowedNeverAfterLoopWithAndCondition.errors.txt new file mode 100644 index 0000000000000..0ba88e426e409 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/narrowedNeverAfterLoopWithAndCondition.errors.txt @@ -0,0 +1,29 @@ +narrowedNeverAfterLoopWithAndCondition.ts(9,9): error TS2322: Type 'false' is not assignable to 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 TS2322: Type 'false' is not assignable to type 'never'. + } + } + + function g(x: boolean) { + let value_def: { last_ref: boolean } | null = null; + if (value_def) { + while (x); + value_def.last_ref = false; + ~~~~~~~~ +!!! error TS2339: Property 'last_ref' does not exist on type 'never'. + } + } + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/narrowedNeverAfterLoopWithAndCondition.symbols b/tsc/testdata/baselines/reference/compiler/narrowedNeverAfterLoopWithAndCondition.symbols new file mode 100644 index 0000000000000..4320e2396f293 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/narrowedNeverAfterLoopWithAndCondition.symbols @@ -0,0 +1,47 @@ +//// [tests/cases/compiler/narrowedNeverAfterLoopWithAndCondition.ts] //// + +=== narrowedNeverAfterLoopWithAndCondition.ts === +// value_def is never inside the if. With a && condition, main and +// Strada leak the loop analysis's incomplete never placeholder +// (silentNever), so the property access is silently allowed and only +// the assignment errors. With `while (x)` they report the access. +function f(x: boolean, y: boolean) { +>f : Symbol(f, Decl(narrowedNeverAfterLoopWithAndCondition.ts, 0, 0)) +>x : Symbol(x, Decl(narrowedNeverAfterLoopWithAndCondition.ts, 4, 11)) +>y : Symbol(y, Decl(narrowedNeverAfterLoopWithAndCondition.ts, 4, 22)) + + let value_def: { last_ref: boolean } | null = null; +>value_def : Symbol(value_def, Decl(narrowedNeverAfterLoopWithAndCondition.ts, 5, 7)) +>last_ref : Symbol(last_ref, Decl(narrowedNeverAfterLoopWithAndCondition.ts, 5, 20)) + + if (value_def) { +>value_def : Symbol(value_def, Decl(narrowedNeverAfterLoopWithAndCondition.ts, 5, 7)) + + while (x && y); +>x : Symbol(x, Decl(narrowedNeverAfterLoopWithAndCondition.ts, 4, 11)) +>y : Symbol(y, Decl(narrowedNeverAfterLoopWithAndCondition.ts, 4, 22)) + + value_def.last_ref = false; +>value_def : Symbol(value_def, Decl(narrowedNeverAfterLoopWithAndCondition.ts, 5, 7)) + } +} + +function g(x: boolean) { +>g : Symbol(g, Decl(narrowedNeverAfterLoopWithAndCondition.ts, 10, 1)) +>x : Symbol(x, Decl(narrowedNeverAfterLoopWithAndCondition.ts, 12, 11)) + + let value_def: { last_ref: boolean } | null = null; +>value_def : Symbol(value_def, Decl(narrowedNeverAfterLoopWithAndCondition.ts, 13, 7)) +>last_ref : Symbol(last_ref, Decl(narrowedNeverAfterLoopWithAndCondition.ts, 13, 20)) + + if (value_def) { +>value_def : Symbol(value_def, Decl(narrowedNeverAfterLoopWithAndCondition.ts, 13, 7)) + + while (x); +>x : Symbol(x, Decl(narrowedNeverAfterLoopWithAndCondition.ts, 12, 11)) + + value_def.last_ref = false; +>value_def : Symbol(value_def, Decl(narrowedNeverAfterLoopWithAndCondition.ts, 13, 7)) + } +} + diff --git a/tsc/testdata/baselines/reference/compiler/narrowedNeverAfterLoopWithAndCondition.types b/tsc/testdata/baselines/reference/compiler/narrowedNeverAfterLoopWithAndCondition.types new file mode 100644 index 0000000000000..ec7b2e4bfcb90 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/narrowedNeverAfterLoopWithAndCondition.types @@ -0,0 +1,56 @@ +//// [tests/cases/compiler/narrowedNeverAfterLoopWithAndCondition.ts] //// + +=== narrowedNeverAfterLoopWithAndCondition.ts === +// value_def is never inside the if. With a && condition, main and +// Strada leak the loop analysis's incomplete never placeholder +// (silentNever), so the property access is silently allowed and only +// the assignment errors. With `while (x)` they report the access. +function f(x: boolean, y: boolean) { +>f : (x: boolean, y: boolean) => void +>x : boolean +>y : boolean + + let value_def: { last_ref: boolean } | null = null; +>value_def : { last_ref: boolean; } | null +>last_ref : boolean + + if (value_def) { +>value_def : null + + while (x && y); +>x && y : boolean +>x : boolean +>y : boolean + + value_def.last_ref = false; +>value_def.last_ref = false : false +>value_def.last_ref : any +>value_def : never +>last_ref : any +>false : false + } +} + +function g(x: boolean) { +>g : (x: boolean) => void +>x : boolean + + let value_def: { last_ref: boolean } | null = null; +>value_def : { last_ref: boolean; } | null +>last_ref : boolean + + if (value_def) { +>value_def : null + + while (x); +>x : boolean + + value_def.last_ref = false; +>value_def.last_ref = false : false +>value_def.last_ref : any +>value_def : never +>last_ref : any +>false : false + } +} + diff --git a/tsc/testdata/baselines/reference/compiler/nestedCallContextualTypeCheckOrder(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/nestedCallContextualTypeCheckOrder(checkorder=default).errors.txt new file mode 100644 index 0000000000000..3d0dd7f90da44 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/nestedCallContextualTypeCheckOrder(checkorder=default).errors.txt @@ -0,0 +1,75 @@ +nestedCallContextualTypeCheckOrder.ts(12,7): error TS2345: Argument of type '(x: never) => never' is not assignable to parameter of type '(x: number) => void'. + Types of parameters 'x' and 'x' are incompatible. + Type 'number' is not assignable to type 'never'. +nestedCallContextualTypeCheckOrder.ts(13,10): error TS2345: Argument of type '{ cb: (x: never) => never; v: number; }' is not assignable to parameter of type '{ cb: (x: number) => void; v: number; }'. + Types of property 'cb' are incompatible. + Type '(x: never) => never' is not assignable to type '(x: number) => void'. + Types of parameters 'x' and 'x' are incompatible. + Type 'number' is not assignable to type 'never'. +nestedCallContextualTypeCheckOrder.ts(14,15): error TS7006: Parameter 'x' implicitly has an 'any' type. +nestedCallContextualTypeCheckOrder.ts(15,7): error TS2345: Argument of type '(x: never) => never' is not assignable to parameter of type '(x: number) => void'. + Types of parameters 'x' and 'x' are incompatible. + Type 'number' is not assignable to type 'never'. +nestedCallContextualTypeCheckOrder.ts(16,7): error TS2345: Argument of type '(x: never) => never' is not assignable to parameter of type '(x: number) => void'. + Types of parameters 'x' and 'x' are incompatible. + Type 'number' is not assignable to type 'never'. +nestedCallContextualTypeCheckOrder.ts(17,10): error TS2345: Argument of type '() => Generator<(x: never) => never, void, any>' is not assignable to parameter of type '() => Generator<(x: number) => void, any, any>'. + Type 'Generator<(x: never) => never, void, any>' is not assignable to type 'Generator<(x: number) => void, any, any>'. + The types returned by 'next(...)' are incompatible between these types. + Type 'IteratorResult<(x: never) => never, void>' is not assignable to type 'IteratorResult<(x: number) => void, any>'. + Type 'IteratorYieldResult<(x: never) => never>' is not assignable to type 'IteratorResult<(x: number) => void, any>'. + Type 'IteratorYieldResult<(x: never) => never>' is not assignable to type 'IteratorYieldResult<(x: number) => void>'. + Type '(x: never) => never' is not assignable to type '(x: number) => void'. + Types of parameters 'x' and 'x' are incompatible. + Type 'number' is not assignable to type 'never'. + + +==== nestedCallContextualTypeCheckOrder.ts (6 errors) ==== + // A generic call whose contextual type comes from an enclosing call is + // resolved after it, whichever is queried first, through every expression + // that passes the contextual type on. + + declare function outer(cb: (x: T) => void, v: T): void; + declare function outerObj(o: { cb: (x: T) => void; v: T }): void; + declare function outerGen(g: () => Generator<(x: T) => void>, v: T): void; + declare function wrap(f: U): U; + declare function tag(s: TemplateStringsArray, cb: (x: T) => void, v: T): void; + declare function tagWrap(s: TemplateStringsArray, f: U): U; + + outer(wrap((x) => x.toFixed())!, 1); + ~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2345: Argument of type '(x: never) => never' is not assignable to parameter of type '(x: number) => void'. +!!! error TS2345: Types of parameters 'x' and 'x' are incompatible. +!!! error TS2345: Type 'number' is not assignable to type 'never'. + outerObj({ ...{ cb: wrap((x) => x.toFixed()) }, v: 1 }); + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2345: Argument of type '{ cb: (x: never) => never; v: number; }' is not assignable to parameter of type '{ cb: (x: number) => void; v: number; }'. +!!! error TS2345: Types of property 'cb' are incompatible. +!!! error TS2345: Type '(x: never) => never' is not assignable to type '(x: number) => void'. +!!! error TS2345: Types of parameters 'x' and 'x' are incompatible. +!!! error TS2345: Type 'number' is not assignable to type 'never'. + outer(([wrap((x) => x.toFixed())] as const)[0], 1); + ~ +!!! error TS7006: Parameter 'x' implicitly has an 'any' type. + tag`${wrap((x) => x.toFixed())}${1}`; + ~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2345: Argument of type '(x: never) => never' is not assignable to parameter of type '(x: number) => void'. +!!! error TS2345: Types of parameters 'x' and 'x' are incompatible. +!!! error TS2345: Type 'number' is not assignable to type 'never'. + outer(tagWrap`${(x) => x.toFixed()}`, 1); + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2345: Argument of type '(x: never) => never' is not assignable to parameter of type '(x: number) => void'. +!!! error TS2345: Types of parameters 'x' and 'x' are incompatible. +!!! error TS2345: Type 'number' is not assignable to type 'never'. + outerGen(function* () { yield wrap((x) => x.toFixed()); }, 1); + ~~~~~~~~ +!!! error TS2345: Argument of type '() => Generator<(x: never) => never, void, any>' is not assignable to parameter of type '() => Generator<(x: number) => void, any, any>'. +!!! error TS2345: Type 'Generator<(x: never) => never, void, any>' is not assignable to type 'Generator<(x: number) => void, any, any>'. +!!! error TS2345: The types returned by 'next(...)' are incompatible between these types. +!!! error TS2345: Type 'IteratorResult<(x: never) => never, void>' is not assignable to type 'IteratorResult<(x: number) => void, any>'. +!!! error TS2345: Type 'IteratorYieldResult<(x: never) => never>' is not assignable to type 'IteratorResult<(x: number) => void, any>'. +!!! error TS2345: Type 'IteratorYieldResult<(x: never) => never>' is not assignable to type 'IteratorYieldResult<(x: number) => void>'. +!!! error TS2345: Type '(x: never) => never' is not assignable to type '(x: number) => void'. +!!! error TS2345: Types of parameters 'x' and 'x' are incompatible. +!!! error TS2345: Type 'number' is not assignable to type 'never'. + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/nestedCallContextualTypeCheckOrder(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/nestedCallContextualTypeCheckOrder(checkorder=default).symbols new file mode 100644 index 0000000000000..c570d8990f40c --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/nestedCallContextualTypeCheckOrder(checkorder=default).symbols @@ -0,0 +1,103 @@ +//// [tests/cases/compiler/nestedCallContextualTypeCheckOrder.ts] //// + +=== nestedCallContextualTypeCheckOrder.ts === +// A generic call whose contextual type comes from an enclosing call is +// resolved after it, whichever is queried first, through every expression +// that passes the contextual type on. + +declare function outer(cb: (x: T) => void, v: T): void; +>outer : Symbol(outer, Decl(nestedCallContextualTypeCheckOrder.ts, 0, 0)) +>T : Symbol(T, Decl(nestedCallContextualTypeCheckOrder.ts, 4, 23)) +>cb : Symbol(cb, Decl(nestedCallContextualTypeCheckOrder.ts, 4, 26)) +>x : Symbol(x, Decl(nestedCallContextualTypeCheckOrder.ts, 4, 31)) +>T : Symbol(T, Decl(nestedCallContextualTypeCheckOrder.ts, 4, 23)) +>v : Symbol(v, Decl(nestedCallContextualTypeCheckOrder.ts, 4, 45)) +>T : Symbol(T, Decl(nestedCallContextualTypeCheckOrder.ts, 4, 23)) + +declare function outerObj(o: { cb: (x: T) => void; v: T }): void; +>outerObj : Symbol(outerObj, Decl(nestedCallContextualTypeCheckOrder.ts, 4, 58)) +>T : Symbol(T, Decl(nestedCallContextualTypeCheckOrder.ts, 5, 26)) +>o : Symbol(o, Decl(nestedCallContextualTypeCheckOrder.ts, 5, 29)) +>cb : Symbol(cb, Decl(nestedCallContextualTypeCheckOrder.ts, 5, 33)) +>x : Symbol(x, Decl(nestedCallContextualTypeCheckOrder.ts, 5, 39)) +>T : Symbol(T, Decl(nestedCallContextualTypeCheckOrder.ts, 5, 26)) +>v : Symbol(v, Decl(nestedCallContextualTypeCheckOrder.ts, 5, 53)) +>T : Symbol(T, Decl(nestedCallContextualTypeCheckOrder.ts, 5, 26)) + +declare function outerGen(g: () => Generator<(x: T) => void>, v: T): void; +>outerGen : Symbol(outerGen, Decl(nestedCallContextualTypeCheckOrder.ts, 5, 68)) +>T : Symbol(T, Decl(nestedCallContextualTypeCheckOrder.ts, 6, 26)) +>g : Symbol(g, Decl(nestedCallContextualTypeCheckOrder.ts, 6, 29)) +>Generator : Symbol(Generator, Decl(lib.es2015.generator.d.ts, --, --)) +>x : Symbol(x, Decl(nestedCallContextualTypeCheckOrder.ts, 6, 49)) +>T : Symbol(T, Decl(nestedCallContextualTypeCheckOrder.ts, 6, 26)) +>v : Symbol(v, Decl(nestedCallContextualTypeCheckOrder.ts, 6, 64)) +>T : Symbol(T, Decl(nestedCallContextualTypeCheckOrder.ts, 6, 26)) + +declare function wrap(f: U): U; +>wrap : Symbol(wrap, Decl(nestedCallContextualTypeCheckOrder.ts, 6, 77)) +>U : Symbol(U, Decl(nestedCallContextualTypeCheckOrder.ts, 7, 22)) +>f : Symbol(f, Decl(nestedCallContextualTypeCheckOrder.ts, 7, 25)) +>U : Symbol(U, Decl(nestedCallContextualTypeCheckOrder.ts, 7, 22)) +>U : Symbol(U, Decl(nestedCallContextualTypeCheckOrder.ts, 7, 22)) + +declare function tag(s: TemplateStringsArray, cb: (x: T) => void, v: T): void; +>tag : Symbol(tag, Decl(nestedCallContextualTypeCheckOrder.ts, 7, 34)) +>T : Symbol(T, Decl(nestedCallContextualTypeCheckOrder.ts, 8, 21)) +>s : Symbol(s, Decl(nestedCallContextualTypeCheckOrder.ts, 8, 24)) +>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es5.d.ts, --, --)) +>cb : Symbol(cb, Decl(nestedCallContextualTypeCheckOrder.ts, 8, 48)) +>x : Symbol(x, Decl(nestedCallContextualTypeCheckOrder.ts, 8, 54)) +>T : Symbol(T, Decl(nestedCallContextualTypeCheckOrder.ts, 8, 21)) +>v : Symbol(v, Decl(nestedCallContextualTypeCheckOrder.ts, 8, 68)) +>T : Symbol(T, Decl(nestedCallContextualTypeCheckOrder.ts, 8, 21)) + +declare function tagWrap(s: TemplateStringsArray, f: U): U; +>tagWrap : Symbol(tagWrap, Decl(nestedCallContextualTypeCheckOrder.ts, 8, 81)) +>U : Symbol(U, Decl(nestedCallContextualTypeCheckOrder.ts, 9, 25)) +>s : Symbol(s, Decl(nestedCallContextualTypeCheckOrder.ts, 9, 28)) +>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es5.d.ts, --, --)) +>f : Symbol(f, Decl(nestedCallContextualTypeCheckOrder.ts, 9, 52)) +>U : Symbol(U, Decl(nestedCallContextualTypeCheckOrder.ts, 9, 25)) +>U : Symbol(U, Decl(nestedCallContextualTypeCheckOrder.ts, 9, 25)) + +outer(wrap((x) => x.toFixed())!, 1); +>outer : Symbol(outer, Decl(nestedCallContextualTypeCheckOrder.ts, 0, 0)) +>wrap : Symbol(wrap, Decl(nestedCallContextualTypeCheckOrder.ts, 6, 77)) +>x : Symbol(x, Decl(nestedCallContextualTypeCheckOrder.ts, 11, 12)) +>x : Symbol(x, Decl(nestedCallContextualTypeCheckOrder.ts, 11, 12)) + +outerObj({ ...{ cb: wrap((x) => x.toFixed()) }, v: 1 }); +>outerObj : Symbol(outerObj, Decl(nestedCallContextualTypeCheckOrder.ts, 4, 58)) +>cb : Symbol(cb, Decl(nestedCallContextualTypeCheckOrder.ts, 12, 15)) +>wrap : Symbol(wrap, Decl(nestedCallContextualTypeCheckOrder.ts, 6, 77)) +>x : Symbol(x, Decl(nestedCallContextualTypeCheckOrder.ts, 12, 26)) +>x : Symbol(x, Decl(nestedCallContextualTypeCheckOrder.ts, 12, 26)) +>v : Symbol(v, Decl(nestedCallContextualTypeCheckOrder.ts, 12, 47)) + +outer(([wrap((x) => x.toFixed())] as const)[0], 1); +>outer : Symbol(outer, Decl(nestedCallContextualTypeCheckOrder.ts, 0, 0)) +>wrap : Symbol(wrap, Decl(nestedCallContextualTypeCheckOrder.ts, 6, 77)) +>x : Symbol(x, Decl(nestedCallContextualTypeCheckOrder.ts, 13, 14)) +>x : Symbol(x, Decl(nestedCallContextualTypeCheckOrder.ts, 13, 14)) +>const : Symbol(const) +>0 : Symbol(0) + +tag`${wrap((x) => x.toFixed())}${1}`; +>tag : Symbol(tag, Decl(nestedCallContextualTypeCheckOrder.ts, 7, 34)) +>wrap : Symbol(wrap, Decl(nestedCallContextualTypeCheckOrder.ts, 6, 77)) +>x : Symbol(x, Decl(nestedCallContextualTypeCheckOrder.ts, 14, 12)) +>x : Symbol(x, Decl(nestedCallContextualTypeCheckOrder.ts, 14, 12)) + +outer(tagWrap`${(x) => x.toFixed()}`, 1); +>outer : Symbol(outer, Decl(nestedCallContextualTypeCheckOrder.ts, 0, 0)) +>tagWrap : Symbol(tagWrap, Decl(nestedCallContextualTypeCheckOrder.ts, 8, 81)) +>x : Symbol(x, Decl(nestedCallContextualTypeCheckOrder.ts, 15, 17)) +>x : Symbol(x, Decl(nestedCallContextualTypeCheckOrder.ts, 15, 17)) + +outerGen(function* () { yield wrap((x) => x.toFixed()); }, 1); +>outerGen : Symbol(outerGen, Decl(nestedCallContextualTypeCheckOrder.ts, 5, 68)) +>wrap : Symbol(wrap, Decl(nestedCallContextualTypeCheckOrder.ts, 6, 77)) +>x : Symbol(x, Decl(nestedCallContextualTypeCheckOrder.ts, 16, 36)) +>x : Symbol(x, Decl(nestedCallContextualTypeCheckOrder.ts, 16, 36)) + diff --git a/tsc/testdata/baselines/reference/compiler/nestedCallContextualTypeCheckOrder(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/nestedCallContextualTypeCheckOrder(checkorder=default).types new file mode 100644 index 0000000000000..2d6dc49211323 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/nestedCallContextualTypeCheckOrder(checkorder=default).types @@ -0,0 +1,134 @@ +//// [tests/cases/compiler/nestedCallContextualTypeCheckOrder.ts] //// + +=== nestedCallContextualTypeCheckOrder.ts === +// A generic call whose contextual type comes from an enclosing call is +// resolved after it, whichever is queried first, through every expression +// that passes the contextual type on. + +declare function outer(cb: (x: T) => void, v: T): void; +>outer : (cb: (x: T) => void, v: T) => void +>cb : (x: T) => void +>x : T +>v : T + +declare function outerObj(o: { cb: (x: T) => void; v: T }): void; +>outerObj : (o: { cb: (x: T) => void; v: T; }) => void +>o : { cb: (x: T) => void; v: T; } +>cb : (x: T) => void +>x : T +>v : T + +declare function outerGen(g: () => Generator<(x: T) => void>, v: T): void; +>outerGen : (g: () => Generator<(x: T) => void>, v: T) => void +>g : () => Generator<(x: T) => void> +>x : T +>v : T + +declare function wrap(f: U): U; +>wrap : (f: U) => U +>f : U + +declare function tag(s: TemplateStringsArray, cb: (x: T) => void, v: T): void; +>tag : (s: TemplateStringsArray, cb: (x: T) => void, v: T) => void +>s : TemplateStringsArray +>cb : (x: T) => void +>x : T +>v : T + +declare function tagWrap(s: TemplateStringsArray, f: U): U; +>tagWrap : (s: TemplateStringsArray, f: U) => U +>s : TemplateStringsArray +>f : U + +outer(wrap((x) => x.toFixed())!, 1); +>outer(wrap((x) => x.toFixed())!, 1) : void +>outer : (cb: (x: T) => void, v: T) => void +>wrap((x) => x.toFixed())! : (x: never) => never +>wrap((x) => x.toFixed()) : (x: never) => never +>wrap : (f: U) => U +>(x) => x.toFixed() : (x: never) => never +>x : never +>x.toFixed() : never +>x.toFixed : never +>x : never +>toFixed : never +>1 : 1 + +outerObj({ ...{ cb: wrap((x) => x.toFixed()) }, v: 1 }); +>outerObj({ ...{ cb: wrap((x) => x.toFixed()) }, v: 1 }) : void +>outerObj : (o: { cb: (x: T) => void; v: T; }) => void +>{ ...{ cb: wrap((x) => x.toFixed()) }, v: 1 } : { cb: (x: never) => never; v: number; } +>{ cb: wrap((x) => x.toFixed()) } : { cb: (x: never) => never; } +>cb : (x: never) => never +>wrap((x) => x.toFixed()) : (x: never) => never +>wrap : (f: U) => U +>(x) => x.toFixed() : (x: never) => never +>x : never +>x.toFixed() : never +>x.toFixed : never +>x : never +>toFixed : never +>v : number +>1 : 1 + +outer(([wrap((x) => x.toFixed())] as const)[0], 1); +>outer(([wrap((x) => x.toFixed())] as const)[0], 1) : void +>outer : (cb: (x: T) => void, v: T) => void +>([wrap((x) => x.toFixed())] as const)[0] : (x: any) => any +>([wrap((x) => x.toFixed())] as const) : readonly [(x: any) => any] +>[wrap((x) => x.toFixed())] as const : readonly [(x: any) => any] +>[wrap((x) => x.toFixed())] : readonly [(x: any) => any] +>wrap((x) => x.toFixed()) : (x: any) => any +>wrap : (f: U) => U +>(x) => x.toFixed() : (x: any) => any +>x : any +>x.toFixed() : any +>x.toFixed : any +>x : any +>toFixed : any +>0 : 0 +>1 : 1 + +tag`${wrap((x) => x.toFixed())}${1}`; +>tag`${wrap((x) => x.toFixed())}${1}` : void +>tag : (s: TemplateStringsArray, cb: (x: T) => void, v: T) => void +>`${wrap((x) => x.toFixed())}${1}` : string +>wrap((x) => x.toFixed()) : (x: never) => never +>wrap : (f: U) => U +>(x) => x.toFixed() : (x: never) => never +>x : never +>x.toFixed() : never +>x.toFixed : never +>x : never +>toFixed : never +>1 : 1 + +outer(tagWrap`${(x) => x.toFixed()}`, 1); +>outer(tagWrap`${(x) => x.toFixed()}`, 1) : void +>outer : (cb: (x: T) => void, v: T) => void +>tagWrap`${(x) => x.toFixed()}` : (x: never) => never +>tagWrap : (s: TemplateStringsArray, f: U) => U +>`${(x) => x.toFixed()}` : string +>(x) => x.toFixed() : (x: never) => never +>x : never +>x.toFixed() : never +>x.toFixed : never +>x : never +>toFixed : never +>1 : 1 + +outerGen(function* () { yield wrap((x) => x.toFixed()); }, 1); +>outerGen(function* () { yield wrap((x) => x.toFixed()); }, 1) : void +>outerGen : (g: () => Generator<(x: T) => void>, v: T) => void +>function* () { yield wrap((x) => x.toFixed()); } : () => Generator<(x: never) => never, void, any> +>yield wrap((x) => x.toFixed()) : any +>wrap((x) => x.toFixed()) : (x: never) => never +>wrap : (f: U) => U +>(x) => x.toFixed() : (x: never) => never +>x : never +>x.toFixed() : never +>x.toFixed : never +>x : never +>toFixed : never +>1 : 1 + diff --git a/tsc/testdata/baselines/reference/compiler/nestedCallContextualTypeCheckOrder(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/nestedCallContextualTypeCheckOrder(checkorder=typesfirst).errors.txt new file mode 100644 index 0000000000000..3d0dd7f90da44 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/nestedCallContextualTypeCheckOrder(checkorder=typesfirst).errors.txt @@ -0,0 +1,75 @@ +nestedCallContextualTypeCheckOrder.ts(12,7): error TS2345: Argument of type '(x: never) => never' is not assignable to parameter of type '(x: number) => void'. + Types of parameters 'x' and 'x' are incompatible. + Type 'number' is not assignable to type 'never'. +nestedCallContextualTypeCheckOrder.ts(13,10): error TS2345: Argument of type '{ cb: (x: never) => never; v: number; }' is not assignable to parameter of type '{ cb: (x: number) => void; v: number; }'. + Types of property 'cb' are incompatible. + Type '(x: never) => never' is not assignable to type '(x: number) => void'. + Types of parameters 'x' and 'x' are incompatible. + Type 'number' is not assignable to type 'never'. +nestedCallContextualTypeCheckOrder.ts(14,15): error TS7006: Parameter 'x' implicitly has an 'any' type. +nestedCallContextualTypeCheckOrder.ts(15,7): error TS2345: Argument of type '(x: never) => never' is not assignable to parameter of type '(x: number) => void'. + Types of parameters 'x' and 'x' are incompatible. + Type 'number' is not assignable to type 'never'. +nestedCallContextualTypeCheckOrder.ts(16,7): error TS2345: Argument of type '(x: never) => never' is not assignable to parameter of type '(x: number) => void'. + Types of parameters 'x' and 'x' are incompatible. + Type 'number' is not assignable to type 'never'. +nestedCallContextualTypeCheckOrder.ts(17,10): error TS2345: Argument of type '() => Generator<(x: never) => never, void, any>' is not assignable to parameter of type '() => Generator<(x: number) => void, any, any>'. + Type 'Generator<(x: never) => never, void, any>' is not assignable to type 'Generator<(x: number) => void, any, any>'. + The types returned by 'next(...)' are incompatible between these types. + Type 'IteratorResult<(x: never) => never, void>' is not assignable to type 'IteratorResult<(x: number) => void, any>'. + Type 'IteratorYieldResult<(x: never) => never>' is not assignable to type 'IteratorResult<(x: number) => void, any>'. + Type 'IteratorYieldResult<(x: never) => never>' is not assignable to type 'IteratorYieldResult<(x: number) => void>'. + Type '(x: never) => never' is not assignable to type '(x: number) => void'. + Types of parameters 'x' and 'x' are incompatible. + Type 'number' is not assignable to type 'never'. + + +==== nestedCallContextualTypeCheckOrder.ts (6 errors) ==== + // A generic call whose contextual type comes from an enclosing call is + // resolved after it, whichever is queried first, through every expression + // that passes the contextual type on. + + declare function outer(cb: (x: T) => void, v: T): void; + declare function outerObj(o: { cb: (x: T) => void; v: T }): void; + declare function outerGen(g: () => Generator<(x: T) => void>, v: T): void; + declare function wrap(f: U): U; + declare function tag(s: TemplateStringsArray, cb: (x: T) => void, v: T): void; + declare function tagWrap(s: TemplateStringsArray, f: U): U; + + outer(wrap((x) => x.toFixed())!, 1); + ~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2345: Argument of type '(x: never) => never' is not assignable to parameter of type '(x: number) => void'. +!!! error TS2345: Types of parameters 'x' and 'x' are incompatible. +!!! error TS2345: Type 'number' is not assignable to type 'never'. + outerObj({ ...{ cb: wrap((x) => x.toFixed()) }, v: 1 }); + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2345: Argument of type '{ cb: (x: never) => never; v: number; }' is not assignable to parameter of type '{ cb: (x: number) => void; v: number; }'. +!!! error TS2345: Types of property 'cb' are incompatible. +!!! error TS2345: Type '(x: never) => never' is not assignable to type '(x: number) => void'. +!!! error TS2345: Types of parameters 'x' and 'x' are incompatible. +!!! error TS2345: Type 'number' is not assignable to type 'never'. + outer(([wrap((x) => x.toFixed())] as const)[0], 1); + ~ +!!! error TS7006: Parameter 'x' implicitly has an 'any' type. + tag`${wrap((x) => x.toFixed())}${1}`; + ~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2345: Argument of type '(x: never) => never' is not assignable to parameter of type '(x: number) => void'. +!!! error TS2345: Types of parameters 'x' and 'x' are incompatible. +!!! error TS2345: Type 'number' is not assignable to type 'never'. + outer(tagWrap`${(x) => x.toFixed()}`, 1); + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2345: Argument of type '(x: never) => never' is not assignable to parameter of type '(x: number) => void'. +!!! error TS2345: Types of parameters 'x' and 'x' are incompatible. +!!! error TS2345: Type 'number' is not assignable to type 'never'. + outerGen(function* () { yield wrap((x) => x.toFixed()); }, 1); + ~~~~~~~~ +!!! error TS2345: Argument of type '() => Generator<(x: never) => never, void, any>' is not assignable to parameter of type '() => Generator<(x: number) => void, any, any>'. +!!! error TS2345: Type 'Generator<(x: never) => never, void, any>' is not assignable to type 'Generator<(x: number) => void, any, any>'. +!!! error TS2345: The types returned by 'next(...)' are incompatible between these types. +!!! error TS2345: Type 'IteratorResult<(x: never) => never, void>' is not assignable to type 'IteratorResult<(x: number) => void, any>'. +!!! error TS2345: Type 'IteratorYieldResult<(x: never) => never>' is not assignable to type 'IteratorResult<(x: number) => void, any>'. +!!! error TS2345: Type 'IteratorYieldResult<(x: never) => never>' is not assignable to type 'IteratorYieldResult<(x: number) => void>'. +!!! error TS2345: Type '(x: never) => never' is not assignable to type '(x: number) => void'. +!!! error TS2345: Types of parameters 'x' and 'x' are incompatible. +!!! error TS2345: Type 'number' is not assignable to type 'never'. + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/nestedCallContextualTypeCheckOrder(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/nestedCallContextualTypeCheckOrder(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..c570d8990f40c --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/nestedCallContextualTypeCheckOrder(checkorder=typesfirst).symbols @@ -0,0 +1,103 @@ +//// [tests/cases/compiler/nestedCallContextualTypeCheckOrder.ts] //// + +=== nestedCallContextualTypeCheckOrder.ts === +// A generic call whose contextual type comes from an enclosing call is +// resolved after it, whichever is queried first, through every expression +// that passes the contextual type on. + +declare function outer(cb: (x: T) => void, v: T): void; +>outer : Symbol(outer, Decl(nestedCallContextualTypeCheckOrder.ts, 0, 0)) +>T : Symbol(T, Decl(nestedCallContextualTypeCheckOrder.ts, 4, 23)) +>cb : Symbol(cb, Decl(nestedCallContextualTypeCheckOrder.ts, 4, 26)) +>x : Symbol(x, Decl(nestedCallContextualTypeCheckOrder.ts, 4, 31)) +>T : Symbol(T, Decl(nestedCallContextualTypeCheckOrder.ts, 4, 23)) +>v : Symbol(v, Decl(nestedCallContextualTypeCheckOrder.ts, 4, 45)) +>T : Symbol(T, Decl(nestedCallContextualTypeCheckOrder.ts, 4, 23)) + +declare function outerObj(o: { cb: (x: T) => void; v: T }): void; +>outerObj : Symbol(outerObj, Decl(nestedCallContextualTypeCheckOrder.ts, 4, 58)) +>T : Symbol(T, Decl(nestedCallContextualTypeCheckOrder.ts, 5, 26)) +>o : Symbol(o, Decl(nestedCallContextualTypeCheckOrder.ts, 5, 29)) +>cb : Symbol(cb, Decl(nestedCallContextualTypeCheckOrder.ts, 5, 33)) +>x : Symbol(x, Decl(nestedCallContextualTypeCheckOrder.ts, 5, 39)) +>T : Symbol(T, Decl(nestedCallContextualTypeCheckOrder.ts, 5, 26)) +>v : Symbol(v, Decl(nestedCallContextualTypeCheckOrder.ts, 5, 53)) +>T : Symbol(T, Decl(nestedCallContextualTypeCheckOrder.ts, 5, 26)) + +declare function outerGen(g: () => Generator<(x: T) => void>, v: T): void; +>outerGen : Symbol(outerGen, Decl(nestedCallContextualTypeCheckOrder.ts, 5, 68)) +>T : Symbol(T, Decl(nestedCallContextualTypeCheckOrder.ts, 6, 26)) +>g : Symbol(g, Decl(nestedCallContextualTypeCheckOrder.ts, 6, 29)) +>Generator : Symbol(Generator, Decl(lib.es2015.generator.d.ts, --, --)) +>x : Symbol(x, Decl(nestedCallContextualTypeCheckOrder.ts, 6, 49)) +>T : Symbol(T, Decl(nestedCallContextualTypeCheckOrder.ts, 6, 26)) +>v : Symbol(v, Decl(nestedCallContextualTypeCheckOrder.ts, 6, 64)) +>T : Symbol(T, Decl(nestedCallContextualTypeCheckOrder.ts, 6, 26)) + +declare function wrap(f: U): U; +>wrap : Symbol(wrap, Decl(nestedCallContextualTypeCheckOrder.ts, 6, 77)) +>U : Symbol(U, Decl(nestedCallContextualTypeCheckOrder.ts, 7, 22)) +>f : Symbol(f, Decl(nestedCallContextualTypeCheckOrder.ts, 7, 25)) +>U : Symbol(U, Decl(nestedCallContextualTypeCheckOrder.ts, 7, 22)) +>U : Symbol(U, Decl(nestedCallContextualTypeCheckOrder.ts, 7, 22)) + +declare function tag(s: TemplateStringsArray, cb: (x: T) => void, v: T): void; +>tag : Symbol(tag, Decl(nestedCallContextualTypeCheckOrder.ts, 7, 34)) +>T : Symbol(T, Decl(nestedCallContextualTypeCheckOrder.ts, 8, 21)) +>s : Symbol(s, Decl(nestedCallContextualTypeCheckOrder.ts, 8, 24)) +>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es5.d.ts, --, --)) +>cb : Symbol(cb, Decl(nestedCallContextualTypeCheckOrder.ts, 8, 48)) +>x : Symbol(x, Decl(nestedCallContextualTypeCheckOrder.ts, 8, 54)) +>T : Symbol(T, Decl(nestedCallContextualTypeCheckOrder.ts, 8, 21)) +>v : Symbol(v, Decl(nestedCallContextualTypeCheckOrder.ts, 8, 68)) +>T : Symbol(T, Decl(nestedCallContextualTypeCheckOrder.ts, 8, 21)) + +declare function tagWrap(s: TemplateStringsArray, f: U): U; +>tagWrap : Symbol(tagWrap, Decl(nestedCallContextualTypeCheckOrder.ts, 8, 81)) +>U : Symbol(U, Decl(nestedCallContextualTypeCheckOrder.ts, 9, 25)) +>s : Symbol(s, Decl(nestedCallContextualTypeCheckOrder.ts, 9, 28)) +>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es5.d.ts, --, --)) +>f : Symbol(f, Decl(nestedCallContextualTypeCheckOrder.ts, 9, 52)) +>U : Symbol(U, Decl(nestedCallContextualTypeCheckOrder.ts, 9, 25)) +>U : Symbol(U, Decl(nestedCallContextualTypeCheckOrder.ts, 9, 25)) + +outer(wrap((x) => x.toFixed())!, 1); +>outer : Symbol(outer, Decl(nestedCallContextualTypeCheckOrder.ts, 0, 0)) +>wrap : Symbol(wrap, Decl(nestedCallContextualTypeCheckOrder.ts, 6, 77)) +>x : Symbol(x, Decl(nestedCallContextualTypeCheckOrder.ts, 11, 12)) +>x : Symbol(x, Decl(nestedCallContextualTypeCheckOrder.ts, 11, 12)) + +outerObj({ ...{ cb: wrap((x) => x.toFixed()) }, v: 1 }); +>outerObj : Symbol(outerObj, Decl(nestedCallContextualTypeCheckOrder.ts, 4, 58)) +>cb : Symbol(cb, Decl(nestedCallContextualTypeCheckOrder.ts, 12, 15)) +>wrap : Symbol(wrap, Decl(nestedCallContextualTypeCheckOrder.ts, 6, 77)) +>x : Symbol(x, Decl(nestedCallContextualTypeCheckOrder.ts, 12, 26)) +>x : Symbol(x, Decl(nestedCallContextualTypeCheckOrder.ts, 12, 26)) +>v : Symbol(v, Decl(nestedCallContextualTypeCheckOrder.ts, 12, 47)) + +outer(([wrap((x) => x.toFixed())] as const)[0], 1); +>outer : Symbol(outer, Decl(nestedCallContextualTypeCheckOrder.ts, 0, 0)) +>wrap : Symbol(wrap, Decl(nestedCallContextualTypeCheckOrder.ts, 6, 77)) +>x : Symbol(x, Decl(nestedCallContextualTypeCheckOrder.ts, 13, 14)) +>x : Symbol(x, Decl(nestedCallContextualTypeCheckOrder.ts, 13, 14)) +>const : Symbol(const) +>0 : Symbol(0) + +tag`${wrap((x) => x.toFixed())}${1}`; +>tag : Symbol(tag, Decl(nestedCallContextualTypeCheckOrder.ts, 7, 34)) +>wrap : Symbol(wrap, Decl(nestedCallContextualTypeCheckOrder.ts, 6, 77)) +>x : Symbol(x, Decl(nestedCallContextualTypeCheckOrder.ts, 14, 12)) +>x : Symbol(x, Decl(nestedCallContextualTypeCheckOrder.ts, 14, 12)) + +outer(tagWrap`${(x) => x.toFixed()}`, 1); +>outer : Symbol(outer, Decl(nestedCallContextualTypeCheckOrder.ts, 0, 0)) +>tagWrap : Symbol(tagWrap, Decl(nestedCallContextualTypeCheckOrder.ts, 8, 81)) +>x : Symbol(x, Decl(nestedCallContextualTypeCheckOrder.ts, 15, 17)) +>x : Symbol(x, Decl(nestedCallContextualTypeCheckOrder.ts, 15, 17)) + +outerGen(function* () { yield wrap((x) => x.toFixed()); }, 1); +>outerGen : Symbol(outerGen, Decl(nestedCallContextualTypeCheckOrder.ts, 5, 68)) +>wrap : Symbol(wrap, Decl(nestedCallContextualTypeCheckOrder.ts, 6, 77)) +>x : Symbol(x, Decl(nestedCallContextualTypeCheckOrder.ts, 16, 36)) +>x : Symbol(x, Decl(nestedCallContextualTypeCheckOrder.ts, 16, 36)) + diff --git a/tsc/testdata/baselines/reference/compiler/nestedCallContextualTypeCheckOrder(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/nestedCallContextualTypeCheckOrder(checkorder=typesfirst).types new file mode 100644 index 0000000000000..2d6dc49211323 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/nestedCallContextualTypeCheckOrder(checkorder=typesfirst).types @@ -0,0 +1,134 @@ +//// [tests/cases/compiler/nestedCallContextualTypeCheckOrder.ts] //// + +=== nestedCallContextualTypeCheckOrder.ts === +// A generic call whose contextual type comes from an enclosing call is +// resolved after it, whichever is queried first, through every expression +// that passes the contextual type on. + +declare function outer(cb: (x: T) => void, v: T): void; +>outer : (cb: (x: T) => void, v: T) => void +>cb : (x: T) => void +>x : T +>v : T + +declare function outerObj(o: { cb: (x: T) => void; v: T }): void; +>outerObj : (o: { cb: (x: T) => void; v: T; }) => void +>o : { cb: (x: T) => void; v: T; } +>cb : (x: T) => void +>x : T +>v : T + +declare function outerGen(g: () => Generator<(x: T) => void>, v: T): void; +>outerGen : (g: () => Generator<(x: T) => void>, v: T) => void +>g : () => Generator<(x: T) => void> +>x : T +>v : T + +declare function wrap(f: U): U; +>wrap : (f: U) => U +>f : U + +declare function tag(s: TemplateStringsArray, cb: (x: T) => void, v: T): void; +>tag : (s: TemplateStringsArray, cb: (x: T) => void, v: T) => void +>s : TemplateStringsArray +>cb : (x: T) => void +>x : T +>v : T + +declare function tagWrap(s: TemplateStringsArray, f: U): U; +>tagWrap : (s: TemplateStringsArray, f: U) => U +>s : TemplateStringsArray +>f : U + +outer(wrap((x) => x.toFixed())!, 1); +>outer(wrap((x) => x.toFixed())!, 1) : void +>outer : (cb: (x: T) => void, v: T) => void +>wrap((x) => x.toFixed())! : (x: never) => never +>wrap((x) => x.toFixed()) : (x: never) => never +>wrap : (f: U) => U +>(x) => x.toFixed() : (x: never) => never +>x : never +>x.toFixed() : never +>x.toFixed : never +>x : never +>toFixed : never +>1 : 1 + +outerObj({ ...{ cb: wrap((x) => x.toFixed()) }, v: 1 }); +>outerObj({ ...{ cb: wrap((x) => x.toFixed()) }, v: 1 }) : void +>outerObj : (o: { cb: (x: T) => void; v: T; }) => void +>{ ...{ cb: wrap((x) => x.toFixed()) }, v: 1 } : { cb: (x: never) => never; v: number; } +>{ cb: wrap((x) => x.toFixed()) } : { cb: (x: never) => never; } +>cb : (x: never) => never +>wrap((x) => x.toFixed()) : (x: never) => never +>wrap : (f: U) => U +>(x) => x.toFixed() : (x: never) => never +>x : never +>x.toFixed() : never +>x.toFixed : never +>x : never +>toFixed : never +>v : number +>1 : 1 + +outer(([wrap((x) => x.toFixed())] as const)[0], 1); +>outer(([wrap((x) => x.toFixed())] as const)[0], 1) : void +>outer : (cb: (x: T) => void, v: T) => void +>([wrap((x) => x.toFixed())] as const)[0] : (x: any) => any +>([wrap((x) => x.toFixed())] as const) : readonly [(x: any) => any] +>[wrap((x) => x.toFixed())] as const : readonly [(x: any) => any] +>[wrap((x) => x.toFixed())] : readonly [(x: any) => any] +>wrap((x) => x.toFixed()) : (x: any) => any +>wrap : (f: U) => U +>(x) => x.toFixed() : (x: any) => any +>x : any +>x.toFixed() : any +>x.toFixed : any +>x : any +>toFixed : any +>0 : 0 +>1 : 1 + +tag`${wrap((x) => x.toFixed())}${1}`; +>tag`${wrap((x) => x.toFixed())}${1}` : void +>tag : (s: TemplateStringsArray, cb: (x: T) => void, v: T) => void +>`${wrap((x) => x.toFixed())}${1}` : string +>wrap((x) => x.toFixed()) : (x: never) => never +>wrap : (f: U) => U +>(x) => x.toFixed() : (x: never) => never +>x : never +>x.toFixed() : never +>x.toFixed : never +>x : never +>toFixed : never +>1 : 1 + +outer(tagWrap`${(x) => x.toFixed()}`, 1); +>outer(tagWrap`${(x) => x.toFixed()}`, 1) : void +>outer : (cb: (x: T) => void, v: T) => void +>tagWrap`${(x) => x.toFixed()}` : (x: never) => never +>tagWrap : (s: TemplateStringsArray, f: U) => U +>`${(x) => x.toFixed()}` : string +>(x) => x.toFixed() : (x: never) => never +>x : never +>x.toFixed() : never +>x.toFixed : never +>x : never +>toFixed : never +>1 : 1 + +outerGen(function* () { yield wrap((x) => x.toFixed()); }, 1); +>outerGen(function* () { yield wrap((x) => x.toFixed()); }, 1) : void +>outerGen : (g: () => Generator<(x: T) => void>, v: T) => void +>function* () { yield wrap((x) => x.toFixed()); } : () => Generator<(x: never) => never, void, any> +>yield wrap((x) => x.toFixed()) : any +>wrap((x) => x.toFixed()) : (x: never) => never +>wrap : (f: U) => U +>(x) => x.toFixed() : (x: never) => never +>x : never +>x.toFixed() : never +>x.toFixed : never +>x : never +>toFixed : never +>1 : 1 + diff --git a/tsc/testdata/baselines/reference/compiler/nestedCallContextualTypeCheckOrderJsx(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/nestedCallContextualTypeCheckOrderJsx(checkorder=default).errors.txt new file mode 100644 index 0000000000000..c6184fc4a6ce6 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/nestedCallContextualTypeCheckOrderJsx(checkorder=default).errors.txt @@ -0,0 +1,35 @@ +nestedCallContextualTypeCheckOrderJsx.tsx(11,18): error TS2322: Type '(x: never) => never' is not assignable to type '(x: number) => void'. + Types of parameters 'x' and 'x' are incompatible. + Type 'number' is not assignable to type 'never'. +nestedCallContextualTypeCheckOrderJsx.tsx(12,12): error TS2322: Type '{ cb: (x: never) => never; v: number; }' is not assignable to type '{ cb: (x: number) => void; v: number; }'. + Types of property 'cb' are incompatible. + Type '(x: never) => never' is not assignable to type '(x: number) => void'. + Types of parameters 'x' and 'x' are incompatible. + Type 'number' is not assignable to type 'never'. + + +==== nestedCallContextualTypeCheckOrderJsx.tsx (2 errors) ==== + // A generic call in a JSX attribute is resolved after the element, whichever + // is queried first. + + declare namespace JSX { + interface Element {} + interface IntrinsicElements {} + } + declare function Outer(props: { cb: (x: T) => void; v: T }): JSX.Element; + declare function wrap(f: U): U; + + const a = x.toFixed())} v={1} />; + ~~ +!!! error TS2322: Type '(x: never) => never' is not assignable to type '(x: number) => void'. +!!! error TS2322: Types of parameters 'x' and 'x' are incompatible. +!!! error TS2322: Type 'number' is not assignable to type 'never'. +!!! related TS6500 nestedCallContextualTypeCheckOrderJsx.tsx:8:36: The expected type comes from property 'cb' which is declared here on type '{ cb: (x: number) => void; v: number; }' + const b = x.toFixed()) }} v={1} />; + ~~~~~ +!!! error TS2322: Type '{ cb: (x: never) => never; v: number; }' is not assignable to type '{ cb: (x: number) => void; v: number; }'. +!!! error TS2322: Types of property 'cb' are incompatible. +!!! error TS2322: Type '(x: never) => never' is not assignable to type '(x: number) => void'. +!!! error TS2322: Types of parameters 'x' and 'x' are incompatible. +!!! error TS2322: Type 'number' is not assignable to type 'never'. + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/nestedCallContextualTypeCheckOrderJsx(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/nestedCallContextualTypeCheckOrderJsx(checkorder=default).symbols new file mode 100644 index 0000000000000..a6cd6b32cc61a --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/nestedCallContextualTypeCheckOrderJsx(checkorder=default).symbols @@ -0,0 +1,52 @@ +//// [tests/cases/compiler/nestedCallContextualTypeCheckOrderJsx.tsx] //// + +=== nestedCallContextualTypeCheckOrderJsx.tsx === +// A generic call in a JSX attribute is resolved after the element, whichever +// is queried first. + +declare namespace JSX { +>JSX : Symbol(JSX, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 0, 0)) + + interface Element {} +>Element : Symbol(Element, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 3, 23)) + + interface IntrinsicElements {} +>IntrinsicElements : Symbol(IntrinsicElements, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 4, 24)) +} +declare function Outer(props: { cb: (x: T) => void; v: T }): JSX.Element; +>Outer : Symbol(Outer, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 6, 1)) +>T : Symbol(T, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 7, 23)) +>props : Symbol(props, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 7, 26)) +>cb : Symbol(cb, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 7, 34)) +>x : Symbol(x, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 7, 40)) +>T : Symbol(T, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 7, 23)) +>v : Symbol(v, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 7, 54)) +>T : Symbol(T, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 7, 23)) +>JSX : Symbol(JSX, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 0, 0)) +>Element : Symbol(JSX.Element, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 3, 23)) + +declare function wrap(f: U): U; +>wrap : Symbol(wrap, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 7, 76)) +>U : Symbol(U, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 8, 22)) +>f : Symbol(f, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 8, 25)) +>U : Symbol(U, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 8, 22)) +>U : Symbol(U, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 8, 22)) + +const a = x.toFixed())} v={1} />; +>a : Symbol(a, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 10, 5)) +>Outer : Symbol(Outer, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 6, 1)) +>cb : Symbol(cb, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 10, 16)) +>wrap : Symbol(wrap, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 7, 76)) +>x : Symbol(x, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 10, 27)) +>x : Symbol(x, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 10, 27)) +>v : Symbol(v, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 10, 46)) + +const b = x.toFixed()) }} v={1} />; +>b : Symbol(b, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 11, 5)) +>Outer : Symbol(Outer, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 6, 1)) +>cb : Symbol(cb, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 11, 22)) +>wrap : Symbol(wrap, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 7, 76)) +>x : Symbol(x, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 11, 33)) +>x : Symbol(x, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 11, 33)) +>v : Symbol(v, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 11, 54)) + diff --git a/tsc/testdata/baselines/reference/compiler/nestedCallContextualTypeCheckOrderJsx(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/nestedCallContextualTypeCheckOrderJsx(checkorder=default).types new file mode 100644 index 0000000000000..2f5dff0329e96 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/nestedCallContextualTypeCheckOrderJsx(checkorder=default).types @@ -0,0 +1,55 @@ +//// [tests/cases/compiler/nestedCallContextualTypeCheckOrderJsx.tsx] //// + +=== nestedCallContextualTypeCheckOrderJsx.tsx === +// A generic call in a JSX attribute is resolved after the element, whichever +// is queried first. + +declare namespace JSX { + interface Element {} + interface IntrinsicElements {} +} +declare function Outer(props: { cb: (x: T) => void; v: T }): JSX.Element; +>Outer : (props: { cb: (x: T) => void; v: T; }) => JSX.Element +>props : { cb: (x: T) => void; v: T; } +>cb : (x: T) => void +>x : T +>v : T +>JSX : any + +declare function wrap(f: U): U; +>wrap : (f: U) => U +>f : U + +const a = x.toFixed())} v={1} />; +>a : JSX.Element +> x.toFixed())} v={1} /> : JSX.Element +>Outer : (props: { cb: (x: T) => void; v: T; }) => JSX.Element +>cb : (x: never) => never +>wrap((x) => x.toFixed()) : (x: never) => never +>wrap : (f: U) => U +>(x) => x.toFixed() : (x: never) => never +>x : never +>x.toFixed() : never +>x.toFixed : never +>x : never +>toFixed : never +>v : number +>1 : 1 + +const b = x.toFixed()) }} v={1} />; +>b : JSX.Element +> x.toFixed()) }} v={1} /> : JSX.Element +>Outer : (props: { cb: (x: T) => void; v: T; }) => JSX.Element +>{ cb: wrap((x) => x.toFixed()) } : { cb: (x: never) => never; } +>cb : (x: never) => never +>wrap((x) => x.toFixed()) : (x: never) => never +>wrap : (f: U) => U +>(x) => x.toFixed() : (x: never) => never +>x : never +>x.toFixed() : never +>x.toFixed : never +>x : never +>toFixed : never +>v : number +>1 : 1 + diff --git a/tsc/testdata/baselines/reference/compiler/nestedCallContextualTypeCheckOrderJsx(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/nestedCallContextualTypeCheckOrderJsx(checkorder=typesfirst).errors.txt new file mode 100644 index 0000000000000..c6184fc4a6ce6 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/nestedCallContextualTypeCheckOrderJsx(checkorder=typesfirst).errors.txt @@ -0,0 +1,35 @@ +nestedCallContextualTypeCheckOrderJsx.tsx(11,18): error TS2322: Type '(x: never) => never' is not assignable to type '(x: number) => void'. + Types of parameters 'x' and 'x' are incompatible. + Type 'number' is not assignable to type 'never'. +nestedCallContextualTypeCheckOrderJsx.tsx(12,12): error TS2322: Type '{ cb: (x: never) => never; v: number; }' is not assignable to type '{ cb: (x: number) => void; v: number; }'. + Types of property 'cb' are incompatible. + Type '(x: never) => never' is not assignable to type '(x: number) => void'. + Types of parameters 'x' and 'x' are incompatible. + Type 'number' is not assignable to type 'never'. + + +==== nestedCallContextualTypeCheckOrderJsx.tsx (2 errors) ==== + // A generic call in a JSX attribute is resolved after the element, whichever + // is queried first. + + declare namespace JSX { + interface Element {} + interface IntrinsicElements {} + } + declare function Outer(props: { cb: (x: T) => void; v: T }): JSX.Element; + declare function wrap(f: U): U; + + const a = x.toFixed())} v={1} />; + ~~ +!!! error TS2322: Type '(x: never) => never' is not assignable to type '(x: number) => void'. +!!! error TS2322: Types of parameters 'x' and 'x' are incompatible. +!!! error TS2322: Type 'number' is not assignable to type 'never'. +!!! related TS6500 nestedCallContextualTypeCheckOrderJsx.tsx:8:36: The expected type comes from property 'cb' which is declared here on type '{ cb: (x: number) => void; v: number; }' + const b = x.toFixed()) }} v={1} />; + ~~~~~ +!!! error TS2322: Type '{ cb: (x: never) => never; v: number; }' is not assignable to type '{ cb: (x: number) => void; v: number; }'. +!!! error TS2322: Types of property 'cb' are incompatible. +!!! error TS2322: Type '(x: never) => never' is not assignable to type '(x: number) => void'. +!!! error TS2322: Types of parameters 'x' and 'x' are incompatible. +!!! error TS2322: Type 'number' is not assignable to type 'never'. + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/nestedCallContextualTypeCheckOrderJsx(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/nestedCallContextualTypeCheckOrderJsx(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..a6cd6b32cc61a --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/nestedCallContextualTypeCheckOrderJsx(checkorder=typesfirst).symbols @@ -0,0 +1,52 @@ +//// [tests/cases/compiler/nestedCallContextualTypeCheckOrderJsx.tsx] //// + +=== nestedCallContextualTypeCheckOrderJsx.tsx === +// A generic call in a JSX attribute is resolved after the element, whichever +// is queried first. + +declare namespace JSX { +>JSX : Symbol(JSX, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 0, 0)) + + interface Element {} +>Element : Symbol(Element, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 3, 23)) + + interface IntrinsicElements {} +>IntrinsicElements : Symbol(IntrinsicElements, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 4, 24)) +} +declare function Outer(props: { cb: (x: T) => void; v: T }): JSX.Element; +>Outer : Symbol(Outer, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 6, 1)) +>T : Symbol(T, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 7, 23)) +>props : Symbol(props, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 7, 26)) +>cb : Symbol(cb, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 7, 34)) +>x : Symbol(x, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 7, 40)) +>T : Symbol(T, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 7, 23)) +>v : Symbol(v, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 7, 54)) +>T : Symbol(T, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 7, 23)) +>JSX : Symbol(JSX, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 0, 0)) +>Element : Symbol(JSX.Element, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 3, 23)) + +declare function wrap(f: U): U; +>wrap : Symbol(wrap, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 7, 76)) +>U : Symbol(U, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 8, 22)) +>f : Symbol(f, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 8, 25)) +>U : Symbol(U, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 8, 22)) +>U : Symbol(U, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 8, 22)) + +const a = x.toFixed())} v={1} />; +>a : Symbol(a, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 10, 5)) +>Outer : Symbol(Outer, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 6, 1)) +>cb : Symbol(cb, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 10, 16)) +>wrap : Symbol(wrap, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 7, 76)) +>x : Symbol(x, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 10, 27)) +>x : Symbol(x, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 10, 27)) +>v : Symbol(v, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 10, 46)) + +const b = x.toFixed()) }} v={1} />; +>b : Symbol(b, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 11, 5)) +>Outer : Symbol(Outer, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 6, 1)) +>cb : Symbol(cb, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 11, 22)) +>wrap : Symbol(wrap, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 7, 76)) +>x : Symbol(x, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 11, 33)) +>x : Symbol(x, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 11, 33)) +>v : Symbol(v, Decl(nestedCallContextualTypeCheckOrderJsx.tsx, 11, 54)) + diff --git a/tsc/testdata/baselines/reference/compiler/nestedCallContextualTypeCheckOrderJsx(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/nestedCallContextualTypeCheckOrderJsx(checkorder=typesfirst).types new file mode 100644 index 0000000000000..2f5dff0329e96 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/nestedCallContextualTypeCheckOrderJsx(checkorder=typesfirst).types @@ -0,0 +1,55 @@ +//// [tests/cases/compiler/nestedCallContextualTypeCheckOrderJsx.tsx] //// + +=== nestedCallContextualTypeCheckOrderJsx.tsx === +// A generic call in a JSX attribute is resolved after the element, whichever +// is queried first. + +declare namespace JSX { + interface Element {} + interface IntrinsicElements {} +} +declare function Outer(props: { cb: (x: T) => void; v: T }): JSX.Element; +>Outer : (props: { cb: (x: T) => void; v: T; }) => JSX.Element +>props : { cb: (x: T) => void; v: T; } +>cb : (x: T) => void +>x : T +>v : T +>JSX : any + +declare function wrap(f: U): U; +>wrap : (f: U) => U +>f : U + +const a = x.toFixed())} v={1} />; +>a : JSX.Element +> x.toFixed())} v={1} /> : JSX.Element +>Outer : (props: { cb: (x: T) => void; v: T; }) => JSX.Element +>cb : (x: never) => never +>wrap((x) => x.toFixed()) : (x: never) => never +>wrap : (f: U) => U +>(x) => x.toFixed() : (x: never) => never +>x : never +>x.toFixed() : never +>x.toFixed : never +>x : never +>toFixed : never +>v : number +>1 : 1 + +const b = x.toFixed()) }} v={1} />; +>b : JSX.Element +> x.toFixed()) }} v={1} /> : JSX.Element +>Outer : (props: { cb: (x: T) => void; v: T; }) => JSX.Element +>{ cb: wrap((x) => x.toFixed()) } : { cb: (x: never) => never; } +>cb : (x: never) => never +>wrap((x) => x.toFixed()) : (x: never) => never +>wrap : (f: U) => U +>(x) => x.toFixed() : (x: never) => never +>x : never +>x.toFixed() : never +>x.toFixed : never +>x : never +>toFixed : never +>v : number +>1 : 1 + diff --git a/tsc/testdata/baselines/reference/compiler/nestedGenericArrayAssignabilityAfterErrors.errors.txt b/tsc/testdata/baselines/reference/compiler/nestedGenericArrayAssignabilityAfterErrors.errors.txt new file mode 100644 index 0000000000000..c5f982be59dda --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/nestedGenericArrayAssignabilityAfterErrors.errors.txt @@ -0,0 +1,38 @@ +nestedGenericArrayAssignabilityAfterErrors.ts(14,27): error TS2322: Type 'boolean' is not assignable to type 'number'. +nestedGenericArrayAssignabilityAfterErrors.ts(17,17): error TS2322: Type 'boolean' is not assignable to type 'number'. + + +==== nestedGenericArrayAssignabilityAfterErrors.ts (2 errors) ==== + // Assigning DataTypeThree to DataTypeThree, and likewise for + // DataTypeTwo, must be reported whether or not earlier assignments errored. + + type TypeA = number; + type TypeB = boolean; + type DataTypeTwo = { + one: Array<{ two: Array }>; + }; + type DataTypeThree = { + one: Array<{ two: Array<{ three: Array }> }>; + }; + + let testingThreeErr: DataTypeThree = { + one: [{ two: [{ three: [true] }] }] + ~~~~ +!!! error TS2322: Type 'boolean' is not assignable to type 'number'. + }; + let testingTwoErr: DataTypeTwo = { + one: [{ two: [false] }] + ~~~~~ +!!! error TS2322: Type 'boolean' is not assignable to type 'number'. + }; + + let testingThree: DataTypeThree = { + one: [{ two: [{ three: [5] }] }] + }; + let t3a: DataTypeThree = testingThree; + + let testingTwo: DataTypeTwo = { + one: [{ two: [5] }] + }; + let t2a: DataTypeTwo = testingTwo; + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/nestedGenericArrayAssignabilityAfterErrors.symbols b/tsc/testdata/baselines/reference/compiler/nestedGenericArrayAssignabilityAfterErrors.symbols new file mode 100644 index 0000000000000..1ff1f70440332 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/nestedGenericArrayAssignabilityAfterErrors.symbols @@ -0,0 +1,98 @@ +//// [tests/cases/compiler/nestedGenericArrayAssignabilityAfterErrors.ts] //// + +=== nestedGenericArrayAssignabilityAfterErrors.ts === +// Assigning DataTypeThree to DataTypeThree, and likewise for +// DataTypeTwo, must be reported whether or not earlier assignments errored. + +type TypeA = number; +>TypeA : Symbol(TypeA, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 0, 0)) + +type TypeB = boolean; +>TypeB : Symbol(TypeB, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 3, 20)) + +type DataTypeTwo = { +>DataTypeTwo : Symbol(DataTypeTwo, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 4, 21)) +>T : Symbol(T, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 5, 17)) +>TypeA : Symbol(TypeA, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 0, 0)) +>TypeB : Symbol(TypeB, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 3, 20)) + + one: Array<{ two: Array }>; +>one : Symbol(one, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 5, 45)) +>Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --) ... and 4 more) +>two : Symbol(two, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 6, 14)) +>Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --) ... and 4 more) +>T : Symbol(T, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 5, 17)) + +}; +type DataTypeThree = { +>DataTypeThree : Symbol(DataTypeThree, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 7, 2)) +>T : Symbol(T, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 8, 19)) +>TypeA : Symbol(TypeA, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 0, 0)) +>TypeB : Symbol(TypeB, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 3, 20)) + + one: Array<{ two: Array<{ three: Array }> }>; +>one : Symbol(one, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 8, 47)) +>Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --) ... and 4 more) +>two : Symbol(two, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 9, 14)) +>Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --) ... and 4 more) +>three : Symbol(three, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 9, 27)) +>Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --) ... and 4 more) +>T : Symbol(T, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 8, 19)) + +}; + +let testingThreeErr: DataTypeThree = { +>testingThreeErr : Symbol(testingThreeErr, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 12, 3)) +>DataTypeThree : Symbol(DataTypeThree, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 7, 2)) +>TypeA : Symbol(TypeA, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 0, 0)) + + one: [{ two: [{ three: [true] }] }] +>one : Symbol(one, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 12, 45)) +>two : Symbol(two, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 13, 9)) +>three : Symbol(three, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 13, 17)) + +}; +let testingTwoErr: DataTypeTwo = { +>testingTwoErr : Symbol(testingTwoErr, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 15, 3)) +>DataTypeTwo : Symbol(DataTypeTwo, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 4, 21)) +>TypeA : Symbol(TypeA, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 0, 0)) + + one: [{ two: [false] }] +>one : Symbol(one, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 15, 41)) +>two : Symbol(two, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 16, 9)) + +}; + +let testingThree: DataTypeThree = { +>testingThree : Symbol(testingThree, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 19, 3)) +>DataTypeThree : Symbol(DataTypeThree, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 7, 2)) +>TypeA : Symbol(TypeA, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 0, 0)) + + one: [{ two: [{ three: [5] }] }] +>one : Symbol(one, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 19, 42)) +>two : Symbol(two, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 20, 9)) +>three : Symbol(three, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 20, 17)) + +}; +let t3a: DataTypeThree = testingThree; +>t3a : Symbol(t3a, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 22, 3)) +>DataTypeThree : Symbol(DataTypeThree, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 7, 2)) +>TypeB : Symbol(TypeB, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 3, 20)) +>testingThree : Symbol(testingThree, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 19, 3)) + +let testingTwo: DataTypeTwo = { +>testingTwo : Symbol(testingTwo, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 24, 3)) +>DataTypeTwo : Symbol(DataTypeTwo, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 4, 21)) +>TypeA : Symbol(TypeA, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 0, 0)) + + one: [{ two: [5] }] +>one : Symbol(one, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 24, 38)) +>two : Symbol(two, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 25, 9)) + +}; +let t2a: DataTypeTwo = testingTwo; +>t2a : Symbol(t2a, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 27, 3)) +>DataTypeTwo : Symbol(DataTypeTwo, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 4, 21)) +>TypeB : Symbol(TypeB, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 3, 20)) +>testingTwo : Symbol(testingTwo, Decl(nestedGenericArrayAssignabilityAfterErrors.ts, 24, 3)) + diff --git a/tsc/testdata/baselines/reference/compiler/nestedGenericArrayAssignabilityAfterErrors.types b/tsc/testdata/baselines/reference/compiler/nestedGenericArrayAssignabilityAfterErrors.types new file mode 100644 index 0000000000000..387d506bb6a05 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/nestedGenericArrayAssignabilityAfterErrors.types @@ -0,0 +1,97 @@ +//// [tests/cases/compiler/nestedGenericArrayAssignabilityAfterErrors.ts] //// + +=== nestedGenericArrayAssignabilityAfterErrors.ts === +// Assigning DataTypeThree to DataTypeThree, and likewise for +// DataTypeTwo, must be reported whether or not earlier assignments errored. + +type TypeA = number; +>TypeA : number + +type TypeB = boolean; +>TypeB : boolean + +type DataTypeTwo = { +>DataTypeTwo : DataTypeTwo + + one: Array<{ two: Array }>; +>one : { two: Array; }[] +>two : T[] + +}; +type DataTypeThree = { +>DataTypeThree : DataTypeThree + + one: Array<{ two: Array<{ three: Array }> }>; +>one : { two: Array<{ three: Array; }>; }[] +>two : { three: Array; }[] +>three : T[] + +}; + +let testingThreeErr: DataTypeThree = { +>testingThreeErr : DataTypeThree +>{ one: [{ two: [{ three: [true] }] }]} : { one: { two: { three: boolean[]; }[]; }[]; } + + one: [{ two: [{ three: [true] }] }] +>one : { two: { three: boolean[]; }[]; }[] +>[{ two: [{ three: [true] }] }] : { two: { three: boolean[]; }[]; }[] +>{ two: [{ three: [true] }] } : { two: { three: boolean[]; }[]; } +>two : { three: boolean[]; }[] +>[{ three: [true] }] : { three: boolean[]; }[] +>{ three: [true] } : { three: boolean[]; } +>three : boolean[] +>[true] : boolean[] +>true : true + +}; +let testingTwoErr: DataTypeTwo = { +>testingTwoErr : DataTypeTwo +>{ one: [{ two: [false] }]} : { one: { two: boolean[]; }[]; } + + one: [{ two: [false] }] +>one : { two: boolean[]; }[] +>[{ two: [false] }] : { two: boolean[]; }[] +>{ two: [false] } : { two: boolean[]; } +>two : boolean[] +>[false] : boolean[] +>false : false + +}; + +let testingThree: DataTypeThree = { +>testingThree : DataTypeThree +>{ one: [{ two: [{ three: [5] }] }]} : { one: { two: { three: number[]; }[]; }[]; } + + one: [{ two: [{ three: [5] }] }] +>one : { two: { three: number[]; }[]; }[] +>[{ two: [{ three: [5] }] }] : { two: { three: number[]; }[]; }[] +>{ two: [{ three: [5] }] } : { two: { three: number[]; }[]; } +>two : { three: number[]; }[] +>[{ three: [5] }] : { three: number[]; }[] +>{ three: [5] } : { three: number[]; } +>three : number[] +>[5] : number[] +>5 : 5 + +}; +let t3a: DataTypeThree = testingThree; +>t3a : DataTypeThree +>testingThree : DataTypeThree + +let testingTwo: DataTypeTwo = { +>testingTwo : DataTypeTwo +>{ one: [{ two: [5] }]} : { one: { two: number[]; }[]; } + + one: [{ two: [5] }] +>one : { two: number[]; }[] +>[{ two: [5] }] : { two: number[]; }[] +>{ two: [5] } : { two: number[]; } +>two : number[] +>[5] : number[] +>5 : 5 + +}; +let t2a: DataTypeTwo = testingTwo; +>t2a : DataTypeTwo +>testingTwo : DataTypeTwo + diff --git a/tsc/testdata/baselines/reference/compiler/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..407435a6f1e42 --- /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?: undefined; } | { a?: undefined; 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..858790155480b --- /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: { b: number; } | { a: string; }; onlyB: { b: number; } | undefined; } +>f({ k: "a", a: "s" }) : { all: { b: number; } | { a: string; }; 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 : { b: number; } | { a: string; } +>o.all : { b: number; } | { a: string; } +>o : { all: { b: number; } | { a: string; }; onlyB: { b: number; } | undefined; } +>all : { b: number; } | { a: string; } + +const onlyB = o.onlyB; +>onlyB : { b: number; } | undefined +>o.onlyB : { b: number; } | undefined +>o : { all: { b: number; } | { a: string; }; 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..e93dbcc6cad6b --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/overloadresolutionWithConstraintCheckingDeferred(checkorder=typesfirst).errors.txt @@ -0,0 +1,76 @@ +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,32): error TS2741: Property 'x' is missing in type 'D' but required in type 'A'. + + +==== overloadresolutionWithConstraintCheckingDeferred.ts (6 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. + 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..7eb08e3ac8acb --- /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 : any + +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 : any + +var result3: string = foo(x => { // x has type D +>result3 : string +>foo(x => { // x has type D var y: G = new G(x); // error that D does not satisfy constraint, y is of type G, entire call to foo is an error return y;}) : never +>foo : { (arg: (x: D) => number): string; (arg: (x: C) => any): string; (arg: (x: B) => any): number; } +>x => { // x has type D var y: G = new G(x); // error that D does not satisfy constraint, y is of type G, entire call to foo is an error return y;} : (x: D) => G +>x : D + + var y: G = new G(x); // error that D does not satisfy constraint, y is of type G, entire call to foo is an error +>y : G +>x : D +>new G(x) : G +>G : typeof G +>x : D + + return y; +>y : G + +}); + diff --git a/tsc/testdata/baselines/reference/compiler/parameterBindingDefaultReferencesSiblingThroughCall(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/parameterBindingDefaultReferencesSiblingThroughCall(checkorder=default).errors.txt new file mode 100644 index 0000000000000..fab2d38147e93 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/parameterBindingDefaultReferencesSiblingThroughCall(checkorder=default).errors.txt @@ -0,0 +1,34 @@ +parameterBindingDefaultReferencesSiblingThroughCall.ts(11,19): error TS7022: 'a' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. +parameterBindingDefaultReferencesSiblingThroughCall.ts(16,11): error TS2322: Type 'unknown' is not assignable to type 'string'. +parameterBindingDefaultReferencesSiblingThroughCall.ts(20,11): error TS2322: Type 'any[]' is not assignable to type 'string'. + + +==== parameterBindingDefaultReferencesSiblingThroughCall.ts (3 errors) ==== + // A default in a destructured parameter that references a sibling element + // makes the sibling's type depend on itself: the type of 'a' comes from the + // parameter initializer '{}', which is padded with the types of the defaults, + // including 'b'. Main reports this cycle (TS7022 on 'a') for 'b = a', but not + // for 'b = id(a)', where the padding reuses the signature resolved while 'a' + // was treated as non-inferrable any during contextual typing of '{}', which + // gives 'b' the type 'unknown' (see tldraw TldrawApp.test.ts). + + declare function id(v: T): T; + + function direct({ a = 1 as number | undefined, b = a } = {}) { + ~ +!!! error TS7022: 'a' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. + const n: string = b; + } + + function viaCall({ a = 1 as number | undefined, b = id(a) } = {}) { + const n: string = b; + ~ +!!! error TS2322: Type 'unknown' is not assignable to type 'string'. + } + + function viaCallArray({ a = 1 as number | undefined, b = id([a]) } = {}) { + const n: string = b; + ~ +!!! error TS2322: Type 'any[]' is not assignable to type 'string'. + } + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/parameterBindingDefaultReferencesSiblingThroughCall(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/parameterBindingDefaultReferencesSiblingThroughCall(checkorder=default).symbols new file mode 100644 index 0000000000000..06dbf91e4f588 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/parameterBindingDefaultReferencesSiblingThroughCall(checkorder=default).symbols @@ -0,0 +1,53 @@ +//// [tests/cases/compiler/parameterBindingDefaultReferencesSiblingThroughCall.ts] //// + +=== parameterBindingDefaultReferencesSiblingThroughCall.ts === +// A default in a destructured parameter that references a sibling element +// makes the sibling's type depend on itself: the type of 'a' comes from the +// parameter initializer '{}', which is padded with the types of the defaults, +// including 'b'. Main reports this cycle (TS7022 on 'a') for 'b = a', but not +// for 'b = id(a)', where the padding reuses the signature resolved while 'a' +// was treated as non-inferrable any during contextual typing of '{}', which +// gives 'b' the type 'unknown' (see tldraw TldrawApp.test.ts). + +declare function id(v: T): T; +>id : Symbol(id, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 0, 0)) +>T : Symbol(T, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 8, 20)) +>v : Symbol(v, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 8, 23)) +>T : Symbol(T, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 8, 20)) +>T : Symbol(T, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 8, 20)) + +function direct({ a = 1 as number | undefined, b = a } = {}) { +>direct : Symbol(direct, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 8, 32)) +>a : Symbol(a, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 10, 17)) +>b : Symbol(b, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 10, 46)) +>a : Symbol(a, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 10, 17)) + + const n: string = b; +>n : Symbol(n, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 11, 9)) +>b : Symbol(b, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 10, 46)) +} + +function viaCall({ a = 1 as number | undefined, b = id(a) } = {}) { +>viaCall : Symbol(viaCall, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 12, 1)) +>a : Symbol(a, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 14, 18)) +>b : Symbol(b, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 14, 47)) +>id : Symbol(id, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 0, 0)) +>a : Symbol(a, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 14, 18)) + + const n: string = b; +>n : Symbol(n, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 15, 9)) +>b : Symbol(b, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 14, 47)) +} + +function viaCallArray({ a = 1 as number | undefined, b = id([a]) } = {}) { +>viaCallArray : Symbol(viaCallArray, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 16, 1)) +>a : Symbol(a, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 18, 23)) +>b : Symbol(b, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 18, 52)) +>id : Symbol(id, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 0, 0)) +>a : Symbol(a, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 18, 23)) + + const n: string = b; +>n : Symbol(n, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 19, 9)) +>b : Symbol(b, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 18, 52)) +} + diff --git a/tsc/testdata/baselines/reference/compiler/parameterBindingDefaultReferencesSiblingThroughCall(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/parameterBindingDefaultReferencesSiblingThroughCall(checkorder=default).types new file mode 100644 index 0000000000000..d8b5d78c1e02b --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/parameterBindingDefaultReferencesSiblingThroughCall(checkorder=default).types @@ -0,0 +1,62 @@ +//// [tests/cases/compiler/parameterBindingDefaultReferencesSiblingThroughCall.ts] //// + +=== parameterBindingDefaultReferencesSiblingThroughCall.ts === +// A default in a destructured parameter that references a sibling element +// makes the sibling's type depend on itself: the type of 'a' comes from the +// parameter initializer '{}', which is padded with the types of the defaults, +// including 'b'. Main reports this cycle (TS7022 on 'a') for 'b = a', but not +// for 'b = id(a)', where the padding reuses the signature resolved while 'a' +// was treated as non-inferrable any during contextual typing of '{}', which +// gives 'b' the type 'unknown' (see tldraw TldrawApp.test.ts). + +declare function id(v: T): T; +>id : (v: T) => T +>v : T + +function direct({ a = 1 as number | undefined, b = a } = {}) { +>direct : ({ a, b }?: { a?: number | undefined; b?: any; }) => void +>a : any +>1 as number | undefined : number | undefined +>1 : 1 +>b : any +>a : any +>{} : {} + + const n: string = b; +>n : string +>b : any +} + +function viaCall({ a = 1 as number | undefined, b = id(a) } = {}) { +>viaCall : ({ a, b }?: { a?: number | undefined; b?: unknown; }) => void +>a : number | undefined +>1 as number | undefined : number | undefined +>1 : 1 +>b : unknown +>id(a) : unknown +>id : (v: T) => T +>a : number | undefined +>{} : {} + + const n: string = b; +>n : string +>b : unknown +} + +function viaCallArray({ a = 1 as number | undefined, b = id([a]) } = {}) { +>viaCallArray : ({ a, b }?: { a?: number | undefined; b?: any[] | undefined; }) => void +>a : number | undefined +>1 as number | undefined : number | undefined +>1 : 1 +>b : any[] +>id([a]) : any[] +>id : (v: T) => T +>[a] : (number | undefined)[] +>a : number | undefined +>{} : {} + + const n: string = b; +>n : string +>b : any[] +} + diff --git a/tsc/testdata/baselines/reference/compiler/parameterBindingDefaultReferencesSiblingThroughCall(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/parameterBindingDefaultReferencesSiblingThroughCall(checkorder=typesfirst).errors.txt new file mode 100644 index 0000000000000..fab2d38147e93 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/parameterBindingDefaultReferencesSiblingThroughCall(checkorder=typesfirst).errors.txt @@ -0,0 +1,34 @@ +parameterBindingDefaultReferencesSiblingThroughCall.ts(11,19): error TS7022: 'a' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. +parameterBindingDefaultReferencesSiblingThroughCall.ts(16,11): error TS2322: Type 'unknown' is not assignable to type 'string'. +parameterBindingDefaultReferencesSiblingThroughCall.ts(20,11): error TS2322: Type 'any[]' is not assignable to type 'string'. + + +==== parameterBindingDefaultReferencesSiblingThroughCall.ts (3 errors) ==== + // A default in a destructured parameter that references a sibling element + // makes the sibling's type depend on itself: the type of 'a' comes from the + // parameter initializer '{}', which is padded with the types of the defaults, + // including 'b'. Main reports this cycle (TS7022 on 'a') for 'b = a', but not + // for 'b = id(a)', where the padding reuses the signature resolved while 'a' + // was treated as non-inferrable any during contextual typing of '{}', which + // gives 'b' the type 'unknown' (see tldraw TldrawApp.test.ts). + + declare function id(v: T): T; + + function direct({ a = 1 as number | undefined, b = a } = {}) { + ~ +!!! error TS7022: 'a' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer. + const n: string = b; + } + + function viaCall({ a = 1 as number | undefined, b = id(a) } = {}) { + const n: string = b; + ~ +!!! error TS2322: Type 'unknown' is not assignable to type 'string'. + } + + function viaCallArray({ a = 1 as number | undefined, b = id([a]) } = {}) { + const n: string = b; + ~ +!!! error TS2322: Type 'any[]' is not assignable to type 'string'. + } + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/parameterBindingDefaultReferencesSiblingThroughCall(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/parameterBindingDefaultReferencesSiblingThroughCall(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..06dbf91e4f588 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/parameterBindingDefaultReferencesSiblingThroughCall(checkorder=typesfirst).symbols @@ -0,0 +1,53 @@ +//// [tests/cases/compiler/parameterBindingDefaultReferencesSiblingThroughCall.ts] //// + +=== parameterBindingDefaultReferencesSiblingThroughCall.ts === +// A default in a destructured parameter that references a sibling element +// makes the sibling's type depend on itself: the type of 'a' comes from the +// parameter initializer '{}', which is padded with the types of the defaults, +// including 'b'. Main reports this cycle (TS7022 on 'a') for 'b = a', but not +// for 'b = id(a)', where the padding reuses the signature resolved while 'a' +// was treated as non-inferrable any during contextual typing of '{}', which +// gives 'b' the type 'unknown' (see tldraw TldrawApp.test.ts). + +declare function id(v: T): T; +>id : Symbol(id, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 0, 0)) +>T : Symbol(T, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 8, 20)) +>v : Symbol(v, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 8, 23)) +>T : Symbol(T, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 8, 20)) +>T : Symbol(T, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 8, 20)) + +function direct({ a = 1 as number | undefined, b = a } = {}) { +>direct : Symbol(direct, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 8, 32)) +>a : Symbol(a, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 10, 17)) +>b : Symbol(b, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 10, 46)) +>a : Symbol(a, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 10, 17)) + + const n: string = b; +>n : Symbol(n, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 11, 9)) +>b : Symbol(b, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 10, 46)) +} + +function viaCall({ a = 1 as number | undefined, b = id(a) } = {}) { +>viaCall : Symbol(viaCall, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 12, 1)) +>a : Symbol(a, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 14, 18)) +>b : Symbol(b, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 14, 47)) +>id : Symbol(id, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 0, 0)) +>a : Symbol(a, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 14, 18)) + + const n: string = b; +>n : Symbol(n, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 15, 9)) +>b : Symbol(b, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 14, 47)) +} + +function viaCallArray({ a = 1 as number | undefined, b = id([a]) } = {}) { +>viaCallArray : Symbol(viaCallArray, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 16, 1)) +>a : Symbol(a, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 18, 23)) +>b : Symbol(b, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 18, 52)) +>id : Symbol(id, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 0, 0)) +>a : Symbol(a, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 18, 23)) + + const n: string = b; +>n : Symbol(n, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 19, 9)) +>b : Symbol(b, Decl(parameterBindingDefaultReferencesSiblingThroughCall.ts, 18, 52)) +} + diff --git a/tsc/testdata/baselines/reference/compiler/parameterBindingDefaultReferencesSiblingThroughCall(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/parameterBindingDefaultReferencesSiblingThroughCall(checkorder=typesfirst).types new file mode 100644 index 0000000000000..d8b5d78c1e02b --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/parameterBindingDefaultReferencesSiblingThroughCall(checkorder=typesfirst).types @@ -0,0 +1,62 @@ +//// [tests/cases/compiler/parameterBindingDefaultReferencesSiblingThroughCall.ts] //// + +=== parameterBindingDefaultReferencesSiblingThroughCall.ts === +// A default in a destructured parameter that references a sibling element +// makes the sibling's type depend on itself: the type of 'a' comes from the +// parameter initializer '{}', which is padded with the types of the defaults, +// including 'b'. Main reports this cycle (TS7022 on 'a') for 'b = a', but not +// for 'b = id(a)', where the padding reuses the signature resolved while 'a' +// was treated as non-inferrable any during contextual typing of '{}', which +// gives 'b' the type 'unknown' (see tldraw TldrawApp.test.ts). + +declare function id(v: T): T; +>id : (v: T) => T +>v : T + +function direct({ a = 1 as number | undefined, b = a } = {}) { +>direct : ({ a, b }?: { a?: number | undefined; b?: any; }) => void +>a : any +>1 as number | undefined : number | undefined +>1 : 1 +>b : any +>a : any +>{} : {} + + const n: string = b; +>n : string +>b : any +} + +function viaCall({ a = 1 as number | undefined, b = id(a) } = {}) { +>viaCall : ({ a, b }?: { a?: number | undefined; b?: unknown; }) => void +>a : number | undefined +>1 as number | undefined : number | undefined +>1 : 1 +>b : unknown +>id(a) : unknown +>id : (v: T) => T +>a : number | undefined +>{} : {} + + const n: string = b; +>n : string +>b : unknown +} + +function viaCallArray({ a = 1 as number | undefined, b = id([a]) } = {}) { +>viaCallArray : ({ a, b }?: { a?: number | undefined; b?: any[] | undefined; }) => void +>a : number | undefined +>1 as number | undefined : number | undefined +>1 : 1 +>b : any[] +>id([a]) : any[] +>id : (v: T) => T +>[a] : (number | undefined)[] +>a : number | undefined +>{} : {} + + const n: string = b; +>n : string +>b : any[] +} + diff --git a/tsc/testdata/baselines/reference/compiler/qualifiedNameCycleErrorCheckOrder(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/qualifiedNameCycleErrorCheckOrder(checkorder=default).errors.txt new file mode 100644 index 0000000000000..9377a11b042da --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/qualifiedNameCycleErrorCheckOrder(checkorder=default).errors.txt @@ -0,0 +1,16 @@ +qualifiedNameCycleErrorCheckOrder.ts(5,15): error TS2502: 'n' is referenced directly or indirectly in its own type annotation. +qualifiedNameCycleErrorCheckOrder.ts(5,20): error TS2694: Namespace 'n' has no exported member 'T'. + + +==== qualifiedNameCycleErrorCheckOrder.ts (2 errors) ==== + // Resolving n.T looks for a value n to suggest typeof, which needs the type of + // n, which is n.T. The missing member must be reported whichever is + // resolved first. + + declare const n: n.T; + ~ +!!! error TS2502: 'n' is referenced directly or indirectly in its own type annotation. + ~ +!!! error TS2694: Namespace 'n' has no exported member 'T'. + declare namespace n {} + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/qualifiedNameCycleErrorCheckOrder(checkorder=default).js b/tsc/testdata/baselines/reference/compiler/qualifiedNameCycleErrorCheckOrder(checkorder=default).js new file mode 100644 index 0000000000000..9ca975f52c7c4 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/qualifiedNameCycleErrorCheckOrder(checkorder=default).js @@ -0,0 +1,16 @@ +//// [tests/cases/compiler/qualifiedNameCycleErrorCheckOrder.ts] //// + +//// [qualifiedNameCycleErrorCheckOrder.ts] +// Resolving n.T looks for a value n to suggest typeof, which needs the type of +// n, which is n.T. The missing member must be reported whichever is +// resolved first. + +declare const n: n.T; +declare namespace n {} + + +//// [qualifiedNameCycleErrorCheckOrder.js] +"use strict"; +// Resolving n.T looks for a value n to suggest typeof, which needs the type of +// n, which is n.T. The missing member must be reported whichever is +// resolved first. diff --git a/tsc/testdata/baselines/reference/compiler/qualifiedNameCycleErrorCheckOrder(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/qualifiedNameCycleErrorCheckOrder(checkorder=default).symbols new file mode 100644 index 0000000000000..3540b50c66446 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/qualifiedNameCycleErrorCheckOrder(checkorder=default).symbols @@ -0,0 +1,15 @@ +//// [tests/cases/compiler/qualifiedNameCycleErrorCheckOrder.ts] //// + +=== qualifiedNameCycleErrorCheckOrder.ts === +// Resolving n.T looks for a value n to suggest typeof, which needs the type of +// n, which is n.T. The missing member must be reported whichever is +// resolved first. + +declare const n: n.T; +>n : Symbol(n, Decl(qualifiedNameCycleErrorCheckOrder.ts, 4, 13), Decl(qualifiedNameCycleErrorCheckOrder.ts, 4, 21)) +>n : Symbol(n, Decl(qualifiedNameCycleErrorCheckOrder.ts, 4, 13), Decl(qualifiedNameCycleErrorCheckOrder.ts, 4, 21)) +>T : Symbol(n.T) + +declare namespace n {} +>n : Symbol(n, Decl(qualifiedNameCycleErrorCheckOrder.ts, 4, 13), Decl(qualifiedNameCycleErrorCheckOrder.ts, 4, 21)) + diff --git a/tsc/testdata/baselines/reference/compiler/qualifiedNameCycleErrorCheckOrder(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/qualifiedNameCycleErrorCheckOrder(checkorder=default).types new file mode 100644 index 0000000000000..0aaabb289b6a6 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/qualifiedNameCycleErrorCheckOrder(checkorder=default).types @@ -0,0 +1,13 @@ +//// [tests/cases/compiler/qualifiedNameCycleErrorCheckOrder.ts] //// + +=== qualifiedNameCycleErrorCheckOrder.ts === +// Resolving n.T looks for a value n to suggest typeof, which needs the type of +// n, which is n.T. The missing member must be reported whichever is +// resolved first. + +declare const n: n.T; +>n : any +>n : any + +declare namespace n {} + diff --git a/tsc/testdata/baselines/reference/compiler/qualifiedNameCycleErrorCheckOrder(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/qualifiedNameCycleErrorCheckOrder(checkorder=typesfirst).errors.txt new file mode 100644 index 0000000000000..9377a11b042da --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/qualifiedNameCycleErrorCheckOrder(checkorder=typesfirst).errors.txt @@ -0,0 +1,16 @@ +qualifiedNameCycleErrorCheckOrder.ts(5,15): error TS2502: 'n' is referenced directly or indirectly in its own type annotation. +qualifiedNameCycleErrorCheckOrder.ts(5,20): error TS2694: Namespace 'n' has no exported member 'T'. + + +==== qualifiedNameCycleErrorCheckOrder.ts (2 errors) ==== + // Resolving n.T looks for a value n to suggest typeof, which needs the type of + // n, which is n.T. The missing member must be reported whichever is + // resolved first. + + declare const n: n.T; + ~ +!!! error TS2502: 'n' is referenced directly or indirectly in its own type annotation. + ~ +!!! error TS2694: Namespace 'n' has no exported member 'T'. + declare namespace n {} + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/qualifiedNameCycleErrorCheckOrder(checkorder=typesfirst).js b/tsc/testdata/baselines/reference/compiler/qualifiedNameCycleErrorCheckOrder(checkorder=typesfirst).js new file mode 100644 index 0000000000000..9ca975f52c7c4 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/qualifiedNameCycleErrorCheckOrder(checkorder=typesfirst).js @@ -0,0 +1,16 @@ +//// [tests/cases/compiler/qualifiedNameCycleErrorCheckOrder.ts] //// + +//// [qualifiedNameCycleErrorCheckOrder.ts] +// Resolving n.T looks for a value n to suggest typeof, which needs the type of +// n, which is n.T. The missing member must be reported whichever is +// resolved first. + +declare const n: n.T; +declare namespace n {} + + +//// [qualifiedNameCycleErrorCheckOrder.js] +"use strict"; +// Resolving n.T looks for a value n to suggest typeof, which needs the type of +// n, which is n.T. The missing member must be reported whichever is +// resolved first. diff --git a/tsc/testdata/baselines/reference/compiler/qualifiedNameCycleErrorCheckOrder(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/qualifiedNameCycleErrorCheckOrder(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..3540b50c66446 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/qualifiedNameCycleErrorCheckOrder(checkorder=typesfirst).symbols @@ -0,0 +1,15 @@ +//// [tests/cases/compiler/qualifiedNameCycleErrorCheckOrder.ts] //// + +=== qualifiedNameCycleErrorCheckOrder.ts === +// Resolving n.T looks for a value n to suggest typeof, which needs the type of +// n, which is n.T. The missing member must be reported whichever is +// resolved first. + +declare const n: n.T; +>n : Symbol(n, Decl(qualifiedNameCycleErrorCheckOrder.ts, 4, 13), Decl(qualifiedNameCycleErrorCheckOrder.ts, 4, 21)) +>n : Symbol(n, Decl(qualifiedNameCycleErrorCheckOrder.ts, 4, 13), Decl(qualifiedNameCycleErrorCheckOrder.ts, 4, 21)) +>T : Symbol(n.T) + +declare namespace n {} +>n : Symbol(n, Decl(qualifiedNameCycleErrorCheckOrder.ts, 4, 13), Decl(qualifiedNameCycleErrorCheckOrder.ts, 4, 21)) + diff --git a/tsc/testdata/baselines/reference/compiler/qualifiedNameCycleErrorCheckOrder(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/qualifiedNameCycleErrorCheckOrder(checkorder=typesfirst).types new file mode 100644 index 0000000000000..0aaabb289b6a6 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/qualifiedNameCycleErrorCheckOrder(checkorder=typesfirst).types @@ -0,0 +1,13 @@ +//// [tests/cases/compiler/qualifiedNameCycleErrorCheckOrder.ts] //// + +=== qualifiedNameCycleErrorCheckOrder.ts === +// Resolving n.T looks for a value n to suggest typeof, which needs the type of +// n, which is n.T. The missing member must be reported whichever is +// resolved first. + +declare const n: n.T; +>n : any +>n : any + +declare namespace n {} + diff --git a/tsc/testdata/baselines/reference/compiler/recursiveGenericInterfaceDeclarationOrder.errors.txt b/tsc/testdata/baselines/reference/compiler/recursiveGenericInterfaceDeclarationOrder.errors.txt new file mode 100644 index 0000000000000..61a80e2b83284 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/recursiveGenericInterfaceDeclarationOrder.errors.txt @@ -0,0 +1,22 @@ +recursiveGenericInterfaceDeclarationOrder.ts(13,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; }'. + + +==== recursiveGenericInterfaceDeclarationOrder.ts (1 errors) ==== + // The assignment is valid, as method parameters are compared bivariantly, and + // must be accepted whichever of the interfaces is declared first. + + type M = { kind: "m" }; + type Filtered = { [K in keyof T as T[K] extends M ? K : never]: T[K] }; + interface Config { measure: keyof T } + interface Ref { dataset: DS, N> } + interface DS { + a(config: Config>): void; + b: Ref; + } + declare const x: DS<{ total: M }, string>; + export const y: DS, string> = x; + ~ +!!! 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; }'. + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/recursiveGenericInterfaceDeclarationOrder.symbols b/tsc/testdata/baselines/reference/compiler/recursiveGenericInterfaceDeclarationOrder.symbols new file mode 100644 index 0000000000000..90c083e029559 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/recursiveGenericInterfaceDeclarationOrder.symbols @@ -0,0 +1,67 @@ +//// [tests/cases/compiler/recursiveGenericInterfaceDeclarationOrder.ts] //// + +=== recursiveGenericInterfaceDeclarationOrder.ts === +// The assignment is valid, as method parameters are compared bivariantly, and +// must be accepted whichever of the interfaces is declared first. + +type M = { kind: "m" }; +>M : Symbol(M, Decl(recursiveGenericInterfaceDeclarationOrder.ts, 0, 0)) +>kind : Symbol(kind, Decl(recursiveGenericInterfaceDeclarationOrder.ts, 3, 10)) + +type Filtered = { [K in keyof T as T[K] extends M ? K : never]: T[K] }; +>Filtered : Symbol(Filtered, Decl(recursiveGenericInterfaceDeclarationOrder.ts, 3, 23)) +>T : Symbol(T, Decl(recursiveGenericInterfaceDeclarationOrder.ts, 4, 14)) +>K : Symbol(K, Decl(recursiveGenericInterfaceDeclarationOrder.ts, 4, 22)) +>T : Symbol(T, Decl(recursiveGenericInterfaceDeclarationOrder.ts, 4, 14)) +>T : Symbol(T, Decl(recursiveGenericInterfaceDeclarationOrder.ts, 4, 14)) +>K : Symbol(K, Decl(recursiveGenericInterfaceDeclarationOrder.ts, 4, 22)) +>M : Symbol(M, Decl(recursiveGenericInterfaceDeclarationOrder.ts, 0, 0)) +>K : Symbol(K, Decl(recursiveGenericInterfaceDeclarationOrder.ts, 4, 22)) +>T : Symbol(T, Decl(recursiveGenericInterfaceDeclarationOrder.ts, 4, 14)) +>K : Symbol(K, Decl(recursiveGenericInterfaceDeclarationOrder.ts, 4, 22)) + +interface Config { measure: keyof T } +>Config : Symbol(Config, Decl(recursiveGenericInterfaceDeclarationOrder.ts, 4, 74)) +>T : Symbol(T, Decl(recursiveGenericInterfaceDeclarationOrder.ts, 5, 17)) +>measure : Symbol(Config.measure, Decl(recursiveGenericInterfaceDeclarationOrder.ts, 5, 21)) +>T : Symbol(T, Decl(recursiveGenericInterfaceDeclarationOrder.ts, 5, 17)) + +interface Ref { dataset: DS, N> } +>Ref : Symbol(Ref, Decl(recursiveGenericInterfaceDeclarationOrder.ts, 5, 40)) +>N : Symbol(N, Decl(recursiveGenericInterfaceDeclarationOrder.ts, 6, 14)) +>dataset : Symbol(Ref.dataset, Decl(recursiveGenericInterfaceDeclarationOrder.ts, 6, 18)) +>DS : Symbol(DS, Decl(recursiveGenericInterfaceDeclarationOrder.ts, 6, 54)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) +>M : Symbol(M, Decl(recursiveGenericInterfaceDeclarationOrder.ts, 0, 0)) +>N : Symbol(N, Decl(recursiveGenericInterfaceDeclarationOrder.ts, 6, 14)) + +interface DS { +>DS : Symbol(DS, Decl(recursiveGenericInterfaceDeclarationOrder.ts, 6, 54)) +>T : Symbol(T, Decl(recursiveGenericInterfaceDeclarationOrder.ts, 7, 13)) +>N : Symbol(N, Decl(recursiveGenericInterfaceDeclarationOrder.ts, 7, 15)) + + a(config: Config>): void; +>a : Symbol(DS.a, Decl(recursiveGenericInterfaceDeclarationOrder.ts, 7, 20)) +>config : Symbol(config, Decl(recursiveGenericInterfaceDeclarationOrder.ts, 8, 4)) +>Config : Symbol(Config, Decl(recursiveGenericInterfaceDeclarationOrder.ts, 4, 74)) +>Filtered : Symbol(Filtered, Decl(recursiveGenericInterfaceDeclarationOrder.ts, 3, 23)) +>T : Symbol(T, Decl(recursiveGenericInterfaceDeclarationOrder.ts, 7, 13)) + + b: Ref; +>b : Symbol(DS.b, Decl(recursiveGenericInterfaceDeclarationOrder.ts, 8, 39)) +>Ref : Symbol(Ref, Decl(recursiveGenericInterfaceDeclarationOrder.ts, 5, 40)) +>N : Symbol(N, Decl(recursiveGenericInterfaceDeclarationOrder.ts, 7, 15)) +} +declare const x: DS<{ total: M }, string>; +>x : Symbol(x, Decl(recursiveGenericInterfaceDeclarationOrder.ts, 11, 13)) +>DS : Symbol(DS, Decl(recursiveGenericInterfaceDeclarationOrder.ts, 6, 54)) +>total : Symbol(total, Decl(recursiveGenericInterfaceDeclarationOrder.ts, 11, 21)) +>M : Symbol(M, Decl(recursiveGenericInterfaceDeclarationOrder.ts, 0, 0)) + +export const y: DS, string> = x; +>y : Symbol(y, Decl(recursiveGenericInterfaceDeclarationOrder.ts, 12, 12)) +>DS : Symbol(DS, Decl(recursiveGenericInterfaceDeclarationOrder.ts, 6, 54)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) +>M : Symbol(M, Decl(recursiveGenericInterfaceDeclarationOrder.ts, 0, 0)) +>x : Symbol(x, Decl(recursiveGenericInterfaceDeclarationOrder.ts, 11, 13)) + diff --git a/tsc/testdata/baselines/reference/compiler/recursiveGenericInterfaceDeclarationOrder.types b/tsc/testdata/baselines/reference/compiler/recursiveGenericInterfaceDeclarationOrder.types new file mode 100644 index 0000000000000..5bdcbb5101541 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/recursiveGenericInterfaceDeclarationOrder.types @@ -0,0 +1,35 @@ +//// [tests/cases/compiler/recursiveGenericInterfaceDeclarationOrder.ts] //// + +=== recursiveGenericInterfaceDeclarationOrder.ts === +// The assignment is valid, as method parameters are compared bivariantly, and +// must be accepted whichever of the interfaces is declared first. + +type M = { kind: "m" }; +>M : M +>kind : "m" + +type Filtered = { [K in keyof T as T[K] extends M ? K : never]: T[K] }; +>Filtered : Filtered + +interface Config { measure: keyof T } +>measure : keyof T + +interface Ref { dataset: DS, N> } +>dataset : DS, N> + +interface DS { + a(config: Config>): void; +>a : (config: Config>) => void +>config : Config> + + b: Ref; +>b : Ref +} +declare const x: DS<{ total: M }, string>; +>x : DS<{ total: M; }, string> +>total : M + +export const y: DS, string> = x; +>y : DS, string> +>x : DS<{ total: M; }, string> + diff --git a/tsc/testdata/baselines/reference/compiler/recursiveVarianceFixedPoint.errors.txt b/tsc/testdata/baselines/reference/compiler/recursiveVarianceFixedPoint.errors.txt new file mode 100644 index 0000000000000..1b54f45a5c6a5 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/recursiveVarianceFixedPoint.errors.txt @@ -0,0 +1,227 @@ +annotations.ts(18,1): error TS2322: Type 'AnnotatedTree' is not assignable to type 'AnnotatedTree'. + Type 'unknown' is not assignable to type 'string'. +annotations.ts(19,1): error TS2322: Type 'AnnotatedStore' is not assignable to type 'AnnotatedStore'. + Types of property 'listener' are incompatible. + Type '(batch: AnnotatedStore) => void' is not assignable to type '(batch: AnnotatedStore) => void'. + Types of parameters 'batch' and 'batch' are incompatible. + Type 'AnnotatedStore' is not assignable to type 'AnnotatedStore'. + Types of property 'value' are incompatible. + Type 'unknown[]' is not assignable to type 'string[]'. + Type 'unknown' is not assignable to type 'string'. +annotations.ts(20,1): error TS2322: Type 'AnnotatedStore' is not assignable to type 'AnnotatedStore'. + Types of property 'value' are incompatible. + Type 'unknown' is not assignable to type 'string'. +columnDefFirst.ts(14,1): error TS2322: Type 'ColumnDef<{ name: string; }, string>' is not assignable to type 'ColumnDef<{ name: string; }, unknown>'. + Type 'unknown' is not assignable to type 'string'. +listenerFirst.ts(14,1): error TS2322: Type 'Listener' is not assignable to type 'Listener'. + Type 'unknown' is not assignable to type 'string'. +nestedComposition.ts(14,1): error TS2322: Type 'Outer' is not assignable to type 'Outer'. + Types of property 'next' are incompatible. + Type 'Inner>' is not assignable to type 'Inner>'. + Type 'Outer' is not assignable to type 'Outer'. + Types of property 'value' are incompatible. + Type 'unknown' is not assignable to type 'string'. +nestedComposition.ts(15,1): error TS2322: Type 'Outer' is not assignable to type 'Outer'. + Types of property 'value' are incompatible. + Type 'unknown' is not assignable to type 'string'. +positiveRecursion.ts(18,1): error TS2322: Type 'Tree' is not assignable to type 'Tree'. + Type 'unknown' is not assignable to type 'string'. +structuralMeasurement.ts(23,1): error TS2322: Type 'GenericMethod' is not assignable to type 'GenericMethod'. + Type 'unknown' is not assignable to type 'string'. + + +==== storeFirst.ts (0 errors) ==== + export {}; + + interface Store { + value: T; + listener: Listener; + } + type Listener = (batch: Store) => void; + + declare let strings: Store; + declare let unknowns: Store; + declare let stringListener: Listener; + declare let unknownListener: Listener; + + unknowns = strings; // Error + unknownListener = stringListener; // Error + +==== listenerFirst.ts (1 errors) ==== + export {}; + + type Listener = (batch: Store) => void; + interface Store { + listener: Listener; + value: T; + } + + declare let strings: Store; + declare let unknowns: Store; + declare let stringListener: Listener; + declare let unknownListener: Listener; + + unknownListener = stringListener; // Error + ~~~~~~~~~~~~~~~ +!!! error TS2322: Type 'Listener' is not assignable to type 'Listener'. +!!! error TS2322: Type 'unknown' is not assignable to type 'string'. + unknowns = strings; // Error + +==== columnDefFirst.ts (1 errors) ==== + export {}; + + interface ColumnDef { + cell?: (column: Column) => void; + } + interface Column { + accessorFn?: (row: Row) => Value; + columnDef: ColumnDef; + } + + declare let stringColumn: ColumnDef<{ name: string }, string>; + declare let unknownColumn: ColumnDef<{ name: string }, unknown>; + + unknownColumn = stringColumn; // Error + ~~~~~~~~~~~~~ +!!! error TS2322: Type 'ColumnDef<{ name: string; }, string>' is not assignable to type 'ColumnDef<{ name: string; }, unknown>'. +!!! error TS2322: Type 'unknown' is not assignable to type 'string'. + stringColumn = unknownColumn; // Error + +==== columnFirst.ts (0 errors) ==== + export {}; + + interface Column { + columnDef: ColumnDef; + accessorFn?: (row: Row) => Value; + } + interface ColumnDef { + cell?: (column: Column) => void; + } + + declare let stringColumn: ColumnDef<{ name: string }, string>; + declare let unknownColumn: ColumnDef<{ name: string }, unknown>; + + unknownColumn = stringColumn; // Error + stringColumn = unknownColumn; // Error + +==== positiveRecursion.ts (1 errors) ==== + export {}; + + interface Tree { + readonly value: T; + readonly children: readonly Tree[]; + readonly metadata: Map; + } + interface Phantom { + next: Phantom; + } + + declare let stringTree: Tree; + declare let unknownTree: Tree; + declare let stringPhantom: Phantom; + declare let numberPhantom: Phantom; + + unknownTree = stringTree; + stringTree = unknownTree; // Error + ~~~~~~~~~~ +!!! error TS2322: Type 'Tree' is not assignable to type 'Tree'. +!!! error TS2322: Type 'unknown' is not assignable to type 'string'. + stringPhantom = numberPhantom; + numberPhantom = stringPhantom; + +==== nestedComposition.ts (2 errors) ==== + export {}; + + interface Outer { + value: T; + next: Inner>; + } + interface Inner { + consume: (value: T) => void; + } + + declare let strings: Outer; + declare let unknowns: Outer; + + unknowns = strings; // Error + ~~~~~~~~ +!!! error TS2322: Type 'Outer' is not assignable to type 'Outer'. +!!! error TS2322: Types of property 'next' are incompatible. +!!! error TS2322: Type 'Inner>' is not assignable to type 'Inner>'. +!!! error TS2322: Type 'Outer' is not assignable to type 'Outer'. +!!! error TS2322: Types of property 'value' are incompatible. +!!! error TS2322: Type 'unknown' is not assignable to type 'string'. + strings = unknowns; // Error + ~~~~~~~ +!!! error TS2322: Type 'Outer' is not assignable to type 'Outer'. +!!! error TS2322: Types of property 'value' are incompatible. +!!! error TS2322: Type 'unknown' is not assignable to type 'string'. + +==== annotations.ts (3 errors) ==== + export {}; + + interface AnnotatedTree { + readonly value: T; + readonly children: AnnotatedTree[]; + } + interface AnnotatedStore { + value: T; + listener: (batch: AnnotatedStore) => void; + } + + declare let stringTree: AnnotatedTree; + declare let unknownTree: AnnotatedTree; + declare let stringStore: AnnotatedStore; + declare let unknownStore: AnnotatedStore; + + unknownTree = stringTree; + stringTree = unknownTree; // Error + ~~~~~~~~~~ +!!! error TS2322: Type 'AnnotatedTree' is not assignable to type 'AnnotatedTree'. +!!! error TS2322: Type 'unknown' is not assignable to type 'string'. + unknownStore = stringStore; // Error + ~~~~~~~~~~~~ +!!! error TS2322: Type 'AnnotatedStore' is not assignable to type 'AnnotatedStore'. +!!! error TS2322: Types of property 'listener' are incompatible. +!!! error TS2322: Type '(batch: AnnotatedStore) => void' is not assignable to type '(batch: AnnotatedStore) => void'. +!!! error TS2322: Types of parameters 'batch' and 'batch' are incompatible. +!!! error TS2322: Type 'AnnotatedStore' is not assignable to type 'AnnotatedStore'. +!!! error TS2322: Types of property 'value' are incompatible. +!!! error TS2322: Type 'unknown[]' is not assignable to type 'string[]'. +!!! error TS2322: Type 'unknown' is not assignable to type 'string'. + stringStore = unknownStore; // Error + ~~~~~~~~~~~ +!!! error TS2322: Type 'AnnotatedStore' is not assignable to type 'AnnotatedStore'. +!!! error TS2322: Types of property 'value' are incompatible. +!!! error TS2322: Type 'unknown' is not assignable to type 'string'. + +==== structuralMeasurement.ts (1 errors) ==== + export {}; + + interface GenericMethod { + value: T; + next: (value: U) => GenericMethod; + } + interface Projected { + value: T["value"]; + next: Projected; + } + interface Method { + value: T; + accept(value: Method): void; + } + + declare let strings: GenericMethod; + declare let unknowns: GenericMethod; + declare let stringMethod: Method; + declare let unknownMethod: Method; + declare let projected: Projected<{ value: string; extra: number }>; + + unknowns = strings; + strings = unknowns; // Error + ~~~~~~~ +!!! error TS2322: Type 'GenericMethod' is not assignable to type 'GenericMethod'. +!!! error TS2322: Type 'unknown' is not assignable to type 'string'. + unknownMethod = stringMethod; + const widened: Projected<{ value: string }> = projected; + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/recursiveVarianceFixedPoint.symbols b/tsc/testdata/baselines/reference/compiler/recursiveVarianceFixedPoint.symbols new file mode 100644 index 0000000000000..5609297b7b09a --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/recursiveVarianceFixedPoint.symbols @@ -0,0 +1,455 @@ +//// [tests/cases/compiler/recursiveVarianceFixedPoint.ts] //// + +=== storeFirst.ts === +export {}; + +interface Store { +>Store : Symbol(Store, Decl(storeFirst.ts, 0, 10)) +>T : Symbol(T, Decl(storeFirst.ts, 2, 16)) + + value: T; +>value : Symbol(Store.value, Decl(storeFirst.ts, 2, 20)) +>T : Symbol(T, Decl(storeFirst.ts, 2, 16)) + + listener: Listener; +>listener : Symbol(Store.listener, Decl(storeFirst.ts, 3, 13)) +>Listener : Symbol(Listener, Decl(storeFirst.ts, 5, 1)) +>T : Symbol(T, Decl(storeFirst.ts, 2, 16)) +} +type Listener = (batch: Store) => void; +>Listener : Symbol(Listener, Decl(storeFirst.ts, 5, 1)) +>T : Symbol(T, Decl(storeFirst.ts, 6, 14)) +>batch : Symbol(batch, Decl(storeFirst.ts, 6, 20)) +>Store : Symbol(Store, Decl(storeFirst.ts, 0, 10)) +>T : Symbol(T, Decl(storeFirst.ts, 6, 14)) + +declare let strings: Store; +>strings : Symbol(strings, Decl(storeFirst.ts, 8, 11)) +>Store : Symbol(Store, Decl(storeFirst.ts, 0, 10)) + +declare let unknowns: Store; +>unknowns : Symbol(unknowns, Decl(storeFirst.ts, 9, 11)) +>Store : Symbol(Store, Decl(storeFirst.ts, 0, 10)) + +declare let stringListener: Listener; +>stringListener : Symbol(stringListener, Decl(storeFirst.ts, 10, 11)) +>Listener : Symbol(Listener, Decl(storeFirst.ts, 5, 1)) + +declare let unknownListener: Listener; +>unknownListener : Symbol(unknownListener, Decl(storeFirst.ts, 11, 11)) +>Listener : Symbol(Listener, Decl(storeFirst.ts, 5, 1)) + +unknowns = strings; // Error +>unknowns : Symbol(unknowns, Decl(storeFirst.ts, 9, 11)) +>strings : Symbol(strings, Decl(storeFirst.ts, 8, 11)) + +unknownListener = stringListener; // Error +>unknownListener : Symbol(unknownListener, Decl(storeFirst.ts, 11, 11)) +>stringListener : Symbol(stringListener, Decl(storeFirst.ts, 10, 11)) + +=== listenerFirst.ts === +export {}; + +type Listener = (batch: Store) => void; +>Listener : Symbol(Listener, Decl(listenerFirst.ts, 0, 10)) +>T : Symbol(T, Decl(listenerFirst.ts, 2, 14)) +>batch : Symbol(batch, Decl(listenerFirst.ts, 2, 20)) +>Store : Symbol(Store, Decl(listenerFirst.ts, 2, 47)) +>T : Symbol(T, Decl(listenerFirst.ts, 2, 14)) + +interface Store { +>Store : Symbol(Store, Decl(listenerFirst.ts, 2, 47)) +>T : Symbol(T, Decl(listenerFirst.ts, 3, 16)) + + listener: Listener; +>listener : Symbol(Store.listener, Decl(listenerFirst.ts, 3, 20)) +>Listener : Symbol(Listener, Decl(listenerFirst.ts, 0, 10)) +>T : Symbol(T, Decl(listenerFirst.ts, 3, 16)) + + value: T; +>value : Symbol(Store.value, Decl(listenerFirst.ts, 4, 26)) +>T : Symbol(T, Decl(listenerFirst.ts, 3, 16)) +} + +declare let strings: Store; +>strings : Symbol(strings, Decl(listenerFirst.ts, 8, 11)) +>Store : Symbol(Store, Decl(listenerFirst.ts, 2, 47)) + +declare let unknowns: Store; +>unknowns : Symbol(unknowns, Decl(listenerFirst.ts, 9, 11)) +>Store : Symbol(Store, Decl(listenerFirst.ts, 2, 47)) + +declare let stringListener: Listener; +>stringListener : Symbol(stringListener, Decl(listenerFirst.ts, 10, 11)) +>Listener : Symbol(Listener, Decl(listenerFirst.ts, 0, 10)) + +declare let unknownListener: Listener; +>unknownListener : Symbol(unknownListener, Decl(listenerFirst.ts, 11, 11)) +>Listener : Symbol(Listener, Decl(listenerFirst.ts, 0, 10)) + +unknownListener = stringListener; // Error +>unknownListener : Symbol(unknownListener, Decl(listenerFirst.ts, 11, 11)) +>stringListener : Symbol(stringListener, Decl(listenerFirst.ts, 10, 11)) + +unknowns = strings; // Error +>unknowns : Symbol(unknowns, Decl(listenerFirst.ts, 9, 11)) +>strings : Symbol(strings, Decl(listenerFirst.ts, 8, 11)) + +=== columnDefFirst.ts === +export {}; + +interface ColumnDef { +>ColumnDef : Symbol(ColumnDef, Decl(columnDefFirst.ts, 0, 10)) +>Row : Symbol(Row, Decl(columnDefFirst.ts, 2, 20)) +>Value : Symbol(Value, Decl(columnDefFirst.ts, 2, 24)) + + cell?: (column: Column) => void; +>cell : Symbol(ColumnDef.cell, Decl(columnDefFirst.ts, 2, 43)) +>column : Symbol(column, Decl(columnDefFirst.ts, 3, 12)) +>Column : Symbol(Column, Decl(columnDefFirst.ts, 4, 1)) +>Row : Symbol(Row, Decl(columnDefFirst.ts, 2, 20)) +>Value : Symbol(Value, Decl(columnDefFirst.ts, 2, 24)) +} +interface Column { +>Column : Symbol(Column, Decl(columnDefFirst.ts, 4, 1)) +>Row : Symbol(Row, Decl(columnDefFirst.ts, 5, 17)) +>Value : Symbol(Value, Decl(columnDefFirst.ts, 5, 21)) + + accessorFn?: (row: Row) => Value; +>accessorFn : Symbol(Column.accessorFn, Decl(columnDefFirst.ts, 5, 40)) +>row : Symbol(row, Decl(columnDefFirst.ts, 6, 18)) +>Row : Symbol(Row, Decl(columnDefFirst.ts, 5, 17)) +>Value : Symbol(Value, Decl(columnDefFirst.ts, 5, 21)) + + columnDef: ColumnDef; +>columnDef : Symbol(Column.columnDef, Decl(columnDefFirst.ts, 6, 37)) +>ColumnDef : Symbol(ColumnDef, Decl(columnDefFirst.ts, 0, 10)) +>Row : Symbol(Row, Decl(columnDefFirst.ts, 5, 17)) +>Value : Symbol(Value, Decl(columnDefFirst.ts, 5, 21)) +} + +declare let stringColumn: ColumnDef<{ name: string }, string>; +>stringColumn : Symbol(stringColumn, Decl(columnDefFirst.ts, 10, 11)) +>ColumnDef : Symbol(ColumnDef, Decl(columnDefFirst.ts, 0, 10)) +>name : Symbol(name, Decl(columnDefFirst.ts, 10, 37)) + +declare let unknownColumn: ColumnDef<{ name: string }, unknown>; +>unknownColumn : Symbol(unknownColumn, Decl(columnDefFirst.ts, 11, 11)) +>ColumnDef : Symbol(ColumnDef, Decl(columnDefFirst.ts, 0, 10)) +>name : Symbol(name, Decl(columnDefFirst.ts, 11, 38)) + +unknownColumn = stringColumn; // Error +>unknownColumn : Symbol(unknownColumn, Decl(columnDefFirst.ts, 11, 11)) +>stringColumn : Symbol(stringColumn, Decl(columnDefFirst.ts, 10, 11)) + +stringColumn = unknownColumn; // Error +>stringColumn : Symbol(stringColumn, Decl(columnDefFirst.ts, 10, 11)) +>unknownColumn : Symbol(unknownColumn, Decl(columnDefFirst.ts, 11, 11)) + +=== columnFirst.ts === +export {}; + +interface Column { +>Column : Symbol(Column, Decl(columnFirst.ts, 0, 10)) +>Row : Symbol(Row, Decl(columnFirst.ts, 2, 17)) +>Value : Symbol(Value, Decl(columnFirst.ts, 2, 21)) + + columnDef: ColumnDef; +>columnDef : Symbol(Column.columnDef, Decl(columnFirst.ts, 2, 40)) +>ColumnDef : Symbol(ColumnDef, Decl(columnFirst.ts, 5, 1)) +>Row : Symbol(Row, Decl(columnFirst.ts, 2, 17)) +>Value : Symbol(Value, Decl(columnFirst.ts, 2, 21)) + + accessorFn?: (row: Row) => Value; +>accessorFn : Symbol(Column.accessorFn, Decl(columnFirst.ts, 3, 37)) +>row : Symbol(row, Decl(columnFirst.ts, 4, 18)) +>Row : Symbol(Row, Decl(columnFirst.ts, 2, 17)) +>Value : Symbol(Value, Decl(columnFirst.ts, 2, 21)) +} +interface ColumnDef { +>ColumnDef : Symbol(ColumnDef, Decl(columnFirst.ts, 5, 1)) +>Row : Symbol(Row, Decl(columnFirst.ts, 6, 20)) +>Value : Symbol(Value, Decl(columnFirst.ts, 6, 24)) + + cell?: (column: Column) => void; +>cell : Symbol(ColumnDef.cell, Decl(columnFirst.ts, 6, 43)) +>column : Symbol(column, Decl(columnFirst.ts, 7, 12)) +>Column : Symbol(Column, Decl(columnFirst.ts, 0, 10)) +>Row : Symbol(Row, Decl(columnFirst.ts, 6, 20)) +>Value : Symbol(Value, Decl(columnFirst.ts, 6, 24)) +} + +declare let stringColumn: ColumnDef<{ name: string }, string>; +>stringColumn : Symbol(stringColumn, Decl(columnFirst.ts, 10, 11)) +>ColumnDef : Symbol(ColumnDef, Decl(columnFirst.ts, 5, 1)) +>name : Symbol(name, Decl(columnFirst.ts, 10, 37)) + +declare let unknownColumn: ColumnDef<{ name: string }, unknown>; +>unknownColumn : Symbol(unknownColumn, Decl(columnFirst.ts, 11, 11)) +>ColumnDef : Symbol(ColumnDef, Decl(columnFirst.ts, 5, 1)) +>name : Symbol(name, Decl(columnFirst.ts, 11, 38)) + +unknownColumn = stringColumn; // Error +>unknownColumn : Symbol(unknownColumn, Decl(columnFirst.ts, 11, 11)) +>stringColumn : Symbol(stringColumn, Decl(columnFirst.ts, 10, 11)) + +stringColumn = unknownColumn; // Error +>stringColumn : Symbol(stringColumn, Decl(columnFirst.ts, 10, 11)) +>unknownColumn : Symbol(unknownColumn, Decl(columnFirst.ts, 11, 11)) + +=== positiveRecursion.ts === +export {}; + +interface Tree { +>Tree : Symbol(Tree, Decl(positiveRecursion.ts, 0, 10)) +>T : Symbol(T, Decl(positiveRecursion.ts, 2, 15)) + + readonly value: T; +>value : Symbol(Tree.value, Decl(positiveRecursion.ts, 2, 19)) +>T : Symbol(T, Decl(positiveRecursion.ts, 2, 15)) + + readonly children: readonly Tree[]; +>children : Symbol(Tree.children, Decl(positiveRecursion.ts, 3, 22)) +>Tree : Symbol(Tree, Decl(positiveRecursion.ts, 0, 10)) +>T : Symbol(T, Decl(positiveRecursion.ts, 2, 15)) + + readonly metadata: Map; +>metadata : Symbol(Tree.metadata, Decl(positiveRecursion.ts, 4, 42)) +>Map : Symbol(Map, Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) +} +interface Phantom { +>Phantom : Symbol(Phantom, Decl(positiveRecursion.ts, 6, 1)) +>T : Symbol(T, Decl(positiveRecursion.ts, 7, 18)) + + next: Phantom; +>next : Symbol(Phantom.next, Decl(positiveRecursion.ts, 7, 22)) +>Phantom : Symbol(Phantom, Decl(positiveRecursion.ts, 6, 1)) +>T : Symbol(T, Decl(positiveRecursion.ts, 7, 18)) +} + +declare let stringTree: Tree; +>stringTree : Symbol(stringTree, Decl(positiveRecursion.ts, 11, 11)) +>Tree : Symbol(Tree, Decl(positiveRecursion.ts, 0, 10)) + +declare let unknownTree: Tree; +>unknownTree : Symbol(unknownTree, Decl(positiveRecursion.ts, 12, 11)) +>Tree : Symbol(Tree, Decl(positiveRecursion.ts, 0, 10)) + +declare let stringPhantom: Phantom; +>stringPhantom : Symbol(stringPhantom, Decl(positiveRecursion.ts, 13, 11)) +>Phantom : Symbol(Phantom, Decl(positiveRecursion.ts, 6, 1)) + +declare let numberPhantom: Phantom; +>numberPhantom : Symbol(numberPhantom, Decl(positiveRecursion.ts, 14, 11)) +>Phantom : Symbol(Phantom, Decl(positiveRecursion.ts, 6, 1)) + +unknownTree = stringTree; +>unknownTree : Symbol(unknownTree, Decl(positiveRecursion.ts, 12, 11)) +>stringTree : Symbol(stringTree, Decl(positiveRecursion.ts, 11, 11)) + +stringTree = unknownTree; // Error +>stringTree : Symbol(stringTree, Decl(positiveRecursion.ts, 11, 11)) +>unknownTree : Symbol(unknownTree, Decl(positiveRecursion.ts, 12, 11)) + +stringPhantom = numberPhantom; +>stringPhantom : Symbol(stringPhantom, Decl(positiveRecursion.ts, 13, 11)) +>numberPhantom : Symbol(numberPhantom, Decl(positiveRecursion.ts, 14, 11)) + +numberPhantom = stringPhantom; +>numberPhantom : Symbol(numberPhantom, Decl(positiveRecursion.ts, 14, 11)) +>stringPhantom : Symbol(stringPhantom, Decl(positiveRecursion.ts, 13, 11)) + +=== nestedComposition.ts === +export {}; + +interface Outer { +>Outer : Symbol(Outer, Decl(nestedComposition.ts, 0, 10)) +>T : Symbol(T, Decl(nestedComposition.ts, 2, 16)) + + value: T; +>value : Symbol(Outer.value, Decl(nestedComposition.ts, 2, 20)) +>T : Symbol(T, Decl(nestedComposition.ts, 2, 16)) + + next: Inner>; +>next : Symbol(Outer.next, Decl(nestedComposition.ts, 3, 13)) +>Inner : Symbol(Inner, Decl(nestedComposition.ts, 5, 1)) +>Outer : Symbol(Outer, Decl(nestedComposition.ts, 0, 10)) +>T : Symbol(T, Decl(nestedComposition.ts, 2, 16)) +} +interface Inner { +>Inner : Symbol(Inner, Decl(nestedComposition.ts, 5, 1)) +>T : Symbol(T, Decl(nestedComposition.ts, 6, 16)) + + consume: (value: T) => void; +>consume : Symbol(Inner.consume, Decl(nestedComposition.ts, 6, 20)) +>value : Symbol(value, Decl(nestedComposition.ts, 7, 14)) +>T : Symbol(T, Decl(nestedComposition.ts, 6, 16)) +} + +declare let strings: Outer; +>strings : Symbol(strings, Decl(nestedComposition.ts, 10, 11)) +>Outer : Symbol(Outer, Decl(nestedComposition.ts, 0, 10)) + +declare let unknowns: Outer; +>unknowns : Symbol(unknowns, Decl(nestedComposition.ts, 11, 11)) +>Outer : Symbol(Outer, Decl(nestedComposition.ts, 0, 10)) + +unknowns = strings; // Error +>unknowns : Symbol(unknowns, Decl(nestedComposition.ts, 11, 11)) +>strings : Symbol(strings, Decl(nestedComposition.ts, 10, 11)) + +strings = unknowns; // Error +>strings : Symbol(strings, Decl(nestedComposition.ts, 10, 11)) +>unknowns : Symbol(unknowns, Decl(nestedComposition.ts, 11, 11)) + +=== annotations.ts === +export {}; + +interface AnnotatedTree { +>AnnotatedTree : Symbol(AnnotatedTree, Decl(annotations.ts, 0, 10)) +>T : Symbol(T, Decl(annotations.ts, 2, 24)) + + readonly value: T; +>value : Symbol(AnnotatedTree.value, Decl(annotations.ts, 2, 32)) +>T : Symbol(T, Decl(annotations.ts, 2, 24)) + + readonly children: AnnotatedTree[]; +>children : Symbol(AnnotatedTree.children, Decl(annotations.ts, 3, 22)) +>AnnotatedTree : Symbol(AnnotatedTree, Decl(annotations.ts, 0, 10)) +>T : Symbol(T, Decl(annotations.ts, 2, 24)) +} +interface AnnotatedStore { +>AnnotatedStore : Symbol(AnnotatedStore, Decl(annotations.ts, 5, 1)) +>T : Symbol(T, Decl(annotations.ts, 6, 25)) + + value: T; +>value : Symbol(AnnotatedStore.value, Decl(annotations.ts, 6, 36)) +>T : Symbol(T, Decl(annotations.ts, 6, 25)) + + listener: (batch: AnnotatedStore) => void; +>listener : Symbol(AnnotatedStore.listener, Decl(annotations.ts, 7, 13)) +>batch : Symbol(batch, Decl(annotations.ts, 8, 15)) +>AnnotatedStore : Symbol(AnnotatedStore, Decl(annotations.ts, 5, 1)) +>T : Symbol(T, Decl(annotations.ts, 6, 25)) +} + +declare let stringTree: AnnotatedTree; +>stringTree : Symbol(stringTree, Decl(annotations.ts, 11, 11)) +>AnnotatedTree : Symbol(AnnotatedTree, Decl(annotations.ts, 0, 10)) + +declare let unknownTree: AnnotatedTree; +>unknownTree : Symbol(unknownTree, Decl(annotations.ts, 12, 11)) +>AnnotatedTree : Symbol(AnnotatedTree, Decl(annotations.ts, 0, 10)) + +declare let stringStore: AnnotatedStore; +>stringStore : Symbol(stringStore, Decl(annotations.ts, 13, 11)) +>AnnotatedStore : Symbol(AnnotatedStore, Decl(annotations.ts, 5, 1)) + +declare let unknownStore: AnnotatedStore; +>unknownStore : Symbol(unknownStore, Decl(annotations.ts, 14, 11)) +>AnnotatedStore : Symbol(AnnotatedStore, Decl(annotations.ts, 5, 1)) + +unknownTree = stringTree; +>unknownTree : Symbol(unknownTree, Decl(annotations.ts, 12, 11)) +>stringTree : Symbol(stringTree, Decl(annotations.ts, 11, 11)) + +stringTree = unknownTree; // Error +>stringTree : Symbol(stringTree, Decl(annotations.ts, 11, 11)) +>unknownTree : Symbol(unknownTree, Decl(annotations.ts, 12, 11)) + +unknownStore = stringStore; // Error +>unknownStore : Symbol(unknownStore, Decl(annotations.ts, 14, 11)) +>stringStore : Symbol(stringStore, Decl(annotations.ts, 13, 11)) + +stringStore = unknownStore; // Error +>stringStore : Symbol(stringStore, Decl(annotations.ts, 13, 11)) +>unknownStore : Symbol(unknownStore, Decl(annotations.ts, 14, 11)) + +=== structuralMeasurement.ts === +export {}; + +interface GenericMethod { +>GenericMethod : Symbol(GenericMethod, Decl(structuralMeasurement.ts, 0, 10)) +>T : Symbol(T, Decl(structuralMeasurement.ts, 2, 24)) + + value: T; +>value : Symbol(GenericMethod.value, Decl(structuralMeasurement.ts, 2, 28)) +>T : Symbol(T, Decl(structuralMeasurement.ts, 2, 24)) + + next: (value: U) => GenericMethod; +>next : Symbol(GenericMethod.next, Decl(structuralMeasurement.ts, 3, 13)) +>U : Symbol(U, Decl(structuralMeasurement.ts, 4, 11)) +>value : Symbol(value, Decl(structuralMeasurement.ts, 4, 14)) +>U : Symbol(U, Decl(structuralMeasurement.ts, 4, 11)) +>GenericMethod : Symbol(GenericMethod, Decl(structuralMeasurement.ts, 0, 10)) +>T : Symbol(T, Decl(structuralMeasurement.ts, 2, 24)) +} +interface Projected { +>Projected : Symbol(Projected, Decl(structuralMeasurement.ts, 5, 1)) +>T : Symbol(T, Decl(structuralMeasurement.ts, 6, 20)) +>value : Symbol(value, Decl(structuralMeasurement.ts, 6, 31)) + + value: T["value"]; +>value : Symbol(Projected.value, Decl(structuralMeasurement.ts, 6, 51)) +>T : Symbol(T, Decl(structuralMeasurement.ts, 6, 20)) + + next: Projected; +>next : Symbol(Projected.next, Decl(structuralMeasurement.ts, 7, 22)) +>Projected : Symbol(Projected, Decl(structuralMeasurement.ts, 5, 1)) +>T : Symbol(T, Decl(structuralMeasurement.ts, 6, 20)) +} +interface Method { +>Method : Symbol(Method, Decl(structuralMeasurement.ts, 9, 1)) +>T : Symbol(T, Decl(structuralMeasurement.ts, 10, 17)) + + value: T; +>value : Symbol(Method.value, Decl(structuralMeasurement.ts, 10, 21)) +>T : Symbol(T, Decl(structuralMeasurement.ts, 10, 17)) + + accept(value: Method): void; +>accept : Symbol(Method.accept, Decl(structuralMeasurement.ts, 11, 13)) +>value : Symbol(value, Decl(structuralMeasurement.ts, 12, 11)) +>Method : Symbol(Method, Decl(structuralMeasurement.ts, 9, 1)) +>T : Symbol(T, Decl(structuralMeasurement.ts, 10, 17)) +} + +declare let strings: GenericMethod; +>strings : Symbol(strings, Decl(structuralMeasurement.ts, 15, 11)) +>GenericMethod : Symbol(GenericMethod, Decl(structuralMeasurement.ts, 0, 10)) + +declare let unknowns: GenericMethod; +>unknowns : Symbol(unknowns, Decl(structuralMeasurement.ts, 16, 11)) +>GenericMethod : Symbol(GenericMethod, Decl(structuralMeasurement.ts, 0, 10)) + +declare let stringMethod: Method; +>stringMethod : Symbol(stringMethod, Decl(structuralMeasurement.ts, 17, 11)) +>Method : Symbol(Method, Decl(structuralMeasurement.ts, 9, 1)) + +declare let unknownMethod: Method; +>unknownMethod : Symbol(unknownMethod, Decl(structuralMeasurement.ts, 18, 11)) +>Method : Symbol(Method, Decl(structuralMeasurement.ts, 9, 1)) + +declare let projected: Projected<{ value: string; extra: number }>; +>projected : Symbol(projected, Decl(structuralMeasurement.ts, 19, 11)) +>Projected : Symbol(Projected, Decl(structuralMeasurement.ts, 5, 1)) +>value : Symbol(value, Decl(structuralMeasurement.ts, 19, 34)) +>extra : Symbol(extra, Decl(structuralMeasurement.ts, 19, 49)) + +unknowns = strings; +>unknowns : Symbol(unknowns, Decl(structuralMeasurement.ts, 16, 11)) +>strings : Symbol(strings, Decl(structuralMeasurement.ts, 15, 11)) + +strings = unknowns; // Error +>strings : Symbol(strings, Decl(structuralMeasurement.ts, 15, 11)) +>unknowns : Symbol(unknowns, Decl(structuralMeasurement.ts, 16, 11)) + +unknownMethod = stringMethod; +>unknownMethod : Symbol(unknownMethod, Decl(structuralMeasurement.ts, 18, 11)) +>stringMethod : Symbol(stringMethod, Decl(structuralMeasurement.ts, 17, 11)) + +const widened: Projected<{ value: string }> = projected; +>widened : Symbol(widened, Decl(structuralMeasurement.ts, 24, 5)) +>Projected : Symbol(Projected, Decl(structuralMeasurement.ts, 5, 1)) +>value : Symbol(value, Decl(structuralMeasurement.ts, 24, 26)) +>projected : Symbol(projected, Decl(structuralMeasurement.ts, 19, 11)) + diff --git a/tsc/testdata/baselines/reference/compiler/recursiveVarianceFixedPoint.types b/tsc/testdata/baselines/reference/compiler/recursiveVarianceFixedPoint.types new file mode 100644 index 0000000000000..e26d435575c06 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/recursiveVarianceFixedPoint.types @@ -0,0 +1,344 @@ +//// [tests/cases/compiler/recursiveVarianceFixedPoint.ts] //// + +=== storeFirst.ts === +export {}; + +interface Store { + value: T; +>value : T + + listener: Listener; +>listener : Listener +} +type Listener = (batch: Store) => void; +>Listener : Listener +>batch : Store + +declare let strings: Store; +>strings : Store + +declare let unknowns: Store; +>unknowns : Store + +declare let stringListener: Listener; +>stringListener : Listener + +declare let unknownListener: Listener; +>unknownListener : Listener + +unknowns = strings; // Error +>unknowns = strings : Store +>unknowns : Store +>strings : Store + +unknownListener = stringListener; // Error +>unknownListener = stringListener : Listener +>unknownListener : Listener +>stringListener : Listener + +=== listenerFirst.ts === +export {}; + +type Listener = (batch: Store) => void; +>Listener : Listener +>batch : Store + +interface Store { + listener: Listener; +>listener : Listener + + value: T; +>value : T +} + +declare let strings: Store; +>strings : Store + +declare let unknowns: Store; +>unknowns : Store + +declare let stringListener: Listener; +>stringListener : Listener + +declare let unknownListener: Listener; +>unknownListener : Listener + +unknownListener = stringListener; // Error +>unknownListener = stringListener : Listener +>unknownListener : Listener +>stringListener : Listener + +unknowns = strings; // Error +>unknowns = strings : Store +>unknowns : Store +>strings : Store + +=== columnDefFirst.ts === +export {}; + +interface ColumnDef { + cell?: (column: Column) => void; +>cell : ((column: Column) => void) | undefined +>column : Column +} +interface Column { + accessorFn?: (row: Row) => Value; +>accessorFn : ((row: Row) => Value) | undefined +>row : Row + + columnDef: ColumnDef; +>columnDef : ColumnDef +} + +declare let stringColumn: ColumnDef<{ name: string }, string>; +>stringColumn : ColumnDef<{ name: string; }, string> +>name : string + +declare let unknownColumn: ColumnDef<{ name: string }, unknown>; +>unknownColumn : ColumnDef<{ name: string; }, unknown> +>name : string + +unknownColumn = stringColumn; // Error +>unknownColumn = stringColumn : ColumnDef<{ name: string; }, string> +>unknownColumn : ColumnDef<{ name: string; }, unknown> +>stringColumn : ColumnDef<{ name: string; }, string> + +stringColumn = unknownColumn; // Error +>stringColumn = unknownColumn : ColumnDef<{ name: string; }, unknown> +>stringColumn : ColumnDef<{ name: string; }, string> +>unknownColumn : ColumnDef<{ name: string; }, unknown> + +=== columnFirst.ts === +export {}; + +interface Column { + columnDef: ColumnDef; +>columnDef : ColumnDef + + accessorFn?: (row: Row) => Value; +>accessorFn : ((row: Row) => Value) | undefined +>row : Row +} +interface ColumnDef { + cell?: (column: Column) => void; +>cell : ((column: Column) => void) | undefined +>column : Column +} + +declare let stringColumn: ColumnDef<{ name: string }, string>; +>stringColumn : ColumnDef<{ name: string; }, string> +>name : string + +declare let unknownColumn: ColumnDef<{ name: string }, unknown>; +>unknownColumn : ColumnDef<{ name: string; }, unknown> +>name : string + +unknownColumn = stringColumn; // Error +>unknownColumn = stringColumn : ColumnDef<{ name: string; }, string> +>unknownColumn : ColumnDef<{ name: string; }, unknown> +>stringColumn : ColumnDef<{ name: string; }, string> + +stringColumn = unknownColumn; // Error +>stringColumn = unknownColumn : ColumnDef<{ name: string; }, unknown> +>stringColumn : ColumnDef<{ name: string; }, string> +>unknownColumn : ColumnDef<{ name: string; }, unknown> + +=== positiveRecursion.ts === +export {}; + +interface Tree { + readonly value: T; +>value : T + + readonly children: readonly Tree[]; +>children : readonly Tree[] + + readonly metadata: Map; +>metadata : Map +} +interface Phantom { + next: Phantom; +>next : Phantom +} + +declare let stringTree: Tree; +>stringTree : Tree + +declare let unknownTree: Tree; +>unknownTree : Tree + +declare let stringPhantom: Phantom; +>stringPhantom : Phantom + +declare let numberPhantom: Phantom; +>numberPhantom : Phantom + +unknownTree = stringTree; +>unknownTree = stringTree : Tree +>unknownTree : Tree +>stringTree : Tree + +stringTree = unknownTree; // Error +>stringTree = unknownTree : Tree +>stringTree : Tree +>unknownTree : Tree + +stringPhantom = numberPhantom; +>stringPhantom = numberPhantom : Phantom +>stringPhantom : Phantom +>numberPhantom : Phantom + +numberPhantom = stringPhantom; +>numberPhantom = stringPhantom : Phantom +>numberPhantom : Phantom +>stringPhantom : Phantom + +=== nestedComposition.ts === +export {}; + +interface Outer { + value: T; +>value : T + + next: Inner>; +>next : Inner> +} +interface Inner { + consume: (value: T) => void; +>consume : (value: T) => void +>value : T +} + +declare let strings: Outer; +>strings : Outer + +declare let unknowns: Outer; +>unknowns : Outer + +unknowns = strings; // Error +>unknowns = strings : Outer +>unknowns : Outer +>strings : Outer + +strings = unknowns; // Error +>strings = unknowns : Outer +>strings : Outer +>unknowns : Outer + +=== annotations.ts === +export {}; + +interface AnnotatedTree { + readonly value: T; +>value : T + + readonly children: AnnotatedTree[]; +>children : AnnotatedTree[] +} +interface AnnotatedStore { + value: T; +>value : T + + listener: (batch: AnnotatedStore) => void; +>listener : (batch: AnnotatedStore) => void +>batch : AnnotatedStore +} + +declare let stringTree: AnnotatedTree; +>stringTree : AnnotatedTree + +declare let unknownTree: AnnotatedTree; +>unknownTree : AnnotatedTree + +declare let stringStore: AnnotatedStore; +>stringStore : AnnotatedStore + +declare let unknownStore: AnnotatedStore; +>unknownStore : AnnotatedStore + +unknownTree = stringTree; +>unknownTree = stringTree : AnnotatedTree +>unknownTree : AnnotatedTree +>stringTree : AnnotatedTree + +stringTree = unknownTree; // Error +>stringTree = unknownTree : AnnotatedTree +>stringTree : AnnotatedTree +>unknownTree : AnnotatedTree + +unknownStore = stringStore; // Error +>unknownStore = stringStore : AnnotatedStore +>unknownStore : AnnotatedStore +>stringStore : AnnotatedStore + +stringStore = unknownStore; // Error +>stringStore = unknownStore : AnnotatedStore +>stringStore : AnnotatedStore +>unknownStore : AnnotatedStore + +=== structuralMeasurement.ts === +export {}; + +interface GenericMethod { + value: T; +>value : T + + next: (value: U) => GenericMethod; +>next : (value: U) => GenericMethod +>value : U +} +interface Projected { +>value : unknown + + value: T["value"]; +>value : T["value"] + + next: Projected; +>next : Projected +} +interface Method { + value: T; +>value : T + + accept(value: Method): void; +>accept : (value: Method) => void +>value : Method +} + +declare let strings: GenericMethod; +>strings : GenericMethod + +declare let unknowns: GenericMethod; +>unknowns : GenericMethod + +declare let stringMethod: Method; +>stringMethod : Method + +declare let unknownMethod: Method; +>unknownMethod : Method + +declare let projected: Projected<{ value: string; extra: number }>; +>projected : Projected<{ value: string; extra: number; }> +>value : string +>extra : number + +unknowns = strings; +>unknowns = strings : GenericMethod +>unknowns : GenericMethod +>strings : GenericMethod + +strings = unknowns; // Error +>strings = unknowns : GenericMethod +>strings : GenericMethod +>unknowns : GenericMethod + +unknownMethod = stringMethod; +>unknownMethod = stringMethod : Method +>unknownMethod : Method +>stringMethod : Method + +const widened: Projected<{ value: string }> = projected; +>widened : Projected<{ value: string; }> +>value : string +>projected : Projected<{ value: string; extra: number; }> + diff --git a/tsc/testdata/baselines/reference/compiler/relationComplexityError(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/relationComplexityError(checkorder=default).errors.txt new file mode 100644 index 0000000000000..e8f947ec283b1 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/relationComplexityError(checkorder=default).errors.txt @@ -0,0 +1,50 @@ +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(22,5): error TS2859: Excessive complexity comparing types 'T1 & T2' and 'T1 | null'. +relationComplexityError.ts(26,5): error TS2322: Type '{ p: T1 & T2; }' is not assignable to type '{ p: T1 | null; }'. + Types of property 'p' are incompatible. + Excessive complexity comparing types 'T1 & T2' and 'T1 | null'. + + +==== relationComplexityError.ts (5 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'. + } + + function f3(x: T1 | null, y: T1 & T2) { + x = y; // Complexity error + ~ +!!! 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 TS2322: Type '{ p: T1 & T2; }' is not assignable to type '{ p: T1 | null; }'. +!!! error TS2322: Types of property 'p' are incompatible. +!!! error TS2322: Excessive complexity comparing types 'T1 & T2' and '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..8a92179def8a5 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/relationComplexityError(checkorder=typesfirst).errors.txt @@ -0,0 +1,50 @@ +relationComplexityError.ts(10,5): error TS2322: Type '{ p: T1 & T2; }' is not assignable to type '{ p: T1 | null; }'. + Types of property 'p' are incompatible. + 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(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 (5 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 TS2322: Type '{ p: T1 & T2; }' is not assignable to type '{ p: T1 | null; }'. +!!! error TS2322: Types of property 'p' are incompatible. +!!! error TS2322: Excessive complexity comparing types 'T1 & T2' and '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'. + } + + function f3(x: T1 | null, y: T1 & T2) { + x = y; // Complexity error + ~ +!!! error TS2859: Excessive complexity comparing types 'T1 & T2' and 'T1 | null'. + } + + function f4(x: { p: T1 | null }, y: { p: T1 & T2 }) { + x = y; // Complexity error + ~ +!!! error TS2859: Excessive complexity comparing types '{ p: T1 & T2; }' and '{ p: T1 | null; }'. + ~~~~~ +!!! error TS2859: Excessive complexity comparing types '{ p: T1 & T2; }' and '{ p: T1 | null; }'. + } + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/relationComplexityError(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/relationComplexityError(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..ea9543f81e755 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/relationComplexityError(checkorder=typesfirst).symbols @@ -0,0 +1,91 @@ +//// [tests/cases/compiler/relationComplexityError.ts] //// + +=== relationComplexityError.ts === +// Repro from #55630 +// Every comparison that needs a comparison that is too complex is too complex +// itself, whether or not that comparison happened before. + +type Digits = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7'; +>Digits : Symbol(Digits, Decl(relationComplexityError.ts, 0, 0)) + +type T1 = `${Digits}${Digits}${Digits}${Digits}` | undefined; +>T1 : Symbol(T1, Decl(relationComplexityError.ts, 4, 60)) +>Digits : Symbol(Digits, Decl(relationComplexityError.ts, 0, 0)) +>Digits : Symbol(Digits, Decl(relationComplexityError.ts, 0, 0)) +>Digits : Symbol(Digits, Decl(relationComplexityError.ts, 0, 0)) +>Digits : Symbol(Digits, Decl(relationComplexityError.ts, 0, 0)) + +type T2 = { a: string } | { b: number }; +>T2 : Symbol(T2, Decl(relationComplexityError.ts, 5, 61)) +>a : Symbol(a, Decl(relationComplexityError.ts, 6, 11)) +>b : Symbol(b, Decl(relationComplexityError.ts, 6, 27)) + +function f0(x: { p: T1 | null }, y: { p: T1 & T2 }) { +>f0 : Symbol(f0, Decl(relationComplexityError.ts, 6, 40)) +>x : Symbol(x, Decl(relationComplexityError.ts, 8, 12)) +>p : Symbol(p, Decl(relationComplexityError.ts, 8, 16)) +>T1 : Symbol(T1, Decl(relationComplexityError.ts, 4, 60)) +>y : Symbol(y, Decl(relationComplexityError.ts, 8, 32)) +>p : Symbol(p, Decl(relationComplexityError.ts, 8, 37)) +>T1 : Symbol(T1, Decl(relationComplexityError.ts, 4, 60)) +>T2 : Symbol(T2, Decl(relationComplexityError.ts, 5, 61)) + + x = y; // Complexity error +>x : Symbol(x, Decl(relationComplexityError.ts, 8, 12)) +>y : Symbol(y, Decl(relationComplexityError.ts, 8, 32)) +} + +function f1(x: T1, y: T1 & T2) { +>f1 : Symbol(f1, Decl(relationComplexityError.ts, 10, 1)) +>x : Symbol(x, Decl(relationComplexityError.ts, 12, 12)) +>T1 : Symbol(T1, Decl(relationComplexityError.ts, 4, 60)) +>y : Symbol(y, Decl(relationComplexityError.ts, 12, 18)) +>T1 : Symbol(T1, Decl(relationComplexityError.ts, 4, 60)) +>T2 : Symbol(T2, Decl(relationComplexityError.ts, 5, 61)) + + x = y; +>x : Symbol(x, Decl(relationComplexityError.ts, 12, 12)) +>y : Symbol(y, Decl(relationComplexityError.ts, 12, 18)) +} + +function f2(x: T1 | null, y: T1 & T2) { +>f2 : Symbol(f2, Decl(relationComplexityError.ts, 14, 1)) +>x : Symbol(x, Decl(relationComplexityError.ts, 16, 12)) +>T1 : Symbol(T1, Decl(relationComplexityError.ts, 4, 60)) +>y : Symbol(y, Decl(relationComplexityError.ts, 16, 25)) +>T1 : Symbol(T1, Decl(relationComplexityError.ts, 4, 60)) +>T2 : Symbol(T2, Decl(relationComplexityError.ts, 5, 61)) + + x = y; // Complexity error +>x : Symbol(x, Decl(relationComplexityError.ts, 16, 12)) +>y : Symbol(y, Decl(relationComplexityError.ts, 16, 25)) +} + +function f3(x: T1 | null, y: T1 & T2) { +>f3 : Symbol(f3, Decl(relationComplexityError.ts, 18, 1)) +>x : Symbol(x, Decl(relationComplexityError.ts, 20, 12)) +>T1 : Symbol(T1, Decl(relationComplexityError.ts, 4, 60)) +>y : Symbol(y, Decl(relationComplexityError.ts, 20, 25)) +>T1 : Symbol(T1, Decl(relationComplexityError.ts, 4, 60)) +>T2 : Symbol(T2, Decl(relationComplexityError.ts, 5, 61)) + + x = y; // Complexity error +>x : Symbol(x, Decl(relationComplexityError.ts, 20, 12)) +>y : Symbol(y, Decl(relationComplexityError.ts, 20, 25)) +} + +function f4(x: { p: T1 | null }, y: { p: T1 & T2 }) { +>f4 : Symbol(f4, Decl(relationComplexityError.ts, 22, 1)) +>x : Symbol(x, Decl(relationComplexityError.ts, 24, 12)) +>p : Symbol(p, Decl(relationComplexityError.ts, 24, 16)) +>T1 : Symbol(T1, Decl(relationComplexityError.ts, 4, 60)) +>y : Symbol(y, Decl(relationComplexityError.ts, 24, 32)) +>p : Symbol(p, Decl(relationComplexityError.ts, 24, 37)) +>T1 : Symbol(T1, Decl(relationComplexityError.ts, 4, 60)) +>T2 : Symbol(T2, Decl(relationComplexityError.ts, 5, 61)) + + x = y; // Complexity error +>x : Symbol(x, Decl(relationComplexityError.ts, 24, 12)) +>y : Symbol(y, Decl(relationComplexityError.ts, 24, 32)) +} + diff --git a/tsc/testdata/baselines/reference/compiler/relationComplexityError(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/relationComplexityError(checkorder=typesfirst).types new file mode 100644 index 0000000000000..a6085a90e7675 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/relationComplexityError(checkorder=typesfirst).types @@ -0,0 +1,77 @@ +//// [tests/cases/compiler/relationComplexityError.ts] //// + +=== relationComplexityError.ts === +// Repro from #55630 +// Every comparison that needs a comparison that is too complex is too complex +// itself, whether or not that comparison happened before. + +type Digits = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7'; +>Digits : Digits + +type T1 = `${Digits}${Digits}${Digits}${Digits}` | undefined; +>T1 : T1 + +type T2 = { a: string } | { b: number }; +>T2 : T2 +>a : string +>b : number + +function f0(x: { p: T1 | null }, y: { p: T1 & T2 }) { +>f0 : (x: { p: T1 | null; }, y: { p: T1 & T2; }) => void +>x : { p: T1 | null; } +>p : T1 | null +>y : { p: T1 & T2; } +>p : T1 & T2 + + x = y; // Complexity error +>x = y : { p: T1 & T2; } +>x : { p: T1 | null; } +>y : { p: T1 & T2; } +} + +function f1(x: T1, y: T1 & T2) { +>f1 : (x: T1, y: T1 & T2) => void +>x : T1 +>y : T1 & T2 + + x = y; +>x = y : T1 & T2 +>x : T1 +>y : T1 & T2 +} + +function f2(x: T1 | null, y: T1 & T2) { +>f2 : (x: T1 | null, y: T1 & T2) => void +>x : T1 | null +>y : T1 & T2 + + x = y; // Complexity error +>x = y : T1 & T2 +>x : T1 | null +>y : T1 & T2 +} + +function f3(x: T1 | null, y: T1 & T2) { +>f3 : (x: T1 | null, y: T1 & T2) => void +>x : T1 | null +>y : T1 & T2 + + x = y; // Complexity error +>x = y : T1 & T2 +>x : T1 | null +>y : T1 & T2 +} + +function f4(x: { p: T1 | null }, y: { p: T1 & T2 }) { +>f4 : (x: { p: T1 | null; }, y: { p: T1 & T2; }) => void +>x : { p: T1 | null; } +>p : T1 | null +>y : { p: T1 & T2; } +>p : T1 & T2 + + x = y; // Complexity error +>x = y : { p: T1 & T2; } +>x : { p: T1 | null; } +>y : { p: T1 & T2; } +} + diff --git a/tsc/testdata/baselines/reference/compiler/relationComplexitySharedCheckOrder(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/relationComplexitySharedCheckOrder(checkorder=default).errors.txt new file mode 100644 index 0000000000000..e9850a7764ef6 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/relationComplexitySharedCheckOrder(checkorder=default).errors.txt @@ -0,0 +1,32 @@ +relationComplexitySharedCheckOrder.ts(22,1): error TS2859: Excessive complexity comparing types 'T1 & T2' and 'T1 | null'. +relationComplexitySharedCheckOrder.ts(22,1): error TS2859: Excessive complexity comparing types 'T1 & T2' and 'T1 | null'. + + +==== relationComplexitySharedCheckOrder.ts (2 errors) ==== + // Relating y to x fresh caches too many comparisons. In program order the + // comparisons before it have cached all but a seventh of them. Whether + // relating y is too complex must not depend on which comes first. + + type D = '0' | '1' | '2' | '3' | '4' | '5' | '6'; + type T1 = `${D}${D}${D}${D}` | undefined; + type T2 = { a: string } | { b: number }; + declare let x: T1 | null; + declare const y1: (`${'0'}${D}${D}${D}` | undefined) & T2; + x = y1; + declare const y2: (`${'0' | '1'}${D}${D}${D}` | undefined) & T2; + x = y2; + declare const y3: (`${'0' | '1' | '2'}${D}${D}${D}` | undefined) & T2; + x = y3; + declare const y4: (`${'0' | '1' | '2' | '3'}${D}${D}${D}` | undefined) & T2; + x = y4; + declare const y5: (`${'0' | '1' | '2' | '3' | '4'}${D}${D}${D}` | undefined) & T2; + x = y5; + declare const y6: (`${'0' | '1' | '2' | '3' | '4' | '5'}${D}${D}${D}` | undefined) & T2; + x = y6; + declare const y: T1 & T2; + x = y; + ~ +!!! error TS2859: Excessive complexity comparing types 'T1 & T2' and 'T1 | null'. + ~~~~~ +!!! error TS2859: Excessive complexity comparing types 'T1 & T2' and 'T1 | null'. + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/relationComplexitySharedCheckOrder(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/relationComplexitySharedCheckOrder(checkorder=default).symbols new file mode 100644 index 0000000000000..af652dc727d64 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/relationComplexitySharedCheckOrder(checkorder=default).symbols @@ -0,0 +1,101 @@ +//// [tests/cases/compiler/relationComplexitySharedCheckOrder.ts] //// + +=== relationComplexitySharedCheckOrder.ts === +// Relating y to x fresh caches too many comparisons. In program order the +// comparisons before it have cached all but a seventh of them. Whether +// relating y is too complex must not depend on which comes first. + +type D = '0' | '1' | '2' | '3' | '4' | '5' | '6'; +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) + +type T1 = `${D}${D}${D}${D}` | undefined; +>T1 : Symbol(T1, Decl(relationComplexitySharedCheckOrder.ts, 4, 49)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) + +type T2 = { a: string } | { b: number }; +>T2 : Symbol(T2, Decl(relationComplexitySharedCheckOrder.ts, 5, 41)) +>a : Symbol(a, Decl(relationComplexitySharedCheckOrder.ts, 6, 11)) +>b : Symbol(b, Decl(relationComplexitySharedCheckOrder.ts, 6, 27)) + +declare let x: T1 | null; +>x : Symbol(x, Decl(relationComplexitySharedCheckOrder.ts, 7, 11)) +>T1 : Symbol(T1, Decl(relationComplexitySharedCheckOrder.ts, 4, 49)) + +declare const y1: (`${'0'}${D}${D}${D}` | undefined) & T2; +>y1 : Symbol(y1, Decl(relationComplexitySharedCheckOrder.ts, 8, 13)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) +>T2 : Symbol(T2, Decl(relationComplexitySharedCheckOrder.ts, 5, 41)) + +x = y1; +>x : Symbol(x, Decl(relationComplexitySharedCheckOrder.ts, 7, 11)) +>y1 : Symbol(y1, Decl(relationComplexitySharedCheckOrder.ts, 8, 13)) + +declare const y2: (`${'0' | '1'}${D}${D}${D}` | undefined) & T2; +>y2 : Symbol(y2, Decl(relationComplexitySharedCheckOrder.ts, 10, 13)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) +>T2 : Symbol(T2, Decl(relationComplexitySharedCheckOrder.ts, 5, 41)) + +x = y2; +>x : Symbol(x, Decl(relationComplexitySharedCheckOrder.ts, 7, 11)) +>y2 : Symbol(y2, Decl(relationComplexitySharedCheckOrder.ts, 10, 13)) + +declare const y3: (`${'0' | '1' | '2'}${D}${D}${D}` | undefined) & T2; +>y3 : Symbol(y3, Decl(relationComplexitySharedCheckOrder.ts, 12, 13)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) +>T2 : Symbol(T2, Decl(relationComplexitySharedCheckOrder.ts, 5, 41)) + +x = y3; +>x : Symbol(x, Decl(relationComplexitySharedCheckOrder.ts, 7, 11)) +>y3 : Symbol(y3, Decl(relationComplexitySharedCheckOrder.ts, 12, 13)) + +declare const y4: (`${'0' | '1' | '2' | '3'}${D}${D}${D}` | undefined) & T2; +>y4 : Symbol(y4, Decl(relationComplexitySharedCheckOrder.ts, 14, 13)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) +>T2 : Symbol(T2, Decl(relationComplexitySharedCheckOrder.ts, 5, 41)) + +x = y4; +>x : Symbol(x, Decl(relationComplexitySharedCheckOrder.ts, 7, 11)) +>y4 : Symbol(y4, Decl(relationComplexitySharedCheckOrder.ts, 14, 13)) + +declare const y5: (`${'0' | '1' | '2' | '3' | '4'}${D}${D}${D}` | undefined) & T2; +>y5 : Symbol(y5, Decl(relationComplexitySharedCheckOrder.ts, 16, 13)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) +>T2 : Symbol(T2, Decl(relationComplexitySharedCheckOrder.ts, 5, 41)) + +x = y5; +>x : Symbol(x, Decl(relationComplexitySharedCheckOrder.ts, 7, 11)) +>y5 : Symbol(y5, Decl(relationComplexitySharedCheckOrder.ts, 16, 13)) + +declare const y6: (`${'0' | '1' | '2' | '3' | '4' | '5'}${D}${D}${D}` | undefined) & T2; +>y6 : Symbol(y6, Decl(relationComplexitySharedCheckOrder.ts, 18, 13)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) +>T2 : Symbol(T2, Decl(relationComplexitySharedCheckOrder.ts, 5, 41)) + +x = y6; +>x : Symbol(x, Decl(relationComplexitySharedCheckOrder.ts, 7, 11)) +>y6 : Symbol(y6, Decl(relationComplexitySharedCheckOrder.ts, 18, 13)) + +declare const y: T1 & T2; +>y : Symbol(y, Decl(relationComplexitySharedCheckOrder.ts, 20, 13)) +>T1 : Symbol(T1, Decl(relationComplexitySharedCheckOrder.ts, 4, 49)) +>T2 : Symbol(T2, Decl(relationComplexitySharedCheckOrder.ts, 5, 41)) + +x = y; +>x : Symbol(x, Decl(relationComplexitySharedCheckOrder.ts, 7, 11)) +>y : Symbol(y, Decl(relationComplexitySharedCheckOrder.ts, 20, 13)) + diff --git a/tsc/testdata/baselines/reference/compiler/relationComplexitySharedCheckOrder(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/relationComplexitySharedCheckOrder(checkorder=default).types new file mode 100644 index 0000000000000..1a678796e4afb --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/relationComplexitySharedCheckOrder(checkorder=default).types @@ -0,0 +1,77 @@ +//// [tests/cases/compiler/relationComplexitySharedCheckOrder.ts] //// + +=== relationComplexitySharedCheckOrder.ts === +// Relating y to x fresh caches too many comparisons. In program order the +// comparisons before it have cached all but a seventh of them. Whether +// relating y is too complex must not depend on which comes first. + +type D = '0' | '1' | '2' | '3' | '4' | '5' | '6'; +>D : D + +type T1 = `${D}${D}${D}${D}` | undefined; +>T1 : T1 + +type T2 = { a: string } | { b: number }; +>T2 : T2 +>a : string +>b : number + +declare let x: T1 | null; +>x : T1 | null + +declare const y1: (`${'0'}${D}${D}${D}` | undefined) & T2; +>y1 : ("0000" | "0001" | "0002" | "0003" | "0004" | "0005" | "0006" | "0010" | "0011" | "0012" | "0013" | "0014" | "0015" | "0016" | "0020" | "0021" | "0022" | "0023" | "0024" | "0025" | "0026" | "0030" | "0031" | "0032" | "0033" | "0034" | "0035" | "0036" | "0040" | "0041" | "0042" | "0043" | "0044" | "0045" | "0046" | "0050" | "0051" | "0052" | "0053" | "0054" | "0055" | "0056" | "0060" | "0061" | "0062" | "0063" | "0064" | "0065" | "0066" | "0100" | "0101" | "0102" | "0103" | "0104" | "0105" | "0106" | "0110" | "0111" | "0112" | "0113" | "0114" | "0115" | "0116" | "0120" | "0121" | "0122" | "0123" | "0124" | "0125" | "0126" | "0130" | "0131" | "0132" | "0133" | "0134" | "0135" | "0136" | "0140" | "0141" | "0142" | "0143" | "0144" | "0145" | "0146" | "0150" | "0151" | "0152" | "0153" | "0154" | "0155" | "0156" | "0160" | "0161" | "0162" | "0163" | "0164" | "0165" | "0166" | "0200" | "0201" | "0202" | "0203" | "0204" | "0205" | "0206" | "0210" | "0211" | "0212" | "0213" | "0214" | "0215" | "0216" | "0220" | "0221" | "0222" | "0223" | "0224" | "0225" | "0226" | "0230" | "0231" | "0232" | "0233" | "0234" | "0235" | "0236" | "0240" | "0241" | "0242" | "0243" | "0244" | "0245" | "0246" | "0250" | "0251" | "0252" | "0253" | "0254" | "0255" | "0256" | "0260" | "0261" | "0262" | "0263" | "0264" | "0265" | "0266" | "0300" | "0301" | "0302" | "0303" | "0304" | "0305" | "0306" | "0310" | "0311" | "0312" | "0313" | "0314" | "0315" | "0316" | "0320" | "0321" | "0322" | "0323" | "0324" | "0325" | "0326" | "0330" | "0331" | "0332" | "0333" | "0334" | "0335" | "0336" | "0340" | "0341" | "0342" | "0343" | "0344" | "0345" | "0346" | "0350" | "0351" | "0352" | "0353" | "0354" | "0355" | "0356" | "0360" | "0361" | "0362" | "0363" | "0364" | "0365" | "0366" | "0400" | "0401" | "0402" | "0403" | "0404" | "0405" | "0406" | "0410" | "0411" | "0412" | "0413" | "0414" | "0415" | "0416" | "0420" | "0421" | "0422" | "0423" | "0424" | "0425" | "0426" | "0430" | "0431" | "0432" | "0433" | "0434" | "0435" | "0436" | "0440" | "0441" | "0442" | "0443" | "0444" | "0445" | "0446" | "0450" | "0451" | "0452" | "0453" | "0454" | "0455" | "0456" | "0460" | "0461" | "0462" | "0463" | "0464" | "0465" | "0466" | "0500" | "0501" | "0502" | "0503" | "0504" | "0505" | "0506" | "0510" | "0511" | "0512" | "0513" | "0514" | "0515" | "0516" | "0520" | "0521" | "0522" | "0523" | "0524" | "0525" | "0526" | "0530" | "0531" | "0532" | "0533" | "0534" | "0535" | "0536" | "0540" | "0541" | "0542" | "0543" | "0544" | "0545" | "0546" | "0550" | "0551" | "0552" | "0553" | "0554" | "0555" | "0556" | "0560" | "0561" | "0562" | "0563" | "0564" | "0565" | "0566" | "0600" | "0601" | "0602" | "0603" | "0604" | "0605" | "0606" | "0610" | "0611" | "0612" | "0613" | "0614" | "0615" | "0616" | "0620" | "0621" | "0622" | "0623" | "0624" | "0625" | "0626" | "0630" | "0631" | "0632" | "0633" | "0634" | "0635" | "0636" | "0640" | "0641" | "0642" | "0643" | "0644" | "0645" | "0646" | "0650" | "0651" | "0652" | "0653" | "0654" | "0655" | "0656" | "0660" | "0661" | "0662" | "0663" | "0664" | "0665" | "0666" | undefined) & T2 + +x = y1; +>x = y1 : ("0000" | "0001" | "0002" | "0003" | "0004" | "0005" | "0006" | "0010" | "0011" | "0012" | "0013" | "0014" | "0015" | "0016" | "0020" | "0021" | "0022" | "0023" | "0024" | "0025" | "0026" | "0030" | "0031" | "0032" | "0033" | "0034" | "0035" | "0036" | "0040" | "0041" | "0042" | "0043" | "0044" | "0045" | "0046" | "0050" | "0051" | "0052" | "0053" | "0054" | "0055" | "0056" | "0060" | "0061" | "0062" | "0063" | "0064" | "0065" | "0066" | "0100" | "0101" | "0102" | "0103" | "0104" | "0105" | "0106" | "0110" | "0111" | "0112" | "0113" | "0114" | "0115" | "0116" | "0120" | "0121" | "0122" | "0123" | "0124" | "0125" | "0126" | "0130" | "0131" | "0132" | "0133" | "0134" | "0135" | "0136" | "0140" | "0141" | "0142" | "0143" | "0144" | "0145" | "0146" | "0150" | "0151" | "0152" | "0153" | "0154" | "0155" | "0156" | "0160" | "0161" | "0162" | "0163" | "0164" | "0165" | "0166" | "0200" | "0201" | "0202" | "0203" | "0204" | "0205" | "0206" | "0210" | "0211" | "0212" | "0213" | "0214" | "0215" | "0216" | "0220" | "0221" | "0222" | "0223" | "0224" | "0225" | "0226" | "0230" | "0231" | "0232" | "0233" | "0234" | "0235" | "0236" | "0240" | "0241" | "0242" | "0243" | "0244" | "0245" | "0246" | "0250" | "0251" | "0252" | "0253" | "0254" | "0255" | "0256" | "0260" | "0261" | "0262" | "0263" | "0264" | "0265" | "0266" | "0300" | "0301" | "0302" | "0303" | "0304" | "0305" | "0306" | "0310" | "0311" | "0312" | "0313" | "0314" | "0315" | "0316" | "0320" | "0321" | "0322" | "0323" | "0324" | "0325" | "0326" | "0330" | "0331" | "0332" | "0333" | "0334" | "0335" | "0336" | "0340" | "0341" | "0342" | "0343" | "0344" | "0345" | "0346" | "0350" | "0351" | "0352" | "0353" | "0354" | "0355" | "0356" | "0360" | "0361" | "0362" | "0363" | "0364" | "0365" | "0366" | "0400" | "0401" | "0402" | "0403" | "0404" | "0405" | "0406" | "0410" | "0411" | "0412" | "0413" | "0414" | "0415" | "0416" | "0420" | "0421" | "0422" | "0423" | "0424" | "0425" | "0426" | "0430" | "0431" | "0432" | "0433" | "0434" | "0435" | "0436" | "0440" | "0441" | "0442" | "0443" | "0444" | "0445" | "0446" | "0450" | "0451" | "0452" | "0453" | "0454" | "0455" | "0456" | "0460" | "0461" | "0462" | "0463" | "0464" | "0465" | "0466" | "0500" | "0501" | "0502" | "0503" | "0504" | "0505" | "0506" | "0510" | "0511" | "0512" | "0513" | "0514" | "0515" | "0516" | "0520" | "0521" | "0522" | "0523" | "0524" | "0525" | "0526" | "0530" | "0531" | "0532" | "0533" | "0534" | "0535" | "0536" | "0540" | "0541" | "0542" | "0543" | "0544" | "0545" | "0546" | "0550" | "0551" | "0552" | "0553" | "0554" | "0555" | "0556" | "0560" | "0561" | "0562" | "0563" | "0564" | "0565" | "0566" | "0600" | "0601" | "0602" | "0603" | "0604" | "0605" | "0606" | "0610" | "0611" | "0612" | "0613" | "0614" | "0615" | "0616" | "0620" | "0621" | "0622" | "0623" | "0624" | "0625" | "0626" | "0630" | "0631" | "0632" | "0633" | "0634" | "0635" | "0636" | "0640" | "0641" | "0642" | "0643" | "0644" | "0645" | "0646" | "0650" | "0651" | "0652" | "0653" | "0654" | "0655" | "0656" | "0660" | "0661" | "0662" | "0663" | "0664" | "0665" | "0666" | undefined) & T2 +>x : T1 | null +>y1 : ("0000" | "0001" | "0002" | "0003" | "0004" | "0005" | "0006" | "0010" | "0011" | "0012" | "0013" | "0014" | "0015" | "0016" | "0020" | "0021" | "0022" | "0023" | "0024" | "0025" | "0026" | "0030" | "0031" | "0032" | "0033" | "0034" | "0035" | "0036" | "0040" | "0041" | "0042" | "0043" | "0044" | "0045" | "0046" | "0050" | "0051" | "0052" | "0053" | "0054" | "0055" | "0056" | "0060" | "0061" | "0062" | "0063" | "0064" | "0065" | "0066" | "0100" | "0101" | "0102" | "0103" | "0104" | "0105" | "0106" | "0110" | "0111" | "0112" | "0113" | "0114" | "0115" | "0116" | "0120" | "0121" | "0122" | "0123" | "0124" | "0125" | "0126" | "0130" | "0131" | "0132" | "0133" | "0134" | "0135" | "0136" | "0140" | "0141" | "0142" | "0143" | "0144" | "0145" | "0146" | "0150" | "0151" | "0152" | "0153" | "0154" | "0155" | "0156" | "0160" | "0161" | "0162" | "0163" | "0164" | "0165" | "0166" | "0200" | "0201" | "0202" | "0203" | "0204" | "0205" | "0206" | "0210" | "0211" | "0212" | "0213" | "0214" | "0215" | "0216" | "0220" | "0221" | "0222" | "0223" | "0224" | "0225" | "0226" | "0230" | "0231" | "0232" | "0233" | "0234" | "0235" | "0236" | "0240" | "0241" | "0242" | "0243" | "0244" | "0245" | "0246" | "0250" | "0251" | "0252" | "0253" | "0254" | "0255" | "0256" | "0260" | "0261" | "0262" | "0263" | "0264" | "0265" | "0266" | "0300" | "0301" | "0302" | "0303" | "0304" | "0305" | "0306" | "0310" | "0311" | "0312" | "0313" | "0314" | "0315" | "0316" | "0320" | "0321" | "0322" | "0323" | "0324" | "0325" | "0326" | "0330" | "0331" | "0332" | "0333" | "0334" | "0335" | "0336" | "0340" | "0341" | "0342" | "0343" | "0344" | "0345" | "0346" | "0350" | "0351" | "0352" | "0353" | "0354" | "0355" | "0356" | "0360" | "0361" | "0362" | "0363" | "0364" | "0365" | "0366" | "0400" | "0401" | "0402" | "0403" | "0404" | "0405" | "0406" | "0410" | "0411" | "0412" | "0413" | "0414" | "0415" | "0416" | "0420" | "0421" | "0422" | "0423" | "0424" | "0425" | "0426" | "0430" | "0431" | "0432" | "0433" | "0434" | "0435" | "0436" | "0440" | "0441" | "0442" | "0443" | "0444" | "0445" | "0446" | "0450" | "0451" | "0452" | "0453" | "0454" | "0455" | "0456" | "0460" | "0461" | "0462" | "0463" | "0464" | "0465" | "0466" | "0500" | "0501" | "0502" | "0503" | "0504" | "0505" | "0506" | "0510" | "0511" | "0512" | "0513" | "0514" | "0515" | "0516" | "0520" | "0521" | "0522" | "0523" | "0524" | "0525" | "0526" | "0530" | "0531" | "0532" | "0533" | "0534" | "0535" | "0536" | "0540" | "0541" | "0542" | "0543" | "0544" | "0545" | "0546" | "0550" | "0551" | "0552" | "0553" | "0554" | "0555" | "0556" | "0560" | "0561" | "0562" | "0563" | "0564" | "0565" | "0566" | "0600" | "0601" | "0602" | "0603" | "0604" | "0605" | "0606" | "0610" | "0611" | "0612" | "0613" | "0614" | "0615" | "0616" | "0620" | "0621" | "0622" | "0623" | "0624" | "0625" | "0626" | "0630" | "0631" | "0632" | "0633" | "0634" | "0635" | "0636" | "0640" | "0641" | "0642" | "0643" | "0644" | "0645" | "0646" | "0650" | "0651" | "0652" | "0653" | "0654" | "0655" | "0656" | "0660" | "0661" | "0662" | "0663" | "0664" | "0665" | "0666" | undefined) & T2 + +declare const y2: (`${'0' | '1'}${D}${D}${D}` | undefined) & T2; +>y2 : ("0000" | "0001" | "0002" | "0003" | "0004" | "0005" | "0006" | "0010" | "0011" | "0012" | "0013" | "0014" | "0015" | "0016" | "0020" | "0021" | "0022" | "0023" | "0024" | "0025" | "0026" | "0030" | "0031" | "0032" | "0033" | "0034" | "0035" | "0036" | "0040" | "0041" | "0042" | "0043" | "0044" | "0045" | "0046" | "0050" | "0051" | "0052" | "0053" | "0054" | "0055" | "0056" | "0060" | "0061" | "0062" | "0063" | "0064" | "0065" | "0066" | "0100" | "0101" | "0102" | "0103" | "0104" | "0105" | "0106" | "0110" | "0111" | "0112" | "0113" | "0114" | "0115" | "0116" | "0120" | "0121" | "0122" | "0123" | "0124" | "0125" | "0126" | "0130" | "0131" | "0132" | "0133" | "0134" | "0135" | "0136" | "0140" | "0141" | "0142" | "0143" | "0144" | "0145" | "0146" | "0150" | "0151" | "0152" | "0153" | "0154" | "0155" | "0156" | "0160" | "0161" | "0162" | "0163" | "0164" | "0165" | "0166" | "0200" | "0201" | "0202" | "0203" | "0204" | "0205" | "0206" | "0210" | "0211" | "0212" | "0213" | "0214" | "0215" | "0216" | "0220" | "0221" | "0222" | "0223" | "0224" | "0225" | "0226" | "0230" | "0231" | "0232" | "0233" | "0234" | "0235" | "0236" | "0240" | "0241" | "0242" | "0243" | "0244" | "0245" | "0246" | "0250" | "0251" | "0252" | "0253" | "0254" | "0255" | "0256" | "0260" | "0261" | "0262" | "0263" | "0264" | "0265" | "0266" | "0300" | "0301" | "0302" | "0303" | "0304" | "0305" | "0306" | "0310" | "0311" | "0312" | "0313" | "0314" | "0315" | "0316" | "0320" | "0321" | "0322" | "0323" | "0324" | "0325" | "0326" | "0330" | "0331" | "0332" | "0333" | "0334" | "0335" | "0336" | "0340" | "0341" | "0342" | "0343" | "0344" | "0345" | "0346" | "0350" | "0351" | "0352" | "0353" | "0354" | "0355" | "0356" | "0360" | "0361" | "0362" | "0363" | "0364" | "0365" | "0366" | "0400" | "0401" | "0402" | "0403" | "0404" | "0405" | "0406" | "0410" | "0411" | "0412" | "0413" | "0414" | "0415" | "0416" | "0420" | "0421" | "0422" | "0423" | "0424" | "0425" | "0426" | "0430" | "0431" | "0432" | "0433" | "0434" | "0435" | "0436" | "0440" | "0441" | "0442" | "0443" | "0444" | "0445" | "0446" | "0450" | "0451" | "0452" | "0453" | "0454" | "0455" | "0456" | "0460" | "0461" | "0462" | "0463" | "0464" | "0465" | "0466" | "0500" | "0501" | "0502" | "0503" | "0504" | "0505" | "0506" | "0510" | "0511" | "0512" | "0513" | "0514" | "0515" | "0516" | "0520" | "0521" | "0522" | "0523" | "0524" | "0525" | "0526" | "0530" | "0531" | "0532" | "0533" | "0534" | "0535" | "0536" | "0540" | "0541" | "0542" | "0543" | "0544" | "0545" | "0546" | "0550" | "0551" | "0552" | "0553" | "0554" | "0555" | "0556" | "0560" | "0561" | "0562" | "0563" | "0564" | "0565" | "0566" | "0600" | "0601" | "0602" | "0603" | "0604" | "0605" | "0606" | "0610" | "0611" | "0612" | "0613" | "0614" | "0615" | "0616" | "0620" | "0621" | "0622" | "0623" | "0624" | "0625" | "0626" | "0630" | "0631" | "0632" | "0633" | "0634" | "0635" | "0636" | "0640" | "0641" | "0642" | "0643" | "0644" | "0645" | "0646" | "0650" | "0651" | "0652" | "0653" | "0654" | "0655" | "0656" | "0660" | "0661" | "0662" | "0663" | "0664" | "0665" | "0666" | "1000" | "1001" | "1002" | "1003" | "1004" | "1005" | "1006" | "1010" | "1011" | "1012" | "1013" | "1014" | "1015" | "1016" | "1020" | "1021" | "1022" | "1023" | "1024" | "1025" | "1026" | "1030" | "1031" | "1032" | "1033" | "1034" | "1035" | "1036" | "1040" | "1041" | "1042" | "1043" | "1044" | "1045" | "1046" | "1050" | "1051" | "1052" | "1053" | "1054" | "1055" | "1056" | "1060" | "1061" | "1062" | "1063" | "1064" | "1065" | "1066" | "1100" | "1101" | "1102" | "1103" | "1104" | "1105" | "1106" | "1110" | "1111" | "1112" | "1113" | "1114" | "1115" | "1116" | "1120" | "1121" | "1122" | "1123" | "1124" | "1125" | "1126" | "1130" | "1131" | "1132" | "1133" | "1134" | "1135" | "1136" | "1140" | "1141" | "1142" | "1143" | "1144" | "1145" | "1146" | "1150" | "1151" | "1152" | "1153" | "1154" | "1155" | "1156" | "1160" | "1161" | "1162" | "1163" | "1164" | "1165" | "1166" | "1200" | "1201" | "1202" | "1203" | "1204" | "1205" | "1206" | "1210" | "1211" | "1212" | "1213" | "1214" | "1215" | "1216" | "1220" | "1221" | "1222" | "1223" | "1224" | "1225" | "1226" | "1230" | "1231" | "1232" | "1233" | "1234" | "1235" | "1236" | "1240" | "1241" | "1242" | "1243" | "1244" | "1245" | "1246" | "1250" | "1251" | "1252" | "1253" | "1254" | "1255" | "1256" | "1260" | "1261" | "1262" | "1263" | "1264" | "1265" | "1266" | "1300" | "1301" | "1302" | "1303" | "1304" | "1305" | "1306" | "1310" | "1311" | "1312" | "1313" | "1314" | "1315" | "1316" | "1320" | "1321" | "1322" | "1323" | "1324" | "1325" | "1326" | "1330" | "1331" | "1332" | "1333" | "1334" | "1335" | "1336" | "1340" | "1341" | "1342" | "1343" | "1344" | "1345" | "1346" | "1350" | "1351" | "1352" | "1353" | "1354" | "1355" | "1356" | "1360" | "1361" | "1362" | "1363" | "1364" | "1365" | "1366" | "1400" | "1401" | "1402" | "1403" | "1404" | "1405" | "1406" | "1410" | "1411" | "1412" | "1413" | "1414" | "1415" | "1416" | "1420" | "1421" | "1422" | "1423" | "1424" | "1425" | "1426" | "1430" | "1431" | "1432" | "1433" | "1434" | "1435" | "1436" | "1440" | "1441" | "1442" | "1443" | "1444" | "1445" | "1446" | "1450" | "1451" | "1452" | "1453" | "1454" | "1455" | "1456" | "1460" | "1461" | "1462" | "1463" | "1464" | "1465" | "1466" | "1500" | "1501" | "1502" | "1503" | "1504" | "1505" | "1506" | "1510" | "1511" | "1512" | "1513" | "1514" | "1515" | "1516" | "1520" | "1521" | "1522" | "1523" | "1524" | "1525" | "1526" | "1530" | "1531" | "1532" | "1533" | "1534" | "1535" | "1536" | "1540" | "1541" | "1542" | "1543" | "1544" | "1545" | "1546" | "1550" | "1551" | "1552" | "1553" | "1554" | "1555" | "1556" | "1560" | "1561" | "1562" | "1563" | "1564" | "1565" | "1566" | "1600" | "1601" | "1602" | "1603" | "1604" | "1605" | "1606" | "1610" | "1611" | "1612" | "1613" | "1614" | "1615" | "1616" | "1620" | "1621" | "1622" | "1623" | "1624" | "1625" | "1626" | "1630" | "1631" | "1632" | "1633" | "1634" | "1635" | "1636" | "1640" | "1641" | "1642" | "1643" | "1644" | "1645" | "1646" | "1650" | "1651" | "1652" | "1653" | "1654" | "1655" | "1656" | "1660" | "1661" | "1662" | "1663" | "1664" | "1665" | "1666" | undefined) & T2 + +x = y2; +>x = y2 : ("0000" | "0001" | "0002" | "0003" | "0004" | "0005" | "0006" | "0010" | "0011" | "0012" | "0013" | "0014" | "0015" | "0016" | "0020" | "0021" | "0022" | "0023" | "0024" | "0025" | "0026" | "0030" | "0031" | "0032" | "0033" | "0034" | "0035" | "0036" | "0040" | "0041" | "0042" | "0043" | "0044" | "0045" | "0046" | "0050" | "0051" | "0052" | "0053" | "0054" | "0055" | "0056" | "0060" | "0061" | "0062" | "0063" | "0064" | "0065" | "0066" | "0100" | "0101" | "0102" | "0103" | "0104" | "0105" | "0106" | "0110" | "0111" | "0112" | "0113" | "0114" | "0115" | "0116" | "0120" | "0121" | "0122" | "0123" | "0124" | "0125" | "0126" | "0130" | "0131" | "0132" | "0133" | "0134" | "0135" | "0136" | "0140" | "0141" | "0142" | "0143" | "0144" | "0145" | "0146" | "0150" | "0151" | "0152" | "0153" | "0154" | "0155" | "0156" | "0160" | "0161" | "0162" | "0163" | "0164" | "0165" | "0166" | "0200" | "0201" | "0202" | "0203" | "0204" | "0205" | "0206" | "0210" | "0211" | "0212" | "0213" | "0214" | "0215" | "0216" | "0220" | "0221" | "0222" | "0223" | "0224" | "0225" | "0226" | "0230" | "0231" | "0232" | "0233" | "0234" | "0235" | "0236" | "0240" | "0241" | "0242" | "0243" | "0244" | "0245" | "0246" | "0250" | "0251" | "0252" | "0253" | "0254" | "0255" | "0256" | "0260" | "0261" | "0262" | "0263" | "0264" | "0265" | "0266" | "0300" | "0301" | "0302" | "0303" | "0304" | "0305" | "0306" | "0310" | "0311" | "0312" | "0313" | "0314" | "0315" | "0316" | "0320" | "0321" | "0322" | "0323" | "0324" | "0325" | "0326" | "0330" | "0331" | "0332" | "0333" | "0334" | "0335" | "0336" | "0340" | "0341" | "0342" | "0343" | "0344" | "0345" | "0346" | "0350" | "0351" | "0352" | "0353" | "0354" | "0355" | "0356" | "0360" | "0361" | "0362" | "0363" | "0364" | "0365" | "0366" | "0400" | "0401" | "0402" | "0403" | "0404" | "0405" | "0406" | "0410" | "0411" | "0412" | "0413" | "0414" | "0415" | "0416" | "0420" | "0421" | "0422" | "0423" | "0424" | "0425" | "0426" | "0430" | "0431" | "0432" | "0433" | "0434" | "0435" | "0436" | "0440" | "0441" | "0442" | "0443" | "0444" | "0445" | "0446" | "0450" | "0451" | "0452" | "0453" | "0454" | "0455" | "0456" | "0460" | "0461" | "0462" | "0463" | "0464" | "0465" | "0466" | "0500" | "0501" | "0502" | "0503" | "0504" | "0505" | "0506" | "0510" | "0511" | "0512" | "0513" | "0514" | "0515" | "0516" | "0520" | "0521" | "0522" | "0523" | "0524" | "0525" | "0526" | "0530" | "0531" | "0532" | "0533" | "0534" | "0535" | "0536" | "0540" | "0541" | "0542" | "0543" | "0544" | "0545" | "0546" | "0550" | "0551" | "0552" | "0553" | "0554" | "0555" | "0556" | "0560" | "0561" | "0562" | "0563" | "0564" | "0565" | "0566" | "0600" | "0601" | "0602" | "0603" | "0604" | "0605" | "0606" | "0610" | "0611" | "0612" | "0613" | "0614" | "0615" | "0616" | "0620" | "0621" | "0622" | "0623" | "0624" | "0625" | "0626" | "0630" | "0631" | "0632" | "0633" | "0634" | "0635" | "0636" | "0640" | "0641" | "0642" | "0643" | "0644" | "0645" | "0646" | "0650" | "0651" | "0652" | "0653" | "0654" | "0655" | "0656" | "0660" | "0661" | "0662" | "0663" | "0664" | "0665" | "0666" | "1000" | "1001" | "1002" | "1003" | "1004" | "1005" | "1006" | "1010" | "1011" | "1012" | "1013" | "1014" | "1015" | "1016" | "1020" | "1021" | "1022" | "1023" | "1024" | "1025" | "1026" | "1030" | "1031" | "1032" | "1033" | "1034" | "1035" | "1036" | "1040" | "1041" | "1042" | "1043" | "1044" | "1045" | "1046" | "1050" | "1051" | "1052" | "1053" | "1054" | "1055" | "1056" | "1060" | "1061" | "1062" | "1063" | "1064" | "1065" | "1066" | "1100" | "1101" | "1102" | "1103" | "1104" | "1105" | "1106" | "1110" | "1111" | "1112" | "1113" | "1114" | "1115" | "1116" | "1120" | "1121" | "1122" | "1123" | "1124" | "1125" | "1126" | "1130" | "1131" | "1132" | "1133" | "1134" | "1135" | "1136" | "1140" | "1141" | "1142" | "1143" | "1144" | "1145" | "1146" | "1150" | "1151" | "1152" | "1153" | "1154" | "1155" | "1156" | "1160" | "1161" | "1162" | "1163" | "1164" | "1165" | "1166" | "1200" | "1201" | "1202" | "1203" | "1204" | "1205" | "1206" | "1210" | "1211" | "1212" | "1213" | "1214" | "1215" | "1216" | "1220" | "1221" | "1222" | "1223" | "1224" | "1225" | "1226" | "1230" | "1231" | "1232" | "1233" | "1234" | "1235" | "1236" | "1240" | "1241" | "1242" | "1243" | "1244" | "1245" | "1246" | "1250" | "1251" | "1252" | "1253" | "1254" | "1255" | "1256" | "1260" | "1261" | "1262" | "1263" | "1264" | "1265" | "1266" | "1300" | "1301" | "1302" | "1303" | "1304" | "1305" | "1306" | "1310" | "1311" | "1312" | "1313" | "1314" | "1315" | "1316" | "1320" | "1321" | "1322" | "1323" | "1324" | "1325" | "1326" | "1330" | "1331" | "1332" | "1333" | "1334" | "1335" | "1336" | "1340" | "1341" | "1342" | "1343" | "1344" | "1345" | "1346" | "1350" | "1351" | "1352" | "1353" | "1354" | "1355" | "1356" | "1360" | "1361" | "1362" | "1363" | "1364" | "1365" | "1366" | "1400" | "1401" | "1402" | "1403" | "1404" | "1405" | "1406" | "1410" | "1411" | "1412" | "1413" | "1414" | "1415" | "1416" | "1420" | "1421" | "1422" | "1423" | "1424" | "1425" | "1426" | "1430" | "1431" | "1432" | "1433" | "1434" | "1435" | "1436" | "1440" | "1441" | "1442" | "1443" | "1444" | "1445" | "1446" | "1450" | "1451" | "1452" | "1453" | "1454" | "1455" | "1456" | "1460" | "1461" | "1462" | "1463" | "1464" | "1465" | "1466" | "1500" | "1501" | "1502" | "1503" | "1504" | "1505" | "1506" | "1510" | "1511" | "1512" | "1513" | "1514" | "1515" | "1516" | "1520" | "1521" | "1522" | "1523" | "1524" | "1525" | "1526" | "1530" | "1531" | "1532" | "1533" | "1534" | "1535" | "1536" | "1540" | "1541" | "1542" | "1543" | "1544" | "1545" | "1546" | "1550" | "1551" | "1552" | "1553" | "1554" | "1555" | "1556" | "1560" | "1561" | "1562" | "1563" | "1564" | "1565" | "1566" | "1600" | "1601" | "1602" | "1603" | "1604" | "1605" | "1606" | "1610" | "1611" | "1612" | "1613" | "1614" | "1615" | "1616" | "1620" | "1621" | "1622" | "1623" | "1624" | "1625" | "1626" | "1630" | "1631" | "1632" | "1633" | "1634" | "1635" | "1636" | "1640" | "1641" | "1642" | "1643" | "1644" | "1645" | "1646" | "1650" | "1651" | "1652" | "1653" | "1654" | "1655" | "1656" | "1660" | "1661" | "1662" | "1663" | "1664" | "1665" | "1666" | undefined) & T2 +>x : T1 | null +>y2 : ("0000" | "0001" | "0002" | "0003" | "0004" | "0005" | "0006" | "0010" | "0011" | "0012" | "0013" | "0014" | "0015" | "0016" | "0020" | "0021" | "0022" | "0023" | "0024" | "0025" | "0026" | "0030" | "0031" | "0032" | "0033" | "0034" | "0035" | "0036" | "0040" | "0041" | "0042" | "0043" | "0044" | "0045" | "0046" | "0050" | "0051" | "0052" | "0053" | "0054" | "0055" | "0056" | "0060" | "0061" | "0062" | "0063" | "0064" | "0065" | "0066" | "0100" | "0101" | "0102" | "0103" | "0104" | "0105" | "0106" | "0110" | "0111" | "0112" | "0113" | "0114" | "0115" | "0116" | "0120" | "0121" | "0122" | "0123" | "0124" | "0125" | "0126" | "0130" | "0131" | "0132" | "0133" | "0134" | "0135" | "0136" | "0140" | "0141" | "0142" | "0143" | "0144" | "0145" | "0146" | "0150" | "0151" | "0152" | "0153" | "0154" | "0155" | "0156" | "0160" | "0161" | "0162" | "0163" | "0164" | "0165" | "0166" | "0200" | "0201" | "0202" | "0203" | "0204" | "0205" | "0206" | "0210" | "0211" | "0212" | "0213" | "0214" | "0215" | "0216" | "0220" | "0221" | "0222" | "0223" | "0224" | "0225" | "0226" | "0230" | "0231" | "0232" | "0233" | "0234" | "0235" | "0236" | "0240" | "0241" | "0242" | "0243" | "0244" | "0245" | "0246" | "0250" | "0251" | "0252" | "0253" | "0254" | "0255" | "0256" | "0260" | "0261" | "0262" | "0263" | "0264" | "0265" | "0266" | "0300" | "0301" | "0302" | "0303" | "0304" | "0305" | "0306" | "0310" | "0311" | "0312" | "0313" | "0314" | "0315" | "0316" | "0320" | "0321" | "0322" | "0323" | "0324" | "0325" | "0326" | "0330" | "0331" | "0332" | "0333" | "0334" | "0335" | "0336" | "0340" | "0341" | "0342" | "0343" | "0344" | "0345" | "0346" | "0350" | "0351" | "0352" | "0353" | "0354" | "0355" | "0356" | "0360" | "0361" | "0362" | "0363" | "0364" | "0365" | "0366" | "0400" | "0401" | "0402" | "0403" | "0404" | "0405" | "0406" | "0410" | "0411" | "0412" | "0413" | "0414" | "0415" | "0416" | "0420" | "0421" | "0422" | "0423" | "0424" | "0425" | "0426" | "0430" | "0431" | "0432" | "0433" | "0434" | "0435" | "0436" | "0440" | "0441" | "0442" | "0443" | "0444" | "0445" | "0446" | "0450" | "0451" | "0452" | "0453" | "0454" | "0455" | "0456" | "0460" | "0461" | "0462" | "0463" | "0464" | "0465" | "0466" | "0500" | "0501" | "0502" | "0503" | "0504" | "0505" | "0506" | "0510" | "0511" | "0512" | "0513" | "0514" | "0515" | "0516" | "0520" | "0521" | "0522" | "0523" | "0524" | "0525" | "0526" | "0530" | "0531" | "0532" | "0533" | "0534" | "0535" | "0536" | "0540" | "0541" | "0542" | "0543" | "0544" | "0545" | "0546" | "0550" | "0551" | "0552" | "0553" | "0554" | "0555" | "0556" | "0560" | "0561" | "0562" | "0563" | "0564" | "0565" | "0566" | "0600" | "0601" | "0602" | "0603" | "0604" | "0605" | "0606" | "0610" | "0611" | "0612" | "0613" | "0614" | "0615" | "0616" | "0620" | "0621" | "0622" | "0623" | "0624" | "0625" | "0626" | "0630" | "0631" | "0632" | "0633" | "0634" | "0635" | "0636" | "0640" | "0641" | "0642" | "0643" | "0644" | "0645" | "0646" | "0650" | "0651" | "0652" | "0653" | "0654" | "0655" | "0656" | "0660" | "0661" | "0662" | "0663" | "0664" | "0665" | "0666" | "1000" | "1001" | "1002" | "1003" | "1004" | "1005" | "1006" | "1010" | "1011" | "1012" | "1013" | "1014" | "1015" | "1016" | "1020" | "1021" | "1022" | "1023" | "1024" | "1025" | "1026" | "1030" | "1031" | "1032" | "1033" | "1034" | "1035" | "1036" | "1040" | "1041" | "1042" | "1043" | "1044" | "1045" | "1046" | "1050" | "1051" | "1052" | "1053" | "1054" | "1055" | "1056" | "1060" | "1061" | "1062" | "1063" | "1064" | "1065" | "1066" | "1100" | "1101" | "1102" | "1103" | "1104" | "1105" | "1106" | "1110" | "1111" | "1112" | "1113" | "1114" | "1115" | "1116" | "1120" | "1121" | "1122" | "1123" | "1124" | "1125" | "1126" | "1130" | "1131" | "1132" | "1133" | "1134" | "1135" | "1136" | "1140" | "1141" | "1142" | "1143" | "1144" | "1145" | "1146" | "1150" | "1151" | "1152" | "1153" | "1154" | "1155" | "1156" | "1160" | "1161" | "1162" | "1163" | "1164" | "1165" | "1166" | "1200" | "1201" | "1202" | "1203" | "1204" | "1205" | "1206" | "1210" | "1211" | "1212" | "1213" | "1214" | "1215" | "1216" | "1220" | "1221" | "1222" | "1223" | "1224" | "1225" | "1226" | "1230" | "1231" | "1232" | "1233" | "1234" | "1235" | "1236" | "1240" | "1241" | "1242" | "1243" | "1244" | "1245" | "1246" | "1250" | "1251" | "1252" | "1253" | "1254" | "1255" | "1256" | "1260" | "1261" | "1262" | "1263" | "1264" | "1265" | "1266" | "1300" | "1301" | "1302" | "1303" | "1304" | "1305" | "1306" | "1310" | "1311" | "1312" | "1313" | "1314" | "1315" | "1316" | "1320" | "1321" | "1322" | "1323" | "1324" | "1325" | "1326" | "1330" | "1331" | "1332" | "1333" | "1334" | "1335" | "1336" | "1340" | "1341" | "1342" | "1343" | "1344" | "1345" | "1346" | "1350" | "1351" | "1352" | "1353" | "1354" | "1355" | "1356" | "1360" | "1361" | "1362" | "1363" | "1364" | "1365" | "1366" | "1400" | "1401" | "1402" | "1403" | "1404" | "1405" | "1406" | "1410" | "1411" | "1412" | "1413" | "1414" | "1415" | "1416" | "1420" | "1421" | "1422" | "1423" | "1424" | "1425" | "1426" | "1430" | "1431" | "1432" | "1433" | "1434" | "1435" | "1436" | "1440" | "1441" | "1442" | "1443" | "1444" | "1445" | "1446" | "1450" | "1451" | "1452" | "1453" | "1454" | "1455" | "1456" | "1460" | "1461" | "1462" | "1463" | "1464" | "1465" | "1466" | "1500" | "1501" | "1502" | "1503" | "1504" | "1505" | "1506" | "1510" | "1511" | "1512" | "1513" | "1514" | "1515" | "1516" | "1520" | "1521" | "1522" | "1523" | "1524" | "1525" | "1526" | "1530" | "1531" | "1532" | "1533" | "1534" | "1535" | "1536" | "1540" | "1541" | "1542" | "1543" | "1544" | "1545" | "1546" | "1550" | "1551" | "1552" | "1553" | "1554" | "1555" | "1556" | "1560" | "1561" | "1562" | "1563" | "1564" | "1565" | "1566" | "1600" | "1601" | "1602" | "1603" | "1604" | "1605" | "1606" | "1610" | "1611" | "1612" | "1613" | "1614" | "1615" | "1616" | "1620" | "1621" | "1622" | "1623" | "1624" | "1625" | "1626" | "1630" | "1631" | "1632" | "1633" | "1634" | "1635" | "1636" | "1640" | "1641" | "1642" | "1643" | "1644" | "1645" | "1646" | "1650" | "1651" | "1652" | "1653" | "1654" | "1655" | "1656" | "1660" | "1661" | "1662" | "1663" | "1664" | "1665" | "1666" | undefined) & T2 + +declare const y3: (`${'0' | '1' | '2'}${D}${D}${D}` | undefined) & T2; +>y3 : ("0000" | "0001" | "0002" | "0003" | "0004" | "0005" | "0006" | "0010" | "0011" | "0012" | "0013" | "0014" | "0015" | "0016" | "0020" | "0021" | "0022" | "0023" | "0024" | "0025" | "0026" | "0030" | "0031" | "0032" | "0033" | "0034" | "0035" | "0036" | "0040" | "0041" | "0042" | "0043" | "0044" | "0045" | "0046" | "0050" | "0051" | "0052" | "0053" | "0054" | "0055" | "0056" | "0060" | "0061" | "0062" | "0063" | "0064" | "0065" | "0066" | "0100" | "0101" | "0102" | "0103" | "0104" | "0105" | "0106" | "0110" | "0111" | "0112" | "0113" | "0114" | "0115" | "0116" | "0120" | "0121" | "0122" | "0123" | "0124" | "0125" | "0126" | "0130" | "0131" | "0132" | "0133" | "0134" | "0135" | "0136" | "0140" | "0141" | "0142" | "0143" | "0144" | "0145" | "0146" | "0150" | "0151" | "0152" | "0153" | "0154" | "0155" | "0156" | "0160" | "0161" | "0162" | "0163" | "0164" | "0165" | "0166" | "0200" | "0201" | "0202" | "0203" | "0204" | "0205" | "0206" | "0210" | "0211" | "0212" | "0213" | "0214" | "0215" | "0216" | "0220" | "0221" | "0222" | "0223" | "0224" | "0225" | "0226" | "0230" | "0231" | "0232" | "0233" | "0234" | "0235" | "0236" | "0240" | "0241" | "0242" | "0243" | "0244" | "0245" | "0246" | "0250" | "0251" | "0252" | "0253" | "0254" | "0255" | "0256" | "0260" | "0261" | "0262" | "0263" | "0264" | "0265" | "0266" | "0300" | "0301" | "0302" | "0303" | "0304" | "0305" | "0306" | "0310" | "0311" | "0312" | "0313" | "0314" | "0315" | "0316" | "0320" | "0321" | "0322" | "0323" | "0324" | "0325" | "0326" | "0330" | "0331" | "0332" | "0333" | "0334" | "0335" | "0336" | "0340" | "0341" | "0342" | "0343" | "0344" | "0345" | "0346" | "0350" | "0351" | "0352" | "0353" | "0354" | "0355" | "0356" | "0360" | "0361" | "0362" | "0363" | "0364" | "0365" | "0366" | "0400" | "0401" | "0402" | "0403" | "0404" | "0405" | "0406" | "0410" | "0411" | "0412" | "0413" | "0414" | "0415" | "0416" | "0420" | "0421" | "0422" | "0423" | "0424" | "0425" | "0426" | "0430" | "0431" | "0432" | "0433" | "0434" | "0435" | "0436" | "0440" | "0441" | "0442" | "0443" | "0444" | "0445" | "0446" | "0450" | "0451" | "0452" | "0453" | "0454" | "0455" | "0456" | "0460" | "0461" | "0462" | "0463" | "0464" | "0465" | "0466" | "0500" | "0501" | "0502" | "0503" | "0504" | "0505" | "0506" | "0510" | "0511" | "0512" | "0513" | "0514" | "0515" | "0516" | "0520" | "0521" | "0522" | "0523" | "0524" | "0525" | "0526" | "0530" | "0531" | "0532" | "0533" | "0534" | "0535" | "0536" | "0540" | "0541" | "0542" | "0543" | "0544" | "0545" | "0546" | "0550" | "0551" | "0552" | "0553" | "0554" | "0555" | "0556" | "0560" | "0561" | "0562" | "0563" | "0564" | "0565" | "0566" | "0600" | "0601" | "0602" | "0603" | "0604" | "0605" | "0606" | "0610" | "0611" | "0612" | "0613" | "0614" | "0615" | "0616" | "0620" | "0621" | "0622" | "0623" | "0624" | "0625" | "0626" | "0630" | "0631" | "0632" | "0633" | "0634" | "0635" | "0636" | "0640" | "0641" | "0642" | "0643" | "0644" | "0645" | "0646" | "0650" | "0651" | "0652" | "0653" | "0654" | "0655" | "0656" | "0660" | "0661" | "0662" | "0663" | "0664" | "0665" | "0666" | "1000" | "1001" | "1002" | "1003" | "1004" | "1005" | "1006" | "1010" | "1011" | "1012" | "1013" | "1014" | "1015" | "1016" | "1020" | "1021" | "1022" | "1023" | "1024" | "1025" | "1026" | "1030" | "1031" | "1032" | "1033" | "1034" | "1035" | "1036" | "1040" | "1041" | "1042" | "1043" | "1044" | "1045" | "1046" | "1050" | "1051" | "1052" | "1053" | "1054" | "1055" | "1056" | "1060" | "1061" | "1062" | "1063" | "1064" | "1065" | "1066" | "1100" | "1101" | "1102" | "1103" | "1104" | "1105" | "1106" | "1110" | "1111" | "1112" | "1113" | "1114" | "1115" | "1116" | "1120" | "1121" | "1122" | "1123" | "1124" | "1125" | "1126" | "1130" | "1131" | "1132" | "1133" | "1134" | "1135" | "1136" | "1140" | "1141" | "1142" | "1143" | "1144" | "1145" | "1146" | "1150" | "1151" | "1152" | "1153" | "1154" | "1155" | "1156" | "1160" | "1161" | "1162" | "1163" | "1164" | "1165" | "1166" | "1200" | "1201" | "1202" | "1203" | "1204" | "1205" | "1206" | "1210" | "1211" | "1212" | "1213" | "1214" | "1215" | "1216" | "1220" | "1221" | "1222" | "1223" | "1224" | "1225" | "1226" | "1230" | "1231" | "1232" | "1233" | "1234" | "1235" | "1236" | "1240" | "1241" | "1242" | "1243" | "1244" | "1245" | "1246" | "1250" | "1251" | "1252" | "1253" | "1254" | "1255" | "1256" | "1260" | "1261" | "1262" | "1263" | "1264" | "1265" | "1266" | "1300" | "1301" | "1302" | "1303" | "1304" | "1305" | "1306" | "1310" | "1311" | "1312" | "1313" | "1314" | "1315" | "1316" | "1320" | "1321" | "1322" | "1323" | "1324" | "1325" | "1326" | "1330" | "1331" | "1332" | "1333" | "1334" | "1335" | "1336" | "1340" | "1341" | "1342" | "1343" | "1344" | "1345" | "1346" | "1350" | "1351" | "1352" | "1353" | "1354" | "1355" | "1356" | "1360" | "1361" | "1362" | "1363" | "1364" | "1365" | "1366" | "1400" | "1401" | "1402" | "1403" | "1404" | "1405" | "1406" | "1410" | "1411" | "1412" | "1413" | "1414" | "1415" | "1416" | "1420" | "1421" | "1422" | "1423" | "1424" | "1425" | "1426" | "1430" | "1431" | "1432" | "1433" | "1434" | "1435" | "1436" | "1440" | "1441" | "1442" | "1443" | "1444" | "1445" | "1446" | "1450" | "1451" | "1452" | "1453" | "1454" | "1455" | "1456" | "1460" | "1461" | "1462" | "1463" | "1464" | "1465" | "1466" | "1500" | "1501" | "1502" | "1503" | "1504" | "1505" | "1506" | "1510" | "1511" | "1512" | "1513" | "1514" | "1515" | "1516" | "1520" | "1521" | "1522" | "1523" | "1524" | "1525" | "1526" | "1530" | "1531" | "1532" | "1533" | "1534" | "1535" | "1536" | "1540" | "1541" | "1542" | "1543" | "1544" | "1545" | "1546" | "1550" | "1551" | "1552" | "1553" | "1554" | "1555" | "1556" | "1560" | "1561" | "1562" | "1563" | "1564" | "1565" | "1566" | "1600" | "1601" | "1602" | "1603" | "1604" | "1605" | "1606" | "1610" | "1611" | "1612" | "1613" | "1614" | "1615" | "1616" | "1620" | "1621" | "1622" | "1623" | "1624" | "1625" | "1626" | "1630" | "1631" | "1632" | "1633" | "1634" | "1635" | "1636" | "1640" | "1641" | "1642" | "1643" | "1644" | "1645" | "1646" | "1650" | "1651" | "1652" | "1653" | "1654" | "1655" | "1656" | "1660" | "1661" | "1662" | "1663" | "1664" | "1665" | "1666" | "2000" | "2001" | "2002" | "2003" | "2004" | "2005" | "2006" | "2010" | "2011" | "2012" | "2013" | "2014" | "2015" | "2016" | "2020" | "2021" | "2022" | "2023" | "2024" | "2025" | "2026" | "2030" | "2031" | "2032" | "2033" | "2034" | "2035" | "2036" | "2040" | "2041" | "2042" | "2043" | "2044" | "2045" | "2046" | "2050" | "2051" | "2052" | "2053" | "2054" | "2055" | "2056" | "2060" | "2061" | "2062" | "2063" | "2064" | "2065" | "2066" | "2100" | "2101" | "2102" | "2103" | "2104" | "2105" | "2106" | "2110" | "2111" | "2112" | "2113" | "2114" | "2115" | "2116" | "2120" | "2121" | "2122" | "2123" | "2124" | "2125" | "2126" | "2130" | "2131" | "2132" | "2133" | "2134" | "2135" | "2136" | "2140" | "2141" | "2142" | "2143" | "2144" | "2145" | "2146" | "2150" | "2151" | "2152" | "2153" | "2154" | "2155" | "2156" | "2160" | "2161" | "2162" | "2163" | "2164" | "2165" | "2166" | "2200" | "2201" | "2202" | "2203" | "2204" | "2205" | "2206" | "2210" | "2211" | "2212" | "2213" | "2214" | "2215" | "2216" | "2220" | "2221" | "2222" | "2223" | "2224" | "2225" | "2226" | "2230" | "2231" | "2232" | "2233" | "2234" | "2235" | "2236" | "2240" | "2241" | "2242" | "2243" | "2244" | "2245" | "2246" | "2250" | "2251" | "2252" | "2253" | "2254" | "2255" | "2256" | "2260" | "2261" | "2262" | "2263" | "2264" | "2265" | "2266" | "2300" | "2301" | "2302" | "2303" | "2304" | "2305" | "2306" | "2310" | "2311" | "2312" | "2313" | "2314" | "2315" | "2316" | "2320" | "2321" | "2322" | "2323" | "2324" | "2325" | "2326" | "2330" | "2331" | "2332" | "2333" | "2334" | "2335" | "2336" | "2340" | "2341" | "2342" | "2343" | "2344" | "2345" | "2346" | "2350" | "2351" | "2352" | "2353" | "2354" | "2355" | "2356" | "2360" | "2361" | "2362" | "2363" | "2364" | "2365" | "2366" | "2400" | "2401" | "2402" | "2403" | "2404" | "2405" | "2406" | "2410" | "2411" | "2412" | "2413" | "2414" | "2415" | "2416" | "2420" | "2421" | "2422" | "2423" | "2424" | "2425" | "2426" | "2430" | "2431" | "2432" | "2433" | "2434" | "2435" | "2436" | "2440" | "2441" | "2442" | "2443" | "2444" | "2445" | "2446" | "2450" | "2451" | "2452" | "2453" | "2454" | "2455" | "2456" | "2460" | "2461" | "2462" | "2463" | "2464" | "2465" | "2466" | "2500" | "2501" | "2502" | "2503" | "2504" | "2505" | "2506" | "2510" | "2511" | "2512" | "2513" | "2514" | "2515" | "2516" | "2520" | "2521" | "2522" | "2523" | "2524" | "2525" | "2526" | "2530" | "2531" | "2532" | "2533" | "2534" | "2535" | "2536" | "2540" | "2541" | "2542" | "2543" | "2544" | "2545" | "2546" | "2550" | "2551" | "2552" | "2553" | "2554" | "2555" | "2556" | "2560" | "2561" | "2562" | "2563" | "2564" | "2565" | "2566" | "2600" | "2601" | "2602" | "2603" | "2604" | "2605" | "2606" | "2610" | "2611" | "2612" | "2613" | "2614" | "2615" | "2616" | "2620" | "2621" | "2622" | "2623" | "2624" | "2625" | "2626" | "2630" | "2631" | "2632" | "2633" | "2634" | "2635" | "2636" | "2640" | "2641" | "2642" | "2643" | "2644" | "2645" | "2646" | "2650" | "2651" | "2652" | "2653" | "2654" | "2655" | "2656" | "2660" | "2661" | "2662" | "2663" | "2664" | "2665" | "2666" | undefined) & T2 + +x = y3; +>x = y3 : ("0000" | "0001" | "0002" | "0003" | "0004" | "0005" | "0006" | "0010" | "0011" | "0012" | "0013" | "0014" | "0015" | "0016" | "0020" | "0021" | "0022" | "0023" | "0024" | "0025" | "0026" | "0030" | "0031" | "0032" | "0033" | "0034" | "0035" | "0036" | "0040" | "0041" | "0042" | "0043" | "0044" | "0045" | "0046" | "0050" | "0051" | "0052" | "0053" | "0054" | "0055" | "0056" | "0060" | "0061" | "0062" | "0063" | "0064" | "0065" | "0066" | "0100" | "0101" | "0102" | "0103" | "0104" | "0105" | "0106" | "0110" | "0111" | "0112" | "0113" | "0114" | "0115" | "0116" | "0120" | "0121" | "0122" | "0123" | "0124" | "0125" | "0126" | "0130" | "0131" | "0132" | "0133" | "0134" | "0135" | "0136" | "0140" | "0141" | "0142" | "0143" | "0144" | "0145" | "0146" | "0150" | "0151" | "0152" | "0153" | "0154" | "0155" | "0156" | "0160" | "0161" | "0162" | "0163" | "0164" | "0165" | "0166" | "0200" | "0201" | "0202" | "0203" | "0204" | "0205" | "0206" | "0210" | "0211" | "0212" | "0213" | "0214" | "0215" | "0216" | "0220" | "0221" | "0222" | "0223" | "0224" | "0225" | "0226" | "0230" | "0231" | "0232" | "0233" | "0234" | "0235" | "0236" | "0240" | "0241" | "0242" | "0243" | "0244" | "0245" | "0246" | "0250" | "0251" | "0252" | "0253" | "0254" | "0255" | "0256" | "0260" | "0261" | "0262" | "0263" | "0264" | "0265" | "0266" | "0300" | "0301" | "0302" | "0303" | "0304" | "0305" | "0306" | "0310" | "0311" | "0312" | "0313" | "0314" | "0315" | "0316" | "0320" | "0321" | "0322" | "0323" | "0324" | "0325" | "0326" | "0330" | "0331" | "0332" | "0333" | "0334" | "0335" | "0336" | "0340" | "0341" | "0342" | "0343" | "0344" | "0345" | "0346" | "0350" | "0351" | "0352" | "0353" | "0354" | "0355" | "0356" | "0360" | "0361" | "0362" | "0363" | "0364" | "0365" | "0366" | "0400" | "0401" | "0402" | "0403" | "0404" | "0405" | "0406" | "0410" | "0411" | "0412" | "0413" | "0414" | "0415" | "0416" | "0420" | "0421" | "0422" | "0423" | "0424" | "0425" | "0426" | "0430" | "0431" | "0432" | "0433" | "0434" | "0435" | "0436" | "0440" | "0441" | "0442" | "0443" | "0444" | "0445" | "0446" | "0450" | "0451" | "0452" | "0453" | "0454" | "0455" | "0456" | "0460" | "0461" | "0462" | "0463" | "0464" | "0465" | "0466" | "0500" | "0501" | "0502" | "0503" | "0504" | "0505" | "0506" | "0510" | "0511" | "0512" | "0513" | "0514" | "0515" | "0516" | "0520" | "0521" | "0522" | "0523" | "0524" | "0525" | "0526" | "0530" | "0531" | "0532" | "0533" | "0534" | "0535" | "0536" | "0540" | "0541" | "0542" | "0543" | "0544" | "0545" | "0546" | "0550" | "0551" | "0552" | "0553" | "0554" | "0555" | "0556" | "0560" | "0561" | "0562" | "0563" | "0564" | "0565" | "0566" | "0600" | "0601" | "0602" | "0603" | "0604" | "0605" | "0606" | "0610" | "0611" | "0612" | "0613" | "0614" | "0615" | "0616" | "0620" | "0621" | "0622" | "0623" | "0624" | "0625" | "0626" | "0630" | "0631" | "0632" | "0633" | "0634" | "0635" | "0636" | "0640" | "0641" | "0642" | "0643" | "0644" | "0645" | "0646" | "0650" | "0651" | "0652" | "0653" | "0654" | "0655" | "0656" | "0660" | "0661" | "0662" | "0663" | "0664" | "0665" | "0666" | "1000" | "1001" | "1002" | "1003" | "1004" | "1005" | "1006" | "1010" | "1011" | "1012" | "1013" | "1014" | "1015" | "1016" | "1020" | "1021" | "1022" | "1023" | "1024" | "1025" | "1026" | "1030" | "1031" | "1032" | "1033" | "1034" | "1035" | "1036" | "1040" | "1041" | "1042" | "1043" | "1044" | "1045" | "1046" | "1050" | "1051" | "1052" | "1053" | "1054" | "1055" | "1056" | "1060" | "1061" | "1062" | "1063" | "1064" | "1065" | "1066" | "1100" | "1101" | "1102" | "1103" | "1104" | "1105" | "1106" | "1110" | "1111" | "1112" | "1113" | "1114" | "1115" | "1116" | "1120" | "1121" | "1122" | "1123" | "1124" | "1125" | "1126" | "1130" | "1131" | "1132" | "1133" | "1134" | "1135" | "1136" | "1140" | "1141" | "1142" | "1143" | "1144" | "1145" | "1146" | "1150" | "1151" | "1152" | "1153" | "1154" | "1155" | "1156" | "1160" | "1161" | "1162" | "1163" | "1164" | "1165" | "1166" | "1200" | "1201" | "1202" | "1203" | "1204" | "1205" | "1206" | "1210" | "1211" | "1212" | "1213" | "1214" | "1215" | "1216" | "1220" | "1221" | "1222" | "1223" | "1224" | "1225" | "1226" | "1230" | "1231" | "1232" | "1233" | "1234" | "1235" | "1236" | "1240" | "1241" | "1242" | "1243" | "1244" | "1245" | "1246" | "1250" | "1251" | "1252" | "1253" | "1254" | "1255" | "1256" | "1260" | "1261" | "1262" | "1263" | "1264" | "1265" | "1266" | "1300" | "1301" | "1302" | "1303" | "1304" | "1305" | "1306" | "1310" | "1311" | "1312" | "1313" | "1314" | "1315" | "1316" | "1320" | "1321" | "1322" | "1323" | "1324" | "1325" | "1326" | "1330" | "1331" | "1332" | "1333" | "1334" | "1335" | "1336" | "1340" | "1341" | "1342" | "1343" | "1344" | "1345" | "1346" | "1350" | "1351" | "1352" | "1353" | "1354" | "1355" | "1356" | "1360" | "1361" | "1362" | "1363" | "1364" | "1365" | "1366" | "1400" | "1401" | "1402" | "1403" | "1404" | "1405" | "1406" | "1410" | "1411" | "1412" | "1413" | "1414" | "1415" | "1416" | "1420" | "1421" | "1422" | "1423" | "1424" | "1425" | "1426" | "1430" | "1431" | "1432" | "1433" | "1434" | "1435" | "1436" | "1440" | "1441" | "1442" | "1443" | "1444" | "1445" | "1446" | "1450" | "1451" | "1452" | "1453" | "1454" | "1455" | "1456" | "1460" | "1461" | "1462" | "1463" | "1464" | "1465" | "1466" | "1500" | "1501" | "1502" | "1503" | "1504" | "1505" | "1506" | "1510" | "1511" | "1512" | "1513" | "1514" | "1515" | "1516" | "1520" | "1521" | "1522" | "1523" | "1524" | "1525" | "1526" | "1530" | "1531" | "1532" | "1533" | "1534" | "1535" | "1536" | "1540" | "1541" | "1542" | "1543" | "1544" | "1545" | "1546" | "1550" | "1551" | "1552" | "1553" | "1554" | "1555" | "1556" | "1560" | "1561" | "1562" | "1563" | "1564" | "1565" | "1566" | "1600" | "1601" | "1602" | "1603" | "1604" | "1605" | "1606" | "1610" | "1611" | "1612" | "1613" | "1614" | "1615" | "1616" | "1620" | "1621" | "1622" | "1623" | "1624" | "1625" | "1626" | "1630" | "1631" | "1632" | "1633" | "1634" | "1635" | "1636" | "1640" | "1641" | "1642" | "1643" | "1644" | "1645" | "1646" | "1650" | "1651" | "1652" | "1653" | "1654" | "1655" | "1656" | "1660" | "1661" | "1662" | "1663" | "1664" | "1665" | "1666" | "2000" | "2001" | "2002" | "2003" | "2004" | "2005" | "2006" | "2010" | "2011" | "2012" | "2013" | "2014" | "2015" | "2016" | "2020" | "2021" | "2022" | "2023" | "2024" | "2025" | "2026" | "2030" | "2031" | "2032" | "2033" | "2034" | "2035" | "2036" | "2040" | "2041" | "2042" | "2043" | "2044" | "2045" | "2046" | "2050" | "2051" | "2052" | "2053" | "2054" | "2055" | "2056" | "2060" | "2061" | "2062" | "2063" | "2064" | "2065" | "2066" | "2100" | "2101" | "2102" | "2103" | "2104" | "2105" | "2106" | "2110" | "2111" | "2112" | "2113" | "2114" | "2115" | "2116" | "2120" | "2121" | "2122" | "2123" | "2124" | "2125" | "2126" | "2130" | "2131" | "2132" | "2133" | "2134" | "2135" | "2136" | "2140" | "2141" | "2142" | "2143" | "2144" | "2145" | "2146" | "2150" | "2151" | "2152" | "2153" | "2154" | "2155" | "2156" | "2160" | "2161" | "2162" | "2163" | "2164" | "2165" | "2166" | "2200" | "2201" | "2202" | "2203" | "2204" | "2205" | "2206" | "2210" | "2211" | "2212" | "2213" | "2214" | "2215" | "2216" | "2220" | "2221" | "2222" | "2223" | "2224" | "2225" | "2226" | "2230" | "2231" | "2232" | "2233" | "2234" | "2235" | "2236" | "2240" | "2241" | "2242" | "2243" | "2244" | "2245" | "2246" | "2250" | "2251" | "2252" | "2253" | "2254" | "2255" | "2256" | "2260" | "2261" | "2262" | "2263" | "2264" | "2265" | "2266" | "2300" | "2301" | "2302" | "2303" | "2304" | "2305" | "2306" | "2310" | "2311" | "2312" | "2313" | "2314" | "2315" | "2316" | "2320" | "2321" | "2322" | "2323" | "2324" | "2325" | "2326" | "2330" | "2331" | "2332" | "2333" | "2334" | "2335" | "2336" | "2340" | "2341" | "2342" | "2343" | "2344" | "2345" | "2346" | "2350" | "2351" | "2352" | "2353" | "2354" | "2355" | "2356" | "2360" | "2361" | "2362" | "2363" | "2364" | "2365" | "2366" | "2400" | "2401" | "2402" | "2403" | "2404" | "2405" | "2406" | "2410" | "2411" | "2412" | "2413" | "2414" | "2415" | "2416" | "2420" | "2421" | "2422" | "2423" | "2424" | "2425" | "2426" | "2430" | "2431" | "2432" | "2433" | "2434" | "2435" | "2436" | "2440" | "2441" | "2442" | "2443" | "2444" | "2445" | "2446" | "2450" | "2451" | "2452" | "2453" | "2454" | "2455" | "2456" | "2460" | "2461" | "2462" | "2463" | "2464" | "2465" | "2466" | "2500" | "2501" | "2502" | "2503" | "2504" | "2505" | "2506" | "2510" | "2511" | "2512" | "2513" | "2514" | "2515" | "2516" | "2520" | "2521" | "2522" | "2523" | "2524" | "2525" | "2526" | "2530" | "2531" | "2532" | "2533" | "2534" | "2535" | "2536" | "2540" | "2541" | "2542" | "2543" | "2544" | "2545" | "2546" | "2550" | "2551" | "2552" | "2553" | "2554" | "2555" | "2556" | "2560" | "2561" | "2562" | "2563" | "2564" | "2565" | "2566" | "2600" | "2601" | "2602" | "2603" | "2604" | "2605" | "2606" | "2610" | "2611" | "2612" | "2613" | "2614" | "2615" | "2616" | "2620" | "2621" | "2622" | "2623" | "2624" | "2625" | "2626" | "2630" | "2631" | "2632" | "2633" | "2634" | "2635" | "2636" | "2640" | "2641" | "2642" | "2643" | "2644" | "2645" | "2646" | "2650" | "2651" | "2652" | "2653" | "2654" | "2655" | "2656" | "2660" | "2661" | "2662" | "2663" | "2664" | "2665" | "2666" | undefined) & T2 +>x : T1 | null +>y3 : ("0000" | "0001" | "0002" | "0003" | "0004" | "0005" | "0006" | "0010" | "0011" | "0012" | "0013" | "0014" | "0015" | "0016" | "0020" | "0021" | "0022" | "0023" | "0024" | "0025" | "0026" | "0030" | "0031" | "0032" | "0033" | "0034" | "0035" | "0036" | "0040" | "0041" | "0042" | "0043" | "0044" | "0045" | "0046" | "0050" | "0051" | "0052" | "0053" | "0054" | "0055" | "0056" | "0060" | "0061" | "0062" | "0063" | "0064" | "0065" | "0066" | "0100" | "0101" | "0102" | "0103" | "0104" | "0105" | "0106" | "0110" | "0111" | "0112" | "0113" | "0114" | "0115" | "0116" | "0120" | "0121" | "0122" | "0123" | "0124" | "0125" | "0126" | "0130" | "0131" | "0132" | "0133" | "0134" | "0135" | "0136" | "0140" | "0141" | "0142" | "0143" | "0144" | "0145" | "0146" | "0150" | "0151" | "0152" | "0153" | "0154" | "0155" | "0156" | "0160" | "0161" | "0162" | "0163" | "0164" | "0165" | "0166" | "0200" | "0201" | "0202" | "0203" | "0204" | "0205" | "0206" | "0210" | "0211" | "0212" | "0213" | "0214" | "0215" | "0216" | "0220" | "0221" | "0222" | "0223" | "0224" | "0225" | "0226" | "0230" | "0231" | "0232" | "0233" | "0234" | "0235" | "0236" | "0240" | "0241" | "0242" | "0243" | "0244" | "0245" | "0246" | "0250" | "0251" | "0252" | "0253" | "0254" | "0255" | "0256" | "0260" | "0261" | "0262" | "0263" | "0264" | "0265" | "0266" | "0300" | "0301" | "0302" | "0303" | "0304" | "0305" | "0306" | "0310" | "0311" | "0312" | "0313" | "0314" | "0315" | "0316" | "0320" | "0321" | "0322" | "0323" | "0324" | "0325" | "0326" | "0330" | "0331" | "0332" | "0333" | "0334" | "0335" | "0336" | "0340" | "0341" | "0342" | "0343" | "0344" | "0345" | "0346" | "0350" | "0351" | "0352" | "0353" | "0354" | "0355" | "0356" | "0360" | "0361" | "0362" | "0363" | "0364" | "0365" | "0366" | "0400" | "0401" | "0402" | "0403" | "0404" | "0405" | "0406" | "0410" | "0411" | "0412" | "0413" | "0414" | "0415" | "0416" | "0420" | "0421" | "0422" | "0423" | "0424" | "0425" | "0426" | "0430" | "0431" | "0432" | "0433" | "0434" | "0435" | "0436" | "0440" | "0441" | "0442" | "0443" | "0444" | "0445" | "0446" | "0450" | "0451" | "0452" | "0453" | "0454" | "0455" | "0456" | "0460" | "0461" | "0462" | "0463" | "0464" | "0465" | "0466" | "0500" | "0501" | "0502" | "0503" | "0504" | "0505" | "0506" | "0510" | "0511" | "0512" | "0513" | "0514" | "0515" | "0516" | "0520" | "0521" | "0522" | "0523" | "0524" | "0525" | "0526" | "0530" | "0531" | "0532" | "0533" | "0534" | "0535" | "0536" | "0540" | "0541" | "0542" | "0543" | "0544" | "0545" | "0546" | "0550" | "0551" | "0552" | "0553" | "0554" | "0555" | "0556" | "0560" | "0561" | "0562" | "0563" | "0564" | "0565" | "0566" | "0600" | "0601" | "0602" | "0603" | "0604" | "0605" | "0606" | "0610" | "0611" | "0612" | "0613" | "0614" | "0615" | "0616" | "0620" | "0621" | "0622" | "0623" | "0624" | "0625" | "0626" | "0630" | "0631" | "0632" | "0633" | "0634" | "0635" | "0636" | "0640" | "0641" | "0642" | "0643" | "0644" | "0645" | "0646" | "0650" | "0651" | "0652" | "0653" | "0654" | "0655" | "0656" | "0660" | "0661" | "0662" | "0663" | "0664" | "0665" | "0666" | "1000" | "1001" | "1002" | "1003" | "1004" | "1005" | "1006" | "1010" | "1011" | "1012" | "1013" | "1014" | "1015" | "1016" | "1020" | "1021" | "1022" | "1023" | "1024" | "1025" | "1026" | "1030" | "1031" | "1032" | "1033" | "1034" | "1035" | "1036" | "1040" | "1041" | "1042" | "1043" | "1044" | "1045" | "1046" | "1050" | "1051" | "1052" | "1053" | "1054" | "1055" | "1056" | "1060" | "1061" | "1062" | "1063" | "1064" | "1065" | "1066" | "1100" | "1101" | "1102" | "1103" | "1104" | "1105" | "1106" | "1110" | "1111" | "1112" | "1113" | "1114" | "1115" | "1116" | "1120" | "1121" | "1122" | "1123" | "1124" | "1125" | "1126" | "1130" | "1131" | "1132" | "1133" | "1134" | "1135" | "1136" | "1140" | "1141" | "1142" | "1143" | "1144" | "1145" | "1146" | "1150" | "1151" | "1152" | "1153" | "1154" | "1155" | "1156" | "1160" | "1161" | "1162" | "1163" | "1164" | "1165" | "1166" | "1200" | "1201" | "1202" | "1203" | "1204" | "1205" | "1206" | "1210" | "1211" | "1212" | "1213" | "1214" | "1215" | "1216" | "1220" | "1221" | "1222" | "1223" | "1224" | "1225" | "1226" | "1230" | "1231" | "1232" | "1233" | "1234" | "1235" | "1236" | "1240" | "1241" | "1242" | "1243" | "1244" | "1245" | "1246" | "1250" | "1251" | "1252" | "1253" | "1254" | "1255" | "1256" | "1260" | "1261" | "1262" | "1263" | "1264" | "1265" | "1266" | "1300" | "1301" | "1302" | "1303" | "1304" | "1305" | "1306" | "1310" | "1311" | "1312" | "1313" | "1314" | "1315" | "1316" | "1320" | "1321" | "1322" | "1323" | "1324" | "1325" | "1326" | "1330" | "1331" | "1332" | "1333" | "1334" | "1335" | "1336" | "1340" | "1341" | "1342" | "1343" | "1344" | "1345" | "1346" | "1350" | "1351" | "1352" | "1353" | "1354" | "1355" | "1356" | "1360" | "1361" | "1362" | "1363" | "1364" | "1365" | "1366" | "1400" | "1401" | "1402" | "1403" | "1404" | "1405" | "1406" | "1410" | "1411" | "1412" | "1413" | "1414" | "1415" | "1416" | "1420" | "1421" | "1422" | "1423" | "1424" | "1425" | "1426" | "1430" | "1431" | "1432" | "1433" | "1434" | "1435" | "1436" | "1440" | "1441" | "1442" | "1443" | "1444" | "1445" | "1446" | "1450" | "1451" | "1452" | "1453" | "1454" | "1455" | "1456" | "1460" | "1461" | "1462" | "1463" | "1464" | "1465" | "1466" | "1500" | "1501" | "1502" | "1503" | "1504" | "1505" | "1506" | "1510" | "1511" | "1512" | "1513" | "1514" | "1515" | "1516" | "1520" | "1521" | "1522" | "1523" | "1524" | "1525" | "1526" | "1530" | "1531" | "1532" | "1533" | "1534" | "1535" | "1536" | "1540" | "1541" | "1542" | "1543" | "1544" | "1545" | "1546" | "1550" | "1551" | "1552" | "1553" | "1554" | "1555" | "1556" | "1560" | "1561" | "1562" | "1563" | "1564" | "1565" | "1566" | "1600" | "1601" | "1602" | "1603" | "1604" | "1605" | "1606" | "1610" | "1611" | "1612" | "1613" | "1614" | "1615" | "1616" | "1620" | "1621" | "1622" | "1623" | "1624" | "1625" | "1626" | "1630" | "1631" | "1632" | "1633" | "1634" | "1635" | "1636" | "1640" | "1641" | "1642" | "1643" | "1644" | "1645" | "1646" | "1650" | "1651" | "1652" | "1653" | "1654" | "1655" | "1656" | "1660" | "1661" | "1662" | "1663" | "1664" | "1665" | "1666" | "2000" | "2001" | "2002" | "2003" | "2004" | "2005" | "2006" | "2010" | "2011" | "2012" | "2013" | "2014" | "2015" | "2016" | "2020" | "2021" | "2022" | "2023" | "2024" | "2025" | "2026" | "2030" | "2031" | "2032" | "2033" | "2034" | "2035" | "2036" | "2040" | "2041" | "2042" | "2043" | "2044" | "2045" | "2046" | "2050" | "2051" | "2052" | "2053" | "2054" | "2055" | "2056" | "2060" | "2061" | "2062" | "2063" | "2064" | "2065" | "2066" | "2100" | "2101" | "2102" | "2103" | "2104" | "2105" | "2106" | "2110" | "2111" | "2112" | "2113" | "2114" | "2115" | "2116" | "2120" | "2121" | "2122" | "2123" | "2124" | "2125" | "2126" | "2130" | "2131" | "2132" | "2133" | "2134" | "2135" | "2136" | "2140" | "2141" | "2142" | "2143" | "2144" | "2145" | "2146" | "2150" | "2151" | "2152" | "2153" | "2154" | "2155" | "2156" | "2160" | "2161" | "2162" | "2163" | "2164" | "2165" | "2166" | "2200" | "2201" | "2202" | "2203" | "2204" | "2205" | "2206" | "2210" | "2211" | "2212" | "2213" | "2214" | "2215" | "2216" | "2220" | "2221" | "2222" | "2223" | "2224" | "2225" | "2226" | "2230" | "2231" | "2232" | "2233" | "2234" | "2235" | "2236" | "2240" | "2241" | "2242" | "2243" | "2244" | "2245" | "2246" | "2250" | "2251" | "2252" | "2253" | "2254" | "2255" | "2256" | "2260" | "2261" | "2262" | "2263" | "2264" | "2265" | "2266" | "2300" | "2301" | "2302" | "2303" | "2304" | "2305" | "2306" | "2310" | "2311" | "2312" | "2313" | "2314" | "2315" | "2316" | "2320" | "2321" | "2322" | "2323" | "2324" | "2325" | "2326" | "2330" | "2331" | "2332" | "2333" | "2334" | "2335" | "2336" | "2340" | "2341" | "2342" | "2343" | "2344" | "2345" | "2346" | "2350" | "2351" | "2352" | "2353" | "2354" | "2355" | "2356" | "2360" | "2361" | "2362" | "2363" | "2364" | "2365" | "2366" | "2400" | "2401" | "2402" | "2403" | "2404" | "2405" | "2406" | "2410" | "2411" | "2412" | "2413" | "2414" | "2415" | "2416" | "2420" | "2421" | "2422" | "2423" | "2424" | "2425" | "2426" | "2430" | "2431" | "2432" | "2433" | "2434" | "2435" | "2436" | "2440" | "2441" | "2442" | "2443" | "2444" | "2445" | "2446" | "2450" | "2451" | "2452" | "2453" | "2454" | "2455" | "2456" | "2460" | "2461" | "2462" | "2463" | "2464" | "2465" | "2466" | "2500" | "2501" | "2502" | "2503" | "2504" | "2505" | "2506" | "2510" | "2511" | "2512" | "2513" | "2514" | "2515" | "2516" | "2520" | "2521" | "2522" | "2523" | "2524" | "2525" | "2526" | "2530" | "2531" | "2532" | "2533" | "2534" | "2535" | "2536" | "2540" | "2541" | "2542" | "2543" | "2544" | "2545" | "2546" | "2550" | "2551" | "2552" | "2553" | "2554" | "2555" | "2556" | "2560" | "2561" | "2562" | "2563" | "2564" | "2565" | "2566" | "2600" | "2601" | "2602" | "2603" | "2604" | "2605" | "2606" | "2610" | "2611" | "2612" | "2613" | "2614" | "2615" | "2616" | "2620" | "2621" | "2622" | "2623" | "2624" | "2625" | "2626" | "2630" | "2631" | "2632" | "2633" | "2634" | "2635" | "2636" | "2640" | "2641" | "2642" | "2643" | "2644" | "2645" | "2646" | "2650" | "2651" | "2652" | "2653" | "2654" | "2655" | "2656" | "2660" | "2661" | "2662" | "2663" | "2664" | "2665" | "2666" | undefined) & T2 + +declare const y4: (`${'0' | '1' | '2' | '3'}${D}${D}${D}` | undefined) & T2; +>y4 : ("0000" | "0001" | "0002" | "0003" | "0004" | "0005" | "0006" | "0010" | "0011" | "0012" | "0013" | "0014" | "0015" | "0016" | "0020" | "0021" | "0022" | "0023" | "0024" | "0025" | "0026" | "0030" | "0031" | "0032" | "0033" | "0034" | "0035" | "0036" | "0040" | "0041" | "0042" | "0043" | "0044" | "0045" | "0046" | "0050" | "0051" | "0052" | "0053" | "0054" | "0055" | "0056" | "0060" | "0061" | "0062" | "0063" | "0064" | "0065" | "0066" | "0100" | "0101" | "0102" | "0103" | "0104" | "0105" | "0106" | "0110" | "0111" | "0112" | "0113" | "0114" | "0115" | "0116" | "0120" | "0121" | "0122" | "0123" | "0124" | "0125" | "0126" | "0130" | "0131" | "0132" | "0133" | "0134" | "0135" | "0136" | "0140" | "0141" | "0142" | "0143" | "0144" | "0145" | "0146" | "0150" | "0151" | "0152" | "0153" | "0154" | "0155" | "0156" | "0160" | "0161" | "0162" | "0163" | "0164" | "0165" | "0166" | "0200" | "0201" | "0202" | "0203" | "0204" | "0205" | "0206" | "0210" | "0211" | "0212" | "0213" | "0214" | "0215" | "0216" | "0220" | "0221" | "0222" | "0223" | "0224" | "0225" | "0226" | "0230" | "0231" | "0232" | "0233" | "0234" | "0235" | "0236" | "0240" | "0241" | "0242" | "0243" | "0244" | "0245" | "0246" | "0250" | "0251" | "0252" | "0253" | "0254" | "0255" | "0256" | "0260" | "0261" | "0262" | "0263" | "0264" | "0265" | "0266" | "0300" | "0301" | "0302" | "0303" | "0304" | "0305" | "0306" | "0310" | "0311" | "0312" | "0313" | "0314" | "0315" | "0316" | "0320" | "0321" | "0322" | "0323" | "0324" | "0325" | "0326" | "0330" | "0331" | "0332" | "0333" | "0334" | "0335" | "0336" | "0340" | "0341" | "0342" | "0343" | "0344" | "0345" | "0346" | "0350" | "0351" | "0352" | "0353" | "0354" | "0355" | "0356" | "0360" | "0361" | "0362" | "0363" | "0364" | "0365" | "0366" | "0400" | "0401" | "0402" | "0403" | "0404" | "0405" | "0406" | "0410" | "0411" | "0412" | "0413" | "0414" | "0415" | "0416" | "0420" | "0421" | "0422" | "0423" | "0424" | "0425" | "0426" | "0430" | "0431" | "0432" | "0433" | "0434" | "0435" | "0436" | "0440" | "0441" | "0442" | "0443" | "0444" | "0445" | "0446" | "0450" | "0451" | "0452" | "0453" | "0454" | "0455" | "0456" | "0460" | "0461" | "0462" | "0463" | "0464" | "0465" | "0466" | "0500" | "0501" | "0502" | "0503" | "0504" | "0505" | "0506" | "0510" | "0511" | "0512" | "0513" | "0514" | "0515" | "0516" | "0520" | "0521" | "0522" | "0523" | "0524" | "0525" | "0526" | "0530" | "0531" | "0532" | "0533" | "0534" | "0535" | "0536" | "0540" | "0541" | "0542" | "0543" | "0544" | "0545" | "0546" | "0550" | "0551" | "0552" | "0553" | "0554" | "0555" | "0556" | "0560" | "0561" | "0562" | "0563" | "0564" | "0565" | "0566" | "0600" | "0601" | "0602" | "0603" | "0604" | "0605" | "0606" | "0610" | "0611" | "0612" | "0613" | "0614" | "0615" | "0616" | "0620" | "0621" | "0622" | "0623" | "0624" | "0625" | "0626" | "0630" | "0631" | "0632" | "0633" | "0634" | "0635" | "0636" | "0640" | "0641" | "0642" | "0643" | "0644" | "0645" | "0646" | "0650" | "0651" | "0652" | "0653" | "0654" | "0655" | "0656" | "0660" | "0661" | "0662" | "0663" | "0664" | "0665" | "0666" | "1000" | "1001" | "1002" | "1003" | "1004" | "1005" | "1006" | "1010" | "1011" | "1012" | "1013" | "1014" | "1015" | "1016" | "1020" | "1021" | "1022" | "1023" | "1024" | "1025" | "1026" | "1030" | "1031" | "1032" | "1033" | "1034" | "1035" | "1036" | "1040" | "1041" | "1042" | "1043" | "1044" | "1045" | "1046" | "1050" | "1051" | "1052" | "1053" | "1054" | "1055" | "1056" | "1060" | "1061" | "1062" | "1063" | "1064" | "1065" | "1066" | "1100" | "1101" | "1102" | "1103" | "1104" | "1105" | "1106" | "1110" | "1111" | "1112" | "1113" | "1114" | "1115" | "1116" | "1120" | "1121" | "1122" | "1123" | "1124" | "1125" | "1126" | "1130" | "1131" | "1132" | "1133" | "1134" | "1135" | "1136" | "1140" | "1141" | "1142" | "1143" | "1144" | "1145" | "1146" | "1150" | "1151" | "1152" | "1153" | "1154" | "1155" | "1156" | "1160" | "1161" | "1162" | "1163" | "1164" | "1165" | "1166" | "1200" | "1201" | "1202" | "1203" | "1204" | "1205" | "1206" | "1210" | "1211" | "1212" | "1213" | "1214" | "1215" | "1216" | "1220" | "1221" | "1222" | "1223" | "1224" | "1225" | "1226" | "1230" | "1231" | "1232" | "1233" | "1234" | "1235" | "1236" | "1240" | "1241" | "1242" | "1243" | "1244" | "1245" | "1246" | "1250" | "1251" | "1252" | "1253" | "1254" | "1255" | "1256" | "1260" | "1261" | "1262" | "1263" | "1264" | "1265" | "1266" | "1300" | "1301" | "1302" | "1303" | "1304" | "1305" | "1306" | "1310" | "1311" | "1312" | "1313" | "1314" | "1315" | "1316" | "1320" | "1321" | "1322" | "1323" | "1324" | "1325" | "1326" | "1330" | "1331" | "1332" | "1333" | "1334" | "1335" | "1336" | "1340" | "1341" | "1342" | "1343" | "1344" | "1345" | "1346" | "1350" | "1351" | "1352" | "1353" | "1354" | "1355" | "1356" | "1360" | "1361" | "1362" | "1363" | "1364" | "1365" | "1366" | "1400" | "1401" | "1402" | "1403" | "1404" | "1405" | "1406" | "1410" | "1411" | "1412" | "1413" | "1414" | "1415" | "1416" | "1420" | "1421" | "1422" | "1423" | "1424" | "1425" | "1426" | "1430" | "1431" | "1432" | "1433" | "1434" | "1435" | "1436" | "1440" | "1441" | "1442" | "1443" | "1444" | "1445" | "1446" | "1450" | "1451" | "1452" | "1453" | "1454" | "1455" | "1456" | "1460" | "1461" | "1462" | "1463" | "1464" | "1465" | "1466" | "1500" | "1501" | "1502" | "1503" | "1504" | "1505" | "1506" | "1510" | "1511" | "1512" | "1513" | "1514" | "1515" | "1516" | "1520" | "1521" | "1522" | "1523" | "1524" | "1525" | "1526" | "1530" | "1531" | "1532" | "1533" | "1534" | "1535" | "1536" | "1540" | "1541" | "1542" | "1543" | "1544" | "1545" | "1546" | "1550" | "1551" | "1552" | "1553" | "1554" | "1555" | "1556" | "1560" | "1561" | "1562" | "1563" | "1564" | "1565" | "1566" | "1600" | "1601" | "1602" | "1603" | "1604" | "1605" | "1606" | "1610" | "1611" | "1612" | "1613" | "1614" | "1615" | "1616" | "1620" | "1621" | "1622" | "1623" | "1624" | "1625" | "1626" | "1630" | "1631" | "1632" | "1633" | "1634" | "1635" | "1636" | "1640" | "1641" | "1642" | "1643" | "1644" | "1645" | "1646" | "1650" | "1651" | "1652" | "1653" | "1654" | "1655" | "1656" | "1660" | "1661" | "1662" | "1663" | "1664" | "1665" | "1666" | "2000" | "2001" | "2002" | "2003" | "2004" | "2005" | "2006" | "2010" | "2011" | "2012" | "2013" | "2014" | "2015" | "2016" | "2020" | "2021" | "2022" | "2023" | "2024" | "2025" | "2026" | "2030" | "2031" | "2032" | "2033" | "2034" | "2035" | "2036" | "2040" | "2041" | "2042" | "2043" | "2044" | "2045" | "2046" | "2050" | "2051" | "2052" | "2053" | "2054" | "2055" | "2056" | "2060" | "2061" | "2062" | "2063" | "2064" | "2065" | "2066" | "2100" | "2101" | "2102" | "2103" | "2104" | "2105" | "2106" | "2110" | "2111" | "2112" | "2113" | "2114" | "2115" | "2116" | "2120" | "2121" | "2122" | "2123" | "2124" | "2125" | "2126" | "2130" | "2131" | "2132" | "2133" | "2134" | "2135" | "2136" | "2140" | "2141" | "2142" | "2143" | "2144" | "2145" | "2146" | "2150" | "2151" | "2152" | "2153" | "2154" | "2155" | "2156" | "2160" | "2161" | "2162" | "2163" | "2164" | "2165" | "2166" | "2200" | "2201" | "2202" | "2203" | "2204" | "2205" | "2206" | "2210" | "2211" | "2212" | "2213" | "2214" | "2215" | "2216" | "2220" | "2221" | "2222" | "2223" | "2224" | "2225" | "2226" | "2230" | "2231" | "2232" | "2233" | "2234" | "2235" | "2236" | "2240" | "2241" | "2242" | "2243" | "2244" | "2245" | "2246" | "2250" | "2251" | "2252" | "2253" | "2254" | "2255" | "2256" | "2260" | "2261" | "2262" | "2263" | "2264" | "2265" | "2266" | "2300" | "2301" | "2302" | "2303" | "2304" | "2305" | "2306" | "2310" | "2311" | "2312" | "2313" | "2314" | "2315" | "2316" | "2320" | "2321" | "2322" | "2323" | "2324" | "2325" | "2326" | "2330" | "2331" | "2332" | "2333" | "2334" | "2335" | "2336" | "2340" | "2341" | "2342" | "2343" | "2344" | "2345" | "2346" | "2350" | "2351" | "2352" | "2353" | "2354" | "2355" | "2356" | "2360" | "2361" | "2362" | "2363" | "2364" | "2365" | "2366" | "2400" | "2401" | "2402" | "2403" | "2404" | "2405" | "2406" | "2410" | "2411" | "2412" | "2413" | "2414" | "2415" | "2416" | "2420" | "2421" | "2422" | "2423" | "2424" | "2425" | "2426" | "2430" | "2431" | "2432" | "2433" | "2434" | "2435" | "2436" | "2440" | "2441" | "2442" | "2443" | "2444" | "2445" | "2446" | "2450" | "2451" | "2452" | "2453" | "2454" | "2455" | "2456" | "2460" | "2461" | "2462" | "2463" | "2464" | "2465" | "2466" | "2500" | "2501" | "2502" | "2503" | "2504" | "2505" | "2506" | "2510" | "2511" | "2512" | "2513" | "2514" | "2515" | "2516" | "2520" | "2521" | "2522" | "2523" | "2524" | "2525" | "2526" | "2530" | "2531" | "2532" | "2533" | "2534" | "2535" | "2536" | "2540" | "2541" | "2542" | "2543" | "2544" | "2545" | "2546" | "2550" | "2551" | "2552" | "2553" | "2554" | "2555" | "2556" | "2560" | "2561" | "2562" | "2563" | "2564" | "2565" | "2566" | "2600" | "2601" | "2602" | "2603" | "2604" | "2605" | "2606" | "2610" | "2611" | "2612" | "2613" | "2614" | "2615" | "2616" | "2620" | "2621" | "2622" | "2623" | "2624" | "2625" | "2626" | "2630" | "2631" | "2632" | "2633" | "2634" | "2635" | "2636" | "2640" | "2641" | "2642" | "2643" | "2644" | "2645" | "2646" | "2650" | "2651" | "2652" | "2653" | "2654" | "2655" | "2656" | "2660" | "2661" | "2662" | "2663" | "2664" | "2665" | "2666" | "3000" | "3001" | "3002" | "3003" | "3004" | "3005" | "3006" | "3010" | "3011" | "3012" | "3013" | "3014" | "3015" | "3016" | "3020" | "3021" | "3022" | "3023" | "3024" | "3025" | "3026" | "3030" | "3031" | "3032" | "3033" | "3034" | "3035" | "3036" | "3040" | "3041" | "3042" | "3043" | "3044" | "3045" | "3046" | "3050" | "3051" | "3052" | "3053" | "3054" | "3055" | "3056" | "3060" | "3061" | "3062" | "3063" | "3064" | "3065" | "3066" | "3100" | "3101" | "3102" | "3103" | "3104" | "3105" | "3106" | "3110" | "3111" | "3112" | "3113" | "3114" | "3115" | "3116" | "3120" | "3121" | "3122" | "3123" | "3124" | "3125" | "3126" | "3130" | "3131" | "3132" | "3133" | "3134" | "3135" | "3136" | "3140" | "3141" | "3142" | "3143" | "3144" | "3145" | "3146" | "3150" | "3151" | "3152" | "3153" | "3154" | "3155" | "3156" | "3160" | "3161" | "3162" | "3163" | "3164" | "3165" | "3166" | "3200" | "3201" | "3202" | "3203" | "3204" | "3205" | "3206" | "3210" | "3211" | "3212" | "3213" | "3214" | "3215" | "3216" | "3220" | "3221" | "3222" | "3223" | "3224" | "3225" | "3226" | "3230" | "3231" | "3232" | "3233" | "3234" | "3235" | "3236" | "3240" | "3241" | "3242" | "3243" | "3244" | "3245" | "3246" | "3250" | "3251" | "3252" | "3253" | "3254" | "3255" | "3256" | "3260" | "3261" | "3262" | "3263" | "3264" | "3265" | "3266" | "3300" | "3301" | "3302" | "3303" | "3304" | "3305" | "3306" | "3310" | "3311" | "3312" | "3313" | "3314" | "3315" | "3316" | "3320" | "3321" | "3322" | "3323" | "3324" | "3325" | "3326" | "3330" | "3331" | "3332" | "3333" | "3334" | "3335" | "3336" | "3340" | "3341" | "3342" | "3343" | "3344" | "3345" | "3346" | "3350" | "3351" | "3352" | "3353" | "3354" | "3355" | "3356" | "3360" | "3361" | "3362" | "3363" | "3364" | "3365" | "3366" | "3400" | "3401" | "3402" | "3403" | "3404" | "3405" | "3406" | "3410" | "3411" | "3412" | "3413" | "3414" | "3415" | "3416" | "3420" | "3421" | "3422" | "3423" | "3424" | "3425" | "3426" | "3430" | "3431" | "3432" | "3433" | "3434" | "3435" | "3436" | "3440" | "3441" | "3442" | "3443" | "3444" | "3445" | "3446" | "3450" | "3451" | "3452" | "3453" | "3454" | "3455" | "3456" | "3460" | "3461" | "3462" | "3463" | "3464" | "3465" | "3466" | "3500" | "3501" | "3502" | "3503" | "3504" | "3505" | "3506" | "3510" | "3511" | "3512" | "3513" | "3514" | "3515" | "3516" | "3520" | "3521" | "3522" | "3523" | "3524" | "3525" | "3526" | "3530" | "3531" | "3532" | "3533" | "3534" | "3535" | "3536" | "3540" | "3541" | "3542" | "3543" | "3544" | "3545" | "3546" | "3550" | "3551" | "3552" | "3553" | "3554" | "3555" | "3556" | "3560" | "3561" | "3562" | "3563" | "3564" | "3565" | "3566" | "3600" | "3601" | "3602" | "3603" | "3604" | "3605" | "3606" | "3610" | "3611" | "3612" | "3613" | "3614" | "3615" | "3616" | "3620" | "3621" | "3622" | "3623" | "3624" | "3625" | "3626" | "3630" | "3631" | "3632" | "3633" | "3634" | "3635" | "3636" | "3640" | "3641" | "3642" | "3643" | "3644" | "3645" | "3646" | "3650" | "3651" | "3652" | "3653" | "3654" | "3655" | "3656" | "3660" | "3661" | "3662" | "3663" | "3664" | "3665" | "3666" | undefined) & T2 + +x = y4; +>x = y4 : ("0000" | "0001" | "0002" | "0003" | "0004" | "0005" | "0006" | "0010" | "0011" | "0012" | "0013" | "0014" | "0015" | "0016" | "0020" | "0021" | "0022" | "0023" | "0024" | "0025" | "0026" | "0030" | "0031" | "0032" | "0033" | "0034" | "0035" | "0036" | "0040" | "0041" | "0042" | "0043" | "0044" | "0045" | "0046" | "0050" | "0051" | "0052" | "0053" | "0054" | "0055" | "0056" | "0060" | "0061" | "0062" | "0063" | "0064" | "0065" | "0066" | "0100" | "0101" | "0102" | "0103" | "0104" | "0105" | "0106" | "0110" | "0111" | "0112" | "0113" | "0114" | "0115" | "0116" | "0120" | "0121" | "0122" | "0123" | "0124" | "0125" | "0126" | "0130" | "0131" | "0132" | "0133" | "0134" | "0135" | "0136" | "0140" | "0141" | "0142" | "0143" | "0144" | "0145" | "0146" | "0150" | "0151" | "0152" | "0153" | "0154" | "0155" | "0156" | "0160" | "0161" | "0162" | "0163" | "0164" | "0165" | "0166" | "0200" | "0201" | "0202" | "0203" | "0204" | "0205" | "0206" | "0210" | "0211" | "0212" | "0213" | "0214" | "0215" | "0216" | "0220" | "0221" | "0222" | "0223" | "0224" | "0225" | "0226" | "0230" | "0231" | "0232" | "0233" | "0234" | "0235" | "0236" | "0240" | "0241" | "0242" | "0243" | "0244" | "0245" | "0246" | "0250" | "0251" | "0252" | "0253" | "0254" | "0255" | "0256" | "0260" | "0261" | "0262" | "0263" | "0264" | "0265" | "0266" | "0300" | "0301" | "0302" | "0303" | "0304" | "0305" | "0306" | "0310" | "0311" | "0312" | "0313" | "0314" | "0315" | "0316" | "0320" | "0321" | "0322" | "0323" | "0324" | "0325" | "0326" | "0330" | "0331" | "0332" | "0333" | "0334" | "0335" | "0336" | "0340" | "0341" | "0342" | "0343" | "0344" | "0345" | "0346" | "0350" | "0351" | "0352" | "0353" | "0354" | "0355" | "0356" | "0360" | "0361" | "0362" | "0363" | "0364" | "0365" | "0366" | "0400" | "0401" | "0402" | "0403" | "0404" | "0405" | "0406" | "0410" | "0411" | "0412" | "0413" | "0414" | "0415" | "0416" | "0420" | "0421" | "0422" | "0423" | "0424" | "0425" | "0426" | "0430" | "0431" | "0432" | "0433" | "0434" | "0435" | "0436" | "0440" | "0441" | "0442" | "0443" | "0444" | "0445" | "0446" | "0450" | "0451" | "0452" | "0453" | "0454" | "0455" | "0456" | "0460" | "0461" | "0462" | "0463" | "0464" | "0465" | "0466" | "0500" | "0501" | "0502" | "0503" | "0504" | "0505" | "0506" | "0510" | "0511" | "0512" | "0513" | "0514" | "0515" | "0516" | "0520" | "0521" | "0522" | "0523" | "0524" | "0525" | "0526" | "0530" | "0531" | "0532" | "0533" | "0534" | "0535" | "0536" | "0540" | "0541" | "0542" | "0543" | "0544" | "0545" | "0546" | "0550" | "0551" | "0552" | "0553" | "0554" | "0555" | "0556" | "0560" | "0561" | "0562" | "0563" | "0564" | "0565" | "0566" | "0600" | "0601" | "0602" | "0603" | "0604" | "0605" | "0606" | "0610" | "0611" | "0612" | "0613" | "0614" | "0615" | "0616" | "0620" | "0621" | "0622" | "0623" | "0624" | "0625" | "0626" | "0630" | "0631" | "0632" | "0633" | "0634" | "0635" | "0636" | "0640" | "0641" | "0642" | "0643" | "0644" | "0645" | "0646" | "0650" | "0651" | "0652" | "0653" | "0654" | "0655" | "0656" | "0660" | "0661" | "0662" | "0663" | "0664" | "0665" | "0666" | "1000" | "1001" | "1002" | "1003" | "1004" | "1005" | "1006" | "1010" | "1011" | "1012" | "1013" | "1014" | "1015" | "1016" | "1020" | "1021" | "1022" | "1023" | "1024" | "1025" | "1026" | "1030" | "1031" | "1032" | "1033" | "1034" | "1035" | "1036" | "1040" | "1041" | "1042" | "1043" | "1044" | "1045" | "1046" | "1050" | "1051" | "1052" | "1053" | "1054" | "1055" | "1056" | "1060" | "1061" | "1062" | "1063" | "1064" | "1065" | "1066" | "1100" | "1101" | "1102" | "1103" | "1104" | "1105" | "1106" | "1110" | "1111" | "1112" | "1113" | "1114" | "1115" | "1116" | "1120" | "1121" | "1122" | "1123" | "1124" | "1125" | "1126" | "1130" | "1131" | "1132" | "1133" | "1134" | "1135" | "1136" | "1140" | "1141" | "1142" | "1143" | "1144" | "1145" | "1146" | "1150" | "1151" | "1152" | "1153" | "1154" | "1155" | "1156" | "1160" | "1161" | "1162" | "1163" | "1164" | "1165" | "1166" | "1200" | "1201" | "1202" | "1203" | "1204" | "1205" | "1206" | "1210" | "1211" | "1212" | "1213" | "1214" | "1215" | "1216" | "1220" | "1221" | "1222" | "1223" | "1224" | "1225" | "1226" | "1230" | "1231" | "1232" | "1233" | "1234" | "1235" | "1236" | "1240" | "1241" | "1242" | "1243" | "1244" | "1245" | "1246" | "1250" | "1251" | "1252" | "1253" | "1254" | "1255" | "1256" | "1260" | "1261" | "1262" | "1263" | "1264" | "1265" | "1266" | "1300" | "1301" | "1302" | "1303" | "1304" | "1305" | "1306" | "1310" | "1311" | "1312" | "1313" | "1314" | "1315" | "1316" | "1320" | "1321" | "1322" | "1323" | "1324" | "1325" | "1326" | "1330" | "1331" | "1332" | "1333" | "1334" | "1335" | "1336" | "1340" | "1341" | "1342" | "1343" | "1344" | "1345" | "1346" | "1350" | "1351" | "1352" | "1353" | "1354" | "1355" | "1356" | "1360" | "1361" | "1362" | "1363" | "1364" | "1365" | "1366" | "1400" | "1401" | "1402" | "1403" | "1404" | "1405" | "1406" | "1410" | "1411" | "1412" | "1413" | "1414" | "1415" | "1416" | "1420" | "1421" | "1422" | "1423" | "1424" | "1425" | "1426" | "1430" | "1431" | "1432" | "1433" | "1434" | "1435" | "1436" | "1440" | "1441" | "1442" | "1443" | "1444" | "1445" | "1446" | "1450" | "1451" | "1452" | "1453" | "1454" | "1455" | "1456" | "1460" | "1461" | "1462" | "1463" | "1464" | "1465" | "1466" | "1500" | "1501" | "1502" | "1503" | "1504" | "1505" | "1506" | "1510" | "1511" | "1512" | "1513" | "1514" | "1515" | "1516" | "1520" | "1521" | "1522" | "1523" | "1524" | "1525" | "1526" | "1530" | "1531" | "1532" | "1533" | "1534" | "1535" | "1536" | "1540" | "1541" | "1542" | "1543" | "1544" | "1545" | "1546" | "1550" | "1551" | "1552" | "1553" | "1554" | "1555" | "1556" | "1560" | "1561" | "1562" | "1563" | "1564" | "1565" | "1566" | "1600" | "1601" | "1602" | "1603" | "1604" | "1605" | "1606" | "1610" | "1611" | "1612" | "1613" | "1614" | "1615" | "1616" | "1620" | "1621" | "1622" | "1623" | "1624" | "1625" | "1626" | "1630" | "1631" | "1632" | "1633" | "1634" | "1635" | "1636" | "1640" | "1641" | "1642" | "1643" | "1644" | "1645" | "1646" | "1650" | "1651" | "1652" | "1653" | "1654" | "1655" | "1656" | "1660" | "1661" | "1662" | "1663" | "1664" | "1665" | "1666" | "2000" | "2001" | "2002" | "2003" | "2004" | "2005" | "2006" | "2010" | "2011" | "2012" | "2013" | "2014" | "2015" | "2016" | "2020" | "2021" | "2022" | "2023" | "2024" | "2025" | "2026" | "2030" | "2031" | "2032" | "2033" | "2034" | "2035" | "2036" | "2040" | "2041" | "2042" | "2043" | "2044" | "2045" | "2046" | "2050" | "2051" | "2052" | "2053" | "2054" | "2055" | "2056" | "2060" | "2061" | "2062" | "2063" | "2064" | "2065" | "2066" | "2100" | "2101" | "2102" | "2103" | "2104" | "2105" | "2106" | "2110" | "2111" | "2112" | "2113" | "2114" | "2115" | "2116" | "2120" | "2121" | "2122" | "2123" | "2124" | "2125" | "2126" | "2130" | "2131" | "2132" | "2133" | "2134" | "2135" | "2136" | "2140" | "2141" | "2142" | "2143" | "2144" | "2145" | "2146" | "2150" | "2151" | "2152" | "2153" | "2154" | "2155" | "2156" | "2160" | "2161" | "2162" | "2163" | "2164" | "2165" | "2166" | "2200" | "2201" | "2202" | "2203" | "2204" | "2205" | "2206" | "2210" | "2211" | "2212" | "2213" | "2214" | "2215" | "2216" | "2220" | "2221" | "2222" | "2223" | "2224" | "2225" | "2226" | "2230" | "2231" | "2232" | "2233" | "2234" | "2235" | "2236" | "2240" | "2241" | "2242" | "2243" | "2244" | "2245" | "2246" | "2250" | "2251" | "2252" | "2253" | "2254" | "2255" | "2256" | "2260" | "2261" | "2262" | "2263" | "2264" | "2265" | "2266" | "2300" | "2301" | "2302" | "2303" | "2304" | "2305" | "2306" | "2310" | "2311" | "2312" | "2313" | "2314" | "2315" | "2316" | "2320" | "2321" | "2322" | "2323" | "2324" | "2325" | "2326" | "2330" | "2331" | "2332" | "2333" | "2334" | "2335" | "2336" | "2340" | "2341" | "2342" | "2343" | "2344" | "2345" | "2346" | "2350" | "2351" | "2352" | "2353" | "2354" | "2355" | "2356" | "2360" | "2361" | "2362" | "2363" | "2364" | "2365" | "2366" | "2400" | "2401" | "2402" | "2403" | "2404" | "2405" | "2406" | "2410" | "2411" | "2412" | "2413" | "2414" | "2415" | "2416" | "2420" | "2421" | "2422" | "2423" | "2424" | "2425" | "2426" | "2430" | "2431" | "2432" | "2433" | "2434" | "2435" | "2436" | "2440" | "2441" | "2442" | "2443" | "2444" | "2445" | "2446" | "2450" | "2451" | "2452" | "2453" | "2454" | "2455" | "2456" | "2460" | "2461" | "2462" | "2463" | "2464" | "2465" | "2466" | "2500" | "2501" | "2502" | "2503" | "2504" | "2505" | "2506" | "2510" | "2511" | "2512" | "2513" | "2514" | "2515" | "2516" | "2520" | "2521" | "2522" | "2523" | "2524" | "2525" | "2526" | "2530" | "2531" | "2532" | "2533" | "2534" | "2535" | "2536" | "2540" | "2541" | "2542" | "2543" | "2544" | "2545" | "2546" | "2550" | "2551" | "2552" | "2553" | "2554" | "2555" | "2556" | "2560" | "2561" | "2562" | "2563" | "2564" | "2565" | "2566" | "2600" | "2601" | "2602" | "2603" | "2604" | "2605" | "2606" | "2610" | "2611" | "2612" | "2613" | "2614" | "2615" | "2616" | "2620" | "2621" | "2622" | "2623" | "2624" | "2625" | "2626" | "2630" | "2631" | "2632" | "2633" | "2634" | "2635" | "2636" | "2640" | "2641" | "2642" | "2643" | "2644" | "2645" | "2646" | "2650" | "2651" | "2652" | "2653" | "2654" | "2655" | "2656" | "2660" | "2661" | "2662" | "2663" | "2664" | "2665" | "2666" | "3000" | "3001" | "3002" | "3003" | "3004" | "3005" | "3006" | "3010" | "3011" | "3012" | "3013" | "3014" | "3015" | "3016" | "3020" | "3021" | "3022" | "3023" | "3024" | "3025" | "3026" | "3030" | "3031" | "3032" | "3033" | "3034" | "3035" | "3036" | "3040" | "3041" | "3042" | "3043" | "3044" | "3045" | "3046" | "3050" | "3051" | "3052" | "3053" | "3054" | "3055" | "3056" | "3060" | "3061" | "3062" | "3063" | "3064" | "3065" | "3066" | "3100" | "3101" | "3102" | "3103" | "3104" | "3105" | "3106" | "3110" | "3111" | "3112" | "3113" | "3114" | "3115" | "3116" | "3120" | "3121" | "3122" | "3123" | "3124" | "3125" | "3126" | "3130" | "3131" | "3132" | "3133" | "3134" | "3135" | "3136" | "3140" | "3141" | "3142" | "3143" | "3144" | "3145" | "3146" | "3150" | "3151" | "3152" | "3153" | "3154" | "3155" | "3156" | "3160" | "3161" | "3162" | "3163" | "3164" | "3165" | "3166" | "3200" | "3201" | "3202" | "3203" | "3204" | "3205" | "3206" | "3210" | "3211" | "3212" | "3213" | "3214" | "3215" | "3216" | "3220" | "3221" | "3222" | "3223" | "3224" | "3225" | "3226" | "3230" | "3231" | "3232" | "3233" | "3234" | "3235" | "3236" | "3240" | "3241" | "3242" | "3243" | "3244" | "3245" | "3246" | "3250" | "3251" | "3252" | "3253" | "3254" | "3255" | "3256" | "3260" | "3261" | "3262" | "3263" | "3264" | "3265" | "3266" | "3300" | "3301" | "3302" | "3303" | "3304" | "3305" | "3306" | "3310" | "3311" | "3312" | "3313" | "3314" | "3315" | "3316" | "3320" | "3321" | "3322" | "3323" | "3324" | "3325" | "3326" | "3330" | "3331" | "3332" | "3333" | "3334" | "3335" | "3336" | "3340" | "3341" | "3342" | "3343" | "3344" | "3345" | "3346" | "3350" | "3351" | "3352" | "3353" | "3354" | "3355" | "3356" | "3360" | "3361" | "3362" | "3363" | "3364" | "3365" | "3366" | "3400" | "3401" | "3402" | "3403" | "3404" | "3405" | "3406" | "3410" | "3411" | "3412" | "3413" | "3414" | "3415" | "3416" | "3420" | "3421" | "3422" | "3423" | "3424" | "3425" | "3426" | "3430" | "3431" | "3432" | "3433" | "3434" | "3435" | "3436" | "3440" | "3441" | "3442" | "3443" | "3444" | "3445" | "3446" | "3450" | "3451" | "3452" | "3453" | "3454" | "3455" | "3456" | "3460" | "3461" | "3462" | "3463" | "3464" | "3465" | "3466" | "3500" | "3501" | "3502" | "3503" | "3504" | "3505" | "3506" | "3510" | "3511" | "3512" | "3513" | "3514" | "3515" | "3516" | "3520" | "3521" | "3522" | "3523" | "3524" | "3525" | "3526" | "3530" | "3531" | "3532" | "3533" | "3534" | "3535" | "3536" | "3540" | "3541" | "3542" | "3543" | "3544" | "3545" | "3546" | "3550" | "3551" | "3552" | "3553" | "3554" | "3555" | "3556" | "3560" | "3561" | "3562" | "3563" | "3564" | "3565" | "3566" | "3600" | "3601" | "3602" | "3603" | "3604" | "3605" | "3606" | "3610" | "3611" | "3612" | "3613" | "3614" | "3615" | "3616" | "3620" | "3621" | "3622" | "3623" | "3624" | "3625" | "3626" | "3630" | "3631" | "3632" | "3633" | "3634" | "3635" | "3636" | "3640" | "3641" | "3642" | "3643" | "3644" | "3645" | "3646" | "3650" | "3651" | "3652" | "3653" | "3654" | "3655" | "3656" | "3660" | "3661" | "3662" | "3663" | "3664" | "3665" | "3666" | undefined) & T2 +>x : T1 | null +>y4 : ("0000" | "0001" | "0002" | "0003" | "0004" | "0005" | "0006" | "0010" | "0011" | "0012" | "0013" | "0014" | "0015" | "0016" | "0020" | "0021" | "0022" | "0023" | "0024" | "0025" | "0026" | "0030" | "0031" | "0032" | "0033" | "0034" | "0035" | "0036" | "0040" | "0041" | "0042" | "0043" | "0044" | "0045" | "0046" | "0050" | "0051" | "0052" | "0053" | "0054" | "0055" | "0056" | "0060" | "0061" | "0062" | "0063" | "0064" | "0065" | "0066" | "0100" | "0101" | "0102" | "0103" | "0104" | "0105" | "0106" | "0110" | "0111" | "0112" | "0113" | "0114" | "0115" | "0116" | "0120" | "0121" | "0122" | "0123" | "0124" | "0125" | "0126" | "0130" | "0131" | "0132" | "0133" | "0134" | "0135" | "0136" | "0140" | "0141" | "0142" | "0143" | "0144" | "0145" | "0146" | "0150" | "0151" | "0152" | "0153" | "0154" | "0155" | "0156" | "0160" | "0161" | "0162" | "0163" | "0164" | "0165" | "0166" | "0200" | "0201" | "0202" | "0203" | "0204" | "0205" | "0206" | "0210" | "0211" | "0212" | "0213" | "0214" | "0215" | "0216" | "0220" | "0221" | "0222" | "0223" | "0224" | "0225" | "0226" | "0230" | "0231" | "0232" | "0233" | "0234" | "0235" | "0236" | "0240" | "0241" | "0242" | "0243" | "0244" | "0245" | "0246" | "0250" | "0251" | "0252" | "0253" | "0254" | "0255" | "0256" | "0260" | "0261" | "0262" | "0263" | "0264" | "0265" | "0266" | "0300" | "0301" | "0302" | "0303" | "0304" | "0305" | "0306" | "0310" | "0311" | "0312" | "0313" | "0314" | "0315" | "0316" | "0320" | "0321" | "0322" | "0323" | "0324" | "0325" | "0326" | "0330" | "0331" | "0332" | "0333" | "0334" | "0335" | "0336" | "0340" | "0341" | "0342" | "0343" | "0344" | "0345" | "0346" | "0350" | "0351" | "0352" | "0353" | "0354" | "0355" | "0356" | "0360" | "0361" | "0362" | "0363" | "0364" | "0365" | "0366" | "0400" | "0401" | "0402" | "0403" | "0404" | "0405" | "0406" | "0410" | "0411" | "0412" | "0413" | "0414" | "0415" | "0416" | "0420" | "0421" | "0422" | "0423" | "0424" | "0425" | "0426" | "0430" | "0431" | "0432" | "0433" | "0434" | "0435" | "0436" | "0440" | "0441" | "0442" | "0443" | "0444" | "0445" | "0446" | "0450" | "0451" | "0452" | "0453" | "0454" | "0455" | "0456" | "0460" | "0461" | "0462" | "0463" | "0464" | "0465" | "0466" | "0500" | "0501" | "0502" | "0503" | "0504" | "0505" | "0506" | "0510" | "0511" | "0512" | "0513" | "0514" | "0515" | "0516" | "0520" | "0521" | "0522" | "0523" | "0524" | "0525" | "0526" | "0530" | "0531" | "0532" | "0533" | "0534" | "0535" | "0536" | "0540" | "0541" | "0542" | "0543" | "0544" | "0545" | "0546" | "0550" | "0551" | "0552" | "0553" | "0554" | "0555" | "0556" | "0560" | "0561" | "0562" | "0563" | "0564" | "0565" | "0566" | "0600" | "0601" | "0602" | "0603" | "0604" | "0605" | "0606" | "0610" | "0611" | "0612" | "0613" | "0614" | "0615" | "0616" | "0620" | "0621" | "0622" | "0623" | "0624" | "0625" | "0626" | "0630" | "0631" | "0632" | "0633" | "0634" | "0635" | "0636" | "0640" | "0641" | "0642" | "0643" | "0644" | "0645" | "0646" | "0650" | "0651" | "0652" | "0653" | "0654" | "0655" | "0656" | "0660" | "0661" | "0662" | "0663" | "0664" | "0665" | "0666" | "1000" | "1001" | "1002" | "1003" | "1004" | "1005" | "1006" | "1010" | "1011" | "1012" | "1013" | "1014" | "1015" | "1016" | "1020" | "1021" | "1022" | "1023" | "1024" | "1025" | "1026" | "1030" | "1031" | "1032" | "1033" | "1034" | "1035" | "1036" | "1040" | "1041" | "1042" | "1043" | "1044" | "1045" | "1046" | "1050" | "1051" | "1052" | "1053" | "1054" | "1055" | "1056" | "1060" | "1061" | "1062" | "1063" | "1064" | "1065" | "1066" | "1100" | "1101" | "1102" | "1103" | "1104" | "1105" | "1106" | "1110" | "1111" | "1112" | "1113" | "1114" | "1115" | "1116" | "1120" | "1121" | "1122" | "1123" | "1124" | "1125" | "1126" | "1130" | "1131" | "1132" | "1133" | "1134" | "1135" | "1136" | "1140" | "1141" | "1142" | "1143" | "1144" | "1145" | "1146" | "1150" | "1151" | "1152" | "1153" | "1154" | "1155" | "1156" | "1160" | "1161" | "1162" | "1163" | "1164" | "1165" | "1166" | "1200" | "1201" | "1202" | "1203" | "1204" | "1205" | "1206" | "1210" | "1211" | "1212" | "1213" | "1214" | "1215" | "1216" | "1220" | "1221" | "1222" | "1223" | "1224" | "1225" | "1226" | "1230" | "1231" | "1232" | "1233" | "1234" | "1235" | "1236" | "1240" | "1241" | "1242" | "1243" | "1244" | "1245" | "1246" | "1250" | "1251" | "1252" | "1253" | "1254" | "1255" | "1256" | "1260" | "1261" | "1262" | "1263" | "1264" | "1265" | "1266" | "1300" | "1301" | "1302" | "1303" | "1304" | "1305" | "1306" | "1310" | "1311" | "1312" | "1313" | "1314" | "1315" | "1316" | "1320" | "1321" | "1322" | "1323" | "1324" | "1325" | "1326" | "1330" | "1331" | "1332" | "1333" | "1334" | "1335" | "1336" | "1340" | "1341" | "1342" | "1343" | "1344" | "1345" | "1346" | "1350" | "1351" | "1352" | "1353" | "1354" | "1355" | "1356" | "1360" | "1361" | "1362" | "1363" | "1364" | "1365" | "1366" | "1400" | "1401" | "1402" | "1403" | "1404" | "1405" | "1406" | "1410" | "1411" | "1412" | "1413" | "1414" | "1415" | "1416" | "1420" | "1421" | "1422" | "1423" | "1424" | "1425" | "1426" | "1430" | "1431" | "1432" | "1433" | "1434" | "1435" | "1436" | "1440" | "1441" | "1442" | "1443" | "1444" | "1445" | "1446" | "1450" | "1451" | "1452" | "1453" | "1454" | "1455" | "1456" | "1460" | "1461" | "1462" | "1463" | "1464" | "1465" | "1466" | "1500" | "1501" | "1502" | "1503" | "1504" | "1505" | "1506" | "1510" | "1511" | "1512" | "1513" | "1514" | "1515" | "1516" | "1520" | "1521" | "1522" | "1523" | "1524" | "1525" | "1526" | "1530" | "1531" | "1532" | "1533" | "1534" | "1535" | "1536" | "1540" | "1541" | "1542" | "1543" | "1544" | "1545" | "1546" | "1550" | "1551" | "1552" | "1553" | "1554" | "1555" | "1556" | "1560" | "1561" | "1562" | "1563" | "1564" | "1565" | "1566" | "1600" | "1601" | "1602" | "1603" | "1604" | "1605" | "1606" | "1610" | "1611" | "1612" | "1613" | "1614" | "1615" | "1616" | "1620" | "1621" | "1622" | "1623" | "1624" | "1625" | "1626" | "1630" | "1631" | "1632" | "1633" | "1634" | "1635" | "1636" | "1640" | "1641" | "1642" | "1643" | "1644" | "1645" | "1646" | "1650" | "1651" | "1652" | "1653" | "1654" | "1655" | "1656" | "1660" | "1661" | "1662" | "1663" | "1664" | "1665" | "1666" | "2000" | "2001" | "2002" | "2003" | "2004" | "2005" | "2006" | "2010" | "2011" | "2012" | "2013" | "2014" | "2015" | "2016" | "2020" | "2021" | "2022" | "2023" | "2024" | "2025" | "2026" | "2030" | "2031" | "2032" | "2033" | "2034" | "2035" | "2036" | "2040" | "2041" | "2042" | "2043" | "2044" | "2045" | "2046" | "2050" | "2051" | "2052" | "2053" | "2054" | "2055" | "2056" | "2060" | "2061" | "2062" | "2063" | "2064" | "2065" | "2066" | "2100" | "2101" | "2102" | "2103" | "2104" | "2105" | "2106" | "2110" | "2111" | "2112" | "2113" | "2114" | "2115" | "2116" | "2120" | "2121" | "2122" | "2123" | "2124" | "2125" | "2126" | "2130" | "2131" | "2132" | "2133" | "2134" | "2135" | "2136" | "2140" | "2141" | "2142" | "2143" | "2144" | "2145" | "2146" | "2150" | "2151" | "2152" | "2153" | "2154" | "2155" | "2156" | "2160" | "2161" | "2162" | "2163" | "2164" | "2165" | "2166" | "2200" | "2201" | "2202" | "2203" | "2204" | "2205" | "2206" | "2210" | "2211" | "2212" | "2213" | "2214" | "2215" | "2216" | "2220" | "2221" | "2222" | "2223" | "2224" | "2225" | "2226" | "2230" | "2231" | "2232" | "2233" | "2234" | "2235" | "2236" | "2240" | "2241" | "2242" | "2243" | "2244" | "2245" | "2246" | "2250" | "2251" | "2252" | "2253" | "2254" | "2255" | "2256" | "2260" | "2261" | "2262" | "2263" | "2264" | "2265" | "2266" | "2300" | "2301" | "2302" | "2303" | "2304" | "2305" | "2306" | "2310" | "2311" | "2312" | "2313" | "2314" | "2315" | "2316" | "2320" | "2321" | "2322" | "2323" | "2324" | "2325" | "2326" | "2330" | "2331" | "2332" | "2333" | "2334" | "2335" | "2336" | "2340" | "2341" | "2342" | "2343" | "2344" | "2345" | "2346" | "2350" | "2351" | "2352" | "2353" | "2354" | "2355" | "2356" | "2360" | "2361" | "2362" | "2363" | "2364" | "2365" | "2366" | "2400" | "2401" | "2402" | "2403" | "2404" | "2405" | "2406" | "2410" | "2411" | "2412" | "2413" | "2414" | "2415" | "2416" | "2420" | "2421" | "2422" | "2423" | "2424" | "2425" | "2426" | "2430" | "2431" | "2432" | "2433" | "2434" | "2435" | "2436" | "2440" | "2441" | "2442" | "2443" | "2444" | "2445" | "2446" | "2450" | "2451" | "2452" | "2453" | "2454" | "2455" | "2456" | "2460" | "2461" | "2462" | "2463" | "2464" | "2465" | "2466" | "2500" | "2501" | "2502" | "2503" | "2504" | "2505" | "2506" | "2510" | "2511" | "2512" | "2513" | "2514" | "2515" | "2516" | "2520" | "2521" | "2522" | "2523" | "2524" | "2525" | "2526" | "2530" | "2531" | "2532" | "2533" | "2534" | "2535" | "2536" | "2540" | "2541" | "2542" | "2543" | "2544" | "2545" | "2546" | "2550" | "2551" | "2552" | "2553" | "2554" | "2555" | "2556" | "2560" | "2561" | "2562" | "2563" | "2564" | "2565" | "2566" | "2600" | "2601" | "2602" | "2603" | "2604" | "2605" | "2606" | "2610" | "2611" | "2612" | "2613" | "2614" | "2615" | "2616" | "2620" | "2621" | "2622" | "2623" | "2624" | "2625" | "2626" | "2630" | "2631" | "2632" | "2633" | "2634" | "2635" | "2636" | "2640" | "2641" | "2642" | "2643" | "2644" | "2645" | "2646" | "2650" | "2651" | "2652" | "2653" | "2654" | "2655" | "2656" | "2660" | "2661" | "2662" | "2663" | "2664" | "2665" | "2666" | "3000" | "3001" | "3002" | "3003" | "3004" | "3005" | "3006" | "3010" | "3011" | "3012" | "3013" | "3014" | "3015" | "3016" | "3020" | "3021" | "3022" | "3023" | "3024" | "3025" | "3026" | "3030" | "3031" | "3032" | "3033" | "3034" | "3035" | "3036" | "3040" | "3041" | "3042" | "3043" | "3044" | "3045" | "3046" | "3050" | "3051" | "3052" | "3053" | "3054" | "3055" | "3056" | "3060" | "3061" | "3062" | "3063" | "3064" | "3065" | "3066" | "3100" | "3101" | "3102" | "3103" | "3104" | "3105" | "3106" | "3110" | "3111" | "3112" | "3113" | "3114" | "3115" | "3116" | "3120" | "3121" | "3122" | "3123" | "3124" | "3125" | "3126" | "3130" | "3131" | "3132" | "3133" | "3134" | "3135" | "3136" | "3140" | "3141" | "3142" | "3143" | "3144" | "3145" | "3146" | "3150" | "3151" | "3152" | "3153" | "3154" | "3155" | "3156" | "3160" | "3161" | "3162" | "3163" | "3164" | "3165" | "3166" | "3200" | "3201" | "3202" | "3203" | "3204" | "3205" | "3206" | "3210" | "3211" | "3212" | "3213" | "3214" | "3215" | "3216" | "3220" | "3221" | "3222" | "3223" | "3224" | "3225" | "3226" | "3230" | "3231" | "3232" | "3233" | "3234" | "3235" | "3236" | "3240" | "3241" | "3242" | "3243" | "3244" | "3245" | "3246" | "3250" | "3251" | "3252" | "3253" | "3254" | "3255" | "3256" | "3260" | "3261" | "3262" | "3263" | "3264" | "3265" | "3266" | "3300" | "3301" | "3302" | "3303" | "3304" | "3305" | "3306" | "3310" | "3311" | "3312" | "3313" | "3314" | "3315" | "3316" | "3320" | "3321" | "3322" | "3323" | "3324" | "3325" | "3326" | "3330" | "3331" | "3332" | "3333" | "3334" | "3335" | "3336" | "3340" | "3341" | "3342" | "3343" | "3344" | "3345" | "3346" | "3350" | "3351" | "3352" | "3353" | "3354" | "3355" | "3356" | "3360" | "3361" | "3362" | "3363" | "3364" | "3365" | "3366" | "3400" | "3401" | "3402" | "3403" | "3404" | "3405" | "3406" | "3410" | "3411" | "3412" | "3413" | "3414" | "3415" | "3416" | "3420" | "3421" | "3422" | "3423" | "3424" | "3425" | "3426" | "3430" | "3431" | "3432" | "3433" | "3434" | "3435" | "3436" | "3440" | "3441" | "3442" | "3443" | "3444" | "3445" | "3446" | "3450" | "3451" | "3452" | "3453" | "3454" | "3455" | "3456" | "3460" | "3461" | "3462" | "3463" | "3464" | "3465" | "3466" | "3500" | "3501" | "3502" | "3503" | "3504" | "3505" | "3506" | "3510" | "3511" | "3512" | "3513" | "3514" | "3515" | "3516" | "3520" | "3521" | "3522" | "3523" | "3524" | "3525" | "3526" | "3530" | "3531" | "3532" | "3533" | "3534" | "3535" | "3536" | "3540" | "3541" | "3542" | "3543" | "3544" | "3545" | "3546" | "3550" | "3551" | "3552" | "3553" | "3554" | "3555" | "3556" | "3560" | "3561" | "3562" | "3563" | "3564" | "3565" | "3566" | "3600" | "3601" | "3602" | "3603" | "3604" | "3605" | "3606" | "3610" | "3611" | "3612" | "3613" | "3614" | "3615" | "3616" | "3620" | "3621" | "3622" | "3623" | "3624" | "3625" | "3626" | "3630" | "3631" | "3632" | "3633" | "3634" | "3635" | "3636" | "3640" | "3641" | "3642" | "3643" | "3644" | "3645" | "3646" | "3650" | "3651" | "3652" | "3653" | "3654" | "3655" | "3656" | "3660" | "3661" | "3662" | "3663" | "3664" | "3665" | "3666" | undefined) & T2 + +declare const y5: (`${'0' | '1' | '2' | '3' | '4'}${D}${D}${D}` | undefined) & T2; +>y5 : ("0000" | "0001" | "0002" | "0003" | "0004" | "0005" | "0006" | "0010" | "0011" | "0012" | "0013" | "0014" | "0015" | "0016" | "0020" | "0021" | "0022" | "0023" | "0024" | "0025" | "0026" | "0030" | "0031" | "0032" | "0033" | "0034" | "0035" | "0036" | "0040" | "0041" | "0042" | "0043" | "0044" | "0045" | "0046" | "0050" | "0051" | "0052" | "0053" | "0054" | "0055" | "0056" | "0060" | "0061" | "0062" | "0063" | "0064" | "0065" | "0066" | "0100" | "0101" | "0102" | "0103" | "0104" | "0105" | "0106" | "0110" | "0111" | "0112" | "0113" | "0114" | "0115" | "0116" | "0120" | "0121" | "0122" | "0123" | "0124" | "0125" | "0126" | "0130" | "0131" | "0132" | "0133" | "0134" | "0135" | "0136" | "0140" | "0141" | "0142" | "0143" | "0144" | "0145" | "0146" | "0150" | "0151" | "0152" | "0153" | "0154" | "0155" | "0156" | "0160" | "0161" | "0162" | "0163" | "0164" | "0165" | "0166" | "0200" | "0201" | "0202" | "0203" | "0204" | "0205" | "0206" | "0210" | "0211" | "0212" | "0213" | "0214" | "0215" | "0216" | "0220" | "0221" | "0222" | "0223" | "0224" | "0225" | "0226" | "0230" | "0231" | "0232" | "0233" | "0234" | "0235" | "0236" | "0240" | "0241" | "0242" | "0243" | "0244" | "0245" | "0246" | "0250" | "0251" | "0252" | "0253" | "0254" | "0255" | "0256" | "0260" | "0261" | "0262" | "0263" | "0264" | "0265" | "0266" | "0300" | "0301" | "0302" | "0303" | "0304" | "0305" | "0306" | "0310" | "0311" | "0312" | "0313" | "0314" | "0315" | "0316" | "0320" | "0321" | "0322" | "0323" | "0324" | "0325" | "0326" | "0330" | "0331" | "0332" | "0333" | "0334" | "0335" | "0336" | "0340" | "0341" | "0342" | "0343" | "0344" | "0345" | "0346" | "0350" | "0351" | "0352" | "0353" | "0354" | "0355" | "0356" | "0360" | "0361" | "0362" | "0363" | "0364" | "0365" | "0366" | "0400" | "0401" | "0402" | "0403" | "0404" | "0405" | "0406" | "0410" | "0411" | "0412" | "0413" | "0414" | "0415" | "0416" | "0420" | "0421" | "0422" | "0423" | "0424" | "0425" | "0426" | "0430" | "0431" | "0432" | "0433" | "0434" | "0435" | "0436" | "0440" | "0441" | "0442" | "0443" | "0444" | "0445" | "0446" | "0450" | "0451" | "0452" | "0453" | "0454" | "0455" | "0456" | "0460" | "0461" | "0462" | "0463" | "0464" | "0465" | "0466" | "0500" | "0501" | "0502" | "0503" | "0504" | "0505" | "0506" | "0510" | "0511" | "0512" | "0513" | "0514" | "0515" | "0516" | "0520" | "0521" | "0522" | "0523" | "0524" | "0525" | "0526" | "0530" | "0531" | "0532" | "0533" | "0534" | "0535" | "0536" | "0540" | "0541" | "0542" | "0543" | "0544" | "0545" | "0546" | "0550" | "0551" | "0552" | "0553" | "0554" | "0555" | "0556" | "0560" | "0561" | "0562" | "0563" | "0564" | "0565" | "0566" | "0600" | "0601" | "0602" | "0603" | "0604" | "0605" | "0606" | "0610" | "0611" | "0612" | "0613" | "0614" | "0615" | "0616" | "0620" | "0621" | "0622" | "0623" | "0624" | "0625" | "0626" | "0630" | "0631" | "0632" | "0633" | "0634" | "0635" | "0636" | "0640" | "0641" | "0642" | "0643" | "0644" | "0645" | "0646" | "0650" | "0651" | "0652" | "0653" | "0654" | "0655" | "0656" | "0660" | "0661" | "0662" | "0663" | "0664" | "0665" | "0666" | "1000" | "1001" | "1002" | "1003" | "1004" | "1005" | "1006" | "1010" | "1011" | "1012" | "1013" | "1014" | "1015" | "1016" | "1020" | "1021" | "1022" | "1023" | "1024" | "1025" | "1026" | "1030" | "1031" | "1032" | "1033" | "1034" | "1035" | "1036" | "1040" | "1041" | "1042" | "1043" | "1044" | "1045" | "1046" | "1050" | "1051" | "1052" | "1053" | "1054" | "1055" | "1056" | "1060" | "1061" | "1062" | "1063" | "1064" | "1065" | "1066" | "1100" | "1101" | "1102" | "1103" | "1104" | "1105" | "1106" | "1110" | "1111" | "1112" | "1113" | "1114" | "1115" | "1116" | "1120" | "1121" | "1122" | "1123" | "1124" | "1125" | "1126" | "1130" | "1131" | "1132" | "1133" | "1134" | "1135" | "1136" | "1140" | "1141" | "1142" | "1143" | "1144" | "1145" | "1146" | "1150" | "1151" | "1152" | "1153" | "1154" | "1155" | "1156" | "1160" | "1161" | "1162" | "1163" | "1164" | "1165" | "1166" | "1200" | "1201" | "1202" | "1203" | "1204" | "1205" | "1206" | "1210" | "1211" | "1212" | "1213" | "1214" | "1215" | "1216" | "1220" | "1221" | "1222" | "1223" | "1224" | "1225" | "1226" | "1230" | "1231" | "1232" | "1233" | "1234" | "1235" | "1236" | "1240" | "1241" | "1242" | "1243" | "1244" | "1245" | "1246" | "1250" | "1251" | "1252" | "1253" | "1254" | "1255" | "1256" | "1260" | "1261" | "1262" | "1263" | "1264" | "1265" | "1266" | "1300" | "1301" | "1302" | "1303" | "1304" | "1305" | "1306" | "1310" | "1311" | "1312" | "1313" | "1314" | "1315" | "1316" | "1320" | "1321" | "1322" | "1323" | "1324" | "1325" | "1326" | "1330" | "1331" | "1332" | "1333" | "1334" | "1335" | "1336" | "1340" | "1341" | "1342" | "1343" | "1344" | "1345" | "1346" | "1350" | "1351" | "1352" | "1353" | "1354" | "1355" | "1356" | "1360" | "1361" | "1362" | "1363" | "1364" | "1365" | "1366" | "1400" | "1401" | "1402" | "1403" | "1404" | "1405" | "1406" | "1410" | "1411" | "1412" | "1413" | "1414" | "1415" | "1416" | "1420" | "1421" | "1422" | "1423" | "1424" | "1425" | "1426" | "1430" | "1431" | "1432" | "1433" | "1434" | "1435" | "1436" | "1440" | "1441" | "1442" | "1443" | "1444" | "1445" | "1446" | "1450" | "1451" | "1452" | "1453" | "1454" | "1455" | "1456" | "1460" | "1461" | "1462" | "1463" | "1464" | "1465" | "1466" | "1500" | "1501" | "1502" | "1503" | "1504" | "1505" | "1506" | "1510" | "1511" | "1512" | "1513" | "1514" | "1515" | "1516" | "1520" | "1521" | "1522" | "1523" | "1524" | "1525" | "1526" | "1530" | "1531" | "1532" | "1533" | "1534" | "1535" | "1536" | "1540" | "1541" | "1542" | "1543" | "1544" | "1545" | "1546" | "1550" | "1551" | "1552" | "1553" | "1554" | "1555" | "1556" | "1560" | "1561" | "1562" | "1563" | "1564" | "1565" | "1566" | "1600" | "1601" | "1602" | "1603" | "1604" | "1605" | "1606" | "1610" | "1611" | "1612" | "1613" | "1614" | "1615" | "1616" | "1620" | "1621" | "1622" | "1623" | "1624" | "1625" | "1626" | "1630" | "1631" | "1632" | "1633" | "1634" | "1635" | "1636" | "1640" | "1641" | "1642" | "1643" | "1644" | "1645" | "1646" | "1650" | "1651" | "1652" | "1653" | "1654" | "1655" | "1656" | "1660" | "1661" | "1662" | "1663" | "1664" | "1665" | "1666" | "2000" | "2001" | "2002" | "2003" | "2004" | "2005" | "2006" | "2010" | "2011" | "2012" | "2013" | "2014" | "2015" | "2016" | "2020" | "2021" | "2022" | "2023" | "2024" | "2025" | "2026" | "2030" | "2031" | "2032" | "2033" | "2034" | "2035" | "2036" | "2040" | "2041" | "2042" | "2043" | "2044" | "2045" | "2046" | "2050" | "2051" | "2052" | "2053" | "2054" | "2055" | "2056" | "2060" | "2061" | "2062" | "2063" | "2064" | "2065" | "2066" | "2100" | "2101" | "2102" | "2103" | "2104" | "2105" | "2106" | "2110" | "2111" | "2112" | "2113" | "2114" | "2115" | "2116" | "2120" | "2121" | "2122" | "2123" | "2124" | "2125" | "2126" | "2130" | "2131" | "2132" | "2133" | "2134" | "2135" | "2136" | "2140" | "2141" | "2142" | "2143" | "2144" | "2145" | "2146" | "2150" | "2151" | "2152" | "2153" | "2154" | "2155" | "2156" | "2160" | "2161" | "2162" | "2163" | "2164" | "2165" | "2166" | "2200" | "2201" | "2202" | "2203" | "2204" | "2205" | "2206" | "2210" | "2211" | "2212" | "2213" | "2214" | "2215" | "2216" | "2220" | "2221" | "2222" | "2223" | "2224" | "2225" | "2226" | "2230" | "2231" | "2232" | "2233" | "2234" | "2235" | "2236" | "2240" | "2241" | "2242" | "2243" | "2244" | "2245" | "2246" | "2250" | "2251" | "2252" | "2253" | "2254" | "2255" | "2256" | "2260" | "2261" | "2262" | "2263" | "2264" | "2265" | "2266" | "2300" | "2301" | "2302" | "2303" | "2304" | "2305" | "2306" | "2310" | "2311" | "2312" | "2313" | "2314" | "2315" | "2316" | "2320" | "2321" | "2322" | "2323" | "2324" | "2325" | "2326" | "2330" | "2331" | "2332" | "2333" | "2334" | "2335" | "2336" | "2340" | "2341" | "2342" | "2343" | "2344" | "2345" | "2346" | "2350" | "2351" | "2352" | "2353" | "2354" | "2355" | "2356" | "2360" | "2361" | "2362" | "2363" | "2364" | "2365" | "2366" | "2400" | "2401" | "2402" | "2403" | "2404" | "2405" | "2406" | "2410" | "2411" | "2412" | "2413" | "2414" | "2415" | "2416" | "2420" | "2421" | "2422" | "2423" | "2424" | "2425" | "2426" | "2430" | "2431" | "2432" | "2433" | "2434" | "2435" | "2436" | "2440" | "2441" | "2442" | "2443" | "2444" | "2445" | "2446" | "2450" | "2451" | "2452" | "2453" | "2454" | "2455" | "2456" | "2460" | "2461" | "2462" | "2463" | "2464" | "2465" | "2466" | "2500" | "2501" | "2502" | "2503" | "2504" | "2505" | "2506" | "2510" | "2511" | "2512" | "2513" | "2514" | "2515" | "2516" | "2520" | "2521" | "2522" | "2523" | "2524" | "2525" | "2526" | "2530" | "2531" | "2532" | "2533" | "2534" | "2535" | "2536" | "2540" | "2541" | "2542" | "2543" | "2544" | "2545" | "2546" | "2550" | "2551" | "2552" | "2553" | "2554" | "2555" | "2556" | "2560" | "2561" | "2562" | "2563" | "2564" | "2565" | "2566" | "2600" | "2601" | "2602" | "2603" | "2604" | "2605" | "2606" | "2610" | "2611" | "2612" | "2613" | "2614" | "2615" | "2616" | "2620" | "2621" | "2622" | "2623" | "2624" | "2625" | "2626" | "2630" | "2631" | "2632" | "2633" | "2634" | "2635" | "2636" | "2640" | "2641" | "2642" | "2643" | "2644" | "2645" | "2646" | "2650" | "2651" | "2652" | "2653" | "2654" | "2655" | "2656" | "2660" | "2661" | "2662" | "2663" | "2664" | "2665" | "2666" | "3000" | "3001" | "3002" | "3003" | "3004" | "3005" | "3006" | "3010" | "3011" | "3012" | "3013" | "3014" | "3015" | "3016" | "3020" | "3021" | "3022" | "3023" | "3024" | "3025" | "3026" | "3030" | "3031" | "3032" | "3033" | "3034" | "3035" | "3036" | "3040" | "3041" | "3042" | "3043" | "3044" | "3045" | "3046" | "3050" | "3051" | "3052" | "3053" | "3054" | "3055" | "3056" | "3060" | "3061" | "3062" | "3063" | "3064" | "3065" | "3066" | "3100" | "3101" | "3102" | "3103" | "3104" | "3105" | "3106" | "3110" | "3111" | "3112" | "3113" | "3114" | "3115" | "3116" | "3120" | "3121" | "3122" | "3123" | "3124" | "3125" | "3126" | "3130" | "3131" | "3132" | "3133" | "3134" | "3135" | "3136" | "3140" | "3141" | "3142" | "3143" | "3144" | "3145" | "3146" | "3150" | "3151" | "3152" | "3153" | "3154" | "3155" | "3156" | "3160" | "3161" | "3162" | "3163" | "3164" | "3165" | "3166" | "3200" | "3201" | "3202" | "3203" | "3204" | "3205" | "3206" | "3210" | "3211" | "3212" | "3213" | "3214" | "3215" | "3216" | "3220" | "3221" | "3222" | "3223" | "3224" | "3225" | "3226" | "3230" | "3231" | "3232" | "3233" | "3234" | "3235" | "3236" | "3240" | "3241" | "3242" | "3243" | "3244" | "3245" | "3246" | "3250" | "3251" | "3252" | "3253" | "3254" | "3255" | "3256" | "3260" | "3261" | "3262" | "3263" | "3264" | "3265" | "3266" | "3300" | "3301" | "3302" | "3303" | "3304" | "3305" | "3306" | "3310" | "3311" | "3312" | "3313" | "3314" | "3315" | "3316" | "3320" | "3321" | "3322" | "3323" | "3324" | "3325" | "3326" | "3330" | "3331" | "3332" | "3333" | "3334" | "3335" | "3336" | "3340" | "3341" | "3342" | "3343" | "3344" | "3345" | "3346" | "3350" | "3351" | "3352" | "3353" | "3354" | "3355" | "3356" | "3360" | "3361" | "3362" | "3363" | "3364" | "3365" | "3366" | "3400" | "3401" | "3402" | "3403" | "3404" | "3405" | "3406" | "3410" | "3411" | "3412" | "3413" | "3414" | "3415" | "3416" | "3420" | "3421" | "3422" | "3423" | "3424" | "3425" | "3426" | "3430" | "3431" | "3432" | "3433" | "3434" | "3435" | "3436" | "3440" | "3441" | "3442" | "3443" | "3444" | "3445" | "3446" | "3450" | "3451" | "3452" | "3453" | "3454" | "3455" | "3456" | "3460" | "3461" | "3462" | "3463" | "3464" | "3465" | "3466" | "3500" | "3501" | "3502" | "3503" | "3504" | "3505" | "3506" | "3510" | "3511" | "3512" | "3513" | "3514" | "3515" | "3516" | "3520" | "3521" | "3522" | "3523" | "3524" | "3525" | "3526" | "3530" | "3531" | "3532" | "3533" | "3534" | "3535" | "3536" | "3540" | "3541" | "3542" | "3543" | "3544" | "3545" | "3546" | "3550" | "3551" | "3552" | "3553" | "3554" | "3555" | "3556" | "3560" | "3561" | "3562" | "3563" | "3564" | "3565" | "3566" | "3600" | "3601" | "3602" | "3603" | "3604" | "3605" | "3606" | "3610" | "3611" | "3612" | "3613" | "3614" | "3615" | "3616" | "3620" | "3621" | "3622" | "3623" | "3624" | "3625" | "3626" | "3630" | "3631" | "3632" | "3633" | "3634" | "3635" | "3636" | "3640" | "3641" | "3642" | "3643" | "3644" | "3645" | "3646" | "3650" | "3651" | "3652" | "3653" | "3654" | "3655" | "3656" | "3660" | "3661" | "3662" | "3663" | "3664" | "3665" | "3666" | "4000" | "4001" | "4002" | "4003" | "4004" | "4005" | "4006" | "4010" | "4011" | "4012" | "4013" | "4014" | "4015" | "4016" | "4020" | "4021" | "4022" | "4023" | "4024" | "4025" | "4026" | "4030" | "4031" | "4032" | "4033" | "4034" | "4035" | "4036" | "4040" | "4041" | "4042" | "4043" | "4044" | "4045" | "4046" | "4050" | "4051" | "4052" | "4053" | "4054" | "4055" | "4056" | "4060" | "4061" | "4062" | "4063" | "4064" | "4065" | "4066" | "4100" | "4101" | "4102" | "4103" | "4104" | "4105" | "4106" | "4110" | "4111" | "4112" | "4113" | "4114" | "4115" | "4116" | "4120" | "4121" | "4122" | "4123" | "4124" | "4125" | "4126" | "4130" | "4131" | "4132" | "4133" | "4134" | "4135" | "4136" | "4140" | "4141" | "4142" | "4143" | "4144" | "4145" | "4146" | "4150" | "4151" | "4152" | "4153" | "4154" | "4155" | "4156" | "4160" | "4161" | "4162" | "4163" | "4164" | "4165" | "4166" | "4200" | "4201" | "4202" | "4203" | "4204" | "4205" | "4206" | "4210" | "4211" | "4212" | "4213" | "4214" | "4215" | "4216" | "4220" | "4221" | "4222" | "4223" | "4224" | "4225" | "4226" | "4230" | "4231" | "4232" | "4233" | "4234" | "4235" | "4236" | "4240" | "4241" | "4242" | "4243" | "4244" | "4245" | "4246" | "4250" | "4251" | "4252" | "4253" | "4254" | "4255" | "4256" | "4260" | "4261" | "4262" | "4263" | "4264" | "4265" | "4266" | "4300" | "4301" | "4302" | "4303" | "4304" | "4305" | "4306" | "4310" | "4311" | "4312" | "4313" | "4314" | "4315" | "4316" | "4320" | "4321" | "4322" | "4323" | "4324" | "4325" | "4326" | "4330" | "4331" | "4332" | "4333" | "4334" | "4335" | "4336" | "4340" | "4341" | "4342" | "4343" | "4344" | "4345" | "4346" | "4350" | "4351" | "4352" | "4353" | "4354" | "4355" | "4356" | "4360" | "4361" | "4362" | "4363" | "4364" | "4365" | "4366" | "4400" | "4401" | "4402" | "4403" | "4404" | "4405" | "4406" | "4410" | "4411" | "4412" | "4413" | "4414" | "4415" | "4416" | "4420" | "4421" | "4422" | "4423" | "4424" | "4425" | "4426" | "4430" | "4431" | "4432" | "4433" | "4434" | "4435" | "4436" | "4440" | "4441" | "4442" | "4443" | "4444" | "4445" | "4446" | "4450" | "4451" | "4452" | "4453" | "4454" | "4455" | "4456" | "4460" | "4461" | "4462" | "4463" | "4464" | "4465" | "4466" | "4500" | "4501" | "4502" | "4503" | "4504" | "4505" | "4506" | "4510" | "4511" | "4512" | "4513" | "4514" | "4515" | "4516" | "4520" | "4521" | "4522" | "4523" | "4524" | "4525" | "4526" | "4530" | "4531" | "4532" | "4533" | "4534" | "4535" | "4536" | "4540" | "4541" | "4542" | "4543" | "4544" | "4545" | "4546" | "4550" | "4551" | "4552" | "4553" | "4554" | "4555" | "4556" | "4560" | "4561" | "4562" | "4563" | "4564" | "4565" | "4566" | "4600" | "4601" | "4602" | "4603" | "4604" | "4605" | "4606" | "4610" | "4611" | "4612" | "4613" | "4614" | "4615" | "4616" | "4620" | "4621" | "4622" | "4623" | "4624" | "4625" | "4626" | "4630" | "4631" | "4632" | "4633" | "4634" | "4635" | "4636" | "4640" | "4641" | "4642" | "4643" | "4644" | "4645" | "4646" | "4650" | "4651" | "4652" | "4653" | "4654" | "4655" | "4656" | "4660" | "4661" | "4662" | "4663" | "4664" | "4665" | "4666" | undefined) & T2 + +x = y5; +>x = y5 : ("0000" | "0001" | "0002" | "0003" | "0004" | "0005" | "0006" | "0010" | "0011" | "0012" | "0013" | "0014" | "0015" | "0016" | "0020" | "0021" | "0022" | "0023" | "0024" | "0025" | "0026" | "0030" | "0031" | "0032" | "0033" | "0034" | "0035" | "0036" | "0040" | "0041" | "0042" | "0043" | "0044" | "0045" | "0046" | "0050" | "0051" | "0052" | "0053" | "0054" | "0055" | "0056" | "0060" | "0061" | "0062" | "0063" | "0064" | "0065" | "0066" | "0100" | "0101" | "0102" | "0103" | "0104" | "0105" | "0106" | "0110" | "0111" | "0112" | "0113" | "0114" | "0115" | "0116" | "0120" | "0121" | "0122" | "0123" | "0124" | "0125" | "0126" | "0130" | "0131" | "0132" | "0133" | "0134" | "0135" | "0136" | "0140" | "0141" | "0142" | "0143" | "0144" | "0145" | "0146" | "0150" | "0151" | "0152" | "0153" | "0154" | "0155" | "0156" | "0160" | "0161" | "0162" | "0163" | "0164" | "0165" | "0166" | "0200" | "0201" | "0202" | "0203" | "0204" | "0205" | "0206" | "0210" | "0211" | "0212" | "0213" | "0214" | "0215" | "0216" | "0220" | "0221" | "0222" | "0223" | "0224" | "0225" | "0226" | "0230" | "0231" | "0232" | "0233" | "0234" | "0235" | "0236" | "0240" | "0241" | "0242" | "0243" | "0244" | "0245" | "0246" | "0250" | "0251" | "0252" | "0253" | "0254" | "0255" | "0256" | "0260" | "0261" | "0262" | "0263" | "0264" | "0265" | "0266" | "0300" | "0301" | "0302" | "0303" | "0304" | "0305" | "0306" | "0310" | "0311" | "0312" | "0313" | "0314" | "0315" | "0316" | "0320" | "0321" | "0322" | "0323" | "0324" | "0325" | "0326" | "0330" | "0331" | "0332" | "0333" | "0334" | "0335" | "0336" | "0340" | "0341" | "0342" | "0343" | "0344" | "0345" | "0346" | "0350" | "0351" | "0352" | "0353" | "0354" | "0355" | "0356" | "0360" | "0361" | "0362" | "0363" | "0364" | "0365" | "0366" | "0400" | "0401" | "0402" | "0403" | "0404" | "0405" | "0406" | "0410" | "0411" | "0412" | "0413" | "0414" | "0415" | "0416" | "0420" | "0421" | "0422" | "0423" | "0424" | "0425" | "0426" | "0430" | "0431" | "0432" | "0433" | "0434" | "0435" | "0436" | "0440" | "0441" | "0442" | "0443" | "0444" | "0445" | "0446" | "0450" | "0451" | "0452" | "0453" | "0454" | "0455" | "0456" | "0460" | "0461" | "0462" | "0463" | "0464" | "0465" | "0466" | "0500" | "0501" | "0502" | "0503" | "0504" | "0505" | "0506" | "0510" | "0511" | "0512" | "0513" | "0514" | "0515" | "0516" | "0520" | "0521" | "0522" | "0523" | "0524" | "0525" | "0526" | "0530" | "0531" | "0532" | "0533" | "0534" | "0535" | "0536" | "0540" | "0541" | "0542" | "0543" | "0544" | "0545" | "0546" | "0550" | "0551" | "0552" | "0553" | "0554" | "0555" | "0556" | "0560" | "0561" | "0562" | "0563" | "0564" | "0565" | "0566" | "0600" | "0601" | "0602" | "0603" | "0604" | "0605" | "0606" | "0610" | "0611" | "0612" | "0613" | "0614" | "0615" | "0616" | "0620" | "0621" | "0622" | "0623" | "0624" | "0625" | "0626" | "0630" | "0631" | "0632" | "0633" | "0634" | "0635" | "0636" | "0640" | "0641" | "0642" | "0643" | "0644" | "0645" | "0646" | "0650" | "0651" | "0652" | "0653" | "0654" | "0655" | "0656" | "0660" | "0661" | "0662" | "0663" | "0664" | "0665" | "0666" | "1000" | "1001" | "1002" | "1003" | "1004" | "1005" | "1006" | "1010" | "1011" | "1012" | "1013" | "1014" | "1015" | "1016" | "1020" | "1021" | "1022" | "1023" | "1024" | "1025" | "1026" | "1030" | "1031" | "1032" | "1033" | "1034" | "1035" | "1036" | "1040" | "1041" | "1042" | "1043" | "1044" | "1045" | "1046" | "1050" | "1051" | "1052" | "1053" | "1054" | "1055" | "1056" | "1060" | "1061" | "1062" | "1063" | "1064" | "1065" | "1066" | "1100" | "1101" | "1102" | "1103" | "1104" | "1105" | "1106" | "1110" | "1111" | "1112" | "1113" | "1114" | "1115" | "1116" | "1120" | "1121" | "1122" | "1123" | "1124" | "1125" | "1126" | "1130" | "1131" | "1132" | "1133" | "1134" | "1135" | "1136" | "1140" | "1141" | "1142" | "1143" | "1144" | "1145" | "1146" | "1150" | "1151" | "1152" | "1153" | "1154" | "1155" | "1156" | "1160" | "1161" | "1162" | "1163" | "1164" | "1165" | "1166" | "1200" | "1201" | "1202" | "1203" | "1204" | "1205" | "1206" | "1210" | "1211" | "1212" | "1213" | "1214" | "1215" | "1216" | "1220" | "1221" | "1222" | "1223" | "1224" | "1225" | "1226" | "1230" | "1231" | "1232" | "1233" | "1234" | "1235" | "1236" | "1240" | "1241" | "1242" | "1243" | "1244" | "1245" | "1246" | "1250" | "1251" | "1252" | "1253" | "1254" | "1255" | "1256" | "1260" | "1261" | "1262" | "1263" | "1264" | "1265" | "1266" | "1300" | "1301" | "1302" | "1303" | "1304" | "1305" | "1306" | "1310" | "1311" | "1312" | "1313" | "1314" | "1315" | "1316" | "1320" | "1321" | "1322" | "1323" | "1324" | "1325" | "1326" | "1330" | "1331" | "1332" | "1333" | "1334" | "1335" | "1336" | "1340" | "1341" | "1342" | "1343" | "1344" | "1345" | "1346" | "1350" | "1351" | "1352" | "1353" | "1354" | "1355" | "1356" | "1360" | "1361" | "1362" | "1363" | "1364" | "1365" | "1366" | "1400" | "1401" | "1402" | "1403" | "1404" | "1405" | "1406" | "1410" | "1411" | "1412" | "1413" | "1414" | "1415" | "1416" | "1420" | "1421" | "1422" | "1423" | "1424" | "1425" | "1426" | "1430" | "1431" | "1432" | "1433" | "1434" | "1435" | "1436" | "1440" | "1441" | "1442" | "1443" | "1444" | "1445" | "1446" | "1450" | "1451" | "1452" | "1453" | "1454" | "1455" | "1456" | "1460" | "1461" | "1462" | "1463" | "1464" | "1465" | "1466" | "1500" | "1501" | "1502" | "1503" | "1504" | "1505" | "1506" | "1510" | "1511" | "1512" | "1513" | "1514" | "1515" | "1516" | "1520" | "1521" | "1522" | "1523" | "1524" | "1525" | "1526" | "1530" | "1531" | "1532" | "1533" | "1534" | "1535" | "1536" | "1540" | "1541" | "1542" | "1543" | "1544" | "1545" | "1546" | "1550" | "1551" | "1552" | "1553" | "1554" | "1555" | "1556" | "1560" | "1561" | "1562" | "1563" | "1564" | "1565" | "1566" | "1600" | "1601" | "1602" | "1603" | "1604" | "1605" | "1606" | "1610" | "1611" | "1612" | "1613" | "1614" | "1615" | "1616" | "1620" | "1621" | "1622" | "1623" | "1624" | "1625" | "1626" | "1630" | "1631" | "1632" | "1633" | "1634" | "1635" | "1636" | "1640" | "1641" | "1642" | "1643" | "1644" | "1645" | "1646" | "1650" | "1651" | "1652" | "1653" | "1654" | "1655" | "1656" | "1660" | "1661" | "1662" | "1663" | "1664" | "1665" | "1666" | "2000" | "2001" | "2002" | "2003" | "2004" | "2005" | "2006" | "2010" | "2011" | "2012" | "2013" | "2014" | "2015" | "2016" | "2020" | "2021" | "2022" | "2023" | "2024" | "2025" | "2026" | "2030" | "2031" | "2032" | "2033" | "2034" | "2035" | "2036" | "2040" | "2041" | "2042" | "2043" | "2044" | "2045" | "2046" | "2050" | "2051" | "2052" | "2053" | "2054" | "2055" | "2056" | "2060" | "2061" | "2062" | "2063" | "2064" | "2065" | "2066" | "2100" | "2101" | "2102" | "2103" | "2104" | "2105" | "2106" | "2110" | "2111" | "2112" | "2113" | "2114" | "2115" | "2116" | "2120" | "2121" | "2122" | "2123" | "2124" | "2125" | "2126" | "2130" | "2131" | "2132" | "2133" | "2134" | "2135" | "2136" | "2140" | "2141" | "2142" | "2143" | "2144" | "2145" | "2146" | "2150" | "2151" | "2152" | "2153" | "2154" | "2155" | "2156" | "2160" | "2161" | "2162" | "2163" | "2164" | "2165" | "2166" | "2200" | "2201" | "2202" | "2203" | "2204" | "2205" | "2206" | "2210" | "2211" | "2212" | "2213" | "2214" | "2215" | "2216" | "2220" | "2221" | "2222" | "2223" | "2224" | "2225" | "2226" | "2230" | "2231" | "2232" | "2233" | "2234" | "2235" | "2236" | "2240" | "2241" | "2242" | "2243" | "2244" | "2245" | "2246" | "2250" | "2251" | "2252" | "2253" | "2254" | "2255" | "2256" | "2260" | "2261" | "2262" | "2263" | "2264" | "2265" | "2266" | "2300" | "2301" | "2302" | "2303" | "2304" | "2305" | "2306" | "2310" | "2311" | "2312" | "2313" | "2314" | "2315" | "2316" | "2320" | "2321" | "2322" | "2323" | "2324" | "2325" | "2326" | "2330" | "2331" | "2332" | "2333" | "2334" | "2335" | "2336" | "2340" | "2341" | "2342" | "2343" | "2344" | "2345" | "2346" | "2350" | "2351" | "2352" | "2353" | "2354" | "2355" | "2356" | "2360" | "2361" | "2362" | "2363" | "2364" | "2365" | "2366" | "2400" | "2401" | "2402" | "2403" | "2404" | "2405" | "2406" | "2410" | "2411" | "2412" | "2413" | "2414" | "2415" | "2416" | "2420" | "2421" | "2422" | "2423" | "2424" | "2425" | "2426" | "2430" | "2431" | "2432" | "2433" | "2434" | "2435" | "2436" | "2440" | "2441" | "2442" | "2443" | "2444" | "2445" | "2446" | "2450" | "2451" | "2452" | "2453" | "2454" | "2455" | "2456" | "2460" | "2461" | "2462" | "2463" | "2464" | "2465" | "2466" | "2500" | "2501" | "2502" | "2503" | "2504" | "2505" | "2506" | "2510" | "2511" | "2512" | "2513" | "2514" | "2515" | "2516" | "2520" | "2521" | "2522" | "2523" | "2524" | "2525" | "2526" | "2530" | "2531" | "2532" | "2533" | "2534" | "2535" | "2536" | "2540" | "2541" | "2542" | "2543" | "2544" | "2545" | "2546" | "2550" | "2551" | "2552" | "2553" | "2554" | "2555" | "2556" | "2560" | "2561" | "2562" | "2563" | "2564" | "2565" | "2566" | "2600" | "2601" | "2602" | "2603" | "2604" | "2605" | "2606" | "2610" | "2611" | "2612" | "2613" | "2614" | "2615" | "2616" | "2620" | "2621" | "2622" | "2623" | "2624" | "2625" | "2626" | "2630" | "2631" | "2632" | "2633" | "2634" | "2635" | "2636" | "2640" | "2641" | "2642" | "2643" | "2644" | "2645" | "2646" | "2650" | "2651" | "2652" | "2653" | "2654" | "2655" | "2656" | "2660" | "2661" | "2662" | "2663" | "2664" | "2665" | "2666" | "3000" | "3001" | "3002" | "3003" | "3004" | "3005" | "3006" | "3010" | "3011" | "3012" | "3013" | "3014" | "3015" | "3016" | "3020" | "3021" | "3022" | "3023" | "3024" | "3025" | "3026" | "3030" | "3031" | "3032" | "3033" | "3034" | "3035" | "3036" | "3040" | "3041" | "3042" | "3043" | "3044" | "3045" | "3046" | "3050" | "3051" | "3052" | "3053" | "3054" | "3055" | "3056" | "3060" | "3061" | "3062" | "3063" | "3064" | "3065" | "3066" | "3100" | "3101" | "3102" | "3103" | "3104" | "3105" | "3106" | "3110" | "3111" | "3112" | "3113" | "3114" | "3115" | "3116" | "3120" | "3121" | "3122" | "3123" | "3124" | "3125" | "3126" | "3130" | "3131" | "3132" | "3133" | "3134" | "3135" | "3136" | "3140" | "3141" | "3142" | "3143" | "3144" | "3145" | "3146" | "3150" | "3151" | "3152" | "3153" | "3154" | "3155" | "3156" | "3160" | "3161" | "3162" | "3163" | "3164" | "3165" | "3166" | "3200" | "3201" | "3202" | "3203" | "3204" | "3205" | "3206" | "3210" | "3211" | "3212" | "3213" | "3214" | "3215" | "3216" | "3220" | "3221" | "3222" | "3223" | "3224" | "3225" | "3226" | "3230" | "3231" | "3232" | "3233" | "3234" | "3235" | "3236" | "3240" | "3241" | "3242" | "3243" | "3244" | "3245" | "3246" | "3250" | "3251" | "3252" | "3253" | "3254" | "3255" | "3256" | "3260" | "3261" | "3262" | "3263" | "3264" | "3265" | "3266" | "3300" | "3301" | "3302" | "3303" | "3304" | "3305" | "3306" | "3310" | "3311" | "3312" | "3313" | "3314" | "3315" | "3316" | "3320" | "3321" | "3322" | "3323" | "3324" | "3325" | "3326" | "3330" | "3331" | "3332" | "3333" | "3334" | "3335" | "3336" | "3340" | "3341" | "3342" | "3343" | "3344" | "3345" | "3346" | "3350" | "3351" | "3352" | "3353" | "3354" | "3355" | "3356" | "3360" | "3361" | "3362" | "3363" | "3364" | "3365" | "3366" | "3400" | "3401" | "3402" | "3403" | "3404" | "3405" | "3406" | "3410" | "3411" | "3412" | "3413" | "3414" | "3415" | "3416" | "3420" | "3421" | "3422" | "3423" | "3424" | "3425" | "3426" | "3430" | "3431" | "3432" | "3433" | "3434" | "3435" | "3436" | "3440" | "3441" | "3442" | "3443" | "3444" | "3445" | "3446" | "3450" | "3451" | "3452" | "3453" | "3454" | "3455" | "3456" | "3460" | "3461" | "3462" | "3463" | "3464" | "3465" | "3466" | "3500" | "3501" | "3502" | "3503" | "3504" | "3505" | "3506" | "3510" | "3511" | "3512" | "3513" | "3514" | "3515" | "3516" | "3520" | "3521" | "3522" | "3523" | "3524" | "3525" | "3526" | "3530" | "3531" | "3532" | "3533" | "3534" | "3535" | "3536" | "3540" | "3541" | "3542" | "3543" | "3544" | "3545" | "3546" | "3550" | "3551" | "3552" | "3553" | "3554" | "3555" | "3556" | "3560" | "3561" | "3562" | "3563" | "3564" | "3565" | "3566" | "3600" | "3601" | "3602" | "3603" | "3604" | "3605" | "3606" | "3610" | "3611" | "3612" | "3613" | "3614" | "3615" | "3616" | "3620" | "3621" | "3622" | "3623" | "3624" | "3625" | "3626" | "3630" | "3631" | "3632" | "3633" | "3634" | "3635" | "3636" | "3640" | "3641" | "3642" | "3643" | "3644" | "3645" | "3646" | "3650" | "3651" | "3652" | "3653" | "3654" | "3655" | "3656" | "3660" | "3661" | "3662" | "3663" | "3664" | "3665" | "3666" | "4000" | "4001" | "4002" | "4003" | "4004" | "4005" | "4006" | "4010" | "4011" | "4012" | "4013" | "4014" | "4015" | "4016" | "4020" | "4021" | "4022" | "4023" | "4024" | "4025" | "4026" | "4030" | "4031" | "4032" | "4033" | "4034" | "4035" | "4036" | "4040" | "4041" | "4042" | "4043" | "4044" | "4045" | "4046" | "4050" | "4051" | "4052" | "4053" | "4054" | "4055" | "4056" | "4060" | "4061" | "4062" | "4063" | "4064" | "4065" | "4066" | "4100" | "4101" | "4102" | "4103" | "4104" | "4105" | "4106" | "4110" | "4111" | "4112" | "4113" | "4114" | "4115" | "4116" | "4120" | "4121" | "4122" | "4123" | "4124" | "4125" | "4126" | "4130" | "4131" | "4132" | "4133" | "4134" | "4135" | "4136" | "4140" | "4141" | "4142" | "4143" | "4144" | "4145" | "4146" | "4150" | "4151" | "4152" | "4153" | "4154" | "4155" | "4156" | "4160" | "4161" | "4162" | "4163" | "4164" | "4165" | "4166" | "4200" | "4201" | "4202" | "4203" | "4204" | "4205" | "4206" | "4210" | "4211" | "4212" | "4213" | "4214" | "4215" | "4216" | "4220" | "4221" | "4222" | "4223" | "4224" | "4225" | "4226" | "4230" | "4231" | "4232" | "4233" | "4234" | "4235" | "4236" | "4240" | "4241" | "4242" | "4243" | "4244" | "4245" | "4246" | "4250" | "4251" | "4252" | "4253" | "4254" | "4255" | "4256" | "4260" | "4261" | "4262" | "4263" | "4264" | "4265" | "4266" | "4300" | "4301" | "4302" | "4303" | "4304" | "4305" | "4306" | "4310" | "4311" | "4312" | "4313" | "4314" | "4315" | "4316" | "4320" | "4321" | "4322" | "4323" | "4324" | "4325" | "4326" | "4330" | "4331" | "4332" | "4333" | "4334" | "4335" | "4336" | "4340" | "4341" | "4342" | "4343" | "4344" | "4345" | "4346" | "4350" | "4351" | "4352" | "4353" | "4354" | "4355" | "4356" | "4360" | "4361" | "4362" | "4363" | "4364" | "4365" | "4366" | "4400" | "4401" | "4402" | "4403" | "4404" | "4405" | "4406" | "4410" | "4411" | "4412" | "4413" | "4414" | "4415" | "4416" | "4420" | "4421" | "4422" | "4423" | "4424" | "4425" | "4426" | "4430" | "4431" | "4432" | "4433" | "4434" | "4435" | "4436" | "4440" | "4441" | "4442" | "4443" | "4444" | "4445" | "4446" | "4450" | "4451" | "4452" | "4453" | "4454" | "4455" | "4456" | "4460" | "4461" | "4462" | "4463" | "4464" | "4465" | "4466" | "4500" | "4501" | "4502" | "4503" | "4504" | "4505" | "4506" | "4510" | "4511" | "4512" | "4513" | "4514" | "4515" | "4516" | "4520" | "4521" | "4522" | "4523" | "4524" | "4525" | "4526" | "4530" | "4531" | "4532" | "4533" | "4534" | "4535" | "4536" | "4540" | "4541" | "4542" | "4543" | "4544" | "4545" | "4546" | "4550" | "4551" | "4552" | "4553" | "4554" | "4555" | "4556" | "4560" | "4561" | "4562" | "4563" | "4564" | "4565" | "4566" | "4600" | "4601" | "4602" | "4603" | "4604" | "4605" | "4606" | "4610" | "4611" | "4612" | "4613" | "4614" | "4615" | "4616" | "4620" | "4621" | "4622" | "4623" | "4624" | "4625" | "4626" | "4630" | "4631" | "4632" | "4633" | "4634" | "4635" | "4636" | "4640" | "4641" | "4642" | "4643" | "4644" | "4645" | "4646" | "4650" | "4651" | "4652" | "4653" | "4654" | "4655" | "4656" | "4660" | "4661" | "4662" | "4663" | "4664" | "4665" | "4666" | undefined) & T2 +>x : T1 | null +>y5 : ("0000" | "0001" | "0002" | "0003" | "0004" | "0005" | "0006" | "0010" | "0011" | "0012" | "0013" | "0014" | "0015" | "0016" | "0020" | "0021" | "0022" | "0023" | "0024" | "0025" | "0026" | "0030" | "0031" | "0032" | "0033" | "0034" | "0035" | "0036" | "0040" | "0041" | "0042" | "0043" | "0044" | "0045" | "0046" | "0050" | "0051" | "0052" | "0053" | "0054" | "0055" | "0056" | "0060" | "0061" | "0062" | "0063" | "0064" | "0065" | "0066" | "0100" | "0101" | "0102" | "0103" | "0104" | "0105" | "0106" | "0110" | "0111" | "0112" | "0113" | "0114" | "0115" | "0116" | "0120" | "0121" | "0122" | "0123" | "0124" | "0125" | "0126" | "0130" | "0131" | "0132" | "0133" | "0134" | "0135" | "0136" | "0140" | "0141" | "0142" | "0143" | "0144" | "0145" | "0146" | "0150" | "0151" | "0152" | "0153" | "0154" | "0155" | "0156" | "0160" | "0161" | "0162" | "0163" | "0164" | "0165" | "0166" | "0200" | "0201" | "0202" | "0203" | "0204" | "0205" | "0206" | "0210" | "0211" | "0212" | "0213" | "0214" | "0215" | "0216" | "0220" | "0221" | "0222" | "0223" | "0224" | "0225" | "0226" | "0230" | "0231" | "0232" | "0233" | "0234" | "0235" | "0236" | "0240" | "0241" | "0242" | "0243" | "0244" | "0245" | "0246" | "0250" | "0251" | "0252" | "0253" | "0254" | "0255" | "0256" | "0260" | "0261" | "0262" | "0263" | "0264" | "0265" | "0266" | "0300" | "0301" | "0302" | "0303" | "0304" | "0305" | "0306" | "0310" | "0311" | "0312" | "0313" | "0314" | "0315" | "0316" | "0320" | "0321" | "0322" | "0323" | "0324" | "0325" | "0326" | "0330" | "0331" | "0332" | "0333" | "0334" | "0335" | "0336" | "0340" | "0341" | "0342" | "0343" | "0344" | "0345" | "0346" | "0350" | "0351" | "0352" | "0353" | "0354" | "0355" | "0356" | "0360" | "0361" | "0362" | "0363" | "0364" | "0365" | "0366" | "0400" | "0401" | "0402" | "0403" | "0404" | "0405" | "0406" | "0410" | "0411" | "0412" | "0413" | "0414" | "0415" | "0416" | "0420" | "0421" | "0422" | "0423" | "0424" | "0425" | "0426" | "0430" | "0431" | "0432" | "0433" | "0434" | "0435" | "0436" | "0440" | "0441" | "0442" | "0443" | "0444" | "0445" | "0446" | "0450" | "0451" | "0452" | "0453" | "0454" | "0455" | "0456" | "0460" | "0461" | "0462" | "0463" | "0464" | "0465" | "0466" | "0500" | "0501" | "0502" | "0503" | "0504" | "0505" | "0506" | "0510" | "0511" | "0512" | "0513" | "0514" | "0515" | "0516" | "0520" | "0521" | "0522" | "0523" | "0524" | "0525" | "0526" | "0530" | "0531" | "0532" | "0533" | "0534" | "0535" | "0536" | "0540" | "0541" | "0542" | "0543" | "0544" | "0545" | "0546" | "0550" | "0551" | "0552" | "0553" | "0554" | "0555" | "0556" | "0560" | "0561" | "0562" | "0563" | "0564" | "0565" | "0566" | "0600" | "0601" | "0602" | "0603" | "0604" | "0605" | "0606" | "0610" | "0611" | "0612" | "0613" | "0614" | "0615" | "0616" | "0620" | "0621" | "0622" | "0623" | "0624" | "0625" | "0626" | "0630" | "0631" | "0632" | "0633" | "0634" | "0635" | "0636" | "0640" | "0641" | "0642" | "0643" | "0644" | "0645" | "0646" | "0650" | "0651" | "0652" | "0653" | "0654" | "0655" | "0656" | "0660" | "0661" | "0662" | "0663" | "0664" | "0665" | "0666" | "1000" | "1001" | "1002" | "1003" | "1004" | "1005" | "1006" | "1010" | "1011" | "1012" | "1013" | "1014" | "1015" | "1016" | "1020" | "1021" | "1022" | "1023" | "1024" | "1025" | "1026" | "1030" | "1031" | "1032" | "1033" | "1034" | "1035" | "1036" | "1040" | "1041" | "1042" | "1043" | "1044" | "1045" | "1046" | "1050" | "1051" | "1052" | "1053" | "1054" | "1055" | "1056" | "1060" | "1061" | "1062" | "1063" | "1064" | "1065" | "1066" | "1100" | "1101" | "1102" | "1103" | "1104" | "1105" | "1106" | "1110" | "1111" | "1112" | "1113" | "1114" | "1115" | "1116" | "1120" | "1121" | "1122" | "1123" | "1124" | "1125" | "1126" | "1130" | "1131" | "1132" | "1133" | "1134" | "1135" | "1136" | "1140" | "1141" | "1142" | "1143" | "1144" | "1145" | "1146" | "1150" | "1151" | "1152" | "1153" | "1154" | "1155" | "1156" | "1160" | "1161" | "1162" | "1163" | "1164" | "1165" | "1166" | "1200" | "1201" | "1202" | "1203" | "1204" | "1205" | "1206" | "1210" | "1211" | "1212" | "1213" | "1214" | "1215" | "1216" | "1220" | "1221" | "1222" | "1223" | "1224" | "1225" | "1226" | "1230" | "1231" | "1232" | "1233" | "1234" | "1235" | "1236" | "1240" | "1241" | "1242" | "1243" | "1244" | "1245" | "1246" | "1250" | "1251" | "1252" | "1253" | "1254" | "1255" | "1256" | "1260" | "1261" | "1262" | "1263" | "1264" | "1265" | "1266" | "1300" | "1301" | "1302" | "1303" | "1304" | "1305" | "1306" | "1310" | "1311" | "1312" | "1313" | "1314" | "1315" | "1316" | "1320" | "1321" | "1322" | "1323" | "1324" | "1325" | "1326" | "1330" | "1331" | "1332" | "1333" | "1334" | "1335" | "1336" | "1340" | "1341" | "1342" | "1343" | "1344" | "1345" | "1346" | "1350" | "1351" | "1352" | "1353" | "1354" | "1355" | "1356" | "1360" | "1361" | "1362" | "1363" | "1364" | "1365" | "1366" | "1400" | "1401" | "1402" | "1403" | "1404" | "1405" | "1406" | "1410" | "1411" | "1412" | "1413" | "1414" | "1415" | "1416" | "1420" | "1421" | "1422" | "1423" | "1424" | "1425" | "1426" | "1430" | "1431" | "1432" | "1433" | "1434" | "1435" | "1436" | "1440" | "1441" | "1442" | "1443" | "1444" | "1445" | "1446" | "1450" | "1451" | "1452" | "1453" | "1454" | "1455" | "1456" | "1460" | "1461" | "1462" | "1463" | "1464" | "1465" | "1466" | "1500" | "1501" | "1502" | "1503" | "1504" | "1505" | "1506" | "1510" | "1511" | "1512" | "1513" | "1514" | "1515" | "1516" | "1520" | "1521" | "1522" | "1523" | "1524" | "1525" | "1526" | "1530" | "1531" | "1532" | "1533" | "1534" | "1535" | "1536" | "1540" | "1541" | "1542" | "1543" | "1544" | "1545" | "1546" | "1550" | "1551" | "1552" | "1553" | "1554" | "1555" | "1556" | "1560" | "1561" | "1562" | "1563" | "1564" | "1565" | "1566" | "1600" | "1601" | "1602" | "1603" | "1604" | "1605" | "1606" | "1610" | "1611" | "1612" | "1613" | "1614" | "1615" | "1616" | "1620" | "1621" | "1622" | "1623" | "1624" | "1625" | "1626" | "1630" | "1631" | "1632" | "1633" | "1634" | "1635" | "1636" | "1640" | "1641" | "1642" | "1643" | "1644" | "1645" | "1646" | "1650" | "1651" | "1652" | "1653" | "1654" | "1655" | "1656" | "1660" | "1661" | "1662" | "1663" | "1664" | "1665" | "1666" | "2000" | "2001" | "2002" | "2003" | "2004" | "2005" | "2006" | "2010" | "2011" | "2012" | "2013" | "2014" | "2015" | "2016" | "2020" | "2021" | "2022" | "2023" | "2024" | "2025" | "2026" | "2030" | "2031" | "2032" | "2033" | "2034" | "2035" | "2036" | "2040" | "2041" | "2042" | "2043" | "2044" | "2045" | "2046" | "2050" | "2051" | "2052" | "2053" | "2054" | "2055" | "2056" | "2060" | "2061" | "2062" | "2063" | "2064" | "2065" | "2066" | "2100" | "2101" | "2102" | "2103" | "2104" | "2105" | "2106" | "2110" | "2111" | "2112" | "2113" | "2114" | "2115" | "2116" | "2120" | "2121" | "2122" | "2123" | "2124" | "2125" | "2126" | "2130" | "2131" | "2132" | "2133" | "2134" | "2135" | "2136" | "2140" | "2141" | "2142" | "2143" | "2144" | "2145" | "2146" | "2150" | "2151" | "2152" | "2153" | "2154" | "2155" | "2156" | "2160" | "2161" | "2162" | "2163" | "2164" | "2165" | "2166" | "2200" | "2201" | "2202" | "2203" | "2204" | "2205" | "2206" | "2210" | "2211" | "2212" | "2213" | "2214" | "2215" | "2216" | "2220" | "2221" | "2222" | "2223" | "2224" | "2225" | "2226" | "2230" | "2231" | "2232" | "2233" | "2234" | "2235" | "2236" | "2240" | "2241" | "2242" | "2243" | "2244" | "2245" | "2246" | "2250" | "2251" | "2252" | "2253" | "2254" | "2255" | "2256" | "2260" | "2261" | "2262" | "2263" | "2264" | "2265" | "2266" | "2300" | "2301" | "2302" | "2303" | "2304" | "2305" | "2306" | "2310" | "2311" | "2312" | "2313" | "2314" | "2315" | "2316" | "2320" | "2321" | "2322" | "2323" | "2324" | "2325" | "2326" | "2330" | "2331" | "2332" | "2333" | "2334" | "2335" | "2336" | "2340" | "2341" | "2342" | "2343" | "2344" | "2345" | "2346" | "2350" | "2351" | "2352" | "2353" | "2354" | "2355" | "2356" | "2360" | "2361" | "2362" | "2363" | "2364" | "2365" | "2366" | "2400" | "2401" | "2402" | "2403" | "2404" | "2405" | "2406" | "2410" | "2411" | "2412" | "2413" | "2414" | "2415" | "2416" | "2420" | "2421" | "2422" | "2423" | "2424" | "2425" | "2426" | "2430" | "2431" | "2432" | "2433" | "2434" | "2435" | "2436" | "2440" | "2441" | "2442" | "2443" | "2444" | "2445" | "2446" | "2450" | "2451" | "2452" | "2453" | "2454" | "2455" | "2456" | "2460" | "2461" | "2462" | "2463" | "2464" | "2465" | "2466" | "2500" | "2501" | "2502" | "2503" | "2504" | "2505" | "2506" | "2510" | "2511" | "2512" | "2513" | "2514" | "2515" | "2516" | "2520" | "2521" | "2522" | "2523" | "2524" | "2525" | "2526" | "2530" | "2531" | "2532" | "2533" | "2534" | "2535" | "2536" | "2540" | "2541" | "2542" | "2543" | "2544" | "2545" | "2546" | "2550" | "2551" | "2552" | "2553" | "2554" | "2555" | "2556" | "2560" | "2561" | "2562" | "2563" | "2564" | "2565" | "2566" | "2600" | "2601" | "2602" | "2603" | "2604" | "2605" | "2606" | "2610" | "2611" | "2612" | "2613" | "2614" | "2615" | "2616" | "2620" | "2621" | "2622" | "2623" | "2624" | "2625" | "2626" | "2630" | "2631" | "2632" | "2633" | "2634" | "2635" | "2636" | "2640" | "2641" | "2642" | "2643" | "2644" | "2645" | "2646" | "2650" | "2651" | "2652" | "2653" | "2654" | "2655" | "2656" | "2660" | "2661" | "2662" | "2663" | "2664" | "2665" | "2666" | "3000" | "3001" | "3002" | "3003" | "3004" | "3005" | "3006" | "3010" | "3011" | "3012" | "3013" | "3014" | "3015" | "3016" | "3020" | "3021" | "3022" | "3023" | "3024" | "3025" | "3026" | "3030" | "3031" | "3032" | "3033" | "3034" | "3035" | "3036" | "3040" | "3041" | "3042" | "3043" | "3044" | "3045" | "3046" | "3050" | "3051" | "3052" | "3053" | "3054" | "3055" | "3056" | "3060" | "3061" | "3062" | "3063" | "3064" | "3065" | "3066" | "3100" | "3101" | "3102" | "3103" | "3104" | "3105" | "3106" | "3110" | "3111" | "3112" | "3113" | "3114" | "3115" | "3116" | "3120" | "3121" | "3122" | "3123" | "3124" | "3125" | "3126" | "3130" | "3131" | "3132" | "3133" | "3134" | "3135" | "3136" | "3140" | "3141" | "3142" | "3143" | "3144" | "3145" | "3146" | "3150" | "3151" | "3152" | "3153" | "3154" | "3155" | "3156" | "3160" | "3161" | "3162" | "3163" | "3164" | "3165" | "3166" | "3200" | "3201" | "3202" | "3203" | "3204" | "3205" | "3206" | "3210" | "3211" | "3212" | "3213" | "3214" | "3215" | "3216" | "3220" | "3221" | "3222" | "3223" | "3224" | "3225" | "3226" | "3230" | "3231" | "3232" | "3233" | "3234" | "3235" | "3236" | "3240" | "3241" | "3242" | "3243" | "3244" | "3245" | "3246" | "3250" | "3251" | "3252" | "3253" | "3254" | "3255" | "3256" | "3260" | "3261" | "3262" | "3263" | "3264" | "3265" | "3266" | "3300" | "3301" | "3302" | "3303" | "3304" | "3305" | "3306" | "3310" | "3311" | "3312" | "3313" | "3314" | "3315" | "3316" | "3320" | "3321" | "3322" | "3323" | "3324" | "3325" | "3326" | "3330" | "3331" | "3332" | "3333" | "3334" | "3335" | "3336" | "3340" | "3341" | "3342" | "3343" | "3344" | "3345" | "3346" | "3350" | "3351" | "3352" | "3353" | "3354" | "3355" | "3356" | "3360" | "3361" | "3362" | "3363" | "3364" | "3365" | "3366" | "3400" | "3401" | "3402" | "3403" | "3404" | "3405" | "3406" | "3410" | "3411" | "3412" | "3413" | "3414" | "3415" | "3416" | "3420" | "3421" | "3422" | "3423" | "3424" | "3425" | "3426" | "3430" | "3431" | "3432" | "3433" | "3434" | "3435" | "3436" | "3440" | "3441" | "3442" | "3443" | "3444" | "3445" | "3446" | "3450" | "3451" | "3452" | "3453" | "3454" | "3455" | "3456" | "3460" | "3461" | "3462" | "3463" | "3464" | "3465" | "3466" | "3500" | "3501" | "3502" | "3503" | "3504" | "3505" | "3506" | "3510" | "3511" | "3512" | "3513" | "3514" | "3515" | "3516" | "3520" | "3521" | "3522" | "3523" | "3524" | "3525" | "3526" | "3530" | "3531" | "3532" | "3533" | "3534" | "3535" | "3536" | "3540" | "3541" | "3542" | "3543" | "3544" | "3545" | "3546" | "3550" | "3551" | "3552" | "3553" | "3554" | "3555" | "3556" | "3560" | "3561" | "3562" | "3563" | "3564" | "3565" | "3566" | "3600" | "3601" | "3602" | "3603" | "3604" | "3605" | "3606" | "3610" | "3611" | "3612" | "3613" | "3614" | "3615" | "3616" | "3620" | "3621" | "3622" | "3623" | "3624" | "3625" | "3626" | "3630" | "3631" | "3632" | "3633" | "3634" | "3635" | "3636" | "3640" | "3641" | "3642" | "3643" | "3644" | "3645" | "3646" | "3650" | "3651" | "3652" | "3653" | "3654" | "3655" | "3656" | "3660" | "3661" | "3662" | "3663" | "3664" | "3665" | "3666" | "4000" | "4001" | "4002" | "4003" | "4004" | "4005" | "4006" | "4010" | "4011" | "4012" | "4013" | "4014" | "4015" | "4016" | "4020" | "4021" | "4022" | "4023" | "4024" | "4025" | "4026" | "4030" | "4031" | "4032" | "4033" | "4034" | "4035" | "4036" | "4040" | "4041" | "4042" | "4043" | "4044" | "4045" | "4046" | "4050" | "4051" | "4052" | "4053" | "4054" | "4055" | "4056" | "4060" | "4061" | "4062" | "4063" | "4064" | "4065" | "4066" | "4100" | "4101" | "4102" | "4103" | "4104" | "4105" | "4106" | "4110" | "4111" | "4112" | "4113" | "4114" | "4115" | "4116" | "4120" | "4121" | "4122" | "4123" | "4124" | "4125" | "4126" | "4130" | "4131" | "4132" | "4133" | "4134" | "4135" | "4136" | "4140" | "4141" | "4142" | "4143" | "4144" | "4145" | "4146" | "4150" | "4151" | "4152" | "4153" | "4154" | "4155" | "4156" | "4160" | "4161" | "4162" | "4163" | "4164" | "4165" | "4166" | "4200" | "4201" | "4202" | "4203" | "4204" | "4205" | "4206" | "4210" | "4211" | "4212" | "4213" | "4214" | "4215" | "4216" | "4220" | "4221" | "4222" | "4223" | "4224" | "4225" | "4226" | "4230" | "4231" | "4232" | "4233" | "4234" | "4235" | "4236" | "4240" | "4241" | "4242" | "4243" | "4244" | "4245" | "4246" | "4250" | "4251" | "4252" | "4253" | "4254" | "4255" | "4256" | "4260" | "4261" | "4262" | "4263" | "4264" | "4265" | "4266" | "4300" | "4301" | "4302" | "4303" | "4304" | "4305" | "4306" | "4310" | "4311" | "4312" | "4313" | "4314" | "4315" | "4316" | "4320" | "4321" | "4322" | "4323" | "4324" | "4325" | "4326" | "4330" | "4331" | "4332" | "4333" | "4334" | "4335" | "4336" | "4340" | "4341" | "4342" | "4343" | "4344" | "4345" | "4346" | "4350" | "4351" | "4352" | "4353" | "4354" | "4355" | "4356" | "4360" | "4361" | "4362" | "4363" | "4364" | "4365" | "4366" | "4400" | "4401" | "4402" | "4403" | "4404" | "4405" | "4406" | "4410" | "4411" | "4412" | "4413" | "4414" | "4415" | "4416" | "4420" | "4421" | "4422" | "4423" | "4424" | "4425" | "4426" | "4430" | "4431" | "4432" | "4433" | "4434" | "4435" | "4436" | "4440" | "4441" | "4442" | "4443" | "4444" | "4445" | "4446" | "4450" | "4451" | "4452" | "4453" | "4454" | "4455" | "4456" | "4460" | "4461" | "4462" | "4463" | "4464" | "4465" | "4466" | "4500" | "4501" | "4502" | "4503" | "4504" | "4505" | "4506" | "4510" | "4511" | "4512" | "4513" | "4514" | "4515" | "4516" | "4520" | "4521" | "4522" | "4523" | "4524" | "4525" | "4526" | "4530" | "4531" | "4532" | "4533" | "4534" | "4535" | "4536" | "4540" | "4541" | "4542" | "4543" | "4544" | "4545" | "4546" | "4550" | "4551" | "4552" | "4553" | "4554" | "4555" | "4556" | "4560" | "4561" | "4562" | "4563" | "4564" | "4565" | "4566" | "4600" | "4601" | "4602" | "4603" | "4604" | "4605" | "4606" | "4610" | "4611" | "4612" | "4613" | "4614" | "4615" | "4616" | "4620" | "4621" | "4622" | "4623" | "4624" | "4625" | "4626" | "4630" | "4631" | "4632" | "4633" | "4634" | "4635" | "4636" | "4640" | "4641" | "4642" | "4643" | "4644" | "4645" | "4646" | "4650" | "4651" | "4652" | "4653" | "4654" | "4655" | "4656" | "4660" | "4661" | "4662" | "4663" | "4664" | "4665" | "4666" | undefined) & T2 + +declare const y6: (`${'0' | '1' | '2' | '3' | '4' | '5'}${D}${D}${D}` | undefined) & T2; +>y6 : ("0000" | "0001" | "0002" | "0003" | "0004" | "0005" | "0006" | "0010" | "0011" | "0012" | "0013" | "0014" | "0015" | "0016" | "0020" | "0021" | "0022" | "0023" | "0024" | "0025" | "0026" | "0030" | "0031" | "0032" | "0033" | "0034" | "0035" | "0036" | "0040" | "0041" | "0042" | "0043" | "0044" | "0045" | "0046" | "0050" | "0051" | "0052" | "0053" | "0054" | "0055" | "0056" | "0060" | "0061" | "0062" | "0063" | "0064" | "0065" | "0066" | "0100" | "0101" | "0102" | "0103" | "0104" | "0105" | "0106" | "0110" | "0111" | "0112" | "0113" | "0114" | "0115" | "0116" | "0120" | "0121" | "0122" | "0123" | "0124" | "0125" | "0126" | "0130" | "0131" | "0132" | "0133" | "0134" | "0135" | "0136" | "0140" | "0141" | "0142" | "0143" | "0144" | "0145" | "0146" | "0150" | "0151" | "0152" | "0153" | "0154" | "0155" | "0156" | "0160" | "0161" | "0162" | "0163" | "0164" | "0165" | "0166" | "0200" | "0201" | "0202" | "0203" | "0204" | "0205" | "0206" | "0210" | "0211" | "0212" | "0213" | "0214" | "0215" | "0216" | "0220" | "0221" | "0222" | "0223" | "0224" | "0225" | "0226" | "0230" | "0231" | "0232" | "0233" | "0234" | "0235" | "0236" | "0240" | "0241" | "0242" | "0243" | "0244" | "0245" | "0246" | "0250" | "0251" | "0252" | "0253" | "0254" | "0255" | "0256" | "0260" | "0261" | "0262" | "0263" | "0264" | "0265" | "0266" | "0300" | "0301" | "0302" | "0303" | "0304" | "0305" | "0306" | "0310" | "0311" | "0312" | "0313" | "0314" | "0315" | "0316" | "0320" | "0321" | "0322" | "0323" | "0324" | "0325" | "0326" | "0330" | "0331" | "0332" | "0333" | "0334" | "0335" | "0336" | "0340" | "0341" | "0342" | "0343" | "0344" | "0345" | "0346" | "0350" | "0351" | "0352" | "0353" | "0354" | "0355" | "0356" | "0360" | "0361" | "0362" | "0363" | "0364" | "0365" | "0366" | "0400" | "0401" | "0402" | "0403" | "0404" | "0405" | "0406" | "0410" | "0411" | "0412" | "0413" | "0414" | "0415" | "0416" | "0420" | "0421" | "0422" | "0423" | "0424" | "0425" | "0426" | "0430" | "0431" | "0432" | "0433" | "0434" | "0435" | "0436" | "0440" | "0441" | "0442" | "0443" | "0444" | "0445" | "0446" | "0450" | "0451" | "0452" | "0453" | "0454" | "0455" | "0456" | "0460" | "0461" | "0462" | "0463" | "0464" | "0465" | "0466" | "0500" | "0501" | "0502" | "0503" | "0504" | "0505" | "0506" | "0510" | "0511" | "0512" | "0513" | "0514" | "0515" | "0516" | "0520" | "0521" | "0522" | "0523" | "0524" | "0525" | "0526" | "0530" | "0531" | "0532" | "0533" | "0534" | "0535" | "0536" | "0540" | "0541" | "0542" | "0543" | "0544" | "0545" | "0546" | "0550" | "0551" | "0552" | "0553" | "0554" | "0555" | "0556" | "0560" | "0561" | "0562" | "0563" | "0564" | "0565" | "0566" | "0600" | "0601" | "0602" | "0603" | "0604" | "0605" | "0606" | "0610" | "0611" | "0612" | "0613" | "0614" | "0615" | "0616" | "0620" | "0621" | "0622" | "0623" | "0624" | "0625" | "0626" | "0630" | "0631" | "0632" | "0633" | "0634" | "0635" | "0636" | "0640" | "0641" | "0642" | "0643" | "0644" | "0645" | "0646" | "0650" | "0651" | "0652" | "0653" | "0654" | "0655" | "0656" | "0660" | "0661" | "0662" | "0663" | "0664" | "0665" | "0666" | "1000" | "1001" | "1002" | "1003" | "1004" | "1005" | "1006" | "1010" | "1011" | "1012" | "1013" | "1014" | "1015" | "1016" | "1020" | "1021" | "1022" | "1023" | "1024" | "1025" | "1026" | "1030" | "1031" | "1032" | "1033" | "1034" | "1035" | "1036" | "1040" | "1041" | "1042" | "1043" | "1044" | "1045" | "1046" | "1050" | "1051" | "1052" | "1053" | "1054" | "1055" | "1056" | "1060" | "1061" | "1062" | "1063" | "1064" | "1065" | "1066" | "1100" | "1101" | "1102" | "1103" | "1104" | "1105" | "1106" | "1110" | "1111" | "1112" | "1113" | "1114" | "1115" | "1116" | "1120" | "1121" | "1122" | "1123" | "1124" | "1125" | "1126" | "1130" | "1131" | "1132" | "1133" | "1134" | "1135" | "1136" | "1140" | "1141" | "1142" | "1143" | "1144" | "1145" | "1146" | "1150" | "1151" | "1152" | "1153" | "1154" | "1155" | "1156" | "1160" | "1161" | "1162" | "1163" | "1164" | "1165" | "1166" | "1200" | "1201" | "1202" | "1203" | "1204" | "1205" | "1206" | "1210" | "1211" | "1212" | "1213" | "1214" | "1215" | "1216" | "1220" | "1221" | "1222" | "1223" | "1224" | "1225" | "1226" | "1230" | "1231" | "1232" | "1233" | "1234" | "1235" | "1236" | "1240" | "1241" | "1242" | "1243" | "1244" | "1245" | "1246" | "1250" | "1251" | "1252" | "1253" | "1254" | "1255" | "1256" | "1260" | "1261" | "1262" | "1263" | "1264" | "1265" | "1266" | "1300" | "1301" | "1302" | "1303" | "1304" | "1305" | "1306" | "1310" | "1311" | "1312" | "1313" | "1314" | "1315" | "1316" | "1320" | "1321" | "1322" | "1323" | "1324" | "1325" | "1326" | "1330" | "1331" | "1332" | "1333" | "1334" | "1335" | "1336" | "1340" | "1341" | "1342" | "1343" | "1344" | "1345" | "1346" | "1350" | "1351" | "1352" | "1353" | "1354" | "1355" | "1356" | "1360" | "1361" | "1362" | "1363" | "1364" | "1365" | "1366" | "1400" | "1401" | "1402" | "1403" | "1404" | "1405" | "1406" | "1410" | "1411" | "1412" | "1413" | "1414" | "1415" | "1416" | "1420" | "1421" | "1422" | "1423" | "1424" | "1425" | "1426" | "1430" | "1431" | "1432" | "1433" | "1434" | "1435" | "1436" | "1440" | "1441" | "1442" | "1443" | "1444" | "1445" | "1446" | "1450" | "1451" | "1452" | "1453" | "1454" | "1455" | "1456" | "1460" | "1461" | "1462" | "1463" | "1464" | "1465" | "1466" | "1500" | "1501" | "1502" | "1503" | "1504" | "1505" | "1506" | "1510" | "1511" | "1512" | "1513" | "1514" | "1515" | "1516" | "1520" | "1521" | "1522" | "1523" | "1524" | "1525" | "1526" | "1530" | "1531" | "1532" | "1533" | "1534" | "1535" | "1536" | "1540" | "1541" | "1542" | "1543" | "1544" | "1545" | "1546" | "1550" | "1551" | "1552" | "1553" | "1554" | "1555" | "1556" | "1560" | "1561" | "1562" | "1563" | "1564" | "1565" | "1566" | "1600" | "1601" | "1602" | "1603" | "1604" | "1605" | "1606" | "1610" | "1611" | "1612" | "1613" | "1614" | "1615" | "1616" | "1620" | "1621" | "1622" | "1623" | "1624" | "1625" | "1626" | "1630" | "1631" | "1632" | "1633" | "1634" | "1635" | "1636" | "1640" | "1641" | "1642" | "1643" | "1644" | "1645" | "1646" | "1650" | "1651" | "1652" | "1653" | "1654" | "1655" | "1656" | "1660" | "1661" | "1662" | "1663" | "1664" | "1665" | "1666" | "2000" | "2001" | "2002" | "2003" | "2004" | "2005" | "2006" | "2010" | "2011" | "2012" | "2013" | "2014" | "2015" | "2016" | "2020" | "2021" | "2022" | "2023" | "2024" | "2025" | "2026" | "2030" | "2031" | "2032" | "2033" | "2034" | "2035" | "2036" | "2040" | "2041" | "2042" | "2043" | "2044" | "2045" | "2046" | "2050" | "2051" | "2052" | "2053" | "2054" | "2055" | "2056" | "2060" | "2061" | "2062" | "2063" | "2064" | "2065" | "2066" | "2100" | "2101" | "2102" | "2103" | "2104" | "2105" | "2106" | "2110" | "2111" | "2112" | "2113" | "2114" | "2115" | "2116" | "2120" | "2121" | "2122" | "2123" | "2124" | "2125" | "2126" | "2130" | "2131" | "2132" | "2133" | "2134" | "2135" | "2136" | "2140" | "2141" | "2142" | "2143" | "2144" | "2145" | "2146" | "2150" | "2151" | "2152" | "2153" | "2154" | "2155" | "2156" | "2160" | "2161" | "2162" | "2163" | "2164" | "2165" | "2166" | "2200" | "2201" | "2202" | "2203" | "2204" | "2205" | "2206" | "2210" | "2211" | "2212" | "2213" | "2214" | "2215" | "2216" | "2220" | "2221" | "2222" | "2223" | "2224" | "2225" | "2226" | "2230" | "2231" | "2232" | "2233" | "2234" | "2235" | "2236" | "2240" | "2241" | "2242" | "2243" | "2244" | "2245" | "2246" | "2250" | "2251" | "2252" | "2253" | "2254" | "2255" | "2256" | "2260" | "2261" | "2262" | "2263" | "2264" | "2265" | "2266" | "2300" | "2301" | "2302" | "2303" | "2304" | "2305" | "2306" | "2310" | "2311" | "2312" | "2313" | "2314" | "2315" | "2316" | "2320" | "2321" | "2322" | "2323" | "2324" | "2325" | "2326" | "2330" | "2331" | "2332" | "2333" | "2334" | "2335" | "2336" | "2340" | "2341" | "2342" | "2343" | "2344" | "2345" | "2346" | "2350" | "2351" | "2352" | "2353" | "2354" | "2355" | "2356" | "2360" | "2361" | "2362" | "2363" | "2364" | "2365" | "2366" | "2400" | "2401" | "2402" | "2403" | "2404" | "2405" | "2406" | "2410" | "2411" | "2412" | "2413" | "2414" | "2415" | "2416" | "2420" | "2421" | "2422" | "2423" | "2424" | "2425" | "2426" | "2430" | "2431" | "2432" | "2433" | "2434" | "2435" | "2436" | "2440" | "2441" | "2442" | "2443" | "2444" | "2445" | "2446" | "2450" | "2451" | "2452" | "2453" | "2454" | "2455" | "2456" | "2460" | "2461" | "2462" | "2463" | "2464" | "2465" | "2466" | "2500" | "2501" | "2502" | "2503" | "2504" | "2505" | "2506" | "2510" | "2511" | "2512" | "2513" | "2514" | "2515" | "2516" | "2520" | "2521" | "2522" | "2523" | "2524" | "2525" | "2526" | "2530" | "2531" | "2532" | "2533" | "2534" | "2535" | "2536" | "2540" | "2541" | "2542" | "2543" | "2544" | "2545" | "2546" | "2550" | "2551" | "2552" | "2553" | "2554" | "2555" | "2556" | "2560" | "2561" | "2562" | "2563" | "2564" | "2565" | "2566" | "2600" | "2601" | "2602" | "2603" | "2604" | "2605" | "2606" | "2610" | "2611" | "2612" | "2613" | "2614" | "2615" | "2616" | "2620" | "2621" | "2622" | "2623" | "2624" | "2625" | "2626" | "2630" | "2631" | "2632" | "2633" | "2634" | "2635" | "2636" | "2640" | "2641" | "2642" | "2643" | "2644" | "2645" | "2646" | "2650" | "2651" | "2652" | "2653" | "2654" | "2655" | "2656" | "2660" | "2661" | "2662" | "2663" | "2664" | "2665" | "2666" | "3000" | "3001" | "3002" | "3003" | "3004" | "3005" | "3006" | "3010" | "3011" | "3012" | "3013" | "3014" | "3015" | "3016" | "3020" | "3021" | "3022" | "3023" | "3024" | "3025" | "3026" | "3030" | "3031" | "3032" | "3033" | "3034" | "3035" | "3036" | "3040" | "3041" | "3042" | "3043" | "3044" | "3045" | "3046" | "3050" | "3051" | "3052" | "3053" | "3054" | "3055" | "3056" | "3060" | "3061" | "3062" | "3063" | "3064" | "3065" | "3066" | "3100" | "3101" | "3102" | "3103" | "3104" | "3105" | "3106" | "3110" | "3111" | "3112" | "3113" | "3114" | "3115" | "3116" | "3120" | "3121" | "3122" | "3123" | "3124" | "3125" | "3126" | "3130" | "3131" | "3132" | "3133" | "3134" | "3135" | "3136" | "3140" | "3141" | "3142" | "3143" | "3144" | "3145" | "3146" | "3150" | "3151" | "3152" | "3153" | "3154" | "3155" | "3156" | "3160" | "3161" | "3162" | "3163" | "3164" | "3165" | "3166" | "3200" | "3201" | "3202" | "3203" | "3204" | "3205" | "3206" | "3210" | "3211" | "3212" | "3213" | "3214" | "3215" | "3216" | "3220" | "3221" | "3222" | "3223" | "3224" | "3225" | "3226" | "3230" | "3231" | "3232" | "3233" | "3234" | "3235" | "3236" | "3240" | "3241" | "3242" | "3243" | "3244" | "3245" | "3246" | "3250" | "3251" | "3252" | "3253" | "3254" | "3255" | "3256" | "3260" | "3261" | "3262" | "3263" | "3264" | "3265" | "3266" | "3300" | "3301" | "3302" | "3303" | "3304" | "3305" | "3306" | "3310" | "3311" | "3312" | "3313" | "3314" | "3315" | "3316" | "3320" | "3321" | "3322" | "3323" | "3324" | "3325" | "3326" | "3330" | "3331" | "3332" | "3333" | "3334" | "3335" | "3336" | "3340" | "3341" | "3342" | "3343" | "3344" | "3345" | "3346" | "3350" | "3351" | "3352" | "3353" | "3354" | "3355" | "3356" | "3360" | "3361" | "3362" | "3363" | "3364" | "3365" | "3366" | "3400" | "3401" | "3402" | "3403" | "3404" | "3405" | "3406" | "3410" | "3411" | "3412" | "3413" | "3414" | "3415" | "3416" | "3420" | "3421" | "3422" | "3423" | "3424" | "3425" | "3426" | "3430" | "3431" | "3432" | "3433" | "3434" | "3435" | "3436" | "3440" | "3441" | "3442" | "3443" | "3444" | "3445" | "3446" | "3450" | "3451" | "3452" | "3453" | "3454" | "3455" | "3456" | "3460" | "3461" | "3462" | "3463" | "3464" | "3465" | "3466" | "3500" | "3501" | "3502" | "3503" | "3504" | "3505" | "3506" | "3510" | "3511" | "3512" | "3513" | "3514" | "3515" | "3516" | "3520" | "3521" | "3522" | "3523" | "3524" | "3525" | "3526" | "3530" | "3531" | "3532" | "3533" | "3534" | "3535" | "3536" | "3540" | "3541" | "3542" | "3543" | "3544" | "3545" | "3546" | "3550" | "3551" | "3552" | "3553" | "3554" | "3555" | "3556" | "3560" | "3561" | "3562" | "3563" | "3564" | "3565" | "3566" | "3600" | "3601" | "3602" | "3603" | "3604" | "3605" | "3606" | "3610" | "3611" | "3612" | "3613" | "3614" | "3615" | "3616" | "3620" | "3621" | "3622" | "3623" | "3624" | "3625" | "3626" | "3630" | "3631" | "3632" | "3633" | "3634" | "3635" | "3636" | "3640" | "3641" | "3642" | "3643" | "3644" | "3645" | "3646" | "3650" | "3651" | "3652" | "3653" | "3654" | "3655" | "3656" | "3660" | "3661" | "3662" | "3663" | "3664" | "3665" | "3666" | "4000" | "4001" | "4002" | "4003" | "4004" | "4005" | "4006" | "4010" | "4011" | "4012" | "4013" | "4014" | "4015" | "4016" | "4020" | "4021" | "4022" | "4023" | "4024" | "4025" | "4026" | "4030" | "4031" | "4032" | "4033" | "4034" | "4035" | "4036" | "4040" | "4041" | "4042" | "4043" | "4044" | "4045" | "4046" | "4050" | "4051" | "4052" | "4053" | "4054" | "4055" | "4056" | "4060" | "4061" | "4062" | "4063" | "4064" | "4065" | "4066" | "4100" | "4101" | "4102" | "4103" | "4104" | "4105" | "4106" | "4110" | "4111" | "4112" | "4113" | "4114" | "4115" | "4116" | "4120" | "4121" | "4122" | "4123" | "4124" | "4125" | "4126" | "4130" | "4131" | "4132" | "4133" | "4134" | "4135" | "4136" | "4140" | "4141" | "4142" | "4143" | "4144" | "4145" | "4146" | "4150" | "4151" | "4152" | "4153" | "4154" | "4155" | "4156" | "4160" | "4161" | "4162" | "4163" | "4164" | "4165" | "4166" | "4200" | "4201" | "4202" | "4203" | "4204" | "4205" | "4206" | "4210" | "4211" | "4212" | "4213" | "4214" | "4215" | "4216" | "4220" | "4221" | "4222" | "4223" | "4224" | "4225" | "4226" | "4230" | "4231" | "4232" | "4233" | "4234" | "4235" | "4236" | "4240" | "4241" | "4242" | "4243" | "4244" | "4245" | "4246" | "4250" | "4251" | "4252" | "4253" | "4254" | "4255" | "4256" | "4260" | "4261" | "4262" | "4263" | "4264" | "4265" | "4266" | "4300" | "4301" | "4302" | "4303" | "4304" | "4305" | "4306" | "4310" | "4311" | "4312" | "4313" | "4314" | "4315" | "4316" | "4320" | "4321" | "4322" | "4323" | "4324" | "4325" | "4326" | "4330" | "4331" | "4332" | "4333" | "4334" | "4335" | "4336" | "4340" | "4341" | "4342" | "4343" | "4344" | "4345" | "4346" | "4350" | "4351" | "4352" | "4353" | "4354" | "4355" | "4356" | "4360" | "4361" | "4362" | "4363" | "4364" | "4365" | "4366" | "4400" | "4401" | "4402" | "4403" | "4404" | "4405" | "4406" | "4410" | "4411" | "4412" | "4413" | "4414" | "4415" | "4416" | "4420" | "4421" | "4422" | "4423" | "4424" | "4425" | "4426" | "4430" | "4431" | "4432" | "4433" | "4434" | "4435" | "4436" | "4440" | "4441" | "4442" | "4443" | "4444" | "4445" | "4446" | "4450" | "4451" | "4452" | "4453" | "4454" | "4455" | "4456" | "4460" | "4461" | "4462" | "4463" | "4464" | "4465" | "4466" | "4500" | "4501" | "4502" | "4503" | "4504" | "4505" | "4506" | "4510" | "4511" | "4512" | "4513" | "4514" | "4515" | "4516" | "4520" | "4521" | "4522" | "4523" | "4524" | "4525" | "4526" | "4530" | "4531" | "4532" | "4533" | "4534" | "4535" | "4536" | "4540" | "4541" | "4542" | "4543" | "4544" | "4545" | "4546" | "4550" | "4551" | "4552" | "4553" | "4554" | "4555" | "4556" | "4560" | "4561" | "4562" | "4563" | "4564" | "4565" | "4566" | "4600" | "4601" | "4602" | "4603" | "4604" | "4605" | "4606" | "4610" | "4611" | "4612" | "4613" | "4614" | "4615" | "4616" | "4620" | "4621" | "4622" | "4623" | "4624" | "4625" | "4626" | "4630" | "4631" | "4632" | "4633" | "4634" | "4635" | "4636" | "4640" | "4641" | "4642" | "4643" | "4644" | "4645" | "4646" | "4650" | "4651" | "4652" | "4653" | "4654" | "4655" | "4656" | "4660" | "4661" | "4662" | "4663" | "4664" | "4665" | "4666" | "5000" | "5001" | "5002" | "5003" | "5004" | "5005" | "5006" | "5010" | "5011" | "5012" | "5013" | "5014" | "5015" | "5016" | "5020" | "5021" | "5022" | "5023" | "5024" | "5025" | "5026" | "5030" | "5031" | "5032" | "5033" | "5034" | "5035" | "5036" | "5040" | "5041" | "5042" | "5043" | "5044" | "5045" | "5046" | "5050" | "5051" | "5052" | "5053" | "5054" | "5055" | "5056" | "5060" | "5061" | "5062" | "5063" | "5064" | "5065" | "5066" | "5100" | "5101" | "5102" | "5103" | "5104" | "5105" | "5106" | "5110" | "5111" | "5112" | "5113" | "5114" | "5115" | "5116" | "5120" | "5121" | "5122" | "5123" | "5124" | "5125" | "5126" | "5130" | "5131" | "5132" | "5133" | "5134" | "5135" | "5136" | "5140" | "5141" | "5142" | "5143" | "5144" | "5145" | "5146" | "5150" | "5151" | "5152" | "5153" | "5154" | "5155" | "5156" | "5160" | "5161" | "5162" | "5163" | "5164" | "5165" | "5166" | "5200" | "5201" | "5202" | "5203" | "5204" | "5205" | "5206" | "5210" | "5211" | "5212" | "5213" | "5214" | "5215" | "5216" | "5220" | "5221" | "5222" | "5223" | "5224" | "5225" | "5226" | "5230" | "5231" | "5232" | "5233" | "5234" | "5235" | "5236" | "5240" | "5241" | "5242" | "5243" | "5244" | "5245" | "5246" | "5250" | "5251" | "5252" | "5253" | "5254" | "5255" | "5256" | "5260" | "5261" | "5262" | "5263" | "5264" | "5265" | "5266" | "5300" | "5301" | "5302" | "5303" | "5304" | "5305" | "5306" | "5310" | "5311" | "5312" | "5313" | "5314" | "5315" | "5316" | "5320" | "5321" | "5322" | "5323" | "5324" | "5325" | "5326" | "5330" | "5331" | "5332" | "5333" | "5334" | "5335" | "5336" | "5340" | "5341" | "5342" | "5343" | "5344" | "5345" | "5346" | "5350" | "5351" | "5352" | "5353" | "5354" | "5355" | "5356" | "5360" | "5361" | "5362" | "5363" | "5364" | "5365" | "5366" | "5400" | "5401" | "5402" | "5403" | "5404" | "5405" | "5406" | "5410" | "5411" | "5412" | "5413" | "5414" | "5415" | "5416" | "5420" | "5421" | "5422" | "5423" | "5424" | "5425" | "5426" | "5430" | "5431" | "5432" | "5433" | "5434" | "5435" | "5436" | "5440" | "5441" | "5442" | "5443" | "5444" | "5445" | "5446" | "5450" | "5451" | "5452" | "5453" | "5454" | "5455" | "5456" | "5460" | "5461" | "5462" | "5463" | "5464" | "5465" | "5466" | "5500" | "5501" | "5502" | "5503" | "5504" | "5505" | "5506" | "5510" | "5511" | "5512" | "5513" | "5514" | "5515" | "5516" | "5520" | "5521" | "5522" | "5523" | "5524" | "5525" | "5526" | "5530" | "5531" | "5532" | "5533" | "5534" | "5535" | "5536" | "5540" | "5541" | "5542" | "5543" | "5544" | "5545" | "5546" | "5550" | "5551" | "5552" | "5553" | "5554" | "5555" | "5556" | "5560" | "5561" | "5562" | "5563" | "5564" | "5565" | "5566" | "5600" | "5601" | "5602" | "5603" | "5604" | "5605" | "5606" | "5610" | "5611" | "5612" | "5613" | "5614" | "5615" | "5616" | "5620" | "5621" | "5622" | "5623" | "5624" | "5625" | "5626" | "5630" | "5631" | "5632" | "5633" | "5634" | "5635" | "5636" | "5640" | "5641" | "5642" | "5643" | "5644" | "5645" | "5646" | "5650" | "5651" | "5652" | "5653" | "5654" | "5655" | "5656" | "5660" | "5661" | "5662" | "5663" | "5664" | "5665" | "5666" | undefined) & T2 + +x = y6; +>x = y6 : ("0000" | "0001" | "0002" | "0003" | "0004" | "0005" | "0006" | "0010" | "0011" | "0012" | "0013" | "0014" | "0015" | "0016" | "0020" | "0021" | "0022" | "0023" | "0024" | "0025" | "0026" | "0030" | "0031" | "0032" | "0033" | "0034" | "0035" | "0036" | "0040" | "0041" | "0042" | "0043" | "0044" | "0045" | "0046" | "0050" | "0051" | "0052" | "0053" | "0054" | "0055" | "0056" | "0060" | "0061" | "0062" | "0063" | "0064" | "0065" | "0066" | "0100" | "0101" | "0102" | "0103" | "0104" | "0105" | "0106" | "0110" | "0111" | "0112" | "0113" | "0114" | "0115" | "0116" | "0120" | "0121" | "0122" | "0123" | "0124" | "0125" | "0126" | "0130" | "0131" | "0132" | "0133" | "0134" | "0135" | "0136" | "0140" | "0141" | "0142" | "0143" | "0144" | "0145" | "0146" | "0150" | "0151" | "0152" | "0153" | "0154" | "0155" | "0156" | "0160" | "0161" | "0162" | "0163" | "0164" | "0165" | "0166" | "0200" | "0201" | "0202" | "0203" | "0204" | "0205" | "0206" | "0210" | "0211" | "0212" | "0213" | "0214" | "0215" | "0216" | "0220" | "0221" | "0222" | "0223" | "0224" | "0225" | "0226" | "0230" | "0231" | "0232" | "0233" | "0234" | "0235" | "0236" | "0240" | "0241" | "0242" | "0243" | "0244" | "0245" | "0246" | "0250" | "0251" | "0252" | "0253" | "0254" | "0255" | "0256" | "0260" | "0261" | "0262" | "0263" | "0264" | "0265" | "0266" | "0300" | "0301" | "0302" | "0303" | "0304" | "0305" | "0306" | "0310" | "0311" | "0312" | "0313" | "0314" | "0315" | "0316" | "0320" | "0321" | "0322" | "0323" | "0324" | "0325" | "0326" | "0330" | "0331" | "0332" | "0333" | "0334" | "0335" | "0336" | "0340" | "0341" | "0342" | "0343" | "0344" | "0345" | "0346" | "0350" | "0351" | "0352" | "0353" | "0354" | "0355" | "0356" | "0360" | "0361" | "0362" | "0363" | "0364" | "0365" | "0366" | "0400" | "0401" | "0402" | "0403" | "0404" | "0405" | "0406" | "0410" | "0411" | "0412" | "0413" | "0414" | "0415" | "0416" | "0420" | "0421" | "0422" | "0423" | "0424" | "0425" | "0426" | "0430" | "0431" | "0432" | "0433" | "0434" | "0435" | "0436" | "0440" | "0441" | "0442" | "0443" | "0444" | "0445" | "0446" | "0450" | "0451" | "0452" | "0453" | "0454" | "0455" | "0456" | "0460" | "0461" | "0462" | "0463" | "0464" | "0465" | "0466" | "0500" | "0501" | "0502" | "0503" | "0504" | "0505" | "0506" | "0510" | "0511" | "0512" | "0513" | "0514" | "0515" | "0516" | "0520" | "0521" | "0522" | "0523" | "0524" | "0525" | "0526" | "0530" | "0531" | "0532" | "0533" | "0534" | "0535" | "0536" | "0540" | "0541" | "0542" | "0543" | "0544" | "0545" | "0546" | "0550" | "0551" | "0552" | "0553" | "0554" | "0555" | "0556" | "0560" | "0561" | "0562" | "0563" | "0564" | "0565" | "0566" | "0600" | "0601" | "0602" | "0603" | "0604" | "0605" | "0606" | "0610" | "0611" | "0612" | "0613" | "0614" | "0615" | "0616" | "0620" | "0621" | "0622" | "0623" | "0624" | "0625" | "0626" | "0630" | "0631" | "0632" | "0633" | "0634" | "0635" | "0636" | "0640" | "0641" | "0642" | "0643" | "0644" | "0645" | "0646" | "0650" | "0651" | "0652" | "0653" | "0654" | "0655" | "0656" | "0660" | "0661" | "0662" | "0663" | "0664" | "0665" | "0666" | "1000" | "1001" | "1002" | "1003" | "1004" | "1005" | "1006" | "1010" | "1011" | "1012" | "1013" | "1014" | "1015" | "1016" | "1020" | "1021" | "1022" | "1023" | "1024" | "1025" | "1026" | "1030" | "1031" | "1032" | "1033" | "1034" | "1035" | "1036" | "1040" | "1041" | "1042" | "1043" | "1044" | "1045" | "1046" | "1050" | "1051" | "1052" | "1053" | "1054" | "1055" | "1056" | "1060" | "1061" | "1062" | "1063" | "1064" | "1065" | "1066" | "1100" | "1101" | "1102" | "1103" | "1104" | "1105" | "1106" | "1110" | "1111" | "1112" | "1113" | "1114" | "1115" | "1116" | "1120" | "1121" | "1122" | "1123" | "1124" | "1125" | "1126" | "1130" | "1131" | "1132" | "1133" | "1134" | "1135" | "1136" | "1140" | "1141" | "1142" | "1143" | "1144" | "1145" | "1146" | "1150" | "1151" | "1152" | "1153" | "1154" | "1155" | "1156" | "1160" | "1161" | "1162" | "1163" | "1164" | "1165" | "1166" | "1200" | "1201" | "1202" | "1203" | "1204" | "1205" | "1206" | "1210" | "1211" | "1212" | "1213" | "1214" | "1215" | "1216" | "1220" | "1221" | "1222" | "1223" | "1224" | "1225" | "1226" | "1230" | "1231" | "1232" | "1233" | "1234" | "1235" | "1236" | "1240" | "1241" | "1242" | "1243" | "1244" | "1245" | "1246" | "1250" | "1251" | "1252" | "1253" | "1254" | "1255" | "1256" | "1260" | "1261" | "1262" | "1263" | "1264" | "1265" | "1266" | "1300" | "1301" | "1302" | "1303" | "1304" | "1305" | "1306" | "1310" | "1311" | "1312" | "1313" | "1314" | "1315" | "1316" | "1320" | "1321" | "1322" | "1323" | "1324" | "1325" | "1326" | "1330" | "1331" | "1332" | "1333" | "1334" | "1335" | "1336" | "1340" | "1341" | "1342" | "1343" | "1344" | "1345" | "1346" | "1350" | "1351" | "1352" | "1353" | "1354" | "1355" | "1356" | "1360" | "1361" | "1362" | "1363" | "1364" | "1365" | "1366" | "1400" | "1401" | "1402" | "1403" | "1404" | "1405" | "1406" | "1410" | "1411" | "1412" | "1413" | "1414" | "1415" | "1416" | "1420" | "1421" | "1422" | "1423" | "1424" | "1425" | "1426" | "1430" | "1431" | "1432" | "1433" | "1434" | "1435" | "1436" | "1440" | "1441" | "1442" | "1443" | "1444" | "1445" | "1446" | "1450" | "1451" | "1452" | "1453" | "1454" | "1455" | "1456" | "1460" | "1461" | "1462" | "1463" | "1464" | "1465" | "1466" | "1500" | "1501" | "1502" | "1503" | "1504" | "1505" | "1506" | "1510" | "1511" | "1512" | "1513" | "1514" | "1515" | "1516" | "1520" | "1521" | "1522" | "1523" | "1524" | "1525" | "1526" | "1530" | "1531" | "1532" | "1533" | "1534" | "1535" | "1536" | "1540" | "1541" | "1542" | "1543" | "1544" | "1545" | "1546" | "1550" | "1551" | "1552" | "1553" | "1554" | "1555" | "1556" | "1560" | "1561" | "1562" | "1563" | "1564" | "1565" | "1566" | "1600" | "1601" | "1602" | "1603" | "1604" | "1605" | "1606" | "1610" | "1611" | "1612" | "1613" | "1614" | "1615" | "1616" | "1620" | "1621" | "1622" | "1623" | "1624" | "1625" | "1626" | "1630" | "1631" | "1632" | "1633" | "1634" | "1635" | "1636" | "1640" | "1641" | "1642" | "1643" | "1644" | "1645" | "1646" | "1650" | "1651" | "1652" | "1653" | "1654" | "1655" | "1656" | "1660" | "1661" | "1662" | "1663" | "1664" | "1665" | "1666" | "2000" | "2001" | "2002" | "2003" | "2004" | "2005" | "2006" | "2010" | "2011" | "2012" | "2013" | "2014" | "2015" | "2016" | "2020" | "2021" | "2022" | "2023" | "2024" | "2025" | "2026" | "2030" | "2031" | "2032" | "2033" | "2034" | "2035" | "2036" | "2040" | "2041" | "2042" | "2043" | "2044" | "2045" | "2046" | "2050" | "2051" | "2052" | "2053" | "2054" | "2055" | "2056" | "2060" | "2061" | "2062" | "2063" | "2064" | "2065" | "2066" | "2100" | "2101" | "2102" | "2103" | "2104" | "2105" | "2106" | "2110" | "2111" | "2112" | "2113" | "2114" | "2115" | "2116" | "2120" | "2121" | "2122" | "2123" | "2124" | "2125" | "2126" | "2130" | "2131" | "2132" | "2133" | "2134" | "2135" | "2136" | "2140" | "2141" | "2142" | "2143" | "2144" | "2145" | "2146" | "2150" | "2151" | "2152" | "2153" | "2154" | "2155" | "2156" | "2160" | "2161" | "2162" | "2163" | "2164" | "2165" | "2166" | "2200" | "2201" | "2202" | "2203" | "2204" | "2205" | "2206" | "2210" | "2211" | "2212" | "2213" | "2214" | "2215" | "2216" | "2220" | "2221" | "2222" | "2223" | "2224" | "2225" | "2226" | "2230" | "2231" | "2232" | "2233" | "2234" | "2235" | "2236" | "2240" | "2241" | "2242" | "2243" | "2244" | "2245" | "2246" | "2250" | "2251" | "2252" | "2253" | "2254" | "2255" | "2256" | "2260" | "2261" | "2262" | "2263" | "2264" | "2265" | "2266" | "2300" | "2301" | "2302" | "2303" | "2304" | "2305" | "2306" | "2310" | "2311" | "2312" | "2313" | "2314" | "2315" | "2316" | "2320" | "2321" | "2322" | "2323" | "2324" | "2325" | "2326" | "2330" | "2331" | "2332" | "2333" | "2334" | "2335" | "2336" | "2340" | "2341" | "2342" | "2343" | "2344" | "2345" | "2346" | "2350" | "2351" | "2352" | "2353" | "2354" | "2355" | "2356" | "2360" | "2361" | "2362" | "2363" | "2364" | "2365" | "2366" | "2400" | "2401" | "2402" | "2403" | "2404" | "2405" | "2406" | "2410" | "2411" | "2412" | "2413" | "2414" | "2415" | "2416" | "2420" | "2421" | "2422" | "2423" | "2424" | "2425" | "2426" | "2430" | "2431" | "2432" | "2433" | "2434" | "2435" | "2436" | "2440" | "2441" | "2442" | "2443" | "2444" | "2445" | "2446" | "2450" | "2451" | "2452" | "2453" | "2454" | "2455" | "2456" | "2460" | "2461" | "2462" | "2463" | "2464" | "2465" | "2466" | "2500" | "2501" | "2502" | "2503" | "2504" | "2505" | "2506" | "2510" | "2511" | "2512" | "2513" | "2514" | "2515" | "2516" | "2520" | "2521" | "2522" | "2523" | "2524" | "2525" | "2526" | "2530" | "2531" | "2532" | "2533" | "2534" | "2535" | "2536" | "2540" | "2541" | "2542" | "2543" | "2544" | "2545" | "2546" | "2550" | "2551" | "2552" | "2553" | "2554" | "2555" | "2556" | "2560" | "2561" | "2562" | "2563" | "2564" | "2565" | "2566" | "2600" | "2601" | "2602" | "2603" | "2604" | "2605" | "2606" | "2610" | "2611" | "2612" | "2613" | "2614" | "2615" | "2616" | "2620" | "2621" | "2622" | "2623" | "2624" | "2625" | "2626" | "2630" | "2631" | "2632" | "2633" | "2634" | "2635" | "2636" | "2640" | "2641" | "2642" | "2643" | "2644" | "2645" | "2646" | "2650" | "2651" | "2652" | "2653" | "2654" | "2655" | "2656" | "2660" | "2661" | "2662" | "2663" | "2664" | "2665" | "2666" | "3000" | "3001" | "3002" | "3003" | "3004" | "3005" | "3006" | "3010" | "3011" | "3012" | "3013" | "3014" | "3015" | "3016" | "3020" | "3021" | "3022" | "3023" | "3024" | "3025" | "3026" | "3030" | "3031" | "3032" | "3033" | "3034" | "3035" | "3036" | "3040" | "3041" | "3042" | "3043" | "3044" | "3045" | "3046" | "3050" | "3051" | "3052" | "3053" | "3054" | "3055" | "3056" | "3060" | "3061" | "3062" | "3063" | "3064" | "3065" | "3066" | "3100" | "3101" | "3102" | "3103" | "3104" | "3105" | "3106" | "3110" | "3111" | "3112" | "3113" | "3114" | "3115" | "3116" | "3120" | "3121" | "3122" | "3123" | "3124" | "3125" | "3126" | "3130" | "3131" | "3132" | "3133" | "3134" | "3135" | "3136" | "3140" | "3141" | "3142" | "3143" | "3144" | "3145" | "3146" | "3150" | "3151" | "3152" | "3153" | "3154" | "3155" | "3156" | "3160" | "3161" | "3162" | "3163" | "3164" | "3165" | "3166" | "3200" | "3201" | "3202" | "3203" | "3204" | "3205" | "3206" | "3210" | "3211" | "3212" | "3213" | "3214" | "3215" | "3216" | "3220" | "3221" | "3222" | "3223" | "3224" | "3225" | "3226" | "3230" | "3231" | "3232" | "3233" | "3234" | "3235" | "3236" | "3240" | "3241" | "3242" | "3243" | "3244" | "3245" | "3246" | "3250" | "3251" | "3252" | "3253" | "3254" | "3255" | "3256" | "3260" | "3261" | "3262" | "3263" | "3264" | "3265" | "3266" | "3300" | "3301" | "3302" | "3303" | "3304" | "3305" | "3306" | "3310" | "3311" | "3312" | "3313" | "3314" | "3315" | "3316" | "3320" | "3321" | "3322" | "3323" | "3324" | "3325" | "3326" | "3330" | "3331" | "3332" | "3333" | "3334" | "3335" | "3336" | "3340" | "3341" | "3342" | "3343" | "3344" | "3345" | "3346" | "3350" | "3351" | "3352" | "3353" | "3354" | "3355" | "3356" | "3360" | "3361" | "3362" | "3363" | "3364" | "3365" | "3366" | "3400" | "3401" | "3402" | "3403" | "3404" | "3405" | "3406" | "3410" | "3411" | "3412" | "3413" | "3414" | "3415" | "3416" | "3420" | "3421" | "3422" | "3423" | "3424" | "3425" | "3426" | "3430" | "3431" | "3432" | "3433" | "3434" | "3435" | "3436" | "3440" | "3441" | "3442" | "3443" | "3444" | "3445" | "3446" | "3450" | "3451" | "3452" | "3453" | "3454" | "3455" | "3456" | "3460" | "3461" | "3462" | "3463" | "3464" | "3465" | "3466" | "3500" | "3501" | "3502" | "3503" | "3504" | "3505" | "3506" | "3510" | "3511" | "3512" | "3513" | "3514" | "3515" | "3516" | "3520" | "3521" | "3522" | "3523" | "3524" | "3525" | "3526" | "3530" | "3531" | "3532" | "3533" | "3534" | "3535" | "3536" | "3540" | "3541" | "3542" | "3543" | "3544" | "3545" | "3546" | "3550" | "3551" | "3552" | "3553" | "3554" | "3555" | "3556" | "3560" | "3561" | "3562" | "3563" | "3564" | "3565" | "3566" | "3600" | "3601" | "3602" | "3603" | "3604" | "3605" | "3606" | "3610" | "3611" | "3612" | "3613" | "3614" | "3615" | "3616" | "3620" | "3621" | "3622" | "3623" | "3624" | "3625" | "3626" | "3630" | "3631" | "3632" | "3633" | "3634" | "3635" | "3636" | "3640" | "3641" | "3642" | "3643" | "3644" | "3645" | "3646" | "3650" | "3651" | "3652" | "3653" | "3654" | "3655" | "3656" | "3660" | "3661" | "3662" | "3663" | "3664" | "3665" | "3666" | "4000" | "4001" | "4002" | "4003" | "4004" | "4005" | "4006" | "4010" | "4011" | "4012" | "4013" | "4014" | "4015" | "4016" | "4020" | "4021" | "4022" | "4023" | "4024" | "4025" | "4026" | "4030" | "4031" | "4032" | "4033" | "4034" | "4035" | "4036" | "4040" | "4041" | "4042" | "4043" | "4044" | "4045" | "4046" | "4050" | "4051" | "4052" | "4053" | "4054" | "4055" | "4056" | "4060" | "4061" | "4062" | "4063" | "4064" | "4065" | "4066" | "4100" | "4101" | "4102" | "4103" | "4104" | "4105" | "4106" | "4110" | "4111" | "4112" | "4113" | "4114" | "4115" | "4116" | "4120" | "4121" | "4122" | "4123" | "4124" | "4125" | "4126" | "4130" | "4131" | "4132" | "4133" | "4134" | "4135" | "4136" | "4140" | "4141" | "4142" | "4143" | "4144" | "4145" | "4146" | "4150" | "4151" | "4152" | "4153" | "4154" | "4155" | "4156" | "4160" | "4161" | "4162" | "4163" | "4164" | "4165" | "4166" | "4200" | "4201" | "4202" | "4203" | "4204" | "4205" | "4206" | "4210" | "4211" | "4212" | "4213" | "4214" | "4215" | "4216" | "4220" | "4221" | "4222" | "4223" | "4224" | "4225" | "4226" | "4230" | "4231" | "4232" | "4233" | "4234" | "4235" | "4236" | "4240" | "4241" | "4242" | "4243" | "4244" | "4245" | "4246" | "4250" | "4251" | "4252" | "4253" | "4254" | "4255" | "4256" | "4260" | "4261" | "4262" | "4263" | "4264" | "4265" | "4266" | "4300" | "4301" | "4302" | "4303" | "4304" | "4305" | "4306" | "4310" | "4311" | "4312" | "4313" | "4314" | "4315" | "4316" | "4320" | "4321" | "4322" | "4323" | "4324" | "4325" | "4326" | "4330" | "4331" | "4332" | "4333" | "4334" | "4335" | "4336" | "4340" | "4341" | "4342" | "4343" | "4344" | "4345" | "4346" | "4350" | "4351" | "4352" | "4353" | "4354" | "4355" | "4356" | "4360" | "4361" | "4362" | "4363" | "4364" | "4365" | "4366" | "4400" | "4401" | "4402" | "4403" | "4404" | "4405" | "4406" | "4410" | "4411" | "4412" | "4413" | "4414" | "4415" | "4416" | "4420" | "4421" | "4422" | "4423" | "4424" | "4425" | "4426" | "4430" | "4431" | "4432" | "4433" | "4434" | "4435" | "4436" | "4440" | "4441" | "4442" | "4443" | "4444" | "4445" | "4446" | "4450" | "4451" | "4452" | "4453" | "4454" | "4455" | "4456" | "4460" | "4461" | "4462" | "4463" | "4464" | "4465" | "4466" | "4500" | "4501" | "4502" | "4503" | "4504" | "4505" | "4506" | "4510" | "4511" | "4512" | "4513" | "4514" | "4515" | "4516" | "4520" | "4521" | "4522" | "4523" | "4524" | "4525" | "4526" | "4530" | "4531" | "4532" | "4533" | "4534" | "4535" | "4536" | "4540" | "4541" | "4542" | "4543" | "4544" | "4545" | "4546" | "4550" | "4551" | "4552" | "4553" | "4554" | "4555" | "4556" | "4560" | "4561" | "4562" | "4563" | "4564" | "4565" | "4566" | "4600" | "4601" | "4602" | "4603" | "4604" | "4605" | "4606" | "4610" | "4611" | "4612" | "4613" | "4614" | "4615" | "4616" | "4620" | "4621" | "4622" | "4623" | "4624" | "4625" | "4626" | "4630" | "4631" | "4632" | "4633" | "4634" | "4635" | "4636" | "4640" | "4641" | "4642" | "4643" | "4644" | "4645" | "4646" | "4650" | "4651" | "4652" | "4653" | "4654" | "4655" | "4656" | "4660" | "4661" | "4662" | "4663" | "4664" | "4665" | "4666" | "5000" | "5001" | "5002" | "5003" | "5004" | "5005" | "5006" | "5010" | "5011" | "5012" | "5013" | "5014" | "5015" | "5016" | "5020" | "5021" | "5022" | "5023" | "5024" | "5025" | "5026" | "5030" | "5031" | "5032" | "5033" | "5034" | "5035" | "5036" | "5040" | "5041" | "5042" | "5043" | "5044" | "5045" | "5046" | "5050" | "5051" | "5052" | "5053" | "5054" | "5055" | "5056" | "5060" | "5061" | "5062" | "5063" | "5064" | "5065" | "5066" | "5100" | "5101" | "5102" | "5103" | "5104" | "5105" | "5106" | "5110" | "5111" | "5112" | "5113" | "5114" | "5115" | "5116" | "5120" | "5121" | "5122" | "5123" | "5124" | "5125" | "5126" | "5130" | "5131" | "5132" | "5133" | "5134" | "5135" | "5136" | "5140" | "5141" | "5142" | "5143" | "5144" | "5145" | "5146" | "5150" | "5151" | "5152" | "5153" | "5154" | "5155" | "5156" | "5160" | "5161" | "5162" | "5163" | "5164" | "5165" | "5166" | "5200" | "5201" | "5202" | "5203" | "5204" | "5205" | "5206" | "5210" | "5211" | "5212" | "5213" | "5214" | "5215" | "5216" | "5220" | "5221" | "5222" | "5223" | "5224" | "5225" | "5226" | "5230" | "5231" | "5232" | "5233" | "5234" | "5235" | "5236" | "5240" | "5241" | "5242" | "5243" | "5244" | "5245" | "5246" | "5250" | "5251" | "5252" | "5253" | "5254" | "5255" | "5256" | "5260" | "5261" | "5262" | "5263" | "5264" | "5265" | "5266" | "5300" | "5301" | "5302" | "5303" | "5304" | "5305" | "5306" | "5310" | "5311" | "5312" | "5313" | "5314" | "5315" | "5316" | "5320" | "5321" | "5322" | "5323" | "5324" | "5325" | "5326" | "5330" | "5331" | "5332" | "5333" | "5334" | "5335" | "5336" | "5340" | "5341" | "5342" | "5343" | "5344" | "5345" | "5346" | "5350" | "5351" | "5352" | "5353" | "5354" | "5355" | "5356" | "5360" | "5361" | "5362" | "5363" | "5364" | "5365" | "5366" | "5400" | "5401" | "5402" | "5403" | "5404" | "5405" | "5406" | "5410" | "5411" | "5412" | "5413" | "5414" | "5415" | "5416" | "5420" | "5421" | "5422" | "5423" | "5424" | "5425" | "5426" | "5430" | "5431" | "5432" | "5433" | "5434" | "5435" | "5436" | "5440" | "5441" | "5442" | "5443" | "5444" | "5445" | "5446" | "5450" | "5451" | "5452" | "5453" | "5454" | "5455" | "5456" | "5460" | "5461" | "5462" | "5463" | "5464" | "5465" | "5466" | "5500" | "5501" | "5502" | "5503" | "5504" | "5505" | "5506" | "5510" | "5511" | "5512" | "5513" | "5514" | "5515" | "5516" | "5520" | "5521" | "5522" | "5523" | "5524" | "5525" | "5526" | "5530" | "5531" | "5532" | "5533" | "5534" | "5535" | "5536" | "5540" | "5541" | "5542" | "5543" | "5544" | "5545" | "5546" | "5550" | "5551" | "5552" | "5553" | "5554" | "5555" | "5556" | "5560" | "5561" | "5562" | "5563" | "5564" | "5565" | "5566" | "5600" | "5601" | "5602" | "5603" | "5604" | "5605" | "5606" | "5610" | "5611" | "5612" | "5613" | "5614" | "5615" | "5616" | "5620" | "5621" | "5622" | "5623" | "5624" | "5625" | "5626" | "5630" | "5631" | "5632" | "5633" | "5634" | "5635" | "5636" | "5640" | "5641" | "5642" | "5643" | "5644" | "5645" | "5646" | "5650" | "5651" | "5652" | "5653" | "5654" | "5655" | "5656" | "5660" | "5661" | "5662" | "5663" | "5664" | "5665" | "5666" | undefined) & T2 +>x : T1 | null +>y6 : ("0000" | "0001" | "0002" | "0003" | "0004" | "0005" | "0006" | "0010" | "0011" | "0012" | "0013" | "0014" | "0015" | "0016" | "0020" | "0021" | "0022" | "0023" | "0024" | "0025" | "0026" | "0030" | "0031" | "0032" | "0033" | "0034" | "0035" | "0036" | "0040" | "0041" | "0042" | "0043" | "0044" | "0045" | "0046" | "0050" | "0051" | "0052" | "0053" | "0054" | "0055" | "0056" | "0060" | "0061" | "0062" | "0063" | "0064" | "0065" | "0066" | "0100" | "0101" | "0102" | "0103" | "0104" | "0105" | "0106" | "0110" | "0111" | "0112" | "0113" | "0114" | "0115" | "0116" | "0120" | "0121" | "0122" | "0123" | "0124" | "0125" | "0126" | "0130" | "0131" | "0132" | "0133" | "0134" | "0135" | "0136" | "0140" | "0141" | "0142" | "0143" | "0144" | "0145" | "0146" | "0150" | "0151" | "0152" | "0153" | "0154" | "0155" | "0156" | "0160" | "0161" | "0162" | "0163" | "0164" | "0165" | "0166" | "0200" | "0201" | "0202" | "0203" | "0204" | "0205" | "0206" | "0210" | "0211" | "0212" | "0213" | "0214" | "0215" | "0216" | "0220" | "0221" | "0222" | "0223" | "0224" | "0225" | "0226" | "0230" | "0231" | "0232" | "0233" | "0234" | "0235" | "0236" | "0240" | "0241" | "0242" | "0243" | "0244" | "0245" | "0246" | "0250" | "0251" | "0252" | "0253" | "0254" | "0255" | "0256" | "0260" | "0261" | "0262" | "0263" | "0264" | "0265" | "0266" | "0300" | "0301" | "0302" | "0303" | "0304" | "0305" | "0306" | "0310" | "0311" | "0312" | "0313" | "0314" | "0315" | "0316" | "0320" | "0321" | "0322" | "0323" | "0324" | "0325" | "0326" | "0330" | "0331" | "0332" | "0333" | "0334" | "0335" | "0336" | "0340" | "0341" | "0342" | "0343" | "0344" | "0345" | "0346" | "0350" | "0351" | "0352" | "0353" | "0354" | "0355" | "0356" | "0360" | "0361" | "0362" | "0363" | "0364" | "0365" | "0366" | "0400" | "0401" | "0402" | "0403" | "0404" | "0405" | "0406" | "0410" | "0411" | "0412" | "0413" | "0414" | "0415" | "0416" | "0420" | "0421" | "0422" | "0423" | "0424" | "0425" | "0426" | "0430" | "0431" | "0432" | "0433" | "0434" | "0435" | "0436" | "0440" | "0441" | "0442" | "0443" | "0444" | "0445" | "0446" | "0450" | "0451" | "0452" | "0453" | "0454" | "0455" | "0456" | "0460" | "0461" | "0462" | "0463" | "0464" | "0465" | "0466" | "0500" | "0501" | "0502" | "0503" | "0504" | "0505" | "0506" | "0510" | "0511" | "0512" | "0513" | "0514" | "0515" | "0516" | "0520" | "0521" | "0522" | "0523" | "0524" | "0525" | "0526" | "0530" | "0531" | "0532" | "0533" | "0534" | "0535" | "0536" | "0540" | "0541" | "0542" | "0543" | "0544" | "0545" | "0546" | "0550" | "0551" | "0552" | "0553" | "0554" | "0555" | "0556" | "0560" | "0561" | "0562" | "0563" | "0564" | "0565" | "0566" | "0600" | "0601" | "0602" | "0603" | "0604" | "0605" | "0606" | "0610" | "0611" | "0612" | "0613" | "0614" | "0615" | "0616" | "0620" | "0621" | "0622" | "0623" | "0624" | "0625" | "0626" | "0630" | "0631" | "0632" | "0633" | "0634" | "0635" | "0636" | "0640" | "0641" | "0642" | "0643" | "0644" | "0645" | "0646" | "0650" | "0651" | "0652" | "0653" | "0654" | "0655" | "0656" | "0660" | "0661" | "0662" | "0663" | "0664" | "0665" | "0666" | "1000" | "1001" | "1002" | "1003" | "1004" | "1005" | "1006" | "1010" | "1011" | "1012" | "1013" | "1014" | "1015" | "1016" | "1020" | "1021" | "1022" | "1023" | "1024" | "1025" | "1026" | "1030" | "1031" | "1032" | "1033" | "1034" | "1035" | "1036" | "1040" | "1041" | "1042" | "1043" | "1044" | "1045" | "1046" | "1050" | "1051" | "1052" | "1053" | "1054" | "1055" | "1056" | "1060" | "1061" | "1062" | "1063" | "1064" | "1065" | "1066" | "1100" | "1101" | "1102" | "1103" | "1104" | "1105" | "1106" | "1110" | "1111" | "1112" | "1113" | "1114" | "1115" | "1116" | "1120" | "1121" | "1122" | "1123" | "1124" | "1125" | "1126" | "1130" | "1131" | "1132" | "1133" | "1134" | "1135" | "1136" | "1140" | "1141" | "1142" | "1143" | "1144" | "1145" | "1146" | "1150" | "1151" | "1152" | "1153" | "1154" | "1155" | "1156" | "1160" | "1161" | "1162" | "1163" | "1164" | "1165" | "1166" | "1200" | "1201" | "1202" | "1203" | "1204" | "1205" | "1206" | "1210" | "1211" | "1212" | "1213" | "1214" | "1215" | "1216" | "1220" | "1221" | "1222" | "1223" | "1224" | "1225" | "1226" | "1230" | "1231" | "1232" | "1233" | "1234" | "1235" | "1236" | "1240" | "1241" | "1242" | "1243" | "1244" | "1245" | "1246" | "1250" | "1251" | "1252" | "1253" | "1254" | "1255" | "1256" | "1260" | "1261" | "1262" | "1263" | "1264" | "1265" | "1266" | "1300" | "1301" | "1302" | "1303" | "1304" | "1305" | "1306" | "1310" | "1311" | "1312" | "1313" | "1314" | "1315" | "1316" | "1320" | "1321" | "1322" | "1323" | "1324" | "1325" | "1326" | "1330" | "1331" | "1332" | "1333" | "1334" | "1335" | "1336" | "1340" | "1341" | "1342" | "1343" | "1344" | "1345" | "1346" | "1350" | "1351" | "1352" | "1353" | "1354" | "1355" | "1356" | "1360" | "1361" | "1362" | "1363" | "1364" | "1365" | "1366" | "1400" | "1401" | "1402" | "1403" | "1404" | "1405" | "1406" | "1410" | "1411" | "1412" | "1413" | "1414" | "1415" | "1416" | "1420" | "1421" | "1422" | "1423" | "1424" | "1425" | "1426" | "1430" | "1431" | "1432" | "1433" | "1434" | "1435" | "1436" | "1440" | "1441" | "1442" | "1443" | "1444" | "1445" | "1446" | "1450" | "1451" | "1452" | "1453" | "1454" | "1455" | "1456" | "1460" | "1461" | "1462" | "1463" | "1464" | "1465" | "1466" | "1500" | "1501" | "1502" | "1503" | "1504" | "1505" | "1506" | "1510" | "1511" | "1512" | "1513" | "1514" | "1515" | "1516" | "1520" | "1521" | "1522" | "1523" | "1524" | "1525" | "1526" | "1530" | "1531" | "1532" | "1533" | "1534" | "1535" | "1536" | "1540" | "1541" | "1542" | "1543" | "1544" | "1545" | "1546" | "1550" | "1551" | "1552" | "1553" | "1554" | "1555" | "1556" | "1560" | "1561" | "1562" | "1563" | "1564" | "1565" | "1566" | "1600" | "1601" | "1602" | "1603" | "1604" | "1605" | "1606" | "1610" | "1611" | "1612" | "1613" | "1614" | "1615" | "1616" | "1620" | "1621" | "1622" | "1623" | "1624" | "1625" | "1626" | "1630" | "1631" | "1632" | "1633" | "1634" | "1635" | "1636" | "1640" | "1641" | "1642" | "1643" | "1644" | "1645" | "1646" | "1650" | "1651" | "1652" | "1653" | "1654" | "1655" | "1656" | "1660" | "1661" | "1662" | "1663" | "1664" | "1665" | "1666" | "2000" | "2001" | "2002" | "2003" | "2004" | "2005" | "2006" | "2010" | "2011" | "2012" | "2013" | "2014" | "2015" | "2016" | "2020" | "2021" | "2022" | "2023" | "2024" | "2025" | "2026" | "2030" | "2031" | "2032" | "2033" | "2034" | "2035" | "2036" | "2040" | "2041" | "2042" | "2043" | "2044" | "2045" | "2046" | "2050" | "2051" | "2052" | "2053" | "2054" | "2055" | "2056" | "2060" | "2061" | "2062" | "2063" | "2064" | "2065" | "2066" | "2100" | "2101" | "2102" | "2103" | "2104" | "2105" | "2106" | "2110" | "2111" | "2112" | "2113" | "2114" | "2115" | "2116" | "2120" | "2121" | "2122" | "2123" | "2124" | "2125" | "2126" | "2130" | "2131" | "2132" | "2133" | "2134" | "2135" | "2136" | "2140" | "2141" | "2142" | "2143" | "2144" | "2145" | "2146" | "2150" | "2151" | "2152" | "2153" | "2154" | "2155" | "2156" | "2160" | "2161" | "2162" | "2163" | "2164" | "2165" | "2166" | "2200" | "2201" | "2202" | "2203" | "2204" | "2205" | "2206" | "2210" | "2211" | "2212" | "2213" | "2214" | "2215" | "2216" | "2220" | "2221" | "2222" | "2223" | "2224" | "2225" | "2226" | "2230" | "2231" | "2232" | "2233" | "2234" | "2235" | "2236" | "2240" | "2241" | "2242" | "2243" | "2244" | "2245" | "2246" | "2250" | "2251" | "2252" | "2253" | "2254" | "2255" | "2256" | "2260" | "2261" | "2262" | "2263" | "2264" | "2265" | "2266" | "2300" | "2301" | "2302" | "2303" | "2304" | "2305" | "2306" | "2310" | "2311" | "2312" | "2313" | "2314" | "2315" | "2316" | "2320" | "2321" | "2322" | "2323" | "2324" | "2325" | "2326" | "2330" | "2331" | "2332" | "2333" | "2334" | "2335" | "2336" | "2340" | "2341" | "2342" | "2343" | "2344" | "2345" | "2346" | "2350" | "2351" | "2352" | "2353" | "2354" | "2355" | "2356" | "2360" | "2361" | "2362" | "2363" | "2364" | "2365" | "2366" | "2400" | "2401" | "2402" | "2403" | "2404" | "2405" | "2406" | "2410" | "2411" | "2412" | "2413" | "2414" | "2415" | "2416" | "2420" | "2421" | "2422" | "2423" | "2424" | "2425" | "2426" | "2430" | "2431" | "2432" | "2433" | "2434" | "2435" | "2436" | "2440" | "2441" | "2442" | "2443" | "2444" | "2445" | "2446" | "2450" | "2451" | "2452" | "2453" | "2454" | "2455" | "2456" | "2460" | "2461" | "2462" | "2463" | "2464" | "2465" | "2466" | "2500" | "2501" | "2502" | "2503" | "2504" | "2505" | "2506" | "2510" | "2511" | "2512" | "2513" | "2514" | "2515" | "2516" | "2520" | "2521" | "2522" | "2523" | "2524" | "2525" | "2526" | "2530" | "2531" | "2532" | "2533" | "2534" | "2535" | "2536" | "2540" | "2541" | "2542" | "2543" | "2544" | "2545" | "2546" | "2550" | "2551" | "2552" | "2553" | "2554" | "2555" | "2556" | "2560" | "2561" | "2562" | "2563" | "2564" | "2565" | "2566" | "2600" | "2601" | "2602" | "2603" | "2604" | "2605" | "2606" | "2610" | "2611" | "2612" | "2613" | "2614" | "2615" | "2616" | "2620" | "2621" | "2622" | "2623" | "2624" | "2625" | "2626" | "2630" | "2631" | "2632" | "2633" | "2634" | "2635" | "2636" | "2640" | "2641" | "2642" | "2643" | "2644" | "2645" | "2646" | "2650" | "2651" | "2652" | "2653" | "2654" | "2655" | "2656" | "2660" | "2661" | "2662" | "2663" | "2664" | "2665" | "2666" | "3000" | "3001" | "3002" | "3003" | "3004" | "3005" | "3006" | "3010" | "3011" | "3012" | "3013" | "3014" | "3015" | "3016" | "3020" | "3021" | "3022" | "3023" | "3024" | "3025" | "3026" | "3030" | "3031" | "3032" | "3033" | "3034" | "3035" | "3036" | "3040" | "3041" | "3042" | "3043" | "3044" | "3045" | "3046" | "3050" | "3051" | "3052" | "3053" | "3054" | "3055" | "3056" | "3060" | "3061" | "3062" | "3063" | "3064" | "3065" | "3066" | "3100" | "3101" | "3102" | "3103" | "3104" | "3105" | "3106" | "3110" | "3111" | "3112" | "3113" | "3114" | "3115" | "3116" | "3120" | "3121" | "3122" | "3123" | "3124" | "3125" | "3126" | "3130" | "3131" | "3132" | "3133" | "3134" | "3135" | "3136" | "3140" | "3141" | "3142" | "3143" | "3144" | "3145" | "3146" | "3150" | "3151" | "3152" | "3153" | "3154" | "3155" | "3156" | "3160" | "3161" | "3162" | "3163" | "3164" | "3165" | "3166" | "3200" | "3201" | "3202" | "3203" | "3204" | "3205" | "3206" | "3210" | "3211" | "3212" | "3213" | "3214" | "3215" | "3216" | "3220" | "3221" | "3222" | "3223" | "3224" | "3225" | "3226" | "3230" | "3231" | "3232" | "3233" | "3234" | "3235" | "3236" | "3240" | "3241" | "3242" | "3243" | "3244" | "3245" | "3246" | "3250" | "3251" | "3252" | "3253" | "3254" | "3255" | "3256" | "3260" | "3261" | "3262" | "3263" | "3264" | "3265" | "3266" | "3300" | "3301" | "3302" | "3303" | "3304" | "3305" | "3306" | "3310" | "3311" | "3312" | "3313" | "3314" | "3315" | "3316" | "3320" | "3321" | "3322" | "3323" | "3324" | "3325" | "3326" | "3330" | "3331" | "3332" | "3333" | "3334" | "3335" | "3336" | "3340" | "3341" | "3342" | "3343" | "3344" | "3345" | "3346" | "3350" | "3351" | "3352" | "3353" | "3354" | "3355" | "3356" | "3360" | "3361" | "3362" | "3363" | "3364" | "3365" | "3366" | "3400" | "3401" | "3402" | "3403" | "3404" | "3405" | "3406" | "3410" | "3411" | "3412" | "3413" | "3414" | "3415" | "3416" | "3420" | "3421" | "3422" | "3423" | "3424" | "3425" | "3426" | "3430" | "3431" | "3432" | "3433" | "3434" | "3435" | "3436" | "3440" | "3441" | "3442" | "3443" | "3444" | "3445" | "3446" | "3450" | "3451" | "3452" | "3453" | "3454" | "3455" | "3456" | "3460" | "3461" | "3462" | "3463" | "3464" | "3465" | "3466" | "3500" | "3501" | "3502" | "3503" | "3504" | "3505" | "3506" | "3510" | "3511" | "3512" | "3513" | "3514" | "3515" | "3516" | "3520" | "3521" | "3522" | "3523" | "3524" | "3525" | "3526" | "3530" | "3531" | "3532" | "3533" | "3534" | "3535" | "3536" | "3540" | "3541" | "3542" | "3543" | "3544" | "3545" | "3546" | "3550" | "3551" | "3552" | "3553" | "3554" | "3555" | "3556" | "3560" | "3561" | "3562" | "3563" | "3564" | "3565" | "3566" | "3600" | "3601" | "3602" | "3603" | "3604" | "3605" | "3606" | "3610" | "3611" | "3612" | "3613" | "3614" | "3615" | "3616" | "3620" | "3621" | "3622" | "3623" | "3624" | "3625" | "3626" | "3630" | "3631" | "3632" | "3633" | "3634" | "3635" | "3636" | "3640" | "3641" | "3642" | "3643" | "3644" | "3645" | "3646" | "3650" | "3651" | "3652" | "3653" | "3654" | "3655" | "3656" | "3660" | "3661" | "3662" | "3663" | "3664" | "3665" | "3666" | "4000" | "4001" | "4002" | "4003" | "4004" | "4005" | "4006" | "4010" | "4011" | "4012" | "4013" | "4014" | "4015" | "4016" | "4020" | "4021" | "4022" | "4023" | "4024" | "4025" | "4026" | "4030" | "4031" | "4032" | "4033" | "4034" | "4035" | "4036" | "4040" | "4041" | "4042" | "4043" | "4044" | "4045" | "4046" | "4050" | "4051" | "4052" | "4053" | "4054" | "4055" | "4056" | "4060" | "4061" | "4062" | "4063" | "4064" | "4065" | "4066" | "4100" | "4101" | "4102" | "4103" | "4104" | "4105" | "4106" | "4110" | "4111" | "4112" | "4113" | "4114" | "4115" | "4116" | "4120" | "4121" | "4122" | "4123" | "4124" | "4125" | "4126" | "4130" | "4131" | "4132" | "4133" | "4134" | "4135" | "4136" | "4140" | "4141" | "4142" | "4143" | "4144" | "4145" | "4146" | "4150" | "4151" | "4152" | "4153" | "4154" | "4155" | "4156" | "4160" | "4161" | "4162" | "4163" | "4164" | "4165" | "4166" | "4200" | "4201" | "4202" | "4203" | "4204" | "4205" | "4206" | "4210" | "4211" | "4212" | "4213" | "4214" | "4215" | "4216" | "4220" | "4221" | "4222" | "4223" | "4224" | "4225" | "4226" | "4230" | "4231" | "4232" | "4233" | "4234" | "4235" | "4236" | "4240" | "4241" | "4242" | "4243" | "4244" | "4245" | "4246" | "4250" | "4251" | "4252" | "4253" | "4254" | "4255" | "4256" | "4260" | "4261" | "4262" | "4263" | "4264" | "4265" | "4266" | "4300" | "4301" | "4302" | "4303" | "4304" | "4305" | "4306" | "4310" | "4311" | "4312" | "4313" | "4314" | "4315" | "4316" | "4320" | "4321" | "4322" | "4323" | "4324" | "4325" | "4326" | "4330" | "4331" | "4332" | "4333" | "4334" | "4335" | "4336" | "4340" | "4341" | "4342" | "4343" | "4344" | "4345" | "4346" | "4350" | "4351" | "4352" | "4353" | "4354" | "4355" | "4356" | "4360" | "4361" | "4362" | "4363" | "4364" | "4365" | "4366" | "4400" | "4401" | "4402" | "4403" | "4404" | "4405" | "4406" | "4410" | "4411" | "4412" | "4413" | "4414" | "4415" | "4416" | "4420" | "4421" | "4422" | "4423" | "4424" | "4425" | "4426" | "4430" | "4431" | "4432" | "4433" | "4434" | "4435" | "4436" | "4440" | "4441" | "4442" | "4443" | "4444" | "4445" | "4446" | "4450" | "4451" | "4452" | "4453" | "4454" | "4455" | "4456" | "4460" | "4461" | "4462" | "4463" | "4464" | "4465" | "4466" | "4500" | "4501" | "4502" | "4503" | "4504" | "4505" | "4506" | "4510" | "4511" | "4512" | "4513" | "4514" | "4515" | "4516" | "4520" | "4521" | "4522" | "4523" | "4524" | "4525" | "4526" | "4530" | "4531" | "4532" | "4533" | "4534" | "4535" | "4536" | "4540" | "4541" | "4542" | "4543" | "4544" | "4545" | "4546" | "4550" | "4551" | "4552" | "4553" | "4554" | "4555" | "4556" | "4560" | "4561" | "4562" | "4563" | "4564" | "4565" | "4566" | "4600" | "4601" | "4602" | "4603" | "4604" | "4605" | "4606" | "4610" | "4611" | "4612" | "4613" | "4614" | "4615" | "4616" | "4620" | "4621" | "4622" | "4623" | "4624" | "4625" | "4626" | "4630" | "4631" | "4632" | "4633" | "4634" | "4635" | "4636" | "4640" | "4641" | "4642" | "4643" | "4644" | "4645" | "4646" | "4650" | "4651" | "4652" | "4653" | "4654" | "4655" | "4656" | "4660" | "4661" | "4662" | "4663" | "4664" | "4665" | "4666" | "5000" | "5001" | "5002" | "5003" | "5004" | "5005" | "5006" | "5010" | "5011" | "5012" | "5013" | "5014" | "5015" | "5016" | "5020" | "5021" | "5022" | "5023" | "5024" | "5025" | "5026" | "5030" | "5031" | "5032" | "5033" | "5034" | "5035" | "5036" | "5040" | "5041" | "5042" | "5043" | "5044" | "5045" | "5046" | "5050" | "5051" | "5052" | "5053" | "5054" | "5055" | "5056" | "5060" | "5061" | "5062" | "5063" | "5064" | "5065" | "5066" | "5100" | "5101" | "5102" | "5103" | "5104" | "5105" | "5106" | "5110" | "5111" | "5112" | "5113" | "5114" | "5115" | "5116" | "5120" | "5121" | "5122" | "5123" | "5124" | "5125" | "5126" | "5130" | "5131" | "5132" | "5133" | "5134" | "5135" | "5136" | "5140" | "5141" | "5142" | "5143" | "5144" | "5145" | "5146" | "5150" | "5151" | "5152" | "5153" | "5154" | "5155" | "5156" | "5160" | "5161" | "5162" | "5163" | "5164" | "5165" | "5166" | "5200" | "5201" | "5202" | "5203" | "5204" | "5205" | "5206" | "5210" | "5211" | "5212" | "5213" | "5214" | "5215" | "5216" | "5220" | "5221" | "5222" | "5223" | "5224" | "5225" | "5226" | "5230" | "5231" | "5232" | "5233" | "5234" | "5235" | "5236" | "5240" | "5241" | "5242" | "5243" | "5244" | "5245" | "5246" | "5250" | "5251" | "5252" | "5253" | "5254" | "5255" | "5256" | "5260" | "5261" | "5262" | "5263" | "5264" | "5265" | "5266" | "5300" | "5301" | "5302" | "5303" | "5304" | "5305" | "5306" | "5310" | "5311" | "5312" | "5313" | "5314" | "5315" | "5316" | "5320" | "5321" | "5322" | "5323" | "5324" | "5325" | "5326" | "5330" | "5331" | "5332" | "5333" | "5334" | "5335" | "5336" | "5340" | "5341" | "5342" | "5343" | "5344" | "5345" | "5346" | "5350" | "5351" | "5352" | "5353" | "5354" | "5355" | "5356" | "5360" | "5361" | "5362" | "5363" | "5364" | "5365" | "5366" | "5400" | "5401" | "5402" | "5403" | "5404" | "5405" | "5406" | "5410" | "5411" | "5412" | "5413" | "5414" | "5415" | "5416" | "5420" | "5421" | "5422" | "5423" | "5424" | "5425" | "5426" | "5430" | "5431" | "5432" | "5433" | "5434" | "5435" | "5436" | "5440" | "5441" | "5442" | "5443" | "5444" | "5445" | "5446" | "5450" | "5451" | "5452" | "5453" | "5454" | "5455" | "5456" | "5460" | "5461" | "5462" | "5463" | "5464" | "5465" | "5466" | "5500" | "5501" | "5502" | "5503" | "5504" | "5505" | "5506" | "5510" | "5511" | "5512" | "5513" | "5514" | "5515" | "5516" | "5520" | "5521" | "5522" | "5523" | "5524" | "5525" | "5526" | "5530" | "5531" | "5532" | "5533" | "5534" | "5535" | "5536" | "5540" | "5541" | "5542" | "5543" | "5544" | "5545" | "5546" | "5550" | "5551" | "5552" | "5553" | "5554" | "5555" | "5556" | "5560" | "5561" | "5562" | "5563" | "5564" | "5565" | "5566" | "5600" | "5601" | "5602" | "5603" | "5604" | "5605" | "5606" | "5610" | "5611" | "5612" | "5613" | "5614" | "5615" | "5616" | "5620" | "5621" | "5622" | "5623" | "5624" | "5625" | "5626" | "5630" | "5631" | "5632" | "5633" | "5634" | "5635" | "5636" | "5640" | "5641" | "5642" | "5643" | "5644" | "5645" | "5646" | "5650" | "5651" | "5652" | "5653" | "5654" | "5655" | "5656" | "5660" | "5661" | "5662" | "5663" | "5664" | "5665" | "5666" | undefined) & T2 + +declare const y: T1 & T2; +>y : T1 & T2 + +x = y; +>x = y : T1 & T2 +>x : T1 | null +>y : T1 & T2 + diff --git a/tsc/testdata/baselines/reference/compiler/relationComplexitySharedCheckOrder(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/relationComplexitySharedCheckOrder(checkorder=typesfirst).errors.txt new file mode 100644 index 0000000000000..814b4254058e7 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/relationComplexitySharedCheckOrder(checkorder=typesfirst).errors.txt @@ -0,0 +1,35 @@ +relationComplexitySharedCheckOrder.ts(20,1): error TS2859: Excessive complexity comparing types '("0000" | "0001" | "0002" | "0003" | "0004" | "0005" | "0006" | "0010" | "0011" | "0012" | "0013" | "0014" | "0015" | "0016" | "0020" | "0021" | "0022" | "0023" | "0024" | "0025" | "0026" | "0030" | "0031" | "0032" | "0033" | "0034" | "0035" | "0036" | "0040" | "0041" | "0042" | "0043" | "0044" | "0045" | "0046" | "0050" | "0051" | "0052" | "0053" | "0054" | "0055" | "0056" | "0060" | "0061" | "0062" | "0063" | "0064" | "0065" | "0066" | "0100" | "0101" | "0102" | "0103" | "0104" | "0105" | "0106" | "0110" | "0111" | "0112" | "0113" | "0114" | "0115" | "0116" | "0120" | "0121" | "0122" | "0123" | "0124" | "0125" | "0126" | "0130" | "0131" | "0132" | "0133" | "0134" | "0135" | "0136" | "0140" | "0141" | "0142" | "0143" | "0144" | "0145" | "0146" | "0150" | "0151" | "0152" | "0153" | "0154" | "0155" | "0156" | "0160" | "0161" | "0162" | "0163" | "0164" | "0165" | "0166" | "0200" | "0201" | "0202" | "0203" | "0204" | "0205" | "0206" | "0210" | "0211" | "0212" | "0213" | "0214" | "0215" | "0216" | "0220" | "0221" | "0222" | "0223" | "0224" | "0225" | "0226" | "0230" | "0231" | "0232" | "0233" | "0234" | "0235" | "0236" | "0240" | "0241" | "0242" | "0243" | "0244" | "0245" | "0246" | "0250" | "0251" | "0252" | "0253" | "0254" | "0255" | "0256" | "0260" | "0261" | "0262" | "0263" | "0264" | "0265" | "0266" | "0300" | "0301" | "0302" | "0303" | "0304" | "0305" | "0306" | "0310" | "0311" | "0312" | "0313" | "0314" | "0315" | "0316" | "0320" | "0321" | "0322" | "0323" | "0324" | "0325" | "0326" | "0330" | "0331" | "0332" | "0333" | "0334" | "0335" | "0336" | "0340" | "0341" | "0342" | "0343" | "0344" | "0345" | "0346" | "0350" | "0351" | "0352" | "0353" | "0354" | "0355" | "0356" | "0360" | "0361" | "0362" | "0363" | "0364" | "0365" | "0366" | "0400" | "0401" | "0402" | "0403" | "0404" | "0405" | "0406" | "0410" | "0411" | "0412" | "0413" | "0414" | "0415" | "0416" | "0420" | "0421" | "0422" | "0423" | "0424" | "0425" | "0426" | "0430" | "0431" | "0432" | "0433" | "0434" | "0435" | "0436" | "0440" | "0441" | "0442" | "0443" | "0444" | "0445" | "0446" | "0450" | "0451" | "0452" | "0453" | "0454" | "0455" | "0456" | "0460" | "0461" | "0462" | "0463" | "0464" | "0465" | "0466" | "0500" | "0501" | "0502" | "0503" | "0504" | "0505" | "0506" | "0510" | "0511" | "0512" | "0513" | "0514" | "0515" | "0516" | "0520" | "0521" | "0522" | "0523" | "0524" | "0525" | "0526" | "0530" | "0531" | "0532" | "0533" | "0534" | "0535" | "0536" | "0540" | "0541" | "0542" | "0543" | "0544" | "0545" | "0546" | "0550" | "0551" | "0552" | "0553" | "0554" | "0555" | "0556" | "0560" | "0561" | "0562" | "0563" | "0564" | "0565" | "0566" | "0600" | "0601" | "0602" | "0603" | "0604" | "0605" | "0606" | "0610" | "0611" | "0612" | "0613" | "0614" | "0615" | "0616" | "0620" | "0621" | "0622" | "0623" | "0624" | "0625" | "0626" | "0630" | "0631" | "0632" | "0633" | "0634" | "0635" | "0636" | "0640" | "0641" | "0642" | "0643" | "0644" | "0645" | "0646" | "0650" | "0651" | "0652" | "0653" | "0654" | "0655" | "0656" | "0660" | "0661" | "0662" | "0663" | "0664" | "0665" | "0666" | "1000" | "1001" | "1002" | "1003" | "1004" | "1005" | "1006" | "1010" | "1011" | "1012" | "1013" | "1014" | "1015" | "1016" | "1020" | "1021" | "1022" | "1023" | "1024" | "1025" | "1026" | "1030" | "1031" | "1032" | "1033" | "1034" | "1035" | "1036" | "1040" | "1041" | "1042" | "1043" | "1044" | "1045" | "1046" | "1050" | "1051" | "1052" | "1053" | "1054" | "1055" | "1056" | "1060" | "1061" | "1062" | "1063" | "1064" | "1065" | "1066" | "1100" | "1101" | "1102" | "1103" | "1104" | "1105" | "1106" | "1110" | "1111" | "1112" | "1113" | "1114" | "1115" | "1116" | "1120" | "1121" | "1122" | "1123" | "1124" | "1125" | "1126" | "1130" | "1131" | "1132" | "1133" | "1134" | "1135" | "1136" | "1140" | "1141" | "1142" | "1143" | "1144" | "1145" | "1146" | "1150" | "1151" | "1152" | "1153" | "1154" | "1155" | "1156" | "1160" | "1161" | "1162" | "1163" | "1164" | "1165" | "1166" | "1200" | "1201" | "1202" | "1203" | "1204" | "1205" | "1206" | "1210" | "1211" | "1212" | "1213" | "1214" | "1215" | "1216" | "1220" | "1221" | "1222" | "1223" | "1224" | "1225" | "1226" | "1230" | "1231" | "1232" | "1233" | "1234" | "1235" | "1236" | "1240" | "1241" | "1242" | "1243" | "1244" | "1245" | "1246" | "1250" | "1251" | "1252" | "1253" | "1254" | "1255" | "1256" | "1260" | "1261" | "1262" | "1263" | "1264" | "1265" | "1266" | "1300" | "1301" | "1302" | "1303" | "1304" | "1305" | "1306" | "1310" | "1311" | "1312" | "1313" | "1314" | "1315" | "1316" | "1320" | "1321" | "1322" | "1323" | "1324" | "1325" | "1326" | "1330" | "1331" | "1332" | "1333" | "1334" | "1335" | "1336" | "1340" | "1341" | "1342" | "1343" | "1344" | "1345" | "1346" | "1350" | "1351" | "1352" | "1353" | "1354" | "1355" | "1356" | "1360" | "1361" | "1362" | "1363" | "1364" | "1365" | "1366" | "1400" | "1401" | "1402" | "1403" | "1404" | "1405" | "1406" | "1410" | "1411" | "1412" | "1413" | "1414" | "1415" | "1416" | "1420" | "1421" | "1422" | "1423" | "1424" | "1425" | "1426" | "1430" | "1431" | "1432" | "1433" | "1434" | "1435" | "1436" | "1440" | "1441" | "1442" | "1443" | "1444" | "1445" | "1446" | "1450" | "1451" | "1452" | "1453" | "1454" | "1455" | "1456" | "1460" | "1461" | "1462" | "1463" | "1464" | "1465" | "1466" | "1500" | "1501" | "1502" | "1503" | "1504" | "1505" | "1506" | "1510" | "1511" | "1512" | "1513" | "1514" | "1515" | "1516" | "1520" | "1521" | "1522" | "1523" | "1524" | "1525" | "1526" | "1530" | "1531" | "1532" | "1533" | "1534" | "1535" | "1536" | "1540" | "1541" | "1542" | "1543" | "1544" | "1545" | "1546" | "1550" | "1551" | "1552" | "1553" | "1554" | "1555" | "1556" | "1560" | "1561" | "1562" | "1563" | "1564" | "1565" | "1566" | "1600" | "1601" | "1602" | "1603" | "1604" | "1605" | "1606" | "1610" | "1611" | "1612" | "1613" | "1614" | "1615" | "1616" | "1620" | "1621" | "1622" | "1623" | "1624" | "1625" | "1626" | "1630" | "1631" | "1632" | "1633" | "1634" | "1635" | "1636" | "1640" | "1641" | "1642" | "1643" | "1644" | "1645" | "1646" | "1650" | "1651" | "1652" | "1653" | "1654" | "1655" | "1656" | "1660" | "1661" | "1662" | "1663" | "1664" | "1665" | "1666" | "2000" | "2001" | "2002" | "2003" | "2004" | "2005" | "2006" | "2010" | "2011" | "2012" | "2013" | "2014" | "2015" | "2016" | "2020" | "2021" | "2022" | "2023" | "2024" | "2025" | "2026" | "2030" | "2031" | "2032" | "2033" | "2034" | "2035" | "2036" | "2040" | "2041" | "2042" | "2043" | "2044" | "2045" | "2046" | "2050" | "2051" | "2052" | "2053" | "2054" | "2055" | "2056" | "2060" | "2061" | "2062" | "2063" | "2064" | "2065" | "2066" | "2100" | "2101" | "2102" | "2103" | "2104" | "2105" | "2106" | "2110" | "2111" | "2112" | "2113" | "2114" | "2115" | "2116" | "2120" | "2121" | "2122" | "2123" | "2124" | "2125" | "2126" | "2130" | "2131" | "2132" | "2133" | "2134" | "2135" | "2136" | "2140" | "2141" | "2142" | "2143" | "2144" | "2145" | "2146" | "2150" | "2151" | "2152" | "2153" | "2154" | "2155" | "2156" | "2160" | "2161" | "2162" | "2163" | "2164" | "2165" | "2166" | "2200" | "2201" | "2202" | "2203" | "2204" | "2205" | "2206" | "2210" | "2211" | "2212" | "2213" | "2214" | "2215" | "2216" | "2220" | "2221" | "2222" | "2223" | "2224" | "2225" | "2226" | "2230" | "2231" | "2232" | "2233" | "2234" | "2235" | "2236" | "2240" | "2241" | "2242" | "2243" | "2244" | "2245" | "2246" | "2250" | "2251" | "2252" | "2253" | "2254" | "2255" | "2256" | "2260" | "2261" | "2262" | "2263" | "2264" | "2265" | "2266" | "2300" | "2301" | "2302" | "2303" | "2304" | "2305" | "2306" | "2310" | "2311" | "2312" | "2313" | "2314" | "2315" | "2316" | "2320" | "2321" | "2322" | "2323" | "2324" | "2325" | "2326" | "2330" | "2331" | "2332" | "2333" | "2334" | "2335" | "2336" | "2340" | "2341" | "2342" | "2343" | "2344" | "2345" | "2346" | "2350" | "2351" | "2352" | "2353" | "2354" | "2355" | "2356" | "2360" | "2361" | "2362" | "2363" | "2364" | "2365" | "2366" | "2400" | "2401" | "2402" | "2403" | "2404" | "2405" | "2406" | "2410" | "2411" | "2412" | "2413" | "2414" | "2415" | "2416" | "2420" | "2421" | "2422" | "2423" | "2424" | "2425" | "2426" | "2430" | "2431" | "2432" | "2433" | "2434" | "2435" | "2436" | "2440" | "2441" | "2442" | "2443" | "2444" | "2445" | "2446" | "2450" | "2451" | "2452" | "2453" | "2454" | "2455" | "2456" | "2460" | "2461" | "2462" | "2463" | "2464" | "2465" | "2466" | "2500" | "2501" | "2502" | "2503" | "2504" | "2505" | "2506" | "2510" | "2511" | "2512" | "2513" | "2514" | "2515" | "2516" | "2520" | "2521" | "2522" | "2523" | "2524" | "2525" | "2526" | "2530" | "2531" | "2532" | "2533" | "2534" | "2535" | "2536" | "2540" | "2541" | "2542" | "2543" | "2544" | "2545" | "2546" | "2550" | "2551" | "2552" | "2553" | "2554" | "2555" | "2556" | "2560" | "2561" | "2562" | "2563" | "2564" | "2565" | "2566" | "2600" | "2601" | "2602" | "2603" | "2604" | "2605" | "2606" | "2610" | "2611" | "2612" | "2613" | "2614" | "2615" | "2616" | "2620" | "2621" | "2622" | "2623" | "2624" | "2625" | "2626" | "2630" | "2631" | "2632" | "2633" | "2634" | "2635" | "2636" | "2640" | "2641" | "2642" | "2643" | "2644" | "2645" | "2646" | "2650" | "2651" | "2652" | "2653" | "2654" | "2655" | "2656" | "2660" | "2661" | "2662" | "2663" | "2664" | "2665" | "2666" | "3000" | "3001" | "3002" | "3003" | "3004" | "3005" | "3006" | "3010" | "3011" | "3012" | "3013" | "3014" | "3015" | "3016" | "3020" | "3021" | "3022" | "3023" | "3024" | "3025" | "3026" | "3030" | "3031" | "3032" | "3033" | "3034" | "3035" | "3036" | "3040" | "3041" | "3042" | "3043" | "3044" | "3045" | "3046" | "3050" | "3051" | "3052" | "3053" | "3054" | "3055" | "3056" | "3060" | "3061" | "3062" | "3063" | "3064" | "3065" | "3066" | "3100" | "3101" | "3102" | "3103" | "3104" | "3105" | "3106" | "3110" | "3111" | "3112" | "3113" | "3114" | "3115" | "3116" | "3120" | "3121" | "3122" | "3123" | "3124" | "3125" | "3126" | "3130" | "3131" | "3132" | "3133" | "3134" | "3135" | "3136" | "3140" | "3141" | "3142" | "3143" | "3144" | "3145" | "3146" | "3150" | "3151" | "3152" | "3153" | "3154" | "3155" | "3156" | "3160" | "3161" | "3162" | "3163" | "3164" | "3165" | "3166" | "3200" | "3201" | "3202" | "3203" | "3204" | "3205" | "3206" | "3210" | "3211" | "3212" | "3213" | "3214" | "3215" | "3216" | "3220" | "3221" | "3222" | "3223" | "3224" | "3225" | "3226" | "3230" | "3231" | "3232" | "3233" | "3234" | "3235" | "3236" | "3240" | "3241" | "3242" | "3243" | "3244" | "3245" | "3246" | "3250" | "3251" | "3252" | "3253" | "3254" | "3255" | "3256" | "3260" | "3261" | "3262" | "3263" | "3264" | "3265" | "3266" | "3300" | "3301" | "3302" | "3303" | "3304" | "3305" | "3306" | "3310" | "3311" | "3312" | "3313" | "3314" | "3315" | "3316" | "3320" | "3321" | "3322" | "3323" | "3324" | "3325" | "3326" | "3330" | "3331" | "3332" | "3333" | "3334" | "3335" | "3336" | "3340" | "3341" | "3342" | "3343" | "3344" | "3345" | "3346" | "3350" | "3351" | "3352" | "3353" | "3354" | "3355" | "3356" | "3360" | "3361" | "3362" | "3363" | "3364" | "3365" | "3366" | "3400" | "3401" | "3402" | "3403" | "3404" | "3405" | "3406" | "3410" | "3411" | "3412" | "3413" | "3414" | "3415" | "3416" | "3420" | "3421" | "3422" | "3423" | "3424" | "3425" | "3426" | "3430" | "3431" | "3432" | "3433" | "3434" | "3435" | "3436" | "3440" | "3441" | "3442" | "3443" | "3444" | "3445" | "3446" | "3450" | "3451" | "3452" | "3453" | "3454" | "3455" | "3456" | "3460" | "3461" | "3462" | "3463" | "3464" | "3465" | "3466" | "3500" | "3501" | "3502" | "3503" | "3504" | "3505" | "3506" | "3510" | "3511" | "3512" | "3513" | "3514" | "3515" | "3516" | "3520" | "3521" | "3522" | "3523" | "3524" | "3525" | "3526" | "3530" | "3531" | "3532" | "3533" | "3534" | "3535" | "3536" | "3540" | "3541" | "3542" | "3543" | "3544" | "3545" | "3546" | "3550" | "3551" | "3552" | "3553" | "3554" | "3555" | "3556" | "3560" | "3561" | "3562" | "3563" | "3564" | "3565" | "3566" | "3600" | "3601" | "3602" | "3603" | "3604" | "3605" | "3606" | "3610" | "3611" | "3612" | "3613" | "3614" | "3615" | "3616" | "3620" | "3621" | "3622" | "3623" | "3624" | "3625" | "3626" | "3630" | "3631" | "3632" | "3633" | "3634" | "3635" | "3636" | "3640" | "3641" | "3642" | "3643" | "3644" | "3645" | "3646" | "3650" | "3651" | "3652" | "3653" | "3654" | "3655" | "3656" | "3660" | "3661" | "3662" | "3663" | "3664" | "3665" | "3666" | "4000" | "4001" | "4002" | "4003" | "4004" | "4005" | "4006" | "4010" | "4011" | "4012" | "4013" | "4014" | "4015" | "4016" | "4020" | "4021" | "4022" | "4023" | "4024" | "4025" | "4026" | "4030" | "4031" | "4032" | "4033" | "4034" | "4035" | "4036" | "4040" | "4041" | "4042" | "4043" | "4044" | "4045" | "4046" | "4050" | "4051" | "4052" | "4053" | "4054" | "4055" | "4056" | "4060" | "4061" | "4062" | "4063" | "4064" | "4065" | "4066" | "4100" | "4101" | "4102" | "4103" | "4104" | "4105" | "4106" | "4110" | "4111" | "4112" | "4113" | "4114" | "4115" | "4116" | "4120" | "4121" | "4122" | "4123" | "4124" | "4125" | "4126" | "4130" | "4131" | "4132" | "4133" | "4134" | "4135" | "4136" | "4140" | "4141" | "4142" | "4143" | "4144" | "4145" | "4146" | "4150" | "4151" | "4152" | "4153" | "4154" | "4155" | "4156" | "4160" | "4161" | "4162" | "4163" | "4164" | "4165" | "4166" | "4200" | "4201" | "4202" | "4203" | "4204" | "4205" | "4206" | "4210" | "4211" | "4212" | "4213" | "4214" | "4215" | "4216" | "4220" | "4221" | "4222" | "4223" | "4224" | "4225" | "4226" | "4230" | "4231" | "4232" | "4233" | "4234" | "4235" | "4236" | "4240" | "4241" | "4242" | "4243" | "4244" | "4245" | "4246" | "4250" | "4251" | "4252" | "4253" | "4254" | "4255" | "4256" | "4260" | "4261" | "4262" | "4263" | "4264" | "4265" | "4266" | "4300" | "4301" | "4302" | "4303" | "4304" | "4305" | "4306" | "4310" | "4311" | "4312" | "4313" | "4314" | "4315" | "4316" | "4320" | "4321" | "4322" | "4323" | "4324" | "4325" | "4326" | "4330" | "4331" | "4332" | "4333" | "4334" | "4335" | "4336" | "4340" | "4341" | "4342" | "4343" | "4344" | "4345" | "4346" | "4350" | "4351" | "4352" | "4353" | "4354" | "4355" | "4356" | "4360" | "4361" | "4362" | "4363" | "4364" | "4365" | "4366" | "4400" | "4401" | "4402" | "4403" | "4404" | "4405" | "4406" | "4410" | "4411" | "4412" | "4413" | "4414" | "4415" | "4416" | "4420" | "4421" | "4422" | "4423" | "4424" | "4425" | "4426" | "4430" | "4431" | "4432" | "4433" | "4434" | "4435" | "4436" | "4440" | "4441" | "4442" | "4443" | "4444" | "4445" | "4446" | "4450" | "4451" | "4452" | "4453" | "4454" | "4455" | "4456" | "4460" | "4461" | "4462" | "4463" | "4464" | "4465" | "4466" | "4500" | "4501" | "4502" | "4503" | "4504" | "4505" | "4506" | "4510" | "4511" | "4512" | "4513" | "4514" | "4515" | "4516" | "4520" | "4521" | "4522" | "4523" | "4524" | "4525" | "4526" | "4530" | "4531" | "4532" | "4533" | "4534" | "4535" | "4536" | "4540" | "4541" | "4542" | "4543" | "4544" | "4545" | "4546" | "4550" | "4551" | "4552" | "4553" | "4554" | "4555" | "4556" | "4560" | "4561" | "4562" | "4563" | "4564" | "4565" | "4566" | "4600" | "4601" | "4602" | "4603" | "4604" | "4605" | "4606" | "4610" | "4611" | "4612" | "4613" | "4614" | "4615" | "4616" | "4620" | "4621" | "4622" | "4623" | "4624" | "4625" | "4626" | "4630" | "4631" | "4632" | "4633" | "4634" | "4635" | "4636" | "4640" | "4641" | "4642" | "4643" | "4644" | "4645" | "4646" | "4650" | "4651" | "4652" | "4653" | "4654" | "4655" | "4656" | "4660" | "4661" | "4662" | "4663" | "4664" | "4665" | "4666" | "5000" | "5001" | "5002" | "5003" | "5004" | "5005" | "5006" | "5010" | "5011" | "5012" | "5013" | "5014" | "5015" | "5016" | "5020" | "5021" | "5022" | "5023" | "5024" | "5025" | "5026" | "5030" | "5031" | "5032" | "5033" | "5034" | "5035" | "5036" | "5040" | "5041" | "5042" | "5043" | "5044" | "5045" | "5046" | "5050" | "5051" | "5052" | "5053" | "5054" | "5055" | "5056" | "5060" | "5061" | "5062" | "5063" | "5064" | "5065" | "5066" | "5100" | "5101" | "5102" | "5103" | "5104" | "5105" | "5106" | "5110" | "5111" | "5112" | "5113" | "5114" | "5115" | "5116" | "5120" | "5121" | "5122" | "5123" | "5124" | "5125" | "5126" | "5130" | "5131" | "5132" | "5133" | "5134" | "5135" | "5136" | "5140" | "5141" | "5142" | "5143" | "5144" | "5145" | "5146" | "5150" | "5151" | "5152" | "5153" | "5154" | "5155" | "5156" | "5160" | "5161" | "5162" | "5163" | "5164" | "5165" | "5166" | "5200" | "5201" | "5202" | "5203" | "5204" | "5205" | "5206" | "5210" | "5211" | "5212" | "5213" | "5214" | "5215" | "5216" | "5220" | "5221" | "5222" | "5223" | "5224" | "5225" | "5226" | "5230" | "5231" | "5232" | "5233" | "5234" | "5235" | "5236" | "5240" | "5241" | "5242" | "5243" | "5244" | "5245" | "5246" | "5250" | "5251" | "5252" | "5253" | "5254" | "5255" | "5256" | "5260" | "5261" | "5262" | "5263" | "5264" | "5265" | "5266" | "5300" | "5301" | "5302" | "5303" | "5304" | "5305" | "5306" | "5310" | "5311" | "5312" | "5313" | "5314" | "5315" | "5316" | "5320" | "5321" | "5322" | "5323" | "5324" | "5325" | "5326" | "5330" | "5331" | "5332" | "5333" | "5334" | "5335" | "5336" | "5340" | "5341" | "5342" | "5343" | "5344" | "5345" | "5346" | "5350" | "5351" | "5352" | "5353" | "5354" | "5355" | "5356" | "5360" | "5361" | "5362" | "5363" | "5364" | "5365" | "5366" | "5400" | "5401" | "5402" | "5403" | "5404" | "5405" | "5406" | "5410" | "5411" | "5412" | "5413" | "5414" | "5415" | "5416" | "5420" | "5421" | "5422" | "5423" | "5424" | "5425" | "5426" | "5430" | "5431" | "5432" | "5433" | "5434" | "5435" | "5436" | "5440" | "5441" | "5442" | "5443" | "5444" | "5445" | "5446" | "5450" | "5451" | "5452" | "5453" | "5454" | "5455" | "5456" | "5460" | "5461" | "5462" | "5463" | "5464" | "5465" | "5466" | "5500" | "5501" | "5502" | "5503" | "5504" | "5505" | "5506" | "5510" | "5511" | "5512" | "5513" | "5514" | "5515" | "5516" | "5520" | "5521" | "5522" | "5523" | "5524" | "5525" | "5526" | "5530" | "5531" | "5532" | "5533" | "5534" | "5535" | "5536" | "5540" | "5541" | "5542" | "5543" | "5544" | "5545" | "5546" | "5550" | "5551" | "5552" | "5553" | "5554" | "5555" | "5556" | "5560" | "5561" | "5562" | "5563" | "5564" | "5565" | "5566" | "5600" | "5601" | "5602" | "5603" | "5604" | "5605" | "5606" | "5610" | "5611" | "5612" | "5613" | "5614" | "5615" | "5616" | "5620" | "5621" | "5622" | "5623" | "5624" | "5625" | "5626" | "5630" | "5631" | "5632" | "5633" | "5634" | "5635" | "5636" | "5640" | "5641" | "5642" | "5643" | "5644" | "5645" | "5646" | "5650" | "5651" | "5652" | "5653" | "5654" | "5655" | "5656" | "5660" | "5661" | "5662" | "5663" | "5664" | "5665" | "5666" | undefined) & T2' and 'T1 | null'. +relationComplexitySharedCheckOrder.ts(22,1): error TS2859: Excessive complexity comparing types 'T1 & T2' and 'T1 | null'. +relationComplexitySharedCheckOrder.ts(22,1): error TS2859: Excessive complexity comparing types 'T1 & T2' and 'T1 | null'. + + +==== relationComplexitySharedCheckOrder.ts (3 errors) ==== + // Relating y to x fresh caches too many comparisons. In program order the + // comparisons before it have cached all but a seventh of them. Whether + // relating y is too complex must not depend on which comes first. + + type D = '0' | '1' | '2' | '3' | '4' | '5' | '6'; + type T1 = `${D}${D}${D}${D}` | undefined; + type T2 = { a: string } | { b: number }; + declare let x: T1 | null; + declare const y1: (`${'0'}${D}${D}${D}` | undefined) & T2; + x = y1; + declare const y2: (`${'0' | '1'}${D}${D}${D}` | undefined) & T2; + x = y2; + declare const y3: (`${'0' | '1' | '2'}${D}${D}${D}` | undefined) & T2; + x = y3; + declare const y4: (`${'0' | '1' | '2' | '3'}${D}${D}${D}` | undefined) & T2; + x = y4; + declare const y5: (`${'0' | '1' | '2' | '3' | '4'}${D}${D}${D}` | undefined) & T2; + x = y5; + declare const y6: (`${'0' | '1' | '2' | '3' | '4' | '5'}${D}${D}${D}` | undefined) & T2; + x = y6; + ~ +!!! error TS2859: Excessive complexity comparing types '("0000" | "0001" | "0002" | "0003" | "0004" | "0005" | "0006" | "0010" | "0011" | "0012" | "0013" | "0014" | "0015" | "0016" | "0020" | "0021" | "0022" | "0023" | "0024" | "0025" | "0026" | "0030" | "0031" | "0032" | "0033" | "0034" | "0035" | "0036" | "0040" | "0041" | "0042" | "0043" | "0044" | "0045" | "0046" | "0050" | "0051" | "0052" | "0053" | "0054" | "0055" | "0056" | "0060" | "0061" | "0062" | "0063" | "0064" | "0065" | "0066" | "0100" | "0101" | "0102" | "0103" | "0104" | "0105" | "0106" | "0110" | "0111" | "0112" | "0113" | "0114" | "0115" | "0116" | "0120" | "0121" | "0122" | "0123" | "0124" | "0125" | "0126" | "0130" | "0131" | "0132" | "0133" | "0134" | "0135" | "0136" | "0140" | "0141" | "0142" | "0143" | "0144" | "0145" | "0146" | "0150" | "0151" | "0152" | "0153" | "0154" | "0155" | "0156" | "0160" | "0161" | "0162" | "0163" | "0164" | "0165" | "0166" | "0200" | "0201" | "0202" | "0203" | "0204" | "0205" | "0206" | "0210" | "0211" | "0212" | "0213" | "0214" | "0215" | "0216" | "0220" | "0221" | "0222" | "0223" | "0224" | "0225" | "0226" | "0230" | "0231" | "0232" | "0233" | "0234" | "0235" | "0236" | "0240" | "0241" | "0242" | "0243" | "0244" | "0245" | "0246" | "0250" | "0251" | "0252" | "0253" | "0254" | "0255" | "0256" | "0260" | "0261" | "0262" | "0263" | "0264" | "0265" | "0266" | "0300" | "0301" | "0302" | "0303" | "0304" | "0305" | "0306" | "0310" | "0311" | "0312" | "0313" | "0314" | "0315" | "0316" | "0320" | "0321" | "0322" | "0323" | "0324" | "0325" | "0326" | "0330" | "0331" | "0332" | "0333" | "0334" | "0335" | "0336" | "0340" | "0341" | "0342" | "0343" | "0344" | "0345" | "0346" | "0350" | "0351" | "0352" | "0353" | "0354" | "0355" | "0356" | "0360" | "0361" | "0362" | "0363" | "0364" | "0365" | "0366" | "0400" | "0401" | "0402" | "0403" | "0404" | "0405" | "0406" | "0410" | "0411" | "0412" | "0413" | "0414" | "0415" | "0416" | "0420" | "0421" | "0422" | "0423" | "0424" | "0425" | "0426" | "0430" | "0431" | "0432" | "0433" | "0434" | "0435" | "0436" | "0440" | "0441" | "0442" | "0443" | "0444" | "0445" | "0446" | "0450" | "0451" | "0452" | "0453" | "0454" | "0455" | "0456" | "0460" | "0461" | "0462" | "0463" | "0464" | "0465" | "0466" | "0500" | "0501" | "0502" | "0503" | "0504" | "0505" | "0506" | "0510" | "0511" | "0512" | "0513" | "0514" | "0515" | "0516" | "0520" | "0521" | "0522" | "0523" | "0524" | "0525" | "0526" | "0530" | "0531" | "0532" | "0533" | "0534" | "0535" | "0536" | "0540" | "0541" | "0542" | "0543" | "0544" | "0545" | "0546" | "0550" | "0551" | "0552" | "0553" | "0554" | "0555" | "0556" | "0560" | "0561" | "0562" | "0563" | "0564" | "0565" | "0566" | "0600" | "0601" | "0602" | "0603" | "0604" | "0605" | "0606" | "0610" | "0611" | "0612" | "0613" | "0614" | "0615" | "0616" | "0620" | "0621" | "0622" | "0623" | "0624" | "0625" | "0626" | "0630" | "0631" | "0632" | "0633" | "0634" | "0635" | "0636" | "0640" | "0641" | "0642" | "0643" | "0644" | "0645" | "0646" | "0650" | "0651" | "0652" | "0653" | "0654" | "0655" | "0656" | "0660" | "0661" | "0662" | "0663" | "0664" | "0665" | "0666" | "1000" | "1001" | "1002" | "1003" | "1004" | "1005" | "1006" | "1010" | "1011" | "1012" | "1013" | "1014" | "1015" | "1016" | "1020" | "1021" | "1022" | "1023" | "1024" | "1025" | "1026" | "1030" | "1031" | "1032" | "1033" | "1034" | "1035" | "1036" | "1040" | "1041" | "1042" | "1043" | "1044" | "1045" | "1046" | "1050" | "1051" | "1052" | "1053" | "1054" | "1055" | "1056" | "1060" | "1061" | "1062" | "1063" | "1064" | "1065" | "1066" | "1100" | "1101" | "1102" | "1103" | "1104" | "1105" | "1106" | "1110" | "1111" | "1112" | "1113" | "1114" | "1115" | "1116" | "1120" | "1121" | "1122" | "1123" | "1124" | "1125" | "1126" | "1130" | "1131" | "1132" | "1133" | "1134" | "1135" | "1136" | "1140" | "1141" | "1142" | "1143" | "1144" | "1145" | "1146" | "1150" | "1151" | "1152" | "1153" | "1154" | "1155" | "1156" | "1160" | "1161" | "1162" | "1163" | "1164" | "1165" | "1166" | "1200" | "1201" | "1202" | "1203" | "1204" | "1205" | "1206" | "1210" | "1211" | "1212" | "1213" | "1214" | "1215" | "1216" | "1220" | "1221" | "1222" | "1223" | "1224" | "1225" | "1226" | "1230" | "1231" | "1232" | "1233" | "1234" | "1235" | "1236" | "1240" | "1241" | "1242" | "1243" | "1244" | "1245" | "1246" | "1250" | "1251" | "1252" | "1253" | "1254" | "1255" | "1256" | "1260" | "1261" | "1262" | "1263" | "1264" | "1265" | "1266" | "1300" | "1301" | "1302" | "1303" | "1304" | "1305" | "1306" | "1310" | "1311" | "1312" | "1313" | "1314" | "1315" | "1316" | "1320" | "1321" | "1322" | "1323" | "1324" | "1325" | "1326" | "1330" | "1331" | "1332" | "1333" | "1334" | "1335" | "1336" | "1340" | "1341" | "1342" | "1343" | "1344" | "1345" | "1346" | "1350" | "1351" | "1352" | "1353" | "1354" | "1355" | "1356" | "1360" | "1361" | "1362" | "1363" | "1364" | "1365" | "1366" | "1400" | "1401" | "1402" | "1403" | "1404" | "1405" | "1406" | "1410" | "1411" | "1412" | "1413" | "1414" | "1415" | "1416" | "1420" | "1421" | "1422" | "1423" | "1424" | "1425" | "1426" | "1430" | "1431" | "1432" | "1433" | "1434" | "1435" | "1436" | "1440" | "1441" | "1442" | "1443" | "1444" | "1445" | "1446" | "1450" | "1451" | "1452" | "1453" | "1454" | "1455" | "1456" | "1460" | "1461" | "1462" | "1463" | "1464" | "1465" | "1466" | "1500" | "1501" | "1502" | "1503" | "1504" | "1505" | "1506" | "1510" | "1511" | "1512" | "1513" | "1514" | "1515" | "1516" | "1520" | "1521" | "1522" | "1523" | "1524" | "1525" | "1526" | "1530" | "1531" | "1532" | "1533" | "1534" | "1535" | "1536" | "1540" | "1541" | "1542" | "1543" | "1544" | "1545" | "1546" | "1550" | "1551" | "1552" | "1553" | "1554" | "1555" | "1556" | "1560" | "1561" | "1562" | "1563" | "1564" | "1565" | "1566" | "1600" | "1601" | "1602" | "1603" | "1604" | "1605" | "1606" | "1610" | "1611" | "1612" | "1613" | "1614" | "1615" | "1616" | "1620" | "1621" | "1622" | "1623" | "1624" | "1625" | "1626" | "1630" | "1631" | "1632" | "1633" | "1634" | "1635" | "1636" | "1640" | "1641" | "1642" | "1643" | "1644" | "1645" | "1646" | "1650" | "1651" | "1652" | "1653" | "1654" | "1655" | "1656" | "1660" | "1661" | "1662" | "1663" | "1664" | "1665" | "1666" | "2000" | "2001" | "2002" | "2003" | "2004" | "2005" | "2006" | "2010" | "2011" | "2012" | "2013" | "2014" | "2015" | "2016" | "2020" | "2021" | "2022" | "2023" | "2024" | "2025" | "2026" | "2030" | "2031" | "2032" | "2033" | "2034" | "2035" | "2036" | "2040" | "2041" | "2042" | "2043" | "2044" | "2045" | "2046" | "2050" | "2051" | "2052" | "2053" | "2054" | "2055" | "2056" | "2060" | "2061" | "2062" | "2063" | "2064" | "2065" | "2066" | "2100" | "2101" | "2102" | "2103" | "2104" | "2105" | "2106" | "2110" | "2111" | "2112" | "2113" | "2114" | "2115" | "2116" | "2120" | "2121" | "2122" | "2123" | "2124" | "2125" | "2126" | "2130" | "2131" | "2132" | "2133" | "2134" | "2135" | "2136" | "2140" | "2141" | "2142" | "2143" | "2144" | "2145" | "2146" | "2150" | "2151" | "2152" | "2153" | "2154" | "2155" | "2156" | "2160" | "2161" | "2162" | "2163" | "2164" | "2165" | "2166" | "2200" | "2201" | "2202" | "2203" | "2204" | "2205" | "2206" | "2210" | "2211" | "2212" | "2213" | "2214" | "2215" | "2216" | "2220" | "2221" | "2222" | "2223" | "2224" | "2225" | "2226" | "2230" | "2231" | "2232" | "2233" | "2234" | "2235" | "2236" | "2240" | "2241" | "2242" | "2243" | "2244" | "2245" | "2246" | "2250" | "2251" | "2252" | "2253" | "2254" | "2255" | "2256" | "2260" | "2261" | "2262" | "2263" | "2264" | "2265" | "2266" | "2300" | "2301" | "2302" | "2303" | "2304" | "2305" | "2306" | "2310" | "2311" | "2312" | "2313" | "2314" | "2315" | "2316" | "2320" | "2321" | "2322" | "2323" | "2324" | "2325" | "2326" | "2330" | "2331" | "2332" | "2333" | "2334" | "2335" | "2336" | "2340" | "2341" | "2342" | "2343" | "2344" | "2345" | "2346" | "2350" | "2351" | "2352" | "2353" | "2354" | "2355" | "2356" | "2360" | "2361" | "2362" | "2363" | "2364" | "2365" | "2366" | "2400" | "2401" | "2402" | "2403" | "2404" | "2405" | "2406" | "2410" | "2411" | "2412" | "2413" | "2414" | "2415" | "2416" | "2420" | "2421" | "2422" | "2423" | "2424" | "2425" | "2426" | "2430" | "2431" | "2432" | "2433" | "2434" | "2435" | "2436" | "2440" | "2441" | "2442" | "2443" | "2444" | "2445" | "2446" | "2450" | "2451" | "2452" | "2453" | "2454" | "2455" | "2456" | "2460" | "2461" | "2462" | "2463" | "2464" | "2465" | "2466" | "2500" | "2501" | "2502" | "2503" | "2504" | "2505" | "2506" | "2510" | "2511" | "2512" | "2513" | "2514" | "2515" | "2516" | "2520" | "2521" | "2522" | "2523" | "2524" | "2525" | "2526" | "2530" | "2531" | "2532" | "2533" | "2534" | "2535" | "2536" | "2540" | "2541" | "2542" | "2543" | "2544" | "2545" | "2546" | "2550" | "2551" | "2552" | "2553" | "2554" | "2555" | "2556" | "2560" | "2561" | "2562" | "2563" | "2564" | "2565" | "2566" | "2600" | "2601" | "2602" | "2603" | "2604" | "2605" | "2606" | "2610" | "2611" | "2612" | "2613" | "2614" | "2615" | "2616" | "2620" | "2621" | "2622" | "2623" | "2624" | "2625" | "2626" | "2630" | "2631" | "2632" | "2633" | "2634" | "2635" | "2636" | "2640" | "2641" | "2642" | "2643" | "2644" | "2645" | "2646" | "2650" | "2651" | "2652" | "2653" | "2654" | "2655" | "2656" | "2660" | "2661" | "2662" | "2663" | "2664" | "2665" | "2666" | "3000" | "3001" | "3002" | "3003" | "3004" | "3005" | "3006" | "3010" | "3011" | "3012" | "3013" | "3014" | "3015" | "3016" | "3020" | "3021" | "3022" | "3023" | "3024" | "3025" | "3026" | "3030" | "3031" | "3032" | "3033" | "3034" | "3035" | "3036" | "3040" | "3041" | "3042" | "3043" | "3044" | "3045" | "3046" | "3050" | "3051" | "3052" | "3053" | "3054" | "3055" | "3056" | "3060" | "3061" | "3062" | "3063" | "3064" | "3065" | "3066" | "3100" | "3101" | "3102" | "3103" | "3104" | "3105" | "3106" | "3110" | "3111" | "3112" | "3113" | "3114" | "3115" | "3116" | "3120" | "3121" | "3122" | "3123" | "3124" | "3125" | "3126" | "3130" | "3131" | "3132" | "3133" | "3134" | "3135" | "3136" | "3140" | "3141" | "3142" | "3143" | "3144" | "3145" | "3146" | "3150" | "3151" | "3152" | "3153" | "3154" | "3155" | "3156" | "3160" | "3161" | "3162" | "3163" | "3164" | "3165" | "3166" | "3200" | "3201" | "3202" | "3203" | "3204" | "3205" | "3206" | "3210" | "3211" | "3212" | "3213" | "3214" | "3215" | "3216" | "3220" | "3221" | "3222" | "3223" | "3224" | "3225" | "3226" | "3230" | "3231" | "3232" | "3233" | "3234" | "3235" | "3236" | "3240" | "3241" | "3242" | "3243" | "3244" | "3245" | "3246" | "3250" | "3251" | "3252" | "3253" | "3254" | "3255" | "3256" | "3260" | "3261" | "3262" | "3263" | "3264" | "3265" | "3266" | "3300" | "3301" | "3302" | "3303" | "3304" | "3305" | "3306" | "3310" | "3311" | "3312" | "3313" | "3314" | "3315" | "3316" | "3320" | "3321" | "3322" | "3323" | "3324" | "3325" | "3326" | "3330" | "3331" | "3332" | "3333" | "3334" | "3335" | "3336" | "3340" | "3341" | "3342" | "3343" | "3344" | "3345" | "3346" | "3350" | "3351" | "3352" | "3353" | "3354" | "3355" | "3356" | "3360" | "3361" | "3362" | "3363" | "3364" | "3365" | "3366" | "3400" | "3401" | "3402" | "3403" | "3404" | "3405" | "3406" | "3410" | "3411" | "3412" | "3413" | "3414" | "3415" | "3416" | "3420" | "3421" | "3422" | "3423" | "3424" | "3425" | "3426" | "3430" | "3431" | "3432" | "3433" | "3434" | "3435" | "3436" | "3440" | "3441" | "3442" | "3443" | "3444" | "3445" | "3446" | "3450" | "3451" | "3452" | "3453" | "3454" | "3455" | "3456" | "3460" | "3461" | "3462" | "3463" | "3464" | "3465" | "3466" | "3500" | "3501" | "3502" | "3503" | "3504" | "3505" | "3506" | "3510" | "3511" | "3512" | "3513" | "3514" | "3515" | "3516" | "3520" | "3521" | "3522" | "3523" | "3524" | "3525" | "3526" | "3530" | "3531" | "3532" | "3533" | "3534" | "3535" | "3536" | "3540" | "3541" | "3542" | "3543" | "3544" | "3545" | "3546" | "3550" | "3551" | "3552" | "3553" | "3554" | "3555" | "3556" | "3560" | "3561" | "3562" | "3563" | "3564" | "3565" | "3566" | "3600" | "3601" | "3602" | "3603" | "3604" | "3605" | "3606" | "3610" | "3611" | "3612" | "3613" | "3614" | "3615" | "3616" | "3620" | "3621" | "3622" | "3623" | "3624" | "3625" | "3626" | "3630" | "3631" | "3632" | "3633" | "3634" | "3635" | "3636" | "3640" | "3641" | "3642" | "3643" | "3644" | "3645" | "3646" | "3650" | "3651" | "3652" | "3653" | "3654" | "3655" | "3656" | "3660" | "3661" | "3662" | "3663" | "3664" | "3665" | "3666" | "4000" | "4001" | "4002" | "4003" | "4004" | "4005" | "4006" | "4010" | "4011" | "4012" | "4013" | "4014" | "4015" | "4016" | "4020" | "4021" | "4022" | "4023" | "4024" | "4025" | "4026" | "4030" | "4031" | "4032" | "4033" | "4034" | "4035" | "4036" | "4040" | "4041" | "4042" | "4043" | "4044" | "4045" | "4046" | "4050" | "4051" | "4052" | "4053" | "4054" | "4055" | "4056" | "4060" | "4061" | "4062" | "4063" | "4064" | "4065" | "4066" | "4100" | "4101" | "4102" | "4103" | "4104" | "4105" | "4106" | "4110" | "4111" | "4112" | "4113" | "4114" | "4115" | "4116" | "4120" | "4121" | "4122" | "4123" | "4124" | "4125" | "4126" | "4130" | "4131" | "4132" | "4133" | "4134" | "4135" | "4136" | "4140" | "4141" | "4142" | "4143" | "4144" | "4145" | "4146" | "4150" | "4151" | "4152" | "4153" | "4154" | "4155" | "4156" | "4160" | "4161" | "4162" | "4163" | "4164" | "4165" | "4166" | "4200" | "4201" | "4202" | "4203" | "4204" | "4205" | "4206" | "4210" | "4211" | "4212" | "4213" | "4214" | "4215" | "4216" | "4220" | "4221" | "4222" | "4223" | "4224" | "4225" | "4226" | "4230" | "4231" | "4232" | "4233" | "4234" | "4235" | "4236" | "4240" | "4241" | "4242" | "4243" | "4244" | "4245" | "4246" | "4250" | "4251" | "4252" | "4253" | "4254" | "4255" | "4256" | "4260" | "4261" | "4262" | "4263" | "4264" | "4265" | "4266" | "4300" | "4301" | "4302" | "4303" | "4304" | "4305" | "4306" | "4310" | "4311" | "4312" | "4313" | "4314" | "4315" | "4316" | "4320" | "4321" | "4322" | "4323" | "4324" | "4325" | "4326" | "4330" | "4331" | "4332" | "4333" | "4334" | "4335" | "4336" | "4340" | "4341" | "4342" | "4343" | "4344" | "4345" | "4346" | "4350" | "4351" | "4352" | "4353" | "4354" | "4355" | "4356" | "4360" | "4361" | "4362" | "4363" | "4364" | "4365" | "4366" | "4400" | "4401" | "4402" | "4403" | "4404" | "4405" | "4406" | "4410" | "4411" | "4412" | "4413" | "4414" | "4415" | "4416" | "4420" | "4421" | "4422" | "4423" | "4424" | "4425" | "4426" | "4430" | "4431" | "4432" | "4433" | "4434" | "4435" | "4436" | "4440" | "4441" | "4442" | "4443" | "4444" | "4445" | "4446" | "4450" | "4451" | "4452" | "4453" | "4454" | "4455" | "4456" | "4460" | "4461" | "4462" | "4463" | "4464" | "4465" | "4466" | "4500" | "4501" | "4502" | "4503" | "4504" | "4505" | "4506" | "4510" | "4511" | "4512" | "4513" | "4514" | "4515" | "4516" | "4520" | "4521" | "4522" | "4523" | "4524" | "4525" | "4526" | "4530" | "4531" | "4532" | "4533" | "4534" | "4535" | "4536" | "4540" | "4541" | "4542" | "4543" | "4544" | "4545" | "4546" | "4550" | "4551" | "4552" | "4553" | "4554" | "4555" | "4556" | "4560" | "4561" | "4562" | "4563" | "4564" | "4565" | "4566" | "4600" | "4601" | "4602" | "4603" | "4604" | "4605" | "4606" | "4610" | "4611" | "4612" | "4613" | "4614" | "4615" | "4616" | "4620" | "4621" | "4622" | "4623" | "4624" | "4625" | "4626" | "4630" | "4631" | "4632" | "4633" | "4634" | "4635" | "4636" | "4640" | "4641" | "4642" | "4643" | "4644" | "4645" | "4646" | "4650" | "4651" | "4652" | "4653" | "4654" | "4655" | "4656" | "4660" | "4661" | "4662" | "4663" | "4664" | "4665" | "4666" | "5000" | "5001" | "5002" | "5003" | "5004" | "5005" | "5006" | "5010" | "5011" | "5012" | "5013" | "5014" | "5015" | "5016" | "5020" | "5021" | "5022" | "5023" | "5024" | "5025" | "5026" | "5030" | "5031" | "5032" | "5033" | "5034" | "5035" | "5036" | "5040" | "5041" | "5042" | "5043" | "5044" | "5045" | "5046" | "5050" | "5051" | "5052" | "5053" | "5054" | "5055" | "5056" | "5060" | "5061" | "5062" | "5063" | "5064" | "5065" | "5066" | "5100" | "5101" | "5102" | "5103" | "5104" | "5105" | "5106" | "5110" | "5111" | "5112" | "5113" | "5114" | "5115" | "5116" | "5120" | "5121" | "5122" | "5123" | "5124" | "5125" | "5126" | "5130" | "5131" | "5132" | "5133" | "5134" | "5135" | "5136" | "5140" | "5141" | "5142" | "5143" | "5144" | "5145" | "5146" | "5150" | "5151" | "5152" | "5153" | "5154" | "5155" | "5156" | "5160" | "5161" | "5162" | "5163" | "5164" | "5165" | "5166" | "5200" | "5201" | "5202" | "5203" | "5204" | "5205" | "5206" | "5210" | "5211" | "5212" | "5213" | "5214" | "5215" | "5216" | "5220" | "5221" | "5222" | "5223" | "5224" | "5225" | "5226" | "5230" | "5231" | "5232" | "5233" | "5234" | "5235" | "5236" | "5240" | "5241" | "5242" | "5243" | "5244" | "5245" | "5246" | "5250" | "5251" | "5252" | "5253" | "5254" | "5255" | "5256" | "5260" | "5261" | "5262" | "5263" | "5264" | "5265" | "5266" | "5300" | "5301" | "5302" | "5303" | "5304" | "5305" | "5306" | "5310" | "5311" | "5312" | "5313" | "5314" | "5315" | "5316" | "5320" | "5321" | "5322" | "5323" | "5324" | "5325" | "5326" | "5330" | "5331" | "5332" | "5333" | "5334" | "5335" | "5336" | "5340" | "5341" | "5342" | "5343" | "5344" | "5345" | "5346" | "5350" | "5351" | "5352" | "5353" | "5354" | "5355" | "5356" | "5360" | "5361" | "5362" | "5363" | "5364" | "5365" | "5366" | "5400" | "5401" | "5402" | "5403" | "5404" | "5405" | "5406" | "5410" | "5411" | "5412" | "5413" | "5414" | "5415" | "5416" | "5420" | "5421" | "5422" | "5423" | "5424" | "5425" | "5426" | "5430" | "5431" | "5432" | "5433" | "5434" | "5435" | "5436" | "5440" | "5441" | "5442" | "5443" | "5444" | "5445" | "5446" | "5450" | "5451" | "5452" | "5453" | "5454" | "5455" | "5456" | "5460" | "5461" | "5462" | "5463" | "5464" | "5465" | "5466" | "5500" | "5501" | "5502" | "5503" | "5504" | "5505" | "5506" | "5510" | "5511" | "5512" | "5513" | "5514" | "5515" | "5516" | "5520" | "5521" | "5522" | "5523" | "5524" | "5525" | "5526" | "5530" | "5531" | "5532" | "5533" | "5534" | "5535" | "5536" | "5540" | "5541" | "5542" | "5543" | "5544" | "5545" | "5546" | "5550" | "5551" | "5552" | "5553" | "5554" | "5555" | "5556" | "5560" | "5561" | "5562" | "5563" | "5564" | "5565" | "5566" | "5600" | "5601" | "5602" | "5603" | "5604" | "5605" | "5606" | "5610" | "5611" | "5612" | "5613" | "5614" | "5615" | "5616" | "5620" | "5621" | "5622" | "5623" | "5624" | "5625" | "5626" | "5630" | "5631" | "5632" | "5633" | "5634" | "5635" | "5636" | "5640" | "5641" | "5642" | "5643" | "5644" | "5645" | "5646" | "5650" | "5651" | "5652" | "5653" | "5654" | "5655" | "5656" | "5660" | "5661" | "5662" | "5663" | "5664" | "5665" | "5666" | undefined) & T2' and 'T1 | null'. + declare const y: T1 & T2; + x = y; + ~ +!!! error TS2859: Excessive complexity comparing types 'T1 & T2' and 'T1 | null'. + ~~~~~ +!!! error TS2859: Excessive complexity comparing types 'T1 & T2' and 'T1 | null'. + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/relationComplexitySharedCheckOrder(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/relationComplexitySharedCheckOrder(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..af652dc727d64 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/relationComplexitySharedCheckOrder(checkorder=typesfirst).symbols @@ -0,0 +1,101 @@ +//// [tests/cases/compiler/relationComplexitySharedCheckOrder.ts] //// + +=== relationComplexitySharedCheckOrder.ts === +// Relating y to x fresh caches too many comparisons. In program order the +// comparisons before it have cached all but a seventh of them. Whether +// relating y is too complex must not depend on which comes first. + +type D = '0' | '1' | '2' | '3' | '4' | '5' | '6'; +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) + +type T1 = `${D}${D}${D}${D}` | undefined; +>T1 : Symbol(T1, Decl(relationComplexitySharedCheckOrder.ts, 4, 49)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) + +type T2 = { a: string } | { b: number }; +>T2 : Symbol(T2, Decl(relationComplexitySharedCheckOrder.ts, 5, 41)) +>a : Symbol(a, Decl(relationComplexitySharedCheckOrder.ts, 6, 11)) +>b : Symbol(b, Decl(relationComplexitySharedCheckOrder.ts, 6, 27)) + +declare let x: T1 | null; +>x : Symbol(x, Decl(relationComplexitySharedCheckOrder.ts, 7, 11)) +>T1 : Symbol(T1, Decl(relationComplexitySharedCheckOrder.ts, 4, 49)) + +declare const y1: (`${'0'}${D}${D}${D}` | undefined) & T2; +>y1 : Symbol(y1, Decl(relationComplexitySharedCheckOrder.ts, 8, 13)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) +>T2 : Symbol(T2, Decl(relationComplexitySharedCheckOrder.ts, 5, 41)) + +x = y1; +>x : Symbol(x, Decl(relationComplexitySharedCheckOrder.ts, 7, 11)) +>y1 : Symbol(y1, Decl(relationComplexitySharedCheckOrder.ts, 8, 13)) + +declare const y2: (`${'0' | '1'}${D}${D}${D}` | undefined) & T2; +>y2 : Symbol(y2, Decl(relationComplexitySharedCheckOrder.ts, 10, 13)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) +>T2 : Symbol(T2, Decl(relationComplexitySharedCheckOrder.ts, 5, 41)) + +x = y2; +>x : Symbol(x, Decl(relationComplexitySharedCheckOrder.ts, 7, 11)) +>y2 : Symbol(y2, Decl(relationComplexitySharedCheckOrder.ts, 10, 13)) + +declare const y3: (`${'0' | '1' | '2'}${D}${D}${D}` | undefined) & T2; +>y3 : Symbol(y3, Decl(relationComplexitySharedCheckOrder.ts, 12, 13)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) +>T2 : Symbol(T2, Decl(relationComplexitySharedCheckOrder.ts, 5, 41)) + +x = y3; +>x : Symbol(x, Decl(relationComplexitySharedCheckOrder.ts, 7, 11)) +>y3 : Symbol(y3, Decl(relationComplexitySharedCheckOrder.ts, 12, 13)) + +declare const y4: (`${'0' | '1' | '2' | '3'}${D}${D}${D}` | undefined) & T2; +>y4 : Symbol(y4, Decl(relationComplexitySharedCheckOrder.ts, 14, 13)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) +>T2 : Symbol(T2, Decl(relationComplexitySharedCheckOrder.ts, 5, 41)) + +x = y4; +>x : Symbol(x, Decl(relationComplexitySharedCheckOrder.ts, 7, 11)) +>y4 : Symbol(y4, Decl(relationComplexitySharedCheckOrder.ts, 14, 13)) + +declare const y5: (`${'0' | '1' | '2' | '3' | '4'}${D}${D}${D}` | undefined) & T2; +>y5 : Symbol(y5, Decl(relationComplexitySharedCheckOrder.ts, 16, 13)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) +>T2 : Symbol(T2, Decl(relationComplexitySharedCheckOrder.ts, 5, 41)) + +x = y5; +>x : Symbol(x, Decl(relationComplexitySharedCheckOrder.ts, 7, 11)) +>y5 : Symbol(y5, Decl(relationComplexitySharedCheckOrder.ts, 16, 13)) + +declare const y6: (`${'0' | '1' | '2' | '3' | '4' | '5'}${D}${D}${D}` | undefined) & T2; +>y6 : Symbol(y6, Decl(relationComplexitySharedCheckOrder.ts, 18, 13)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) +>D : Symbol(D, Decl(relationComplexitySharedCheckOrder.ts, 0, 0)) +>T2 : Symbol(T2, Decl(relationComplexitySharedCheckOrder.ts, 5, 41)) + +x = y6; +>x : Symbol(x, Decl(relationComplexitySharedCheckOrder.ts, 7, 11)) +>y6 : Symbol(y6, Decl(relationComplexitySharedCheckOrder.ts, 18, 13)) + +declare const y: T1 & T2; +>y : Symbol(y, Decl(relationComplexitySharedCheckOrder.ts, 20, 13)) +>T1 : Symbol(T1, Decl(relationComplexitySharedCheckOrder.ts, 4, 49)) +>T2 : Symbol(T2, Decl(relationComplexitySharedCheckOrder.ts, 5, 41)) + +x = y; +>x : Symbol(x, Decl(relationComplexitySharedCheckOrder.ts, 7, 11)) +>y : Symbol(y, Decl(relationComplexitySharedCheckOrder.ts, 20, 13)) + diff --git a/tsc/testdata/baselines/reference/compiler/relationComplexitySharedCheckOrder(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/relationComplexitySharedCheckOrder(checkorder=typesfirst).types new file mode 100644 index 0000000000000..1a678796e4afb --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/relationComplexitySharedCheckOrder(checkorder=typesfirst).types @@ -0,0 +1,77 @@ +//// [tests/cases/compiler/relationComplexitySharedCheckOrder.ts] //// + +=== relationComplexitySharedCheckOrder.ts === +// Relating y to x fresh caches too many comparisons. In program order the +// comparisons before it have cached all but a seventh of them. Whether +// relating y is too complex must not depend on which comes first. + +type D = '0' | '1' | '2' | '3' | '4' | '5' | '6'; +>D : D + +type T1 = `${D}${D}${D}${D}` | undefined; +>T1 : T1 + +type T2 = { a: string } | { b: number }; +>T2 : T2 +>a : string +>b : number + +declare let x: T1 | null; +>x : T1 | null + +declare const y1: (`${'0'}${D}${D}${D}` | undefined) & T2; +>y1 : ("0000" | "0001" | "0002" | "0003" | "0004" | "0005" | "0006" | "0010" | "0011" | "0012" | "0013" | "0014" | "0015" | "0016" | "0020" | "0021" | "0022" | "0023" | "0024" | "0025" | "0026" | "0030" | "0031" | "0032" | "0033" | "0034" | "0035" | "0036" | "0040" | "0041" | "0042" | "0043" | "0044" | "0045" | "0046" | "0050" | "0051" | "0052" | "0053" | "0054" | "0055" | "0056" | "0060" | "0061" | "0062" | "0063" | "0064" | "0065" | "0066" | "0100" | "0101" | "0102" | "0103" | "0104" | "0105" | "0106" | "0110" | "0111" | "0112" | "0113" | "0114" | "0115" | "0116" | "0120" | "0121" | "0122" | "0123" | "0124" | "0125" | "0126" | "0130" | "0131" | "0132" | "0133" | "0134" | "0135" | "0136" | "0140" | "0141" | "0142" | "0143" | "0144" | "0145" | "0146" | "0150" | "0151" | "0152" | "0153" | "0154" | "0155" | "0156" | "0160" | "0161" | "0162" | "0163" | "0164" | "0165" | "0166" | "0200" | "0201" | "0202" | "0203" | "0204" | "0205" | "0206" | "0210" | "0211" | "0212" | "0213" | "0214" | "0215" | "0216" | "0220" | "0221" | "0222" | "0223" | "0224" | "0225" | "0226" | "0230" | "0231" | "0232" | "0233" | "0234" | "0235" | "0236" | "0240" | "0241" | "0242" | "0243" | "0244" | "0245" | "0246" | "0250" | "0251" | "0252" | "0253" | "0254" | "0255" | "0256" | "0260" | "0261" | "0262" | "0263" | "0264" | "0265" | "0266" | "0300" | "0301" | "0302" | "0303" | "0304" | "0305" | "0306" | "0310" | "0311" | "0312" | "0313" | "0314" | "0315" | "0316" | "0320" | "0321" | "0322" | "0323" | "0324" | "0325" | "0326" | "0330" | "0331" | "0332" | "0333" | "0334" | "0335" | "0336" | "0340" | "0341" | "0342" | "0343" | "0344" | "0345" | "0346" | "0350" | "0351" | "0352" | "0353" | "0354" | "0355" | "0356" | "0360" | "0361" | "0362" | "0363" | "0364" | "0365" | "0366" | "0400" | "0401" | "0402" | "0403" | "0404" | "0405" | "0406" | "0410" | "0411" | "0412" | "0413" | "0414" | "0415" | "0416" | "0420" | "0421" | "0422" | "0423" | "0424" | "0425" | "0426" | "0430" | "0431" | "0432" | "0433" | "0434" | "0435" | "0436" | "0440" | "0441" | "0442" | "0443" | "0444" | "0445" | "0446" | "0450" | "0451" | "0452" | "0453" | "0454" | "0455" | "0456" | "0460" | "0461" | "0462" | "0463" | "0464" | "0465" | "0466" | "0500" | "0501" | "0502" | "0503" | "0504" | "0505" | "0506" | "0510" | "0511" | "0512" | "0513" | "0514" | "0515" | "0516" | "0520" | "0521" | "0522" | "0523" | "0524" | "0525" | "0526" | "0530" | "0531" | "0532" | "0533" | "0534" | "0535" | "0536" | "0540" | "0541" | "0542" | "0543" | "0544" | "0545" | "0546" | "0550" | "0551" | "0552" | "0553" | "0554" | "0555" | "0556" | "0560" | "0561" | "0562" | "0563" | "0564" | "0565" | "0566" | "0600" | "0601" | "0602" | "0603" | "0604" | "0605" | "0606" | "0610" | "0611" | "0612" | "0613" | "0614" | "0615" | "0616" | "0620" | "0621" | "0622" | "0623" | "0624" | "0625" | "0626" | "0630" | "0631" | "0632" | "0633" | "0634" | "0635" | "0636" | "0640" | "0641" | "0642" | "0643" | "0644" | "0645" | "0646" | "0650" | "0651" | "0652" | "0653" | "0654" | "0655" | "0656" | "0660" | "0661" | "0662" | "0663" | "0664" | "0665" | "0666" | undefined) & T2 + +x = y1; +>x = y1 : ("0000" | "0001" | "0002" | "0003" | "0004" | "0005" | "0006" | "0010" | "0011" | "0012" | "0013" | "0014" | "0015" | "0016" | "0020" | "0021" | "0022" | "0023" | "0024" | "0025" | "0026" | "0030" | "0031" | "0032" | "0033" | "0034" | "0035" | "0036" | "0040" | "0041" | "0042" | "0043" | "0044" | "0045" | "0046" | "0050" | "0051" | "0052" | "0053" | "0054" | "0055" | "0056" | "0060" | "0061" | "0062" | "0063" | "0064" | "0065" | "0066" | "0100" | "0101" | "0102" | "0103" | "0104" | "0105" | "0106" | "0110" | "0111" | "0112" | "0113" | "0114" | "0115" | "0116" | "0120" | "0121" | "0122" | "0123" | "0124" | "0125" | "0126" | "0130" | "0131" | "0132" | "0133" | "0134" | "0135" | "0136" | "0140" | "0141" | "0142" | "0143" | "0144" | "0145" | "0146" | "0150" | "0151" | "0152" | "0153" | "0154" | "0155" | "0156" | "0160" | "0161" | "0162" | "0163" | "0164" | "0165" | "0166" | "0200" | "0201" | "0202" | "0203" | "0204" | "0205" | "0206" | "0210" | "0211" | "0212" | "0213" | "0214" | "0215" | "0216" | "0220" | "0221" | "0222" | "0223" | "0224" | "0225" | "0226" | "0230" | "0231" | "0232" | "0233" | "0234" | "0235" | "0236" | "0240" | "0241" | "0242" | "0243" | "0244" | "0245" | "0246" | "0250" | "0251" | "0252" | "0253" | "0254" | "0255" | "0256" | "0260" | "0261" | "0262" | "0263" | "0264" | "0265" | "0266" | "0300" | "0301" | "0302" | "0303" | "0304" | "0305" | "0306" | "0310" | "0311" | "0312" | "0313" | "0314" | "0315" | "0316" | "0320" | "0321" | "0322" | "0323" | "0324" | "0325" | "0326" | "0330" | "0331" | "0332" | "0333" | "0334" | "0335" | "0336" | "0340" | "0341" | "0342" | "0343" | "0344" | "0345" | "0346" | "0350" | "0351" | "0352" | "0353" | "0354" | "0355" | "0356" | "0360" | "0361" | "0362" | "0363" | "0364" | "0365" | "0366" | "0400" | "0401" | "0402" | "0403" | "0404" | "0405" | "0406" | "0410" | "0411" | "0412" | "0413" | "0414" | "0415" | "0416" | "0420" | "0421" | "0422" | "0423" | "0424" | "0425" | "0426" | "0430" | "0431" | "0432" | "0433" | "0434" | "0435" | "0436" | "0440" | "0441" | "0442" | "0443" | "0444" | "0445" | "0446" | "0450" | "0451" | "0452" | "0453" | "0454" | "0455" | "0456" | "0460" | "0461" | "0462" | "0463" | "0464" | "0465" | "0466" | "0500" | "0501" | "0502" | "0503" | "0504" | "0505" | "0506" | "0510" | "0511" | "0512" | "0513" | "0514" | "0515" | "0516" | "0520" | "0521" | "0522" | "0523" | "0524" | "0525" | "0526" | "0530" | "0531" | "0532" | "0533" | "0534" | "0535" | "0536" | "0540" | "0541" | "0542" | "0543" | "0544" | "0545" | "0546" | "0550" | "0551" | "0552" | "0553" | "0554" | "0555" | "0556" | "0560" | "0561" | "0562" | "0563" | "0564" | "0565" | "0566" | "0600" | "0601" | "0602" | "0603" | "0604" | "0605" | "0606" | "0610" | "0611" | "0612" | "0613" | "0614" | "0615" | "0616" | "0620" | "0621" | "0622" | "0623" | "0624" | "0625" | "0626" | "0630" | "0631" | "0632" | "0633" | "0634" | "0635" | "0636" | "0640" | "0641" | "0642" | "0643" | "0644" | "0645" | "0646" | "0650" | "0651" | "0652" | "0653" | "0654" | "0655" | "0656" | "0660" | "0661" | "0662" | "0663" | "0664" | "0665" | "0666" | undefined) & T2 +>x : T1 | null +>y1 : ("0000" | "0001" | "0002" | "0003" | "0004" | "0005" | "0006" | "0010" | "0011" | "0012" | "0013" | "0014" | "0015" | "0016" | "0020" | "0021" | "0022" | "0023" | "0024" | "0025" | "0026" | "0030" | "0031" | "0032" | "0033" | "0034" | "0035" | "0036" | "0040" | "0041" | "0042" | "0043" | "0044" | "0045" | "0046" | "0050" | "0051" | "0052" | "0053" | "0054" | "0055" | "0056" | "0060" | "0061" | "0062" | "0063" | "0064" | "0065" | "0066" | "0100" | "0101" | "0102" | "0103" | "0104" | "0105" | "0106" | "0110" | "0111" | "0112" | "0113" | "0114" | "0115" | "0116" | "0120" | "0121" | "0122" | "0123" | "0124" | "0125" | "0126" | "0130" | "0131" | "0132" | "0133" | "0134" | "0135" | "0136" | "0140" | "0141" | "0142" | "0143" | "0144" | "0145" | "0146" | "0150" | "0151" | "0152" | "0153" | "0154" | "0155" | "0156" | "0160" | "0161" | "0162" | "0163" | "0164" | "0165" | "0166" | "0200" | "0201" | "0202" | "0203" | "0204" | "0205" | "0206" | "0210" | "0211" | "0212" | "0213" | "0214" | "0215" | "0216" | "0220" | "0221" | "0222" | "0223" | "0224" | "0225" | "0226" | "0230" | "0231" | "0232" | "0233" | "0234" | "0235" | "0236" | "0240" | "0241" | "0242" | "0243" | "0244" | "0245" | "0246" | "0250" | "0251" | "0252" | "0253" | "0254" | "0255" | "0256" | "0260" | "0261" | "0262" | "0263" | "0264" | "0265" | "0266" | "0300" | "0301" | "0302" | "0303" | "0304" | "0305" | "0306" | "0310" | "0311" | "0312" | "0313" | "0314" | "0315" | "0316" | "0320" | "0321" | "0322" | "0323" | "0324" | "0325" | "0326" | "0330" | "0331" | "0332" | "0333" | "0334" | "0335" | "0336" | "0340" | "0341" | "0342" | "0343" | "0344" | "0345" | "0346" | "0350" | "0351" | "0352" | "0353" | "0354" | "0355" | "0356" | "0360" | "0361" | "0362" | "0363" | "0364" | "0365" | "0366" | "0400" | "0401" | "0402" | "0403" | "0404" | "0405" | "0406" | "0410" | "0411" | "0412" | "0413" | "0414" | "0415" | "0416" | "0420" | "0421" | "0422" | "0423" | "0424" | "0425" | "0426" | "0430" | "0431" | "0432" | "0433" | "0434" | "0435" | "0436" | "0440" | "0441" | "0442" | "0443" | "0444" | "0445" | "0446" | "0450" | "0451" | "0452" | "0453" | "0454" | "0455" | "0456" | "0460" | "0461" | "0462" | "0463" | "0464" | "0465" | "0466" | "0500" | "0501" | "0502" | "0503" | "0504" | "0505" | "0506" | "0510" | "0511" | "0512" | "0513" | "0514" | "0515" | "0516" | "0520" | "0521" | "0522" | "0523" | "0524" | "0525" | "0526" | "0530" | "0531" | "0532" | "0533" | "0534" | "0535" | "0536" | "0540" | "0541" | "0542" | "0543" | "0544" | "0545" | "0546" | "0550" | "0551" | "0552" | "0553" | "0554" | "0555" | "0556" | "0560" | "0561" | "0562" | "0563" | "0564" | "0565" | "0566" | "0600" | "0601" | "0602" | "0603" | "0604" | "0605" | "0606" | "0610" | "0611" | "0612" | "0613" | "0614" | "0615" | "0616" | "0620" | "0621" | "0622" | "0623" | "0624" | "0625" | "0626" | "0630" | "0631" | "0632" | "0633" | "0634" | "0635" | "0636" | "0640" | "0641" | "0642" | "0643" | "0644" | "0645" | "0646" | "0650" | "0651" | "0652" | "0653" | "0654" | "0655" | "0656" | "0660" | "0661" | "0662" | "0663" | "0664" | "0665" | "0666" | undefined) & T2 + +declare const y2: (`${'0' | '1'}${D}${D}${D}` | undefined) & T2; +>y2 : ("0000" | "0001" | "0002" | "0003" | "0004" | "0005" | "0006" | "0010" | "0011" | "0012" | "0013" | "0014" | "0015" | "0016" | "0020" | "0021" | "0022" | "0023" | "0024" | "0025" | "0026" | "0030" | "0031" | "0032" | "0033" | "0034" | "0035" | "0036" | "0040" | "0041" | "0042" | "0043" | "0044" | "0045" | "0046" | "0050" | "0051" | "0052" | "0053" | "0054" | "0055" | "0056" | "0060" | "0061" | "0062" | "0063" | "0064" | "0065" | "0066" | "0100" | "0101" | "0102" | "0103" | "0104" | "0105" | "0106" | "0110" | "0111" | "0112" | "0113" | "0114" | "0115" | "0116" | "0120" | "0121" | "0122" | "0123" | "0124" | "0125" | "0126" | "0130" | "0131" | "0132" | "0133" | "0134" | "0135" | "0136" | "0140" | "0141" | "0142" | "0143" | "0144" | "0145" | "0146" | "0150" | "0151" | "0152" | "0153" | "0154" | "0155" | "0156" | "0160" | "0161" | "0162" | "0163" | "0164" | "0165" | "0166" | "0200" | "0201" | "0202" | "0203" | "0204" | "0205" | "0206" | "0210" | "0211" | "0212" | "0213" | "0214" | "0215" | "0216" | "0220" | "0221" | "0222" | "0223" | "0224" | "0225" | "0226" | "0230" | "0231" | "0232" | "0233" | "0234" | "0235" | "0236" | "0240" | "0241" | "0242" | "0243" | "0244" | "0245" | "0246" | "0250" | "0251" | "0252" | "0253" | "0254" | "0255" | "0256" | "0260" | "0261" | "0262" | "0263" | "0264" | "0265" | "0266" | "0300" | "0301" | "0302" | "0303" | "0304" | "0305" | "0306" | "0310" | "0311" | "0312" | "0313" | "0314" | "0315" | "0316" | "0320" | "0321" | "0322" | "0323" | "0324" | "0325" | "0326" | "0330" | "0331" | "0332" | "0333" | "0334" | "0335" | "0336" | "0340" | "0341" | "0342" | "0343" | "0344" | "0345" | "0346" | "0350" | "0351" | "0352" | "0353" | "0354" | "0355" | "0356" | "0360" | "0361" | "0362" | "0363" | "0364" | "0365" | "0366" | "0400" | "0401" | "0402" | "0403" | "0404" | "0405" | "0406" | "0410" | "0411" | "0412" | "0413" | "0414" | "0415" | "0416" | "0420" | "0421" | "0422" | "0423" | "0424" | "0425" | "0426" | "0430" | "0431" | "0432" | "0433" | "0434" | "0435" | "0436" | "0440" | "0441" | "0442" | "0443" | "0444" | "0445" | "0446" | "0450" | "0451" | "0452" | "0453" | "0454" | "0455" | "0456" | "0460" | "0461" | "0462" | "0463" | "0464" | "0465" | "0466" | "0500" | "0501" | "0502" | "0503" | "0504" | "0505" | "0506" | "0510" | "0511" | "0512" | "0513" | "0514" | "0515" | "0516" | "0520" | "0521" | "0522" | "0523" | "0524" | "0525" | "0526" | "0530" | "0531" | "0532" | "0533" | "0534" | "0535" | "0536" | "0540" | "0541" | "0542" | "0543" | "0544" | "0545" | "0546" | "0550" | "0551" | "0552" | "0553" | "0554" | "0555" | "0556" | "0560" | "0561" | "0562" | "0563" | "0564" | "0565" | "0566" | "0600" | "0601" | "0602" | "0603" | "0604" | "0605" | "0606" | "0610" | "0611" | "0612" | "0613" | "0614" | "0615" | "0616" | "0620" | "0621" | "0622" | "0623" | "0624" | "0625" | "0626" | "0630" | "0631" | "0632" | "0633" | "0634" | "0635" | "0636" | "0640" | "0641" | "0642" | "0643" | "0644" | "0645" | "0646" | "0650" | "0651" | "0652" | "0653" | "0654" | "0655" | "0656" | "0660" | "0661" | "0662" | "0663" | "0664" | "0665" | "0666" | "1000" | "1001" | "1002" | "1003" | "1004" | "1005" | "1006" | "1010" | "1011" | "1012" | "1013" | "1014" | "1015" | "1016" | "1020" | "1021" | "1022" | "1023" | "1024" | "1025" | "1026" | "1030" | "1031" | "1032" | "1033" | "1034" | "1035" | "1036" | "1040" | "1041" | "1042" | "1043" | "1044" | "1045" | "1046" | "1050" | "1051" | "1052" | "1053" | "1054" | "1055" | "1056" | "1060" | "1061" | "1062" | "1063" | "1064" | "1065" | "1066" | "1100" | "1101" | "1102" | "1103" | "1104" | "1105" | "1106" | "1110" | "1111" | "1112" | "1113" | "1114" | "1115" | "1116" | "1120" | "1121" | "1122" | "1123" | "1124" | "1125" | "1126" | "1130" | "1131" | "1132" | "1133" | "1134" | "1135" | "1136" | "1140" | "1141" | "1142" | "1143" | "1144" | "1145" | "1146" | "1150" | "1151" | "1152" | "1153" | "1154" | "1155" | "1156" | "1160" | "1161" | "1162" | "1163" | "1164" | "1165" | "1166" | "1200" | "1201" | "1202" | "1203" | "1204" | "1205" | "1206" | "1210" | "1211" | "1212" | "1213" | "1214" | "1215" | "1216" | "1220" | "1221" | "1222" | "1223" | "1224" | "1225" | "1226" | "1230" | "1231" | "1232" | "1233" | "1234" | "1235" | "1236" | "1240" | "1241" | "1242" | "1243" | "1244" | "1245" | "1246" | "1250" | "1251" | "1252" | "1253" | "1254" | "1255" | "1256" | "1260" | "1261" | "1262" | "1263" | "1264" | "1265" | "1266" | "1300" | "1301" | "1302" | "1303" | "1304" | "1305" | "1306" | "1310" | "1311" | "1312" | "1313" | "1314" | "1315" | "1316" | "1320" | "1321" | "1322" | "1323" | "1324" | "1325" | "1326" | "1330" | "1331" | "1332" | "1333" | "1334" | "1335" | "1336" | "1340" | "1341" | "1342" | "1343" | "1344" | "1345" | "1346" | "1350" | "1351" | "1352" | "1353" | "1354" | "1355" | "1356" | "1360" | "1361" | "1362" | "1363" | "1364" | "1365" | "1366" | "1400" | "1401" | "1402" | "1403" | "1404" | "1405" | "1406" | "1410" | "1411" | "1412" | "1413" | "1414" | "1415" | "1416" | "1420" | "1421" | "1422" | "1423" | "1424" | "1425" | "1426" | "1430" | "1431" | "1432" | "1433" | "1434" | "1435" | "1436" | "1440" | "1441" | "1442" | "1443" | "1444" | "1445" | "1446" | "1450" | "1451" | "1452" | "1453" | "1454" | "1455" | "1456" | "1460" | "1461" | "1462" | "1463" | "1464" | "1465" | "1466" | "1500" | "1501" | "1502" | "1503" | "1504" | "1505" | "1506" | "1510" | "1511" | "1512" | "1513" | "1514" | "1515" | "1516" | "1520" | "1521" | "1522" | "1523" | "1524" | "1525" | "1526" | "1530" | "1531" | "1532" | "1533" | "1534" | "1535" | "1536" | "1540" | "1541" | "1542" | "1543" | "1544" | "1545" | "1546" | "1550" | "1551" | "1552" | "1553" | "1554" | "1555" | "1556" | "1560" | "1561" | "1562" | "1563" | "1564" | "1565" | "1566" | "1600" | "1601" | "1602" | "1603" | "1604" | "1605" | "1606" | "1610" | "1611" | "1612" | "1613" | "1614" | "1615" | "1616" | "1620" | "1621" | "1622" | "1623" | "1624" | "1625" | "1626" | "1630" | "1631" | "1632" | "1633" | "1634" | "1635" | "1636" | "1640" | "1641" | "1642" | "1643" | "1644" | "1645" | "1646" | "1650" | "1651" | "1652" | "1653" | "1654" | "1655" | "1656" | "1660" | "1661" | "1662" | "1663" | "1664" | "1665" | "1666" | undefined) & T2 + +x = y2; +>x = y2 : ("0000" | "0001" | "0002" | "0003" | "0004" | "0005" | "0006" | "0010" | "0011" | "0012" | "0013" | "0014" | "0015" | "0016" | "0020" | "0021" | "0022" | "0023" | "0024" | "0025" | "0026" | "0030" | "0031" | "0032" | "0033" | "0034" | "0035" | "0036" | "0040" | "0041" | "0042" | "0043" | "0044" | "0045" | "0046" | "0050" | "0051" | "0052" | "0053" | "0054" | "0055" | "0056" | "0060" | "0061" | "0062" | "0063" | "0064" | "0065" | "0066" | "0100" | "0101" | "0102" | "0103" | "0104" | "0105" | "0106" | "0110" | "0111" | "0112" | "0113" | "0114" | "0115" | "0116" | "0120" | "0121" | "0122" | "0123" | "0124" | "0125" | "0126" | "0130" | "0131" | "0132" | "0133" | "0134" | "0135" | "0136" | "0140" | "0141" | "0142" | "0143" | "0144" | "0145" | "0146" | "0150" | "0151" | "0152" | "0153" | "0154" | "0155" | "0156" | "0160" | "0161" | "0162" | "0163" | "0164" | "0165" | "0166" | "0200" | "0201" | "0202" | "0203" | "0204" | "0205" | "0206" | "0210" | "0211" | "0212" | "0213" | "0214" | "0215" | "0216" | "0220" | "0221" | "0222" | "0223" | "0224" | "0225" | "0226" | "0230" | "0231" | "0232" | "0233" | "0234" | "0235" | "0236" | "0240" | "0241" | "0242" | "0243" | "0244" | "0245" | "0246" | "0250" | "0251" | "0252" | "0253" | "0254" | "0255" | "0256" | "0260" | "0261" | "0262" | "0263" | "0264" | "0265" | "0266" | "0300" | "0301" | "0302" | "0303" | "0304" | "0305" | "0306" | "0310" | "0311" | "0312" | "0313" | "0314" | "0315" | "0316" | "0320" | "0321" | "0322" | "0323" | "0324" | "0325" | "0326" | "0330" | "0331" | "0332" | "0333" | "0334" | "0335" | "0336" | "0340" | "0341" | "0342" | "0343" | "0344" | "0345" | "0346" | "0350" | "0351" | "0352" | "0353" | "0354" | "0355" | "0356" | "0360" | "0361" | "0362" | "0363" | "0364" | "0365" | "0366" | "0400" | "0401" | "0402" | "0403" | "0404" | "0405" | "0406" | "0410" | "0411" | "0412" | "0413" | "0414" | "0415" | "0416" | "0420" | "0421" | "0422" | "0423" | "0424" | "0425" | "0426" | "0430" | "0431" | "0432" | "0433" | "0434" | "0435" | "0436" | "0440" | "0441" | "0442" | "0443" | "0444" | "0445" | "0446" | "0450" | "0451" | "0452" | "0453" | "0454" | "0455" | "0456" | "0460" | "0461" | "0462" | "0463" | "0464" | "0465" | "0466" | "0500" | "0501" | "0502" | "0503" | "0504" | "0505" | "0506" | "0510" | "0511" | "0512" | "0513" | "0514" | "0515" | "0516" | "0520" | "0521" | "0522" | "0523" | "0524" | "0525" | "0526" | "0530" | "0531" | "0532" | "0533" | "0534" | "0535" | "0536" | "0540" | "0541" | "0542" | "0543" | "0544" | "0545" | "0546" | "0550" | "0551" | "0552" | "0553" | "0554" | "0555" | "0556" | "0560" | "0561" | "0562" | "0563" | "0564" | "0565" | "0566" | "0600" | "0601" | "0602" | "0603" | "0604" | "0605" | "0606" | "0610" | "0611" | "0612" | "0613" | "0614" | "0615" | "0616" | "0620" | "0621" | "0622" | "0623" | "0624" | "0625" | "0626" | "0630" | "0631" | "0632" | "0633" | "0634" | "0635" | "0636" | "0640" | "0641" | "0642" | "0643" | "0644" | "0645" | "0646" | "0650" | "0651" | "0652" | "0653" | "0654" | "0655" | "0656" | "0660" | "0661" | "0662" | "0663" | "0664" | "0665" | "0666" | "1000" | "1001" | "1002" | "1003" | "1004" | "1005" | "1006" | "1010" | "1011" | "1012" | "1013" | "1014" | "1015" | "1016" | "1020" | "1021" | "1022" | "1023" | "1024" | "1025" | "1026" | "1030" | "1031" | "1032" | "1033" | "1034" | "1035" | "1036" | "1040" | "1041" | "1042" | "1043" | "1044" | "1045" | "1046" | "1050" | "1051" | "1052" | "1053" | "1054" | "1055" | "1056" | "1060" | "1061" | "1062" | "1063" | "1064" | "1065" | "1066" | "1100" | "1101" | "1102" | "1103" | "1104" | "1105" | "1106" | "1110" | "1111" | "1112" | "1113" | "1114" | "1115" | "1116" | "1120" | "1121" | "1122" | "1123" | "1124" | "1125" | "1126" | "1130" | "1131" | "1132" | "1133" | "1134" | "1135" | "1136" | "1140" | "1141" | "1142" | "1143" | "1144" | "1145" | "1146" | "1150" | "1151" | "1152" | "1153" | "1154" | "1155" | "1156" | "1160" | "1161" | "1162" | "1163" | "1164" | "1165" | "1166" | "1200" | "1201" | "1202" | "1203" | "1204" | "1205" | "1206" | "1210" | "1211" | "1212" | "1213" | "1214" | "1215" | "1216" | "1220" | "1221" | "1222" | "1223" | "1224" | "1225" | "1226" | "1230" | "1231" | "1232" | "1233" | "1234" | "1235" | "1236" | "1240" | "1241" | "1242" | "1243" | "1244" | "1245" | "1246" | "1250" | "1251" | "1252" | "1253" | "1254" | "1255" | "1256" | "1260" | "1261" | "1262" | "1263" | "1264" | "1265" | "1266" | "1300" | "1301" | "1302" | "1303" | "1304" | "1305" | "1306" | "1310" | "1311" | "1312" | "1313" | "1314" | "1315" | "1316" | "1320" | "1321" | "1322" | "1323" | "1324" | "1325" | "1326" | "1330" | "1331" | "1332" | "1333" | "1334" | "1335" | "1336" | "1340" | "1341" | "1342" | "1343" | "1344" | "1345" | "1346" | "1350" | "1351" | "1352" | "1353" | "1354" | "1355" | "1356" | "1360" | "1361" | "1362" | "1363" | "1364" | "1365" | "1366" | "1400" | "1401" | "1402" | "1403" | "1404" | "1405" | "1406" | "1410" | "1411" | "1412" | "1413" | "1414" | "1415" | "1416" | "1420" | "1421" | "1422" | "1423" | "1424" | "1425" | "1426" | "1430" | "1431" | "1432" | "1433" | "1434" | "1435" | "1436" | "1440" | "1441" | "1442" | "1443" | "1444" | "1445" | "1446" | "1450" | "1451" | "1452" | "1453" | "1454" | "1455" | "1456" | "1460" | "1461" | "1462" | "1463" | "1464" | "1465" | "1466" | "1500" | "1501" | "1502" | "1503" | "1504" | "1505" | "1506" | "1510" | "1511" | "1512" | "1513" | "1514" | "1515" | "1516" | "1520" | "1521" | "1522" | "1523" | "1524" | "1525" | "1526" | "1530" | "1531" | "1532" | "1533" | "1534" | "1535" | "1536" | "1540" | "1541" | "1542" | "1543" | "1544" | "1545" | "1546" | "1550" | "1551" | "1552" | "1553" | "1554" | "1555" | "1556" | "1560" | "1561" | "1562" | "1563" | "1564" | "1565" | "1566" | "1600" | "1601" | "1602" | "1603" | "1604" | "1605" | "1606" | "1610" | "1611" | "1612" | "1613" | "1614" | "1615" | "1616" | "1620" | "1621" | "1622" | "1623" | "1624" | "1625" | "1626" | "1630" | "1631" | "1632" | "1633" | "1634" | "1635" | "1636" | "1640" | "1641" | "1642" | "1643" | "1644" | "1645" | "1646" | "1650" | "1651" | "1652" | "1653" | "1654" | "1655" | "1656" | "1660" | "1661" | "1662" | "1663" | "1664" | "1665" | "1666" | undefined) & T2 +>x : T1 | null +>y2 : ("0000" | "0001" | "0002" | "0003" | "0004" | "0005" | "0006" | "0010" | "0011" | "0012" | "0013" | "0014" | "0015" | "0016" | "0020" | "0021" | "0022" | "0023" | "0024" | "0025" | "0026" | "0030" | "0031" | "0032" | "0033" | "0034" | "0035" | "0036" | "0040" | "0041" | "0042" | "0043" | "0044" | "0045" | "0046" | "0050" | "0051" | "0052" | "0053" | "0054" | "0055" | "0056" | "0060" | "0061" | "0062" | "0063" | "0064" | "0065" | "0066" | "0100" | "0101" | "0102" | "0103" | "0104" | "0105" | "0106" | "0110" | "0111" | "0112" | "0113" | "0114" | "0115" | "0116" | "0120" | "0121" | "0122" | "0123" | "0124" | "0125" | "0126" | "0130" | "0131" | "0132" | "0133" | "0134" | "0135" | "0136" | "0140" | "0141" | "0142" | "0143" | "0144" | "0145" | "0146" | "0150" | "0151" | "0152" | "0153" | "0154" | "0155" | "0156" | "0160" | "0161" | "0162" | "0163" | "0164" | "0165" | "0166" | "0200" | "0201" | "0202" | "0203" | "0204" | "0205" | "0206" | "0210" | "0211" | "0212" | "0213" | "0214" | "0215" | "0216" | "0220" | "0221" | "0222" | "0223" | "0224" | "0225" | "0226" | "0230" | "0231" | "0232" | "0233" | "0234" | "0235" | "0236" | "0240" | "0241" | "0242" | "0243" | "0244" | "0245" | "0246" | "0250" | "0251" | "0252" | "0253" | "0254" | "0255" | "0256" | "0260" | "0261" | "0262" | "0263" | "0264" | "0265" | "0266" | "0300" | "0301" | "0302" | "0303" | "0304" | "0305" | "0306" | "0310" | "0311" | "0312" | "0313" | "0314" | "0315" | "0316" | "0320" | "0321" | "0322" | "0323" | "0324" | "0325" | "0326" | "0330" | "0331" | "0332" | "0333" | "0334" | "0335" | "0336" | "0340" | "0341" | "0342" | "0343" | "0344" | "0345" | "0346" | "0350" | "0351" | "0352" | "0353" | "0354" | "0355" | "0356" | "0360" | "0361" | "0362" | "0363" | "0364" | "0365" | "0366" | "0400" | "0401" | "0402" | "0403" | "0404" | "0405" | "0406" | "0410" | "0411" | "0412" | "0413" | "0414" | "0415" | "0416" | "0420" | "0421" | "0422" | "0423" | "0424" | "0425" | "0426" | "0430" | "0431" | "0432" | "0433" | "0434" | "0435" | "0436" | "0440" | "0441" | "0442" | "0443" | "0444" | "0445" | "0446" | "0450" | "0451" | "0452" | "0453" | "0454" | "0455" | "0456" | "0460" | "0461" | "0462" | "0463" | "0464" | "0465" | "0466" | "0500" | "0501" | "0502" | "0503" | "0504" | "0505" | "0506" | "0510" | "0511" | "0512" | "0513" | "0514" | "0515" | "0516" | "0520" | "0521" | "0522" | "0523" | "0524" | "0525" | "0526" | "0530" | "0531" | "0532" | "0533" | "0534" | "0535" | "0536" | "0540" | "0541" | "0542" | "0543" | "0544" | "0545" | "0546" | "0550" | "0551" | "0552" | "0553" | "0554" | "0555" | "0556" | "0560" | "0561" | "0562" | "0563" | "0564" | "0565" | "0566" | "0600" | "0601" | "0602" | "0603" | "0604" | "0605" | "0606" | "0610" | "0611" | "0612" | "0613" | "0614" | "0615" | "0616" | "0620" | "0621" | "0622" | "0623" | "0624" | "0625" | "0626" | "0630" | "0631" | "0632" | "0633" | "0634" | "0635" | "0636" | "0640" | "0641" | "0642" | "0643" | "0644" | "0645" | "0646" | "0650" | "0651" | "0652" | "0653" | "0654" | "0655" | "0656" | "0660" | "0661" | "0662" | "0663" | "0664" | "0665" | "0666" | "1000" | "1001" | "1002" | "1003" | "1004" | "1005" | "1006" | "1010" | "1011" | "1012" | "1013" | "1014" | "1015" | "1016" | "1020" | "1021" | "1022" | "1023" | "1024" | "1025" | "1026" | "1030" | "1031" | "1032" | "1033" | "1034" | "1035" | "1036" | "1040" | "1041" | "1042" | "1043" | "1044" | "1045" | "1046" | "1050" | "1051" | "1052" | "1053" | "1054" | "1055" | "1056" | "1060" | "1061" | "1062" | "1063" | "1064" | "1065" | "1066" | "1100" | "1101" | "1102" | "1103" | "1104" | "1105" | "1106" | "1110" | "1111" | "1112" | "1113" | "1114" | "1115" | "1116" | "1120" | "1121" | "1122" | "1123" | "1124" | "1125" | "1126" | "1130" | "1131" | "1132" | "1133" | "1134" | "1135" | "1136" | "1140" | "1141" | "1142" | "1143" | "1144" | "1145" | "1146" | "1150" | "1151" | "1152" | "1153" | "1154" | "1155" | "1156" | "1160" | "1161" | "1162" | "1163" | "1164" | "1165" | "1166" | "1200" | "1201" | "1202" | "1203" | "1204" | "1205" | "1206" | "1210" | "1211" | "1212" | "1213" | "1214" | "1215" | "1216" | "1220" | "1221" | "1222" | "1223" | "1224" | "1225" | "1226" | "1230" | "1231" | "1232" | "1233" | "1234" | "1235" | "1236" | "1240" | "1241" | "1242" | "1243" | "1244" | "1245" | "1246" | "1250" | "1251" | "1252" | "1253" | "1254" | "1255" | "1256" | "1260" | "1261" | "1262" | "1263" | "1264" | "1265" | "1266" | "1300" | "1301" | "1302" | "1303" | "1304" | "1305" | "1306" | "1310" | "1311" | "1312" | "1313" | "1314" | "1315" | "1316" | "1320" | "1321" | "1322" | "1323" | "1324" | "1325" | "1326" | "1330" | "1331" | "1332" | "1333" | "1334" | "1335" | "1336" | "1340" | "1341" | "1342" | "1343" | "1344" | "1345" | "1346" | "1350" | "1351" | "1352" | "1353" | "1354" | "1355" | "1356" | "1360" | "1361" | "1362" | "1363" | "1364" | "1365" | "1366" | "1400" | "1401" | "1402" | "1403" | "1404" | "1405" | "1406" | "1410" | "1411" | "1412" | "1413" | "1414" | "1415" | "1416" | "1420" | "1421" | "1422" | "1423" | "1424" | "1425" | "1426" | "1430" | "1431" | "1432" | "1433" | "1434" | "1435" | "1436" | "1440" | "1441" | "1442" | "1443" | "1444" | "1445" | "1446" | "1450" | "1451" | "1452" | "1453" | "1454" | "1455" | "1456" | "1460" | "1461" | "1462" | "1463" | "1464" | "1465" | "1466" | "1500" | "1501" | "1502" | "1503" | "1504" | "1505" | "1506" | "1510" | "1511" | "1512" | "1513" | "1514" | "1515" | "1516" | "1520" | "1521" | "1522" | "1523" | "1524" | "1525" | "1526" | "1530" | "1531" | "1532" | "1533" | "1534" | "1535" | "1536" | "1540" | "1541" | "1542" | "1543" | "1544" | "1545" | "1546" | "1550" | "1551" | "1552" | "1553" | "1554" | "1555" | "1556" | "1560" | "1561" | "1562" | "1563" | "1564" | "1565" | "1566" | "1600" | "1601" | "1602" | "1603" | "1604" | "1605" | "1606" | "1610" | "1611" | "1612" | "1613" | "1614" | "1615" | "1616" | "1620" | "1621" | "1622" | "1623" | "1624" | "1625" | "1626" | "1630" | "1631" | "1632" | "1633" | "1634" | "1635" | "1636" | "1640" | "1641" | "1642" | "1643" | "1644" | "1645" | "1646" | "1650" | "1651" | "1652" | "1653" | "1654" | "1655" | "1656" | "1660" | "1661" | "1662" | "1663" | "1664" | "1665" | "1666" | undefined) & T2 + +declare const y3: (`${'0' | '1' | '2'}${D}${D}${D}` | undefined) & T2; +>y3 : ("0000" | "0001" | "0002" | "0003" | "0004" | "0005" | "0006" | "0010" | "0011" | "0012" | "0013" | "0014" | "0015" | "0016" | "0020" | "0021" | "0022" | "0023" | "0024" | "0025" | "0026" | "0030" | "0031" | "0032" | "0033" | "0034" | "0035" | "0036" | "0040" | "0041" | "0042" | "0043" | "0044" | "0045" | "0046" | "0050" | "0051" | "0052" | "0053" | "0054" | "0055" | "0056" | "0060" | "0061" | "0062" | "0063" | "0064" | "0065" | "0066" | "0100" | "0101" | "0102" | "0103" | "0104" | "0105" | "0106" | "0110" | "0111" | "0112" | "0113" | "0114" | "0115" | "0116" | "0120" | "0121" | "0122" | "0123" | "0124" | "0125" | "0126" | "0130" | "0131" | "0132" | "0133" | "0134" | "0135" | "0136" | "0140" | "0141" | "0142" | "0143" | "0144" | "0145" | "0146" | "0150" | "0151" | "0152" | "0153" | "0154" | "0155" | "0156" | "0160" | "0161" | "0162" | "0163" | "0164" | "0165" | "0166" | "0200" | "0201" | "0202" | "0203" | "0204" | "0205" | "0206" | "0210" | "0211" | "0212" | "0213" | "0214" | "0215" | "0216" | "0220" | "0221" | "0222" | "0223" | "0224" | "0225" | "0226" | "0230" | "0231" | "0232" | "0233" | "0234" | "0235" | "0236" | "0240" | "0241" | "0242" | "0243" | "0244" | "0245" | "0246" | "0250" | "0251" | "0252" | "0253" | "0254" | "0255" | "0256" | "0260" | "0261" | "0262" | "0263" | "0264" | "0265" | "0266" | "0300" | "0301" | "0302" | "0303" | "0304" | "0305" | "0306" | "0310" | "0311" | "0312" | "0313" | "0314" | "0315" | "0316" | "0320" | "0321" | "0322" | "0323" | "0324" | "0325" | "0326" | "0330" | "0331" | "0332" | "0333" | "0334" | "0335" | "0336" | "0340" | "0341" | "0342" | "0343" | "0344" | "0345" | "0346" | "0350" | "0351" | "0352" | "0353" | "0354" | "0355" | "0356" | "0360" | "0361" | "0362" | "0363" | "0364" | "0365" | "0366" | "0400" | "0401" | "0402" | "0403" | "0404" | "0405" | "0406" | "0410" | "0411" | "0412" | "0413" | "0414" | "0415" | "0416" | "0420" | "0421" | "0422" | "0423" | "0424" | "0425" | "0426" | "0430" | "0431" | "0432" | "0433" | "0434" | "0435" | "0436" | "0440" | "0441" | "0442" | "0443" | "0444" | "0445" | "0446" | "0450" | "0451" | "0452" | "0453" | "0454" | "0455" | "0456" | "0460" | "0461" | "0462" | "0463" | "0464" | "0465" | "0466" | "0500" | "0501" | "0502" | "0503" | "0504" | "0505" | "0506" | "0510" | "0511" | "0512" | "0513" | "0514" | "0515" | "0516" | "0520" | "0521" | "0522" | "0523" | "0524" | "0525" | "0526" | "0530" | "0531" | "0532" | "0533" | "0534" | "0535" | "0536" | "0540" | "0541" | "0542" | "0543" | "0544" | "0545" | "0546" | "0550" | "0551" | "0552" | "0553" | "0554" | "0555" | "0556" | "0560" | "0561" | "0562" | "0563" | "0564" | "0565" | "0566" | "0600" | "0601" | "0602" | "0603" | "0604" | "0605" | "0606" | "0610" | "0611" | "0612" | "0613" | "0614" | "0615" | "0616" | "0620" | "0621" | "0622" | "0623" | "0624" | "0625" | "0626" | "0630" | "0631" | "0632" | "0633" | "0634" | "0635" | "0636" | "0640" | "0641" | "0642" | "0643" | "0644" | "0645" | "0646" | "0650" | "0651" | "0652" | "0653" | "0654" | "0655" | "0656" | "0660" | "0661" | "0662" | "0663" | "0664" | "0665" | "0666" | "1000" | "1001" | "1002" | "1003" | "1004" | "1005" | "1006" | "1010" | "1011" | "1012" | "1013" | "1014" | "1015" | "1016" | "1020" | "1021" | "1022" | "1023" | "1024" | "1025" | "1026" | "1030" | "1031" | "1032" | "1033" | "1034" | "1035" | "1036" | "1040" | "1041" | "1042" | "1043" | "1044" | "1045" | "1046" | "1050" | "1051" | "1052" | "1053" | "1054" | "1055" | "1056" | "1060" | "1061" | "1062" | "1063" | "1064" | "1065" | "1066" | "1100" | "1101" | "1102" | "1103" | "1104" | "1105" | "1106" | "1110" | "1111" | "1112" | "1113" | "1114" | "1115" | "1116" | "1120" | "1121" | "1122" | "1123" | "1124" | "1125" | "1126" | "1130" | "1131" | "1132" | "1133" | "1134" | "1135" | "1136" | "1140" | "1141" | "1142" | "1143" | "1144" | "1145" | "1146" | "1150" | "1151" | "1152" | "1153" | "1154" | "1155" | "1156" | "1160" | "1161" | "1162" | "1163" | "1164" | "1165" | "1166" | "1200" | "1201" | "1202" | "1203" | "1204" | "1205" | "1206" | "1210" | "1211" | "1212" | "1213" | "1214" | "1215" | "1216" | "1220" | "1221" | "1222" | "1223" | "1224" | "1225" | "1226" | "1230" | "1231" | "1232" | "1233" | "1234" | "1235" | "1236" | "1240" | "1241" | "1242" | "1243" | "1244" | "1245" | "1246" | "1250" | "1251" | "1252" | "1253" | "1254" | "1255" | "1256" | "1260" | "1261" | "1262" | "1263" | "1264" | "1265" | "1266" | "1300" | "1301" | "1302" | "1303" | "1304" | "1305" | "1306" | "1310" | "1311" | "1312" | "1313" | "1314" | "1315" | "1316" | "1320" | "1321" | "1322" | "1323" | "1324" | "1325" | "1326" | "1330" | "1331" | "1332" | "1333" | "1334" | "1335" | "1336" | "1340" | "1341" | "1342" | "1343" | "1344" | "1345" | "1346" | "1350" | "1351" | "1352" | "1353" | "1354" | "1355" | "1356" | "1360" | "1361" | "1362" | "1363" | "1364" | "1365" | "1366" | "1400" | "1401" | "1402" | "1403" | "1404" | "1405" | "1406" | "1410" | "1411" | "1412" | "1413" | "1414" | "1415" | "1416" | "1420" | "1421" | "1422" | "1423" | "1424" | "1425" | "1426" | "1430" | "1431" | "1432" | "1433" | "1434" | "1435" | "1436" | "1440" | "1441" | "1442" | "1443" | "1444" | "1445" | "1446" | "1450" | "1451" | "1452" | "1453" | "1454" | "1455" | "1456" | "1460" | "1461" | "1462" | "1463" | "1464" | "1465" | "1466" | "1500" | "1501" | "1502" | "1503" | "1504" | "1505" | "1506" | "1510" | "1511" | "1512" | "1513" | "1514" | "1515" | "1516" | "1520" | "1521" | "1522" | "1523" | "1524" | "1525" | "1526" | "1530" | "1531" | "1532" | "1533" | "1534" | "1535" | "1536" | "1540" | "1541" | "1542" | "1543" | "1544" | "1545" | "1546" | "1550" | "1551" | "1552" | "1553" | "1554" | "1555" | "1556" | "1560" | "1561" | "1562" | "1563" | "1564" | "1565" | "1566" | "1600" | "1601" | "1602" | "1603" | "1604" | "1605" | "1606" | "1610" | "1611" | "1612" | "1613" | "1614" | "1615" | "1616" | "1620" | "1621" | "1622" | "1623" | "1624" | "1625" | "1626" | "1630" | "1631" | "1632" | "1633" | "1634" | "1635" | "1636" | "1640" | "1641" | "1642" | "1643" | "1644" | "1645" | "1646" | "1650" | "1651" | "1652" | "1653" | "1654" | "1655" | "1656" | "1660" | "1661" | "1662" | "1663" | "1664" | "1665" | "1666" | "2000" | "2001" | "2002" | "2003" | "2004" | "2005" | "2006" | "2010" | "2011" | "2012" | "2013" | "2014" | "2015" | "2016" | "2020" | "2021" | "2022" | "2023" | "2024" | "2025" | "2026" | "2030" | "2031" | "2032" | "2033" | "2034" | "2035" | "2036" | "2040" | "2041" | "2042" | "2043" | "2044" | "2045" | "2046" | "2050" | "2051" | "2052" | "2053" | "2054" | "2055" | "2056" | "2060" | "2061" | "2062" | "2063" | "2064" | "2065" | "2066" | "2100" | "2101" | "2102" | "2103" | "2104" | "2105" | "2106" | "2110" | "2111" | "2112" | "2113" | "2114" | "2115" | "2116" | "2120" | "2121" | "2122" | "2123" | "2124" | "2125" | "2126" | "2130" | "2131" | "2132" | "2133" | "2134" | "2135" | "2136" | "2140" | "2141" | "2142" | "2143" | "2144" | "2145" | "2146" | "2150" | "2151" | "2152" | "2153" | "2154" | "2155" | "2156" | "2160" | "2161" | "2162" | "2163" | "2164" | "2165" | "2166" | "2200" | "2201" | "2202" | "2203" | "2204" | "2205" | "2206" | "2210" | "2211" | "2212" | "2213" | "2214" | "2215" | "2216" | "2220" | "2221" | "2222" | "2223" | "2224" | "2225" | "2226" | "2230" | "2231" | "2232" | "2233" | "2234" | "2235" | "2236" | "2240" | "2241" | "2242" | "2243" | "2244" | "2245" | "2246" | "2250" | "2251" | "2252" | "2253" | "2254" | "2255" | "2256" | "2260" | "2261" | "2262" | "2263" | "2264" | "2265" | "2266" | "2300" | "2301" | "2302" | "2303" | "2304" | "2305" | "2306" | "2310" | "2311" | "2312" | "2313" | "2314" | "2315" | "2316" | "2320" | "2321" | "2322" | "2323" | "2324" | "2325" | "2326" | "2330" | "2331" | "2332" | "2333" | "2334" | "2335" | "2336" | "2340" | "2341" | "2342" | "2343" | "2344" | "2345" | "2346" | "2350" | "2351" | "2352" | "2353" | "2354" | "2355" | "2356" | "2360" | "2361" | "2362" | "2363" | "2364" | "2365" | "2366" | "2400" | "2401" | "2402" | "2403" | "2404" | "2405" | "2406" | "2410" | "2411" | "2412" | "2413" | "2414" | "2415" | "2416" | "2420" | "2421" | "2422" | "2423" | "2424" | "2425" | "2426" | "2430" | "2431" | "2432" | "2433" | "2434" | "2435" | "2436" | "2440" | "2441" | "2442" | "2443" | "2444" | "2445" | "2446" | "2450" | "2451" | "2452" | "2453" | "2454" | "2455" | "2456" | "2460" | "2461" | "2462" | "2463" | "2464" | "2465" | "2466" | "2500" | "2501" | "2502" | "2503" | "2504" | "2505" | "2506" | "2510" | "2511" | "2512" | "2513" | "2514" | "2515" | "2516" | "2520" | "2521" | "2522" | "2523" | "2524" | "2525" | "2526" | "2530" | "2531" | "2532" | "2533" | "2534" | "2535" | "2536" | "2540" | "2541" | "2542" | "2543" | "2544" | "2545" | "2546" | "2550" | "2551" | "2552" | "2553" | "2554" | "2555" | "2556" | "2560" | "2561" | "2562" | "2563" | "2564" | "2565" | "2566" | "2600" | "2601" | "2602" | "2603" | "2604" | "2605" | "2606" | "2610" | "2611" | "2612" | "2613" | "2614" | "2615" | "2616" | "2620" | "2621" | "2622" | "2623" | "2624" | "2625" | "2626" | "2630" | "2631" | "2632" | "2633" | "2634" | "2635" | "2636" | "2640" | "2641" | "2642" | "2643" | "2644" | "2645" | "2646" | "2650" | "2651" | "2652" | "2653" | "2654" | "2655" | "2656" | "2660" | "2661" | "2662" | "2663" | "2664" | "2665" | "2666" | undefined) & T2 + +x = y3; +>x = y3 : ("0000" | "0001" | "0002" | "0003" | "0004" | "0005" | "0006" | "0010" | "0011" | "0012" | "0013" | "0014" | "0015" | "0016" | "0020" | "0021" | "0022" | "0023" | "0024" | "0025" | "0026" | "0030" | "0031" | "0032" | "0033" | "0034" | "0035" | "0036" | "0040" | "0041" | "0042" | "0043" | "0044" | "0045" | "0046" | "0050" | "0051" | "0052" | "0053" | "0054" | "0055" | "0056" | "0060" | "0061" | "0062" | "0063" | "0064" | "0065" | "0066" | "0100" | "0101" | "0102" | "0103" | "0104" | "0105" | "0106" | "0110" | "0111" | "0112" | "0113" | "0114" | "0115" | "0116" | "0120" | "0121" | "0122" | "0123" | "0124" | "0125" | "0126" | "0130" | "0131" | "0132" | "0133" | "0134" | "0135" | "0136" | "0140" | "0141" | "0142" | "0143" | "0144" | "0145" | "0146" | "0150" | "0151" | "0152" | "0153" | "0154" | "0155" | "0156" | "0160" | "0161" | "0162" | "0163" | "0164" | "0165" | "0166" | "0200" | "0201" | "0202" | "0203" | "0204" | "0205" | "0206" | "0210" | "0211" | "0212" | "0213" | "0214" | "0215" | "0216" | "0220" | "0221" | "0222" | "0223" | "0224" | "0225" | "0226" | "0230" | "0231" | "0232" | "0233" | "0234" | "0235" | "0236" | "0240" | "0241" | "0242" | "0243" | "0244" | "0245" | "0246" | "0250" | "0251" | "0252" | "0253" | "0254" | "0255" | "0256" | "0260" | "0261" | "0262" | "0263" | "0264" | "0265" | "0266" | "0300" | "0301" | "0302" | "0303" | "0304" | "0305" | "0306" | "0310" | "0311" | "0312" | "0313" | "0314" | "0315" | "0316" | "0320" | "0321" | "0322" | "0323" | "0324" | "0325" | "0326" | "0330" | "0331" | "0332" | "0333" | "0334" | "0335" | "0336" | "0340" | "0341" | "0342" | "0343" | "0344" | "0345" | "0346" | "0350" | "0351" | "0352" | "0353" | "0354" | "0355" | "0356" | "0360" | "0361" | "0362" | "0363" | "0364" | "0365" | "0366" | "0400" | "0401" | "0402" | "0403" | "0404" | "0405" | "0406" | "0410" | "0411" | "0412" | "0413" | "0414" | "0415" | "0416" | "0420" | "0421" | "0422" | "0423" | "0424" | "0425" | "0426" | "0430" | "0431" | "0432" | "0433" | "0434" | "0435" | "0436" | "0440" | "0441" | "0442" | "0443" | "0444" | "0445" | "0446" | "0450" | "0451" | "0452" | "0453" | "0454" | "0455" | "0456" | "0460" | "0461" | "0462" | "0463" | "0464" | "0465" | "0466" | "0500" | "0501" | "0502" | "0503" | "0504" | "0505" | "0506" | "0510" | "0511" | "0512" | "0513" | "0514" | "0515" | "0516" | "0520" | "0521" | "0522" | "0523" | "0524" | "0525" | "0526" | "0530" | "0531" | "0532" | "0533" | "0534" | "0535" | "0536" | "0540" | "0541" | "0542" | "0543" | "0544" | "0545" | "0546" | "0550" | "0551" | "0552" | "0553" | "0554" | "0555" | "0556" | "0560" | "0561" | "0562" | "0563" | "0564" | "0565" | "0566" | "0600" | "0601" | "0602" | "0603" | "0604" | "0605" | "0606" | "0610" | "0611" | "0612" | "0613" | "0614" | "0615" | "0616" | "0620" | "0621" | "0622" | "0623" | "0624" | "0625" | "0626" | "0630" | "0631" | "0632" | "0633" | "0634" | "0635" | "0636" | "0640" | "0641" | "0642" | "0643" | "0644" | "0645" | "0646" | "0650" | "0651" | "0652" | "0653" | "0654" | "0655" | "0656" | "0660" | "0661" | "0662" | "0663" | "0664" | "0665" | "0666" | "1000" | "1001" | "1002" | "1003" | "1004" | "1005" | "1006" | "1010" | "1011" | "1012" | "1013" | "1014" | "1015" | "1016" | "1020" | "1021" | "1022" | "1023" | "1024" | "1025" | "1026" | "1030" | "1031" | "1032" | "1033" | "1034" | "1035" | "1036" | "1040" | "1041" | "1042" | "1043" | "1044" | "1045" | "1046" | "1050" | "1051" | "1052" | "1053" | "1054" | "1055" | "1056" | "1060" | "1061" | "1062" | "1063" | "1064" | "1065" | "1066" | "1100" | "1101" | "1102" | "1103" | "1104" | "1105" | "1106" | "1110" | "1111" | "1112" | "1113" | "1114" | "1115" | "1116" | "1120" | "1121" | "1122" | "1123" | "1124" | "1125" | "1126" | "1130" | "1131" | "1132" | "1133" | "1134" | "1135" | "1136" | "1140" | "1141" | "1142" | "1143" | "1144" | "1145" | "1146" | "1150" | "1151" | "1152" | "1153" | "1154" | "1155" | "1156" | "1160" | "1161" | "1162" | "1163" | "1164" | "1165" | "1166" | "1200" | "1201" | "1202" | "1203" | "1204" | "1205" | "1206" | "1210" | "1211" | "1212" | "1213" | "1214" | "1215" | "1216" | "1220" | "1221" | "1222" | "1223" | "1224" | "1225" | "1226" | "1230" | "1231" | "1232" | "1233" | "1234" | "1235" | "1236" | "1240" | "1241" | "1242" | "1243" | "1244" | "1245" | "1246" | "1250" | "1251" | "1252" | "1253" | "1254" | "1255" | "1256" | "1260" | "1261" | "1262" | "1263" | "1264" | "1265" | "1266" | "1300" | "1301" | "1302" | "1303" | "1304" | "1305" | "1306" | "1310" | "1311" | "1312" | "1313" | "1314" | "1315" | "1316" | "1320" | "1321" | "1322" | "1323" | "1324" | "1325" | "1326" | "1330" | "1331" | "1332" | "1333" | "1334" | "1335" | "1336" | "1340" | "1341" | "1342" | "1343" | "1344" | "1345" | "1346" | "1350" | "1351" | "1352" | "1353" | "1354" | "1355" | "1356" | "1360" | "1361" | "1362" | "1363" | "1364" | "1365" | "1366" | "1400" | "1401" | "1402" | "1403" | "1404" | "1405" | "1406" | "1410" | "1411" | "1412" | "1413" | "1414" | "1415" | "1416" | "1420" | "1421" | "1422" | "1423" | "1424" | "1425" | "1426" | "1430" | "1431" | "1432" | "1433" | "1434" | "1435" | "1436" | "1440" | "1441" | "1442" | "1443" | "1444" | "1445" | "1446" | "1450" | "1451" | "1452" | "1453" | "1454" | "1455" | "1456" | "1460" | "1461" | "1462" | "1463" | "1464" | "1465" | "1466" | "1500" | "1501" | "1502" | "1503" | "1504" | "1505" | "1506" | "1510" | "1511" | "1512" | "1513" | "1514" | "1515" | "1516" | "1520" | "1521" | "1522" | "1523" | "1524" | "1525" | "1526" | "1530" | "1531" | "1532" | "1533" | "1534" | "1535" | "1536" | "1540" | "1541" | "1542" | "1543" | "1544" | "1545" | "1546" | "1550" | "1551" | "1552" | "1553" | "1554" | "1555" | "1556" | "1560" | "1561" | "1562" | "1563" | "1564" | "1565" | "1566" | "1600" | "1601" | "1602" | "1603" | "1604" | "1605" | "1606" | "1610" | "1611" | "1612" | "1613" | "1614" | "1615" | "1616" | "1620" | "1621" | "1622" | "1623" | "1624" | "1625" | "1626" | "1630" | "1631" | "1632" | "1633" | "1634" | "1635" | "1636" | "1640" | "1641" | "1642" | "1643" | "1644" | "1645" | "1646" | "1650" | "1651" | "1652" | "1653" | "1654" | "1655" | "1656" | "1660" | "1661" | "1662" | "1663" | "1664" | "1665" | "1666" | "2000" | "2001" | "2002" | "2003" | "2004" | "2005" | "2006" | "2010" | "2011" | "2012" | "2013" | "2014" | "2015" | "2016" | "2020" | "2021" | "2022" | "2023" | "2024" | "2025" | "2026" | "2030" | "2031" | "2032" | "2033" | "2034" | "2035" | "2036" | "2040" | "2041" | "2042" | "2043" | "2044" | "2045" | "2046" | "2050" | "2051" | "2052" | "2053" | "2054" | "2055" | "2056" | "2060" | "2061" | "2062" | "2063" | "2064" | "2065" | "2066" | "2100" | "2101" | "2102" | "2103" | "2104" | "2105" | "2106" | "2110" | "2111" | "2112" | "2113" | "2114" | "2115" | "2116" | "2120" | "2121" | "2122" | "2123" | "2124" | "2125" | "2126" | "2130" | "2131" | "2132" | "2133" | "2134" | "2135" | "2136" | "2140" | "2141" | "2142" | "2143" | "2144" | "2145" | "2146" | "2150" | "2151" | "2152" | "2153" | "2154" | "2155" | "2156" | "2160" | "2161" | "2162" | "2163" | "2164" | "2165" | "2166" | "2200" | "2201" | "2202" | "2203" | "2204" | "2205" | "2206" | "2210" | "2211" | "2212" | "2213" | "2214" | "2215" | "2216" | "2220" | "2221" | "2222" | "2223" | "2224" | "2225" | "2226" | "2230" | "2231" | "2232" | "2233" | "2234" | "2235" | "2236" | "2240" | "2241" | "2242" | "2243" | "2244" | "2245" | "2246" | "2250" | "2251" | "2252" | "2253" | "2254" | "2255" | "2256" | "2260" | "2261" | "2262" | "2263" | "2264" | "2265" | "2266" | "2300" | "2301" | "2302" | "2303" | "2304" | "2305" | "2306" | "2310" | "2311" | "2312" | "2313" | "2314" | "2315" | "2316" | "2320" | "2321" | "2322" | "2323" | "2324" | "2325" | "2326" | "2330" | "2331" | "2332" | "2333" | "2334" | "2335" | "2336" | "2340" | "2341" | "2342" | "2343" | "2344" | "2345" | "2346" | "2350" | "2351" | "2352" | "2353" | "2354" | "2355" | "2356" | "2360" | "2361" | "2362" | "2363" | "2364" | "2365" | "2366" | "2400" | "2401" | "2402" | "2403" | "2404" | "2405" | "2406" | "2410" | "2411" | "2412" | "2413" | "2414" | "2415" | "2416" | "2420" | "2421" | "2422" | "2423" | "2424" | "2425" | "2426" | "2430" | "2431" | "2432" | "2433" | "2434" | "2435" | "2436" | "2440" | "2441" | "2442" | "2443" | "2444" | "2445" | "2446" | "2450" | "2451" | "2452" | "2453" | "2454" | "2455" | "2456" | "2460" | "2461" | "2462" | "2463" | "2464" | "2465" | "2466" | "2500" | "2501" | "2502" | "2503" | "2504" | "2505" | "2506" | "2510" | "2511" | "2512" | "2513" | "2514" | "2515" | "2516" | "2520" | "2521" | "2522" | "2523" | "2524" | "2525" | "2526" | "2530" | "2531" | "2532" | "2533" | "2534" | "2535" | "2536" | "2540" | "2541" | "2542" | "2543" | "2544" | "2545" | "2546" | "2550" | "2551" | "2552" | "2553" | "2554" | "2555" | "2556" | "2560" | "2561" | "2562" | "2563" | "2564" | "2565" | "2566" | "2600" | "2601" | "2602" | "2603" | "2604" | "2605" | "2606" | "2610" | "2611" | "2612" | "2613" | "2614" | "2615" | "2616" | "2620" | "2621" | "2622" | "2623" | "2624" | "2625" | "2626" | "2630" | "2631" | "2632" | "2633" | "2634" | "2635" | "2636" | "2640" | "2641" | "2642" | "2643" | "2644" | "2645" | "2646" | "2650" | "2651" | "2652" | "2653" | "2654" | "2655" | "2656" | "2660" | "2661" | "2662" | "2663" | "2664" | "2665" | "2666" | undefined) & T2 +>x : T1 | null +>y3 : ("0000" | "0001" | "0002" | "0003" | "0004" | "0005" | "0006" | "0010" | "0011" | "0012" | "0013" | "0014" | "0015" | "0016" | "0020" | "0021" | "0022" | "0023" | "0024" | "0025" | "0026" | "0030" | "0031" | "0032" | "0033" | "0034" | "0035" | "0036" | "0040" | "0041" | "0042" | "0043" | "0044" | "0045" | "0046" | "0050" | "0051" | "0052" | "0053" | "0054" | "0055" | "0056" | "0060" | "0061" | "0062" | "0063" | "0064" | "0065" | "0066" | "0100" | "0101" | "0102" | "0103" | "0104" | "0105" | "0106" | "0110" | "0111" | "0112" | "0113" | "0114" | "0115" | "0116" | "0120" | "0121" | "0122" | "0123" | "0124" | "0125" | "0126" | "0130" | "0131" | "0132" | "0133" | "0134" | "0135" | "0136" | "0140" | "0141" | "0142" | "0143" | "0144" | "0145" | "0146" | "0150" | "0151" | "0152" | "0153" | "0154" | "0155" | "0156" | "0160" | "0161" | "0162" | "0163" | "0164" | "0165" | "0166" | "0200" | "0201" | "0202" | "0203" | "0204" | "0205" | "0206" | "0210" | "0211" | "0212" | "0213" | "0214" | "0215" | "0216" | "0220" | "0221" | "0222" | "0223" | "0224" | "0225" | "0226" | "0230" | "0231" | "0232" | "0233" | "0234" | "0235" | "0236" | "0240" | "0241" | "0242" | "0243" | "0244" | "0245" | "0246" | "0250" | "0251" | "0252" | "0253" | "0254" | "0255" | "0256" | "0260" | "0261" | "0262" | "0263" | "0264" | "0265" | "0266" | "0300" | "0301" | "0302" | "0303" | "0304" | "0305" | "0306" | "0310" | "0311" | "0312" | "0313" | "0314" | "0315" | "0316" | "0320" | "0321" | "0322" | "0323" | "0324" | "0325" | "0326" | "0330" | "0331" | "0332" | "0333" | "0334" | "0335" | "0336" | "0340" | "0341" | "0342" | "0343" | "0344" | "0345" | "0346" | "0350" | "0351" | "0352" | "0353" | "0354" | "0355" | "0356" | "0360" | "0361" | "0362" | "0363" | "0364" | "0365" | "0366" | "0400" | "0401" | "0402" | "0403" | "0404" | "0405" | "0406" | "0410" | "0411" | "0412" | "0413" | "0414" | "0415" | "0416" | "0420" | "0421" | "0422" | "0423" | "0424" | "0425" | "0426" | "0430" | "0431" | "0432" | "0433" | "0434" | "0435" | "0436" | "0440" | "0441" | "0442" | "0443" | "0444" | "0445" | "0446" | "0450" | "0451" | "0452" | "0453" | "0454" | "0455" | "0456" | "0460" | "0461" | "0462" | "0463" | "0464" | "0465" | "0466" | "0500" | "0501" | "0502" | "0503" | "0504" | "0505" | "0506" | "0510" | "0511" | "0512" | "0513" | "0514" | "0515" | "0516" | "0520" | "0521" | "0522" | "0523" | "0524" | "0525" | "0526" | "0530" | "0531" | "0532" | "0533" | "0534" | "0535" | "0536" | "0540" | "0541" | "0542" | "0543" | "0544" | "0545" | "0546" | "0550" | "0551" | "0552" | "0553" | "0554" | "0555" | "0556" | "0560" | "0561" | "0562" | "0563" | "0564" | "0565" | "0566" | "0600" | "0601" | "0602" | "0603" | "0604" | "0605" | "0606" | "0610" | "0611" | "0612" | "0613" | "0614" | "0615" | "0616" | "0620" | "0621" | "0622" | "0623" | "0624" | "0625" | "0626" | "0630" | "0631" | "0632" | "0633" | "0634" | "0635" | "0636" | "0640" | "0641" | "0642" | "0643" | "0644" | "0645" | "0646" | "0650" | "0651" | "0652" | "0653" | "0654" | "0655" | "0656" | "0660" | "0661" | "0662" | "0663" | "0664" | "0665" | "0666" | "1000" | "1001" | "1002" | "1003" | "1004" | "1005" | "1006" | "1010" | "1011" | "1012" | "1013" | "1014" | "1015" | "1016" | "1020" | "1021" | "1022" | "1023" | "1024" | "1025" | "1026" | "1030" | "1031" | "1032" | "1033" | "1034" | "1035" | "1036" | "1040" | "1041" | "1042" | "1043" | "1044" | "1045" | "1046" | "1050" | "1051" | "1052" | "1053" | "1054" | "1055" | "1056" | "1060" | "1061" | "1062" | "1063" | "1064" | "1065" | "1066" | "1100" | "1101" | "1102" | "1103" | "1104" | "1105" | "1106" | "1110" | "1111" | "1112" | "1113" | "1114" | "1115" | "1116" | "1120" | "1121" | "1122" | "1123" | "1124" | "1125" | "1126" | "1130" | "1131" | "1132" | "1133" | "1134" | "1135" | "1136" | "1140" | "1141" | "1142" | "1143" | "1144" | "1145" | "1146" | "1150" | "1151" | "1152" | "1153" | "1154" | "1155" | "1156" | "1160" | "1161" | "1162" | "1163" | "1164" | "1165" | "1166" | "1200" | "1201" | "1202" | "1203" | "1204" | "1205" | "1206" | "1210" | "1211" | "1212" | "1213" | "1214" | "1215" | "1216" | "1220" | "1221" | "1222" | "1223" | "1224" | "1225" | "1226" | "1230" | "1231" | "1232" | "1233" | "1234" | "1235" | "1236" | "1240" | "1241" | "1242" | "1243" | "1244" | "1245" | "1246" | "1250" | "1251" | "1252" | "1253" | "1254" | "1255" | "1256" | "1260" | "1261" | "1262" | "1263" | "1264" | "1265" | "1266" | "1300" | "1301" | "1302" | "1303" | "1304" | "1305" | "1306" | "1310" | "1311" | "1312" | "1313" | "1314" | "1315" | "1316" | "1320" | "1321" | "1322" | "1323" | "1324" | "1325" | "1326" | "1330" | "1331" | "1332" | "1333" | "1334" | "1335" | "1336" | "1340" | "1341" | "1342" | "1343" | "1344" | "1345" | "1346" | "1350" | "1351" | "1352" | "1353" | "1354" | "1355" | "1356" | "1360" | "1361" | "1362" | "1363" | "1364" | "1365" | "1366" | "1400" | "1401" | "1402" | "1403" | "1404" | "1405" | "1406" | "1410" | "1411" | "1412" | "1413" | "1414" | "1415" | "1416" | "1420" | "1421" | "1422" | "1423" | "1424" | "1425" | "1426" | "1430" | "1431" | "1432" | "1433" | "1434" | "1435" | "1436" | "1440" | "1441" | "1442" | "1443" | "1444" | "1445" | "1446" | "1450" | "1451" | "1452" | "1453" | "1454" | "1455" | "1456" | "1460" | "1461" | "1462" | "1463" | "1464" | "1465" | "1466" | "1500" | "1501" | "1502" | "1503" | "1504" | "1505" | "1506" | "1510" | "1511" | "1512" | "1513" | "1514" | "1515" | "1516" | "1520" | "1521" | "1522" | "1523" | "1524" | "1525" | "1526" | "1530" | "1531" | "1532" | "1533" | "1534" | "1535" | "1536" | "1540" | "1541" | "1542" | "1543" | "1544" | "1545" | "1546" | "1550" | "1551" | "1552" | "1553" | "1554" | "1555" | "1556" | "1560" | "1561" | "1562" | "1563" | "1564" | "1565" | "1566" | "1600" | "1601" | "1602" | "1603" | "1604" | "1605" | "1606" | "1610" | "1611" | "1612" | "1613" | "1614" | "1615" | "1616" | "1620" | "1621" | "1622" | "1623" | "1624" | "1625" | "1626" | "1630" | "1631" | "1632" | "1633" | "1634" | "1635" | "1636" | "1640" | "1641" | "1642" | "1643" | "1644" | "1645" | "1646" | "1650" | "1651" | "1652" | "1653" | "1654" | "1655" | "1656" | "1660" | "1661" | "1662" | "1663" | "1664" | "1665" | "1666" | "2000" | "2001" | "2002" | "2003" | "2004" | "2005" | "2006" | "2010" | "2011" | "2012" | "2013" | "2014" | "2015" | "2016" | "2020" | "2021" | "2022" | "2023" | "2024" | "2025" | "2026" | "2030" | "2031" | "2032" | "2033" | "2034" | "2035" | "2036" | "2040" | "2041" | "2042" | "2043" | "2044" | "2045" | "2046" | "2050" | "2051" | "2052" | "2053" | "2054" | "2055" | "2056" | "2060" | "2061" | "2062" | "2063" | "2064" | "2065" | "2066" | "2100" | "2101" | "2102" | "2103" | "2104" | "2105" | "2106" | "2110" | "2111" | "2112" | "2113" | "2114" | "2115" | "2116" | "2120" | "2121" | "2122" | "2123" | "2124" | "2125" | "2126" | "2130" | "2131" | "2132" | "2133" | "2134" | "2135" | "2136" | "2140" | "2141" | "2142" | "2143" | "2144" | "2145" | "2146" | "2150" | "2151" | "2152" | "2153" | "2154" | "2155" | "2156" | "2160" | "2161" | "2162" | "2163" | "2164" | "2165" | "2166" | "2200" | "2201" | "2202" | "2203" | "2204" | "2205" | "2206" | "2210" | "2211" | "2212" | "2213" | "2214" | "2215" | "2216" | "2220" | "2221" | "2222" | "2223" | "2224" | "2225" | "2226" | "2230" | "2231" | "2232" | "2233" | "2234" | "2235" | "2236" | "2240" | "2241" | "2242" | "2243" | "2244" | "2245" | "2246" | "2250" | "2251" | "2252" | "2253" | "2254" | "2255" | "2256" | "2260" | "2261" | "2262" | "2263" | "2264" | "2265" | "2266" | "2300" | "2301" | "2302" | "2303" | "2304" | "2305" | "2306" | "2310" | "2311" | "2312" | "2313" | "2314" | "2315" | "2316" | "2320" | "2321" | "2322" | "2323" | "2324" | "2325" | "2326" | "2330" | "2331" | "2332" | "2333" | "2334" | "2335" | "2336" | "2340" | "2341" | "2342" | "2343" | "2344" | "2345" | "2346" | "2350" | "2351" | "2352" | "2353" | "2354" | "2355" | "2356" | "2360" | "2361" | "2362" | "2363" | "2364" | "2365" | "2366" | "2400" | "2401" | "2402" | "2403" | "2404" | "2405" | "2406" | "2410" | "2411" | "2412" | "2413" | "2414" | "2415" | "2416" | "2420" | "2421" | "2422" | "2423" | "2424" | "2425" | "2426" | "2430" | "2431" | "2432" | "2433" | "2434" | "2435" | "2436" | "2440" | "2441" | "2442" | "2443" | "2444" | "2445" | "2446" | "2450" | "2451" | "2452" | "2453" | "2454" | "2455" | "2456" | "2460" | "2461" | "2462" | "2463" | "2464" | "2465" | "2466" | "2500" | "2501" | "2502" | "2503" | "2504" | "2505" | "2506" | "2510" | "2511" | "2512" | "2513" | "2514" | "2515" | "2516" | "2520" | "2521" | "2522" | "2523" | "2524" | "2525" | "2526" | "2530" | "2531" | "2532" | "2533" | "2534" | "2535" | "2536" | "2540" | "2541" | "2542" | "2543" | "2544" | "2545" | "2546" | "2550" | "2551" | "2552" | "2553" | "2554" | "2555" | "2556" | "2560" | "2561" | "2562" | "2563" | "2564" | "2565" | "2566" | "2600" | "2601" | "2602" | "2603" | "2604" | "2605" | "2606" | "2610" | "2611" | "2612" | "2613" | "2614" | "2615" | "2616" | "2620" | "2621" | "2622" | "2623" | "2624" | "2625" | "2626" | "2630" | "2631" | "2632" | "2633" | "2634" | "2635" | "2636" | "2640" | "2641" | "2642" | "2643" | "2644" | "2645" | "2646" | "2650" | "2651" | "2652" | "2653" | "2654" | "2655" | "2656" | "2660" | "2661" | "2662" | "2663" | "2664" | "2665" | "2666" | undefined) & T2 + +declare const y4: (`${'0' | '1' | '2' | '3'}${D}${D}${D}` | undefined) & T2; +>y4 : ("0000" | "0001" | "0002" | "0003" | "0004" | "0005" | "0006" | "0010" | "0011" | "0012" | "0013" | "0014" | "0015" | "0016" | "0020" | "0021" | "0022" | "0023" | "0024" | "0025" | "0026" | "0030" | "0031" | "0032" | "0033" | "0034" | "0035" | "0036" | "0040" | "0041" | "0042" | "0043" | "0044" | "0045" | "0046" | "0050" | "0051" | "0052" | "0053" | "0054" | "0055" | "0056" | "0060" | "0061" | "0062" | "0063" | "0064" | "0065" | "0066" | "0100" | "0101" | "0102" | "0103" | "0104" | "0105" | "0106" | "0110" | "0111" | "0112" | "0113" | "0114" | "0115" | "0116" | "0120" | "0121" | "0122" | "0123" | "0124" | "0125" | "0126" | "0130" | "0131" | "0132" | "0133" | "0134" | "0135" | "0136" | "0140" | "0141" | "0142" | "0143" | "0144" | "0145" | "0146" | "0150" | "0151" | "0152" | "0153" | "0154" | "0155" | "0156" | "0160" | "0161" | "0162" | "0163" | "0164" | "0165" | "0166" | "0200" | "0201" | "0202" | "0203" | "0204" | "0205" | "0206" | "0210" | "0211" | "0212" | "0213" | "0214" | "0215" | "0216" | "0220" | "0221" | "0222" | "0223" | "0224" | "0225" | "0226" | "0230" | "0231" | "0232" | "0233" | "0234" | "0235" | "0236" | "0240" | "0241" | "0242" | "0243" | "0244" | "0245" | "0246" | "0250" | "0251" | "0252" | "0253" | "0254" | "0255" | "0256" | "0260" | "0261" | "0262" | "0263" | "0264" | "0265" | "0266" | "0300" | "0301" | "0302" | "0303" | "0304" | "0305" | "0306" | "0310" | "0311" | "0312" | "0313" | "0314" | "0315" | "0316" | "0320" | "0321" | "0322" | "0323" | "0324" | "0325" | "0326" | "0330" | "0331" | "0332" | "0333" | "0334" | "0335" | "0336" | "0340" | "0341" | "0342" | "0343" | "0344" | "0345" | "0346" | "0350" | "0351" | "0352" | "0353" | "0354" | "0355" | "0356" | "0360" | "0361" | "0362" | "0363" | "0364" | "0365" | "0366" | "0400" | "0401" | "0402" | "0403" | "0404" | "0405" | "0406" | "0410" | "0411" | "0412" | "0413" | "0414" | "0415" | "0416" | "0420" | "0421" | "0422" | "0423" | "0424" | "0425" | "0426" | "0430" | "0431" | "0432" | "0433" | "0434" | "0435" | "0436" | "0440" | "0441" | "0442" | "0443" | "0444" | "0445" | "0446" | "0450" | "0451" | "0452" | "0453" | "0454" | "0455" | "0456" | "0460" | "0461" | "0462" | "0463" | "0464" | "0465" | "0466" | "0500" | "0501" | "0502" | "0503" | "0504" | "0505" | "0506" | "0510" | "0511" | "0512" | "0513" | "0514" | "0515" | "0516" | "0520" | "0521" | "0522" | "0523" | "0524" | "0525" | "0526" | "0530" | "0531" | "0532" | "0533" | "0534" | "0535" | "0536" | "0540" | "0541" | "0542" | "0543" | "0544" | "0545" | "0546" | "0550" | "0551" | "0552" | "0553" | "0554" | "0555" | "0556" | "0560" | "0561" | "0562" | "0563" | "0564" | "0565" | "0566" | "0600" | "0601" | "0602" | "0603" | "0604" | "0605" | "0606" | "0610" | "0611" | "0612" | "0613" | "0614" | "0615" | "0616" | "0620" | "0621" | "0622" | "0623" | "0624" | "0625" | "0626" | "0630" | "0631" | "0632" | "0633" | "0634" | "0635" | "0636" | "0640" | "0641" | "0642" | "0643" | "0644" | "0645" | "0646" | "0650" | "0651" | "0652" | "0653" | "0654" | "0655" | "0656" | "0660" | "0661" | "0662" | "0663" | "0664" | "0665" | "0666" | "1000" | "1001" | "1002" | "1003" | "1004" | "1005" | "1006" | "1010" | "1011" | "1012" | "1013" | "1014" | "1015" | "1016" | "1020" | "1021" | "1022" | "1023" | "1024" | "1025" | "1026" | "1030" | "1031" | "1032" | "1033" | "1034" | "1035" | "1036" | "1040" | "1041" | "1042" | "1043" | "1044" | "1045" | "1046" | "1050" | "1051" | "1052" | "1053" | "1054" | "1055" | "1056" | "1060" | "1061" | "1062" | "1063" | "1064" | "1065" | "1066" | "1100" | "1101" | "1102" | "1103" | "1104" | "1105" | "1106" | "1110" | "1111" | "1112" | "1113" | "1114" | "1115" | "1116" | "1120" | "1121" | "1122" | "1123" | "1124" | "1125" | "1126" | "1130" | "1131" | "1132" | "1133" | "1134" | "1135" | "1136" | "1140" | "1141" | "1142" | "1143" | "1144" | "1145" | "1146" | "1150" | "1151" | "1152" | "1153" | "1154" | "1155" | "1156" | "1160" | "1161" | "1162" | "1163" | "1164" | "1165" | "1166" | "1200" | "1201" | "1202" | "1203" | "1204" | "1205" | "1206" | "1210" | "1211" | "1212" | "1213" | "1214" | "1215" | "1216" | "1220" | "1221" | "1222" | "1223" | "1224" | "1225" | "1226" | "1230" | "1231" | "1232" | "1233" | "1234" | "1235" | "1236" | "1240" | "1241" | "1242" | "1243" | "1244" | "1245" | "1246" | "1250" | "1251" | "1252" | "1253" | "1254" | "1255" | "1256" | "1260" | "1261" | "1262" | "1263" | "1264" | "1265" | "1266" | "1300" | "1301" | "1302" | "1303" | "1304" | "1305" | "1306" | "1310" | "1311" | "1312" | "1313" | "1314" | "1315" | "1316" | "1320" | "1321" | "1322" | "1323" | "1324" | "1325" | "1326" | "1330" | "1331" | "1332" | "1333" | "1334" | "1335" | "1336" | "1340" | "1341" | "1342" | "1343" | "1344" | "1345" | "1346" | "1350" | "1351" | "1352" | "1353" | "1354" | "1355" | "1356" | "1360" | "1361" | "1362" | "1363" | "1364" | "1365" | "1366" | "1400" | "1401" | "1402" | "1403" | "1404" | "1405" | "1406" | "1410" | "1411" | "1412" | "1413" | "1414" | "1415" | "1416" | "1420" | "1421" | "1422" | "1423" | "1424" | "1425" | "1426" | "1430" | "1431" | "1432" | "1433" | "1434" | "1435" | "1436" | "1440" | "1441" | "1442" | "1443" | "1444" | "1445" | "1446" | "1450" | "1451" | "1452" | "1453" | "1454" | "1455" | "1456" | "1460" | "1461" | "1462" | "1463" | "1464" | "1465" | "1466" | "1500" | "1501" | "1502" | "1503" | "1504" | "1505" | "1506" | "1510" | "1511" | "1512" | "1513" | "1514" | "1515" | "1516" | "1520" | "1521" | "1522" | "1523" | "1524" | "1525" | "1526" | "1530" | "1531" | "1532" | "1533" | "1534" | "1535" | "1536" | "1540" | "1541" | "1542" | "1543" | "1544" | "1545" | "1546" | "1550" | "1551" | "1552" | "1553" | "1554" | "1555" | "1556" | "1560" | "1561" | "1562" | "1563" | "1564" | "1565" | "1566" | "1600" | "1601" | "1602" | "1603" | "1604" | "1605" | "1606" | "1610" | "1611" | "1612" | "1613" | "1614" | "1615" | "1616" | "1620" | "1621" | "1622" | "1623" | "1624" | "1625" | "1626" | "1630" | "1631" | "1632" | "1633" | "1634" | "1635" | "1636" | "1640" | "1641" | "1642" | "1643" | "1644" | "1645" | "1646" | "1650" | "1651" | "1652" | "1653" | "1654" | "1655" | "1656" | "1660" | "1661" | "1662" | "1663" | "1664" | "1665" | "1666" | "2000" | "2001" | "2002" | "2003" | "2004" | "2005" | "2006" | "2010" | "2011" | "2012" | "2013" | "2014" | "2015" | "2016" | "2020" | "2021" | "2022" | "2023" | "2024" | "2025" | "2026" | "2030" | "2031" | "2032" | "2033" | "2034" | "2035" | "2036" | "2040" | "2041" | "2042" | "2043" | "2044" | "2045" | "2046" | "2050" | "2051" | "2052" | "2053" | "2054" | "2055" | "2056" | "2060" | "2061" | "2062" | "2063" | "2064" | "2065" | "2066" | "2100" | "2101" | "2102" | "2103" | "2104" | "2105" | "2106" | "2110" | "2111" | "2112" | "2113" | "2114" | "2115" | "2116" | "2120" | "2121" | "2122" | "2123" | "2124" | "2125" | "2126" | "2130" | "2131" | "2132" | "2133" | "2134" | "2135" | "2136" | "2140" | "2141" | "2142" | "2143" | "2144" | "2145" | "2146" | "2150" | "2151" | "2152" | "2153" | "2154" | "2155" | "2156" | "2160" | "2161" | "2162" | "2163" | "2164" | "2165" | "2166" | "2200" | "2201" | "2202" | "2203" | "2204" | "2205" | "2206" | "2210" | "2211" | "2212" | "2213" | "2214" | "2215" | "2216" | "2220" | "2221" | "2222" | "2223" | "2224" | "2225" | "2226" | "2230" | "2231" | "2232" | "2233" | "2234" | "2235" | "2236" | "2240" | "2241" | "2242" | "2243" | "2244" | "2245" | "2246" | "2250" | "2251" | "2252" | "2253" | "2254" | "2255" | "2256" | "2260" | "2261" | "2262" | "2263" | "2264" | "2265" | "2266" | "2300" | "2301" | "2302" | "2303" | "2304" | "2305" | "2306" | "2310" | "2311" | "2312" | "2313" | "2314" | "2315" | "2316" | "2320" | "2321" | "2322" | "2323" | "2324" | "2325" | "2326" | "2330" | "2331" | "2332" | "2333" | "2334" | "2335" | "2336" | "2340" | "2341" | "2342" | "2343" | "2344" | "2345" | "2346" | "2350" | "2351" | "2352" | "2353" | "2354" | "2355" | "2356" | "2360" | "2361" | "2362" | "2363" | "2364" | "2365" | "2366" | "2400" | "2401" | "2402" | "2403" | "2404" | "2405" | "2406" | "2410" | "2411" | "2412" | "2413" | "2414" | "2415" | "2416" | "2420" | "2421" | "2422" | "2423" | "2424" | "2425" | "2426" | "2430" | "2431" | "2432" | "2433" | "2434" | "2435" | "2436" | "2440" | "2441" | "2442" | "2443" | "2444" | "2445" | "2446" | "2450" | "2451" | "2452" | "2453" | "2454" | "2455" | "2456" | "2460" | "2461" | "2462" | "2463" | "2464" | "2465" | "2466" | "2500" | "2501" | "2502" | "2503" | "2504" | "2505" | "2506" | "2510" | "2511" | "2512" | "2513" | "2514" | "2515" | "2516" | "2520" | "2521" | "2522" | "2523" | "2524" | "2525" | "2526" | "2530" | "2531" | "2532" | "2533" | "2534" | "2535" | "2536" | "2540" | "2541" | "2542" | "2543" | "2544" | "2545" | "2546" | "2550" | "2551" | "2552" | "2553" | "2554" | "2555" | "2556" | "2560" | "2561" | "2562" | "2563" | "2564" | "2565" | "2566" | "2600" | "2601" | "2602" | "2603" | "2604" | "2605" | "2606" | "2610" | "2611" | "2612" | "2613" | "2614" | "2615" | "2616" | "2620" | "2621" | "2622" | "2623" | "2624" | "2625" | "2626" | "2630" | "2631" | "2632" | "2633" | "2634" | "2635" | "2636" | "2640" | "2641" | "2642" | "2643" | "2644" | "2645" | "2646" | "2650" | "2651" | "2652" | "2653" | "2654" | "2655" | "2656" | "2660" | "2661" | "2662" | "2663" | "2664" | "2665" | "2666" | "3000" | "3001" | "3002" | "3003" | "3004" | "3005" | "3006" | "3010" | "3011" | "3012" | "3013" | "3014" | "3015" | "3016" | "3020" | "3021" | "3022" | "3023" | "3024" | "3025" | "3026" | "3030" | "3031" | "3032" | "3033" | "3034" | "3035" | "3036" | "3040" | "3041" | "3042" | "3043" | "3044" | "3045" | "3046" | "3050" | "3051" | "3052" | "3053" | "3054" | "3055" | "3056" | "3060" | "3061" | "3062" | "3063" | "3064" | "3065" | "3066" | "3100" | "3101" | "3102" | "3103" | "3104" | "3105" | "3106" | "3110" | "3111" | "3112" | "3113" | "3114" | "3115" | "3116" | "3120" | "3121" | "3122" | "3123" | "3124" | "3125" | "3126" | "3130" | "3131" | "3132" | "3133" | "3134" | "3135" | "3136" | "3140" | "3141" | "3142" | "3143" | "3144" | "3145" | "3146" | "3150" | "3151" | "3152" | "3153" | "3154" | "3155" | "3156" | "3160" | "3161" | "3162" | "3163" | "3164" | "3165" | "3166" | "3200" | "3201" | "3202" | "3203" | "3204" | "3205" | "3206" | "3210" | "3211" | "3212" | "3213" | "3214" | "3215" | "3216" | "3220" | "3221" | "3222" | "3223" | "3224" | "3225" | "3226" | "3230" | "3231" | "3232" | "3233" | "3234" | "3235" | "3236" | "3240" | "3241" | "3242" | "3243" | "3244" | "3245" | "3246" | "3250" | "3251" | "3252" | "3253" | "3254" | "3255" | "3256" | "3260" | "3261" | "3262" | "3263" | "3264" | "3265" | "3266" | "3300" | "3301" | "3302" | "3303" | "3304" | "3305" | "3306" | "3310" | "3311" | "3312" | "3313" | "3314" | "3315" | "3316" | "3320" | "3321" | "3322" | "3323" | "3324" | "3325" | "3326" | "3330" | "3331" | "3332" | "3333" | "3334" | "3335" | "3336" | "3340" | "3341" | "3342" | "3343" | "3344" | "3345" | "3346" | "3350" | "3351" | "3352" | "3353" | "3354" | "3355" | "3356" | "3360" | "3361" | "3362" | "3363" | "3364" | "3365" | "3366" | "3400" | "3401" | "3402" | "3403" | "3404" | "3405" | "3406" | "3410" | "3411" | "3412" | "3413" | "3414" | "3415" | "3416" | "3420" | "3421" | "3422" | "3423" | "3424" | "3425" | "3426" | "3430" | "3431" | "3432" | "3433" | "3434" | "3435" | "3436" | "3440" | "3441" | "3442" | "3443" | "3444" | "3445" | "3446" | "3450" | "3451" | "3452" | "3453" | "3454" | "3455" | "3456" | "3460" | "3461" | "3462" | "3463" | "3464" | "3465" | "3466" | "3500" | "3501" | "3502" | "3503" | "3504" | "3505" | "3506" | "3510" | "3511" | "3512" | "3513" | "3514" | "3515" | "3516" | "3520" | "3521" | "3522" | "3523" | "3524" | "3525" | "3526" | "3530" | "3531" | "3532" | "3533" | "3534" | "3535" | "3536" | "3540" | "3541" | "3542" | "3543" | "3544" | "3545" | "3546" | "3550" | "3551" | "3552" | "3553" | "3554" | "3555" | "3556" | "3560" | "3561" | "3562" | "3563" | "3564" | "3565" | "3566" | "3600" | "3601" | "3602" | "3603" | "3604" | "3605" | "3606" | "3610" | "3611" | "3612" | "3613" | "3614" | "3615" | "3616" | "3620" | "3621" | "3622" | "3623" | "3624" | "3625" | "3626" | "3630" | "3631" | "3632" | "3633" | "3634" | "3635" | "3636" | "3640" | "3641" | "3642" | "3643" | "3644" | "3645" | "3646" | "3650" | "3651" | "3652" | "3653" | "3654" | "3655" | "3656" | "3660" | "3661" | "3662" | "3663" | "3664" | "3665" | "3666" | undefined) & T2 + +x = y4; +>x = y4 : ("0000" | "0001" | "0002" | "0003" | "0004" | "0005" | "0006" | "0010" | "0011" | "0012" | "0013" | "0014" | "0015" | "0016" | "0020" | "0021" | "0022" | "0023" | "0024" | "0025" | "0026" | "0030" | "0031" | "0032" | "0033" | "0034" | "0035" | "0036" | "0040" | "0041" | "0042" | "0043" | "0044" | "0045" | "0046" | "0050" | "0051" | "0052" | "0053" | "0054" | "0055" | "0056" | "0060" | "0061" | "0062" | "0063" | "0064" | "0065" | "0066" | "0100" | "0101" | "0102" | "0103" | "0104" | "0105" | "0106" | "0110" | "0111" | "0112" | "0113" | "0114" | "0115" | "0116" | "0120" | "0121" | "0122" | "0123" | "0124" | "0125" | "0126" | "0130" | "0131" | "0132" | "0133" | "0134" | "0135" | "0136" | "0140" | "0141" | "0142" | "0143" | "0144" | "0145" | "0146" | "0150" | "0151" | "0152" | "0153" | "0154" | "0155" | "0156" | "0160" | "0161" | "0162" | "0163" | "0164" | "0165" | "0166" | "0200" | "0201" | "0202" | "0203" | "0204" | "0205" | "0206" | "0210" | "0211" | "0212" | "0213" | "0214" | "0215" | "0216" | "0220" | "0221" | "0222" | "0223" | "0224" | "0225" | "0226" | "0230" | "0231" | "0232" | "0233" | "0234" | "0235" | "0236" | "0240" | "0241" | "0242" | "0243" | "0244" | "0245" | "0246" | "0250" | "0251" | "0252" | "0253" | "0254" | "0255" | "0256" | "0260" | "0261" | "0262" | "0263" | "0264" | "0265" | "0266" | "0300" | "0301" | "0302" | "0303" | "0304" | "0305" | "0306" | "0310" | "0311" | "0312" | "0313" | "0314" | "0315" | "0316" | "0320" | "0321" | "0322" | "0323" | "0324" | "0325" | "0326" | "0330" | "0331" | "0332" | "0333" | "0334" | "0335" | "0336" | "0340" | "0341" | "0342" | "0343" | "0344" | "0345" | "0346" | "0350" | "0351" | "0352" | "0353" | "0354" | "0355" | "0356" | "0360" | "0361" | "0362" | "0363" | "0364" | "0365" | "0366" | "0400" | "0401" | "0402" | "0403" | "0404" | "0405" | "0406" | "0410" | "0411" | "0412" | "0413" | "0414" | "0415" | "0416" | "0420" | "0421" | "0422" | "0423" | "0424" | "0425" | "0426" | "0430" | "0431" | "0432" | "0433" | "0434" | "0435" | "0436" | "0440" | "0441" | "0442" | "0443" | "0444" | "0445" | "0446" | "0450" | "0451" | "0452" | "0453" | "0454" | "0455" | "0456" | "0460" | "0461" | "0462" | "0463" | "0464" | "0465" | "0466" | "0500" | "0501" | "0502" | "0503" | "0504" | "0505" | "0506" | "0510" | "0511" | "0512" | "0513" | "0514" | "0515" | "0516" | "0520" | "0521" | "0522" | "0523" | "0524" | "0525" | "0526" | "0530" | "0531" | "0532" | "0533" | "0534" | "0535" | "0536" | "0540" | "0541" | "0542" | "0543" | "0544" | "0545" | "0546" | "0550" | "0551" | "0552" | "0553" | "0554" | "0555" | "0556" | "0560" | "0561" | "0562" | "0563" | "0564" | "0565" | "0566" | "0600" | "0601" | "0602" | "0603" | "0604" | "0605" | "0606" | "0610" | "0611" | "0612" | "0613" | "0614" | "0615" | "0616" | "0620" | "0621" | "0622" | "0623" | "0624" | "0625" | "0626" | "0630" | "0631" | "0632" | "0633" | "0634" | "0635" | "0636" | "0640" | "0641" | "0642" | "0643" | "0644" | "0645" | "0646" | "0650" | "0651" | "0652" | "0653" | "0654" | "0655" | "0656" | "0660" | "0661" | "0662" | "0663" | "0664" | "0665" | "0666" | "1000" | "1001" | "1002" | "1003" | "1004" | "1005" | "1006" | "1010" | "1011" | "1012" | "1013" | "1014" | "1015" | "1016" | "1020" | "1021" | "1022" | "1023" | "1024" | "1025" | "1026" | "1030" | "1031" | "1032" | "1033" | "1034" | "1035" | "1036" | "1040" | "1041" | "1042" | "1043" | "1044" | "1045" | "1046" | "1050" | "1051" | "1052" | "1053" | "1054" | "1055" | "1056" | "1060" | "1061" | "1062" | "1063" | "1064" | "1065" | "1066" | "1100" | "1101" | "1102" | "1103" | "1104" | "1105" | "1106" | "1110" | "1111" | "1112" | "1113" | "1114" | "1115" | "1116" | "1120" | "1121" | "1122" | "1123" | "1124" | "1125" | "1126" | "1130" | "1131" | "1132" | "1133" | "1134" | "1135" | "1136" | "1140" | "1141" | "1142" | "1143" | "1144" | "1145" | "1146" | "1150" | "1151" | "1152" | "1153" | "1154" | "1155" | "1156" | "1160" | "1161" | "1162" | "1163" | "1164" | "1165" | "1166" | "1200" | "1201" | "1202" | "1203" | "1204" | "1205" | "1206" | "1210" | "1211" | "1212" | "1213" | "1214" | "1215" | "1216" | "1220" | "1221" | "1222" | "1223" | "1224" | "1225" | "1226" | "1230" | "1231" | "1232" | "1233" | "1234" | "1235" | "1236" | "1240" | "1241" | "1242" | "1243" | "1244" | "1245" | "1246" | "1250" | "1251" | "1252" | "1253" | "1254" | "1255" | "1256" | "1260" | "1261" | "1262" | "1263" | "1264" | "1265" | "1266" | "1300" | "1301" | "1302" | "1303" | "1304" | "1305" | "1306" | "1310" | "1311" | "1312" | "1313" | "1314" | "1315" | "1316" | "1320" | "1321" | "1322" | "1323" | "1324" | "1325" | "1326" | "1330" | "1331" | "1332" | "1333" | "1334" | "1335" | "1336" | "1340" | "1341" | "1342" | "1343" | "1344" | "1345" | "1346" | "1350" | "1351" | "1352" | "1353" | "1354" | "1355" | "1356" | "1360" | "1361" | "1362" | "1363" | "1364" | "1365" | "1366" | "1400" | "1401" | "1402" | "1403" | "1404" | "1405" | "1406" | "1410" | "1411" | "1412" | "1413" | "1414" | "1415" | "1416" | "1420" | "1421" | "1422" | "1423" | "1424" | "1425" | "1426" | "1430" | "1431" | "1432" | "1433" | "1434" | "1435" | "1436" | "1440" | "1441" | "1442" | "1443" | "1444" | "1445" | "1446" | "1450" | "1451" | "1452" | "1453" | "1454" | "1455" | "1456" | "1460" | "1461" | "1462" | "1463" | "1464" | "1465" | "1466" | "1500" | "1501" | "1502" | "1503" | "1504" | "1505" | "1506" | "1510" | "1511" | "1512" | "1513" | "1514" | "1515" | "1516" | "1520" | "1521" | "1522" | "1523" | "1524" | "1525" | "1526" | "1530" | "1531" | "1532" | "1533" | "1534" | "1535" | "1536" | "1540" | "1541" | "1542" | "1543" | "1544" | "1545" | "1546" | "1550" | "1551" | "1552" | "1553" | "1554" | "1555" | "1556" | "1560" | "1561" | "1562" | "1563" | "1564" | "1565" | "1566" | "1600" | "1601" | "1602" | "1603" | "1604" | "1605" | "1606" | "1610" | "1611" | "1612" | "1613" | "1614" | "1615" | "1616" | "1620" | "1621" | "1622" | "1623" | "1624" | "1625" | "1626" | "1630" | "1631" | "1632" | "1633" | "1634" | "1635" | "1636" | "1640" | "1641" | "1642" | "1643" | "1644" | "1645" | "1646" | "1650" | "1651" | "1652" | "1653" | "1654" | "1655" | "1656" | "1660" | "1661" | "1662" | "1663" | "1664" | "1665" | "1666" | "2000" | "2001" | "2002" | "2003" | "2004" | "2005" | "2006" | "2010" | "2011" | "2012" | "2013" | "2014" | "2015" | "2016" | "2020" | "2021" | "2022" | "2023" | "2024" | "2025" | "2026" | "2030" | "2031" | "2032" | "2033" | "2034" | "2035" | "2036" | "2040" | "2041" | "2042" | "2043" | "2044" | "2045" | "2046" | "2050" | "2051" | "2052" | "2053" | "2054" | "2055" | "2056" | "2060" | "2061" | "2062" | "2063" | "2064" | "2065" | "2066" | "2100" | "2101" | "2102" | "2103" | "2104" | "2105" | "2106" | "2110" | "2111" | "2112" | "2113" | "2114" | "2115" | "2116" | "2120" | "2121" | "2122" | "2123" | "2124" | "2125" | "2126" | "2130" | "2131" | "2132" | "2133" | "2134" | "2135" | "2136" | "2140" | "2141" | "2142" | "2143" | "2144" | "2145" | "2146" | "2150" | "2151" | "2152" | "2153" | "2154" | "2155" | "2156" | "2160" | "2161" | "2162" | "2163" | "2164" | "2165" | "2166" | "2200" | "2201" | "2202" | "2203" | "2204" | "2205" | "2206" | "2210" | "2211" | "2212" | "2213" | "2214" | "2215" | "2216" | "2220" | "2221" | "2222" | "2223" | "2224" | "2225" | "2226" | "2230" | "2231" | "2232" | "2233" | "2234" | "2235" | "2236" | "2240" | "2241" | "2242" | "2243" | "2244" | "2245" | "2246" | "2250" | "2251" | "2252" | "2253" | "2254" | "2255" | "2256" | "2260" | "2261" | "2262" | "2263" | "2264" | "2265" | "2266" | "2300" | "2301" | "2302" | "2303" | "2304" | "2305" | "2306" | "2310" | "2311" | "2312" | "2313" | "2314" | "2315" | "2316" | "2320" | "2321" | "2322" | "2323" | "2324" | "2325" | "2326" | "2330" | "2331" | "2332" | "2333" | "2334" | "2335" | "2336" | "2340" | "2341" | "2342" | "2343" | "2344" | "2345" | "2346" | "2350" | "2351" | "2352" | "2353" | "2354" | "2355" | "2356" | "2360" | "2361" | "2362" | "2363" | "2364" | "2365" | "2366" | "2400" | "2401" | "2402" | "2403" | "2404" | "2405" | "2406" | "2410" | "2411" | "2412" | "2413" | "2414" | "2415" | "2416" | "2420" | "2421" | "2422" | "2423" | "2424" | "2425" | "2426" | "2430" | "2431" | "2432" | "2433" | "2434" | "2435" | "2436" | "2440" | "2441" | "2442" | "2443" | "2444" | "2445" | "2446" | "2450" | "2451" | "2452" | "2453" | "2454" | "2455" | "2456" | "2460" | "2461" | "2462" | "2463" | "2464" | "2465" | "2466" | "2500" | "2501" | "2502" | "2503" | "2504" | "2505" | "2506" | "2510" | "2511" | "2512" | "2513" | "2514" | "2515" | "2516" | "2520" | "2521" | "2522" | "2523" | "2524" | "2525" | "2526" | "2530" | "2531" | "2532" | "2533" | "2534" | "2535" | "2536" | "2540" | "2541" | "2542" | "2543" | "2544" | "2545" | "2546" | "2550" | "2551" | "2552" | "2553" | "2554" | "2555" | "2556" | "2560" | "2561" | "2562" | "2563" | "2564" | "2565" | "2566" | "2600" | "2601" | "2602" | "2603" | "2604" | "2605" | "2606" | "2610" | "2611" | "2612" | "2613" | "2614" | "2615" | "2616" | "2620" | "2621" | "2622" | "2623" | "2624" | "2625" | "2626" | "2630" | "2631" | "2632" | "2633" | "2634" | "2635" | "2636" | "2640" | "2641" | "2642" | "2643" | "2644" | "2645" | "2646" | "2650" | "2651" | "2652" | "2653" | "2654" | "2655" | "2656" | "2660" | "2661" | "2662" | "2663" | "2664" | "2665" | "2666" | "3000" | "3001" | "3002" | "3003" | "3004" | "3005" | "3006" | "3010" | "3011" | "3012" | "3013" | "3014" | "3015" | "3016" | "3020" | "3021" | "3022" | "3023" | "3024" | "3025" | "3026" | "3030" | "3031" | "3032" | "3033" | "3034" | "3035" | "3036" | "3040" | "3041" | "3042" | "3043" | "3044" | "3045" | "3046" | "3050" | "3051" | "3052" | "3053" | "3054" | "3055" | "3056" | "3060" | "3061" | "3062" | "3063" | "3064" | "3065" | "3066" | "3100" | "3101" | "3102" | "3103" | "3104" | "3105" | "3106" | "3110" | "3111" | "3112" | "3113" | "3114" | "3115" | "3116" | "3120" | "3121" | "3122" | "3123" | "3124" | "3125" | "3126" | "3130" | "3131" | "3132" | "3133" | "3134" | "3135" | "3136" | "3140" | "3141" | "3142" | "3143" | "3144" | "3145" | "3146" | "3150" | "3151" | "3152" | "3153" | "3154" | "3155" | "3156" | "3160" | "3161" | "3162" | "3163" | "3164" | "3165" | "3166" | "3200" | "3201" | "3202" | "3203" | "3204" | "3205" | "3206" | "3210" | "3211" | "3212" | "3213" | "3214" | "3215" | "3216" | "3220" | "3221" | "3222" | "3223" | "3224" | "3225" | "3226" | "3230" | "3231" | "3232" | "3233" | "3234" | "3235" | "3236" | "3240" | "3241" | "3242" | "3243" | "3244" | "3245" | "3246" | "3250" | "3251" | "3252" | "3253" | "3254" | "3255" | "3256" | "3260" | "3261" | "3262" | "3263" | "3264" | "3265" | "3266" | "3300" | "3301" | "3302" | "3303" | "3304" | "3305" | "3306" | "3310" | "3311" | "3312" | "3313" | "3314" | "3315" | "3316" | "3320" | "3321" | "3322" | "3323" | "3324" | "3325" | "3326" | "3330" | "3331" | "3332" | "3333" | "3334" | "3335" | "3336" | "3340" | "3341" | "3342" | "3343" | "3344" | "3345" | "3346" | "3350" | "3351" | "3352" | "3353" | "3354" | "3355" | "3356" | "3360" | "3361" | "3362" | "3363" | "3364" | "3365" | "3366" | "3400" | "3401" | "3402" | "3403" | "3404" | "3405" | "3406" | "3410" | "3411" | "3412" | "3413" | "3414" | "3415" | "3416" | "3420" | "3421" | "3422" | "3423" | "3424" | "3425" | "3426" | "3430" | "3431" | "3432" | "3433" | "3434" | "3435" | "3436" | "3440" | "3441" | "3442" | "3443" | "3444" | "3445" | "3446" | "3450" | "3451" | "3452" | "3453" | "3454" | "3455" | "3456" | "3460" | "3461" | "3462" | "3463" | "3464" | "3465" | "3466" | "3500" | "3501" | "3502" | "3503" | "3504" | "3505" | "3506" | "3510" | "3511" | "3512" | "3513" | "3514" | "3515" | "3516" | "3520" | "3521" | "3522" | "3523" | "3524" | "3525" | "3526" | "3530" | "3531" | "3532" | "3533" | "3534" | "3535" | "3536" | "3540" | "3541" | "3542" | "3543" | "3544" | "3545" | "3546" | "3550" | "3551" | "3552" | "3553" | "3554" | "3555" | "3556" | "3560" | "3561" | "3562" | "3563" | "3564" | "3565" | "3566" | "3600" | "3601" | "3602" | "3603" | "3604" | "3605" | "3606" | "3610" | "3611" | "3612" | "3613" | "3614" | "3615" | "3616" | "3620" | "3621" | "3622" | "3623" | "3624" | "3625" | "3626" | "3630" | "3631" | "3632" | "3633" | "3634" | "3635" | "3636" | "3640" | "3641" | "3642" | "3643" | "3644" | "3645" | "3646" | "3650" | "3651" | "3652" | "3653" | "3654" | "3655" | "3656" | "3660" | "3661" | "3662" | "3663" | "3664" | "3665" | "3666" | undefined) & T2 +>x : T1 | null +>y4 : ("0000" | "0001" | "0002" | "0003" | "0004" | "0005" | "0006" | "0010" | "0011" | "0012" | "0013" | "0014" | "0015" | "0016" | "0020" | "0021" | "0022" | "0023" | "0024" | "0025" | "0026" | "0030" | "0031" | "0032" | "0033" | "0034" | "0035" | "0036" | "0040" | "0041" | "0042" | "0043" | "0044" | "0045" | "0046" | "0050" | "0051" | "0052" | "0053" | "0054" | "0055" | "0056" | "0060" | "0061" | "0062" | "0063" | "0064" | "0065" | "0066" | "0100" | "0101" | "0102" | "0103" | "0104" | "0105" | "0106" | "0110" | "0111" | "0112" | "0113" | "0114" | "0115" | "0116" | "0120" | "0121" | "0122" | "0123" | "0124" | "0125" | "0126" | "0130" | "0131" | "0132" | "0133" | "0134" | "0135" | "0136" | "0140" | "0141" | "0142" | "0143" | "0144" | "0145" | "0146" | "0150" | "0151" | "0152" | "0153" | "0154" | "0155" | "0156" | "0160" | "0161" | "0162" | "0163" | "0164" | "0165" | "0166" | "0200" | "0201" | "0202" | "0203" | "0204" | "0205" | "0206" | "0210" | "0211" | "0212" | "0213" | "0214" | "0215" | "0216" | "0220" | "0221" | "0222" | "0223" | "0224" | "0225" | "0226" | "0230" | "0231" | "0232" | "0233" | "0234" | "0235" | "0236" | "0240" | "0241" | "0242" | "0243" | "0244" | "0245" | "0246" | "0250" | "0251" | "0252" | "0253" | "0254" | "0255" | "0256" | "0260" | "0261" | "0262" | "0263" | "0264" | "0265" | "0266" | "0300" | "0301" | "0302" | "0303" | "0304" | "0305" | "0306" | "0310" | "0311" | "0312" | "0313" | "0314" | "0315" | "0316" | "0320" | "0321" | "0322" | "0323" | "0324" | "0325" | "0326" | "0330" | "0331" | "0332" | "0333" | "0334" | "0335" | "0336" | "0340" | "0341" | "0342" | "0343" | "0344" | "0345" | "0346" | "0350" | "0351" | "0352" | "0353" | "0354" | "0355" | "0356" | "0360" | "0361" | "0362" | "0363" | "0364" | "0365" | "0366" | "0400" | "0401" | "0402" | "0403" | "0404" | "0405" | "0406" | "0410" | "0411" | "0412" | "0413" | "0414" | "0415" | "0416" | "0420" | "0421" | "0422" | "0423" | "0424" | "0425" | "0426" | "0430" | "0431" | "0432" | "0433" | "0434" | "0435" | "0436" | "0440" | "0441" | "0442" | "0443" | "0444" | "0445" | "0446" | "0450" | "0451" | "0452" | "0453" | "0454" | "0455" | "0456" | "0460" | "0461" | "0462" | "0463" | "0464" | "0465" | "0466" | "0500" | "0501" | "0502" | "0503" | "0504" | "0505" | "0506" | "0510" | "0511" | "0512" | "0513" | "0514" | "0515" | "0516" | "0520" | "0521" | "0522" | "0523" | "0524" | "0525" | "0526" | "0530" | "0531" | "0532" | "0533" | "0534" | "0535" | "0536" | "0540" | "0541" | "0542" | "0543" | "0544" | "0545" | "0546" | "0550" | "0551" | "0552" | "0553" | "0554" | "0555" | "0556" | "0560" | "0561" | "0562" | "0563" | "0564" | "0565" | "0566" | "0600" | "0601" | "0602" | "0603" | "0604" | "0605" | "0606" | "0610" | "0611" | "0612" | "0613" | "0614" | "0615" | "0616" | "0620" | "0621" | "0622" | "0623" | "0624" | "0625" | "0626" | "0630" | "0631" | "0632" | "0633" | "0634" | "0635" | "0636" | "0640" | "0641" | "0642" | "0643" | "0644" | "0645" | "0646" | "0650" | "0651" | "0652" | "0653" | "0654" | "0655" | "0656" | "0660" | "0661" | "0662" | "0663" | "0664" | "0665" | "0666" | "1000" | "1001" | "1002" | "1003" | "1004" | "1005" | "1006" | "1010" | "1011" | "1012" | "1013" | "1014" | "1015" | "1016" | "1020" | "1021" | "1022" | "1023" | "1024" | "1025" | "1026" | "1030" | "1031" | "1032" | "1033" | "1034" | "1035" | "1036" | "1040" | "1041" | "1042" | "1043" | "1044" | "1045" | "1046" | "1050" | "1051" | "1052" | "1053" | "1054" | "1055" | "1056" | "1060" | "1061" | "1062" | "1063" | "1064" | "1065" | "1066" | "1100" | "1101" | "1102" | "1103" | "1104" | "1105" | "1106" | "1110" | "1111" | "1112" | "1113" | "1114" | "1115" | "1116" | "1120" | "1121" | "1122" | "1123" | "1124" | "1125" | "1126" | "1130" | "1131" | "1132" | "1133" | "1134" | "1135" | "1136" | "1140" | "1141" | "1142" | "1143" | "1144" | "1145" | "1146" | "1150" | "1151" | "1152" | "1153" | "1154" | "1155" | "1156" | "1160" | "1161" | "1162" | "1163" | "1164" | "1165" | "1166" | "1200" | "1201" | "1202" | "1203" | "1204" | "1205" | "1206" | "1210" | "1211" | "1212" | "1213" | "1214" | "1215" | "1216" | "1220" | "1221" | "1222" | "1223" | "1224" | "1225" | "1226" | "1230" | "1231" | "1232" | "1233" | "1234" | "1235" | "1236" | "1240" | "1241" | "1242" | "1243" | "1244" | "1245" | "1246" | "1250" | "1251" | "1252" | "1253" | "1254" | "1255" | "1256" | "1260" | "1261" | "1262" | "1263" | "1264" | "1265" | "1266" | "1300" | "1301" | "1302" | "1303" | "1304" | "1305" | "1306" | "1310" | "1311" | "1312" | "1313" | "1314" | "1315" | "1316" | "1320" | "1321" | "1322" | "1323" | "1324" | "1325" | "1326" | "1330" | "1331" | "1332" | "1333" | "1334" | "1335" | "1336" | "1340" | "1341" | "1342" | "1343" | "1344" | "1345" | "1346" | "1350" | "1351" | "1352" | "1353" | "1354" | "1355" | "1356" | "1360" | "1361" | "1362" | "1363" | "1364" | "1365" | "1366" | "1400" | "1401" | "1402" | "1403" | "1404" | "1405" | "1406" | "1410" | "1411" | "1412" | "1413" | "1414" | "1415" | "1416" | "1420" | "1421" | "1422" | "1423" | "1424" | "1425" | "1426" | "1430" | "1431" | "1432" | "1433" | "1434" | "1435" | "1436" | "1440" | "1441" | "1442" | "1443" | "1444" | "1445" | "1446" | "1450" | "1451" | "1452" | "1453" | "1454" | "1455" | "1456" | "1460" | "1461" | "1462" | "1463" | "1464" | "1465" | "1466" | "1500" | "1501" | "1502" | "1503" | "1504" | "1505" | "1506" | "1510" | "1511" | "1512" | "1513" | "1514" | "1515" | "1516" | "1520" | "1521" | "1522" | "1523" | "1524" | "1525" | "1526" | "1530" | "1531" | "1532" | "1533" | "1534" | "1535" | "1536" | "1540" | "1541" | "1542" | "1543" | "1544" | "1545" | "1546" | "1550" | "1551" | "1552" | "1553" | "1554" | "1555" | "1556" | "1560" | "1561" | "1562" | "1563" | "1564" | "1565" | "1566" | "1600" | "1601" | "1602" | "1603" | "1604" | "1605" | "1606" | "1610" | "1611" | "1612" | "1613" | "1614" | "1615" | "1616" | "1620" | "1621" | "1622" | "1623" | "1624" | "1625" | "1626" | "1630" | "1631" | "1632" | "1633" | "1634" | "1635" | "1636" | "1640" | "1641" | "1642" | "1643" | "1644" | "1645" | "1646" | "1650" | "1651" | "1652" | "1653" | "1654" | "1655" | "1656" | "1660" | "1661" | "1662" | "1663" | "1664" | "1665" | "1666" | "2000" | "2001" | "2002" | "2003" | "2004" | "2005" | "2006" | "2010" | "2011" | "2012" | "2013" | "2014" | "2015" | "2016" | "2020" | "2021" | "2022" | "2023" | "2024" | "2025" | "2026" | "2030" | "2031" | "2032" | "2033" | "2034" | "2035" | "2036" | "2040" | "2041" | "2042" | "2043" | "2044" | "2045" | "2046" | "2050" | "2051" | "2052" | "2053" | "2054" | "2055" | "2056" | "2060" | "2061" | "2062" | "2063" | "2064" | "2065" | "2066" | "2100" | "2101" | "2102" | "2103" | "2104" | "2105" | "2106" | "2110" | "2111" | "2112" | "2113" | "2114" | "2115" | "2116" | "2120" | "2121" | "2122" | "2123" | "2124" | "2125" | "2126" | "2130" | "2131" | "2132" | "2133" | "2134" | "2135" | "2136" | "2140" | "2141" | "2142" | "2143" | "2144" | "2145" | "2146" | "2150" | "2151" | "2152" | "2153" | "2154" | "2155" | "2156" | "2160" | "2161" | "2162" | "2163" | "2164" | "2165" | "2166" | "2200" | "2201" | "2202" | "2203" | "2204" | "2205" | "2206" | "2210" | "2211" | "2212" | "2213" | "2214" | "2215" | "2216" | "2220" | "2221" | "2222" | "2223" | "2224" | "2225" | "2226" | "2230" | "2231" | "2232" | "2233" | "2234" | "2235" | "2236" | "2240" | "2241" | "2242" | "2243" | "2244" | "2245" | "2246" | "2250" | "2251" | "2252" | "2253" | "2254" | "2255" | "2256" | "2260" | "2261" | "2262" | "2263" | "2264" | "2265" | "2266" | "2300" | "2301" | "2302" | "2303" | "2304" | "2305" | "2306" | "2310" | "2311" | "2312" | "2313" | "2314" | "2315" | "2316" | "2320" | "2321" | "2322" | "2323" | "2324" | "2325" | "2326" | "2330" | "2331" | "2332" | "2333" | "2334" | "2335" | "2336" | "2340" | "2341" | "2342" | "2343" | "2344" | "2345" | "2346" | "2350" | "2351" | "2352" | "2353" | "2354" | "2355" | "2356" | "2360" | "2361" | "2362" | "2363" | "2364" | "2365" | "2366" | "2400" | "2401" | "2402" | "2403" | "2404" | "2405" | "2406" | "2410" | "2411" | "2412" | "2413" | "2414" | "2415" | "2416" | "2420" | "2421" | "2422" | "2423" | "2424" | "2425" | "2426" | "2430" | "2431" | "2432" | "2433" | "2434" | "2435" | "2436" | "2440" | "2441" | "2442" | "2443" | "2444" | "2445" | "2446" | "2450" | "2451" | "2452" | "2453" | "2454" | "2455" | "2456" | "2460" | "2461" | "2462" | "2463" | "2464" | "2465" | "2466" | "2500" | "2501" | "2502" | "2503" | "2504" | "2505" | "2506" | "2510" | "2511" | "2512" | "2513" | "2514" | "2515" | "2516" | "2520" | "2521" | "2522" | "2523" | "2524" | "2525" | "2526" | "2530" | "2531" | "2532" | "2533" | "2534" | "2535" | "2536" | "2540" | "2541" | "2542" | "2543" | "2544" | "2545" | "2546" | "2550" | "2551" | "2552" | "2553" | "2554" | "2555" | "2556" | "2560" | "2561" | "2562" | "2563" | "2564" | "2565" | "2566" | "2600" | "2601" | "2602" | "2603" | "2604" | "2605" | "2606" | "2610" | "2611" | "2612" | "2613" | "2614" | "2615" | "2616" | "2620" | "2621" | "2622" | "2623" | "2624" | "2625" | "2626" | "2630" | "2631" | "2632" | "2633" | "2634" | "2635" | "2636" | "2640" | "2641" | "2642" | "2643" | "2644" | "2645" | "2646" | "2650" | "2651" | "2652" | "2653" | "2654" | "2655" | "2656" | "2660" | "2661" | "2662" | "2663" | "2664" | "2665" | "2666" | "3000" | "3001" | "3002" | "3003" | "3004" | "3005" | "3006" | "3010" | "3011" | "3012" | "3013" | "3014" | "3015" | "3016" | "3020" | "3021" | "3022" | "3023" | "3024" | "3025" | "3026" | "3030" | "3031" | "3032" | "3033" | "3034" | "3035" | "3036" | "3040" | "3041" | "3042" | "3043" | "3044" | "3045" | "3046" | "3050" | "3051" | "3052" | "3053" | "3054" | "3055" | "3056" | "3060" | "3061" | "3062" | "3063" | "3064" | "3065" | "3066" | "3100" | "3101" | "3102" | "3103" | "3104" | "3105" | "3106" | "3110" | "3111" | "3112" | "3113" | "3114" | "3115" | "3116" | "3120" | "3121" | "3122" | "3123" | "3124" | "3125" | "3126" | "3130" | "3131" | "3132" | "3133" | "3134" | "3135" | "3136" | "3140" | "3141" | "3142" | "3143" | "3144" | "3145" | "3146" | "3150" | "3151" | "3152" | "3153" | "3154" | "3155" | "3156" | "3160" | "3161" | "3162" | "3163" | "3164" | "3165" | "3166" | "3200" | "3201" | "3202" | "3203" | "3204" | "3205" | "3206" | "3210" | "3211" | "3212" | "3213" | "3214" | "3215" | "3216" | "3220" | "3221" | "3222" | "3223" | "3224" | "3225" | "3226" | "3230" | "3231" | "3232" | "3233" | "3234" | "3235" | "3236" | "3240" | "3241" | "3242" | "3243" | "3244" | "3245" | "3246" | "3250" | "3251" | "3252" | "3253" | "3254" | "3255" | "3256" | "3260" | "3261" | "3262" | "3263" | "3264" | "3265" | "3266" | "3300" | "3301" | "3302" | "3303" | "3304" | "3305" | "3306" | "3310" | "3311" | "3312" | "3313" | "3314" | "3315" | "3316" | "3320" | "3321" | "3322" | "3323" | "3324" | "3325" | "3326" | "3330" | "3331" | "3332" | "3333" | "3334" | "3335" | "3336" | "3340" | "3341" | "3342" | "3343" | "3344" | "3345" | "3346" | "3350" | "3351" | "3352" | "3353" | "3354" | "3355" | "3356" | "3360" | "3361" | "3362" | "3363" | "3364" | "3365" | "3366" | "3400" | "3401" | "3402" | "3403" | "3404" | "3405" | "3406" | "3410" | "3411" | "3412" | "3413" | "3414" | "3415" | "3416" | "3420" | "3421" | "3422" | "3423" | "3424" | "3425" | "3426" | "3430" | "3431" | "3432" | "3433" | "3434" | "3435" | "3436" | "3440" | "3441" | "3442" | "3443" | "3444" | "3445" | "3446" | "3450" | "3451" | "3452" | "3453" | "3454" | "3455" | "3456" | "3460" | "3461" | "3462" | "3463" | "3464" | "3465" | "3466" | "3500" | "3501" | "3502" | "3503" | "3504" | "3505" | "3506" | "3510" | "3511" | "3512" | "3513" | "3514" | "3515" | "3516" | "3520" | "3521" | "3522" | "3523" | "3524" | "3525" | "3526" | "3530" | "3531" | "3532" | "3533" | "3534" | "3535" | "3536" | "3540" | "3541" | "3542" | "3543" | "3544" | "3545" | "3546" | "3550" | "3551" | "3552" | "3553" | "3554" | "3555" | "3556" | "3560" | "3561" | "3562" | "3563" | "3564" | "3565" | "3566" | "3600" | "3601" | "3602" | "3603" | "3604" | "3605" | "3606" | "3610" | "3611" | "3612" | "3613" | "3614" | "3615" | "3616" | "3620" | "3621" | "3622" | "3623" | "3624" | "3625" | "3626" | "3630" | "3631" | "3632" | "3633" | "3634" | "3635" | "3636" | "3640" | "3641" | "3642" | "3643" | "3644" | "3645" | "3646" | "3650" | "3651" | "3652" | "3653" | "3654" | "3655" | "3656" | "3660" | "3661" | "3662" | "3663" | "3664" | "3665" | "3666" | undefined) & T2 + +declare const y5: (`${'0' | '1' | '2' | '3' | '4'}${D}${D}${D}` | undefined) & T2; +>y5 : ("0000" | "0001" | "0002" | "0003" | "0004" | "0005" | "0006" | "0010" | "0011" | "0012" | "0013" | "0014" | "0015" | "0016" | "0020" | "0021" | "0022" | "0023" | "0024" | "0025" | "0026" | "0030" | "0031" | "0032" | "0033" | "0034" | "0035" | "0036" | "0040" | "0041" | "0042" | "0043" | "0044" | "0045" | "0046" | "0050" | "0051" | "0052" | "0053" | "0054" | "0055" | "0056" | "0060" | "0061" | "0062" | "0063" | "0064" | "0065" | "0066" | "0100" | "0101" | "0102" | "0103" | "0104" | "0105" | "0106" | "0110" | "0111" | "0112" | "0113" | "0114" | "0115" | "0116" | "0120" | "0121" | "0122" | "0123" | "0124" | "0125" | "0126" | "0130" | "0131" | "0132" | "0133" | "0134" | "0135" | "0136" | "0140" | "0141" | "0142" | "0143" | "0144" | "0145" | "0146" | "0150" | "0151" | "0152" | "0153" | "0154" | "0155" | "0156" | "0160" | "0161" | "0162" | "0163" | "0164" | "0165" | "0166" | "0200" | "0201" | "0202" | "0203" | "0204" | "0205" | "0206" | "0210" | "0211" | "0212" | "0213" | "0214" | "0215" | "0216" | "0220" | "0221" | "0222" | "0223" | "0224" | "0225" | "0226" | "0230" | "0231" | "0232" | "0233" | "0234" | "0235" | "0236" | "0240" | "0241" | "0242" | "0243" | "0244" | "0245" | "0246" | "0250" | "0251" | "0252" | "0253" | "0254" | "0255" | "0256" | "0260" | "0261" | "0262" | "0263" | "0264" | "0265" | "0266" | "0300" | "0301" | "0302" | "0303" | "0304" | "0305" | "0306" | "0310" | "0311" | "0312" | "0313" | "0314" | "0315" | "0316" | "0320" | "0321" | "0322" | "0323" | "0324" | "0325" | "0326" | "0330" | "0331" | "0332" | "0333" | "0334" | "0335" | "0336" | "0340" | "0341" | "0342" | "0343" | "0344" | "0345" | "0346" | "0350" | "0351" | "0352" | "0353" | "0354" | "0355" | "0356" | "0360" | "0361" | "0362" | "0363" | "0364" | "0365" | "0366" | "0400" | "0401" | "0402" | "0403" | "0404" | "0405" | "0406" | "0410" | "0411" | "0412" | "0413" | "0414" | "0415" | "0416" | "0420" | "0421" | "0422" | "0423" | "0424" | "0425" | "0426" | "0430" | "0431" | "0432" | "0433" | "0434" | "0435" | "0436" | "0440" | "0441" | "0442" | "0443" | "0444" | "0445" | "0446" | "0450" | "0451" | "0452" | "0453" | "0454" | "0455" | "0456" | "0460" | "0461" | "0462" | "0463" | "0464" | "0465" | "0466" | "0500" | "0501" | "0502" | "0503" | "0504" | "0505" | "0506" | "0510" | "0511" | "0512" | "0513" | "0514" | "0515" | "0516" | "0520" | "0521" | "0522" | "0523" | "0524" | "0525" | "0526" | "0530" | "0531" | "0532" | "0533" | "0534" | "0535" | "0536" | "0540" | "0541" | "0542" | "0543" | "0544" | "0545" | "0546" | "0550" | "0551" | "0552" | "0553" | "0554" | "0555" | "0556" | "0560" | "0561" | "0562" | "0563" | "0564" | "0565" | "0566" | "0600" | "0601" | "0602" | "0603" | "0604" | "0605" | "0606" | "0610" | "0611" | "0612" | "0613" | "0614" | "0615" | "0616" | "0620" | "0621" | "0622" | "0623" | "0624" | "0625" | "0626" | "0630" | "0631" | "0632" | "0633" | "0634" | "0635" | "0636" | "0640" | "0641" | "0642" | "0643" | "0644" | "0645" | "0646" | "0650" | "0651" | "0652" | "0653" | "0654" | "0655" | "0656" | "0660" | "0661" | "0662" | "0663" | "0664" | "0665" | "0666" | "1000" | "1001" | "1002" | "1003" | "1004" | "1005" | "1006" | "1010" | "1011" | "1012" | "1013" | "1014" | "1015" | "1016" | "1020" | "1021" | "1022" | "1023" | "1024" | "1025" | "1026" | "1030" | "1031" | "1032" | "1033" | "1034" | "1035" | "1036" | "1040" | "1041" | "1042" | "1043" | "1044" | "1045" | "1046" | "1050" | "1051" | "1052" | "1053" | "1054" | "1055" | "1056" | "1060" | "1061" | "1062" | "1063" | "1064" | "1065" | "1066" | "1100" | "1101" | "1102" | "1103" | "1104" | "1105" | "1106" | "1110" | "1111" | "1112" | "1113" | "1114" | "1115" | "1116" | "1120" | "1121" | "1122" | "1123" | "1124" | "1125" | "1126" | "1130" | "1131" | "1132" | "1133" | "1134" | "1135" | "1136" | "1140" | "1141" | "1142" | "1143" | "1144" | "1145" | "1146" | "1150" | "1151" | "1152" | "1153" | "1154" | "1155" | "1156" | "1160" | "1161" | "1162" | "1163" | "1164" | "1165" | "1166" | "1200" | "1201" | "1202" | "1203" | "1204" | "1205" | "1206" | "1210" | "1211" | "1212" | "1213" | "1214" | "1215" | "1216" | "1220" | "1221" | "1222" | "1223" | "1224" | "1225" | "1226" | "1230" | "1231" | "1232" | "1233" | "1234" | "1235" | "1236" | "1240" | "1241" | "1242" | "1243" | "1244" | "1245" | "1246" | "1250" | "1251" | "1252" | "1253" | "1254" | "1255" | "1256" | "1260" | "1261" | "1262" | "1263" | "1264" | "1265" | "1266" | "1300" | "1301" | "1302" | "1303" | "1304" | "1305" | "1306" | "1310" | "1311" | "1312" | "1313" | "1314" | "1315" | "1316" | "1320" | "1321" | "1322" | "1323" | "1324" | "1325" | "1326" | "1330" | "1331" | "1332" | "1333" | "1334" | "1335" | "1336" | "1340" | "1341" | "1342" | "1343" | "1344" | "1345" | "1346" | "1350" | "1351" | "1352" | "1353" | "1354" | "1355" | "1356" | "1360" | "1361" | "1362" | "1363" | "1364" | "1365" | "1366" | "1400" | "1401" | "1402" | "1403" | "1404" | "1405" | "1406" | "1410" | "1411" | "1412" | "1413" | "1414" | "1415" | "1416" | "1420" | "1421" | "1422" | "1423" | "1424" | "1425" | "1426" | "1430" | "1431" | "1432" | "1433" | "1434" | "1435" | "1436" | "1440" | "1441" | "1442" | "1443" | "1444" | "1445" | "1446" | "1450" | "1451" | "1452" | "1453" | "1454" | "1455" | "1456" | "1460" | "1461" | "1462" | "1463" | "1464" | "1465" | "1466" | "1500" | "1501" | "1502" | "1503" | "1504" | "1505" | "1506" | "1510" | "1511" | "1512" | "1513" | "1514" | "1515" | "1516" | "1520" | "1521" | "1522" | "1523" | "1524" | "1525" | "1526" | "1530" | "1531" | "1532" | "1533" | "1534" | "1535" | "1536" | "1540" | "1541" | "1542" | "1543" | "1544" | "1545" | "1546" | "1550" | "1551" | "1552" | "1553" | "1554" | "1555" | "1556" | "1560" | "1561" | "1562" | "1563" | "1564" | "1565" | "1566" | "1600" | "1601" | "1602" | "1603" | "1604" | "1605" | "1606" | "1610" | "1611" | "1612" | "1613" | "1614" | "1615" | "1616" | "1620" | "1621" | "1622" | "1623" | "1624" | "1625" | "1626" | "1630" | "1631" | "1632" | "1633" | "1634" | "1635" | "1636" | "1640" | "1641" | "1642" | "1643" | "1644" | "1645" | "1646" | "1650" | "1651" | "1652" | "1653" | "1654" | "1655" | "1656" | "1660" | "1661" | "1662" | "1663" | "1664" | "1665" | "1666" | "2000" | "2001" | "2002" | "2003" | "2004" | "2005" | "2006" | "2010" | "2011" | "2012" | "2013" | "2014" | "2015" | "2016" | "2020" | "2021" | "2022" | "2023" | "2024" | "2025" | "2026" | "2030" | "2031" | "2032" | "2033" | "2034" | "2035" | "2036" | "2040" | "2041" | "2042" | "2043" | "2044" | "2045" | "2046" | "2050" | "2051" | "2052" | "2053" | "2054" | "2055" | "2056" | "2060" | "2061" | "2062" | "2063" | "2064" | "2065" | "2066" | "2100" | "2101" | "2102" | "2103" | "2104" | "2105" | "2106" | "2110" | "2111" | "2112" | "2113" | "2114" | "2115" | "2116" | "2120" | "2121" | "2122" | "2123" | "2124" | "2125" | "2126" | "2130" | "2131" | "2132" | "2133" | "2134" | "2135" | "2136" | "2140" | "2141" | "2142" | "2143" | "2144" | "2145" | "2146" | "2150" | "2151" | "2152" | "2153" | "2154" | "2155" | "2156" | "2160" | "2161" | "2162" | "2163" | "2164" | "2165" | "2166" | "2200" | "2201" | "2202" | "2203" | "2204" | "2205" | "2206" | "2210" | "2211" | "2212" | "2213" | "2214" | "2215" | "2216" | "2220" | "2221" | "2222" | "2223" | "2224" | "2225" | "2226" | "2230" | "2231" | "2232" | "2233" | "2234" | "2235" | "2236" | "2240" | "2241" | "2242" | "2243" | "2244" | "2245" | "2246" | "2250" | "2251" | "2252" | "2253" | "2254" | "2255" | "2256" | "2260" | "2261" | "2262" | "2263" | "2264" | "2265" | "2266" | "2300" | "2301" | "2302" | "2303" | "2304" | "2305" | "2306" | "2310" | "2311" | "2312" | "2313" | "2314" | "2315" | "2316" | "2320" | "2321" | "2322" | "2323" | "2324" | "2325" | "2326" | "2330" | "2331" | "2332" | "2333" | "2334" | "2335" | "2336" | "2340" | "2341" | "2342" | "2343" | "2344" | "2345" | "2346" | "2350" | "2351" | "2352" | "2353" | "2354" | "2355" | "2356" | "2360" | "2361" | "2362" | "2363" | "2364" | "2365" | "2366" | "2400" | "2401" | "2402" | "2403" | "2404" | "2405" | "2406" | "2410" | "2411" | "2412" | "2413" | "2414" | "2415" | "2416" | "2420" | "2421" | "2422" | "2423" | "2424" | "2425" | "2426" | "2430" | "2431" | "2432" | "2433" | "2434" | "2435" | "2436" | "2440" | "2441" | "2442" | "2443" | "2444" | "2445" | "2446" | "2450" | "2451" | "2452" | "2453" | "2454" | "2455" | "2456" | "2460" | "2461" | "2462" | "2463" | "2464" | "2465" | "2466" | "2500" | "2501" | "2502" | "2503" | "2504" | "2505" | "2506" | "2510" | "2511" | "2512" | "2513" | "2514" | "2515" | "2516" | "2520" | "2521" | "2522" | "2523" | "2524" | "2525" | "2526" | "2530" | "2531" | "2532" | "2533" | "2534" | "2535" | "2536" | "2540" | "2541" | "2542" | "2543" | "2544" | "2545" | "2546" | "2550" | "2551" | "2552" | "2553" | "2554" | "2555" | "2556" | "2560" | "2561" | "2562" | "2563" | "2564" | "2565" | "2566" | "2600" | "2601" | "2602" | "2603" | "2604" | "2605" | "2606" | "2610" | "2611" | "2612" | "2613" | "2614" | "2615" | "2616" | "2620" | "2621" | "2622" | "2623" | "2624" | "2625" | "2626" | "2630" | "2631" | "2632" | "2633" | "2634" | "2635" | "2636" | "2640" | "2641" | "2642" | "2643" | "2644" | "2645" | "2646" | "2650" | "2651" | "2652" | "2653" | "2654" | "2655" | "2656" | "2660" | "2661" | "2662" | "2663" | "2664" | "2665" | "2666" | "3000" | "3001" | "3002" | "3003" | "3004" | "3005" | "3006" | "3010" | "3011" | "3012" | "3013" | "3014" | "3015" | "3016" | "3020" | "3021" | "3022" | "3023" | "3024" | "3025" | "3026" | "3030" | "3031" | "3032" | "3033" | "3034" | "3035" | "3036" | "3040" | "3041" | "3042" | "3043" | "3044" | "3045" | "3046" | "3050" | "3051" | "3052" | "3053" | "3054" | "3055" | "3056" | "3060" | "3061" | "3062" | "3063" | "3064" | "3065" | "3066" | "3100" | "3101" | "3102" | "3103" | "3104" | "3105" | "3106" | "3110" | "3111" | "3112" | "3113" | "3114" | "3115" | "3116" | "3120" | "3121" | "3122" | "3123" | "3124" | "3125" | "3126" | "3130" | "3131" | "3132" | "3133" | "3134" | "3135" | "3136" | "3140" | "3141" | "3142" | "3143" | "3144" | "3145" | "3146" | "3150" | "3151" | "3152" | "3153" | "3154" | "3155" | "3156" | "3160" | "3161" | "3162" | "3163" | "3164" | "3165" | "3166" | "3200" | "3201" | "3202" | "3203" | "3204" | "3205" | "3206" | "3210" | "3211" | "3212" | "3213" | "3214" | "3215" | "3216" | "3220" | "3221" | "3222" | "3223" | "3224" | "3225" | "3226" | "3230" | "3231" | "3232" | "3233" | "3234" | "3235" | "3236" | "3240" | "3241" | "3242" | "3243" | "3244" | "3245" | "3246" | "3250" | "3251" | "3252" | "3253" | "3254" | "3255" | "3256" | "3260" | "3261" | "3262" | "3263" | "3264" | "3265" | "3266" | "3300" | "3301" | "3302" | "3303" | "3304" | "3305" | "3306" | "3310" | "3311" | "3312" | "3313" | "3314" | "3315" | "3316" | "3320" | "3321" | "3322" | "3323" | "3324" | "3325" | "3326" | "3330" | "3331" | "3332" | "3333" | "3334" | "3335" | "3336" | "3340" | "3341" | "3342" | "3343" | "3344" | "3345" | "3346" | "3350" | "3351" | "3352" | "3353" | "3354" | "3355" | "3356" | "3360" | "3361" | "3362" | "3363" | "3364" | "3365" | "3366" | "3400" | "3401" | "3402" | "3403" | "3404" | "3405" | "3406" | "3410" | "3411" | "3412" | "3413" | "3414" | "3415" | "3416" | "3420" | "3421" | "3422" | "3423" | "3424" | "3425" | "3426" | "3430" | "3431" | "3432" | "3433" | "3434" | "3435" | "3436" | "3440" | "3441" | "3442" | "3443" | "3444" | "3445" | "3446" | "3450" | "3451" | "3452" | "3453" | "3454" | "3455" | "3456" | "3460" | "3461" | "3462" | "3463" | "3464" | "3465" | "3466" | "3500" | "3501" | "3502" | "3503" | "3504" | "3505" | "3506" | "3510" | "3511" | "3512" | "3513" | "3514" | "3515" | "3516" | "3520" | "3521" | "3522" | "3523" | "3524" | "3525" | "3526" | "3530" | "3531" | "3532" | "3533" | "3534" | "3535" | "3536" | "3540" | "3541" | "3542" | "3543" | "3544" | "3545" | "3546" | "3550" | "3551" | "3552" | "3553" | "3554" | "3555" | "3556" | "3560" | "3561" | "3562" | "3563" | "3564" | "3565" | "3566" | "3600" | "3601" | "3602" | "3603" | "3604" | "3605" | "3606" | "3610" | "3611" | "3612" | "3613" | "3614" | "3615" | "3616" | "3620" | "3621" | "3622" | "3623" | "3624" | "3625" | "3626" | "3630" | "3631" | "3632" | "3633" | "3634" | "3635" | "3636" | "3640" | "3641" | "3642" | "3643" | "3644" | "3645" | "3646" | "3650" | "3651" | "3652" | "3653" | "3654" | "3655" | "3656" | "3660" | "3661" | "3662" | "3663" | "3664" | "3665" | "3666" | "4000" | "4001" | "4002" | "4003" | "4004" | "4005" | "4006" | "4010" | "4011" | "4012" | "4013" | "4014" | "4015" | "4016" | "4020" | "4021" | "4022" | "4023" | "4024" | "4025" | "4026" | "4030" | "4031" | "4032" | "4033" | "4034" | "4035" | "4036" | "4040" | "4041" | "4042" | "4043" | "4044" | "4045" | "4046" | "4050" | "4051" | "4052" | "4053" | "4054" | "4055" | "4056" | "4060" | "4061" | "4062" | "4063" | "4064" | "4065" | "4066" | "4100" | "4101" | "4102" | "4103" | "4104" | "4105" | "4106" | "4110" | "4111" | "4112" | "4113" | "4114" | "4115" | "4116" | "4120" | "4121" | "4122" | "4123" | "4124" | "4125" | "4126" | "4130" | "4131" | "4132" | "4133" | "4134" | "4135" | "4136" | "4140" | "4141" | "4142" | "4143" | "4144" | "4145" | "4146" | "4150" | "4151" | "4152" | "4153" | "4154" | "4155" | "4156" | "4160" | "4161" | "4162" | "4163" | "4164" | "4165" | "4166" | "4200" | "4201" | "4202" | "4203" | "4204" | "4205" | "4206" | "4210" | "4211" | "4212" | "4213" | "4214" | "4215" | "4216" | "4220" | "4221" | "4222" | "4223" | "4224" | "4225" | "4226" | "4230" | "4231" | "4232" | "4233" | "4234" | "4235" | "4236" | "4240" | "4241" | "4242" | "4243" | "4244" | "4245" | "4246" | "4250" | "4251" | "4252" | "4253" | "4254" | "4255" | "4256" | "4260" | "4261" | "4262" | "4263" | "4264" | "4265" | "4266" | "4300" | "4301" | "4302" | "4303" | "4304" | "4305" | "4306" | "4310" | "4311" | "4312" | "4313" | "4314" | "4315" | "4316" | "4320" | "4321" | "4322" | "4323" | "4324" | "4325" | "4326" | "4330" | "4331" | "4332" | "4333" | "4334" | "4335" | "4336" | "4340" | "4341" | "4342" | "4343" | "4344" | "4345" | "4346" | "4350" | "4351" | "4352" | "4353" | "4354" | "4355" | "4356" | "4360" | "4361" | "4362" | "4363" | "4364" | "4365" | "4366" | "4400" | "4401" | "4402" | "4403" | "4404" | "4405" | "4406" | "4410" | "4411" | "4412" | "4413" | "4414" | "4415" | "4416" | "4420" | "4421" | "4422" | "4423" | "4424" | "4425" | "4426" | "4430" | "4431" | "4432" | "4433" | "4434" | "4435" | "4436" | "4440" | "4441" | "4442" | "4443" | "4444" | "4445" | "4446" | "4450" | "4451" | "4452" | "4453" | "4454" | "4455" | "4456" | "4460" | "4461" | "4462" | "4463" | "4464" | "4465" | "4466" | "4500" | "4501" | "4502" | "4503" | "4504" | "4505" | "4506" | "4510" | "4511" | "4512" | "4513" | "4514" | "4515" | "4516" | "4520" | "4521" | "4522" | "4523" | "4524" | "4525" | "4526" | "4530" | "4531" | "4532" | "4533" | "4534" | "4535" | "4536" | "4540" | "4541" | "4542" | "4543" | "4544" | "4545" | "4546" | "4550" | "4551" | "4552" | "4553" | "4554" | "4555" | "4556" | "4560" | "4561" | "4562" | "4563" | "4564" | "4565" | "4566" | "4600" | "4601" | "4602" | "4603" | "4604" | "4605" | "4606" | "4610" | "4611" | "4612" | "4613" | "4614" | "4615" | "4616" | "4620" | "4621" | "4622" | "4623" | "4624" | "4625" | "4626" | "4630" | "4631" | "4632" | "4633" | "4634" | "4635" | "4636" | "4640" | "4641" | "4642" | "4643" | "4644" | "4645" | "4646" | "4650" | "4651" | "4652" | "4653" | "4654" | "4655" | "4656" | "4660" | "4661" | "4662" | "4663" | "4664" | "4665" | "4666" | undefined) & T2 + +x = y5; +>x = y5 : ("0000" | "0001" | "0002" | "0003" | "0004" | "0005" | "0006" | "0010" | "0011" | "0012" | "0013" | "0014" | "0015" | "0016" | "0020" | "0021" | "0022" | "0023" | "0024" | "0025" | "0026" | "0030" | "0031" | "0032" | "0033" | "0034" | "0035" | "0036" | "0040" | "0041" | "0042" | "0043" | "0044" | "0045" | "0046" | "0050" | "0051" | "0052" | "0053" | "0054" | "0055" | "0056" | "0060" | "0061" | "0062" | "0063" | "0064" | "0065" | "0066" | "0100" | "0101" | "0102" | "0103" | "0104" | "0105" | "0106" | "0110" | "0111" | "0112" | "0113" | "0114" | "0115" | "0116" | "0120" | "0121" | "0122" | "0123" | "0124" | "0125" | "0126" | "0130" | "0131" | "0132" | "0133" | "0134" | "0135" | "0136" | "0140" | "0141" | "0142" | "0143" | "0144" | "0145" | "0146" | "0150" | "0151" | "0152" | "0153" | "0154" | "0155" | "0156" | "0160" | "0161" | "0162" | "0163" | "0164" | "0165" | "0166" | "0200" | "0201" | "0202" | "0203" | "0204" | "0205" | "0206" | "0210" | "0211" | "0212" | "0213" | "0214" | "0215" | "0216" | "0220" | "0221" | "0222" | "0223" | "0224" | "0225" | "0226" | "0230" | "0231" | "0232" | "0233" | "0234" | "0235" | "0236" | "0240" | "0241" | "0242" | "0243" | "0244" | "0245" | "0246" | "0250" | "0251" | "0252" | "0253" | "0254" | "0255" | "0256" | "0260" | "0261" | "0262" | "0263" | "0264" | "0265" | "0266" | "0300" | "0301" | "0302" | "0303" | "0304" | "0305" | "0306" | "0310" | "0311" | "0312" | "0313" | "0314" | "0315" | "0316" | "0320" | "0321" | "0322" | "0323" | "0324" | "0325" | "0326" | "0330" | "0331" | "0332" | "0333" | "0334" | "0335" | "0336" | "0340" | "0341" | "0342" | "0343" | "0344" | "0345" | "0346" | "0350" | "0351" | "0352" | "0353" | "0354" | "0355" | "0356" | "0360" | "0361" | "0362" | "0363" | "0364" | "0365" | "0366" | "0400" | "0401" | "0402" | "0403" | "0404" | "0405" | "0406" | "0410" | "0411" | "0412" | "0413" | "0414" | "0415" | "0416" | "0420" | "0421" | "0422" | "0423" | "0424" | "0425" | "0426" | "0430" | "0431" | "0432" | "0433" | "0434" | "0435" | "0436" | "0440" | "0441" | "0442" | "0443" | "0444" | "0445" | "0446" | "0450" | "0451" | "0452" | "0453" | "0454" | "0455" | "0456" | "0460" | "0461" | "0462" | "0463" | "0464" | "0465" | "0466" | "0500" | "0501" | "0502" | "0503" | "0504" | "0505" | "0506" | "0510" | "0511" | "0512" | "0513" | "0514" | "0515" | "0516" | "0520" | "0521" | "0522" | "0523" | "0524" | "0525" | "0526" | "0530" | "0531" | "0532" | "0533" | "0534" | "0535" | "0536" | "0540" | "0541" | "0542" | "0543" | "0544" | "0545" | "0546" | "0550" | "0551" | "0552" | "0553" | "0554" | "0555" | "0556" | "0560" | "0561" | "0562" | "0563" | "0564" | "0565" | "0566" | "0600" | "0601" | "0602" | "0603" | "0604" | "0605" | "0606" | "0610" | "0611" | "0612" | "0613" | "0614" | "0615" | "0616" | "0620" | "0621" | "0622" | "0623" | "0624" | "0625" | "0626" | "0630" | "0631" | "0632" | "0633" | "0634" | "0635" | "0636" | "0640" | "0641" | "0642" | "0643" | "0644" | "0645" | "0646" | "0650" | "0651" | "0652" | "0653" | "0654" | "0655" | "0656" | "0660" | "0661" | "0662" | "0663" | "0664" | "0665" | "0666" | "1000" | "1001" | "1002" | "1003" | "1004" | "1005" | "1006" | "1010" | "1011" | "1012" | "1013" | "1014" | "1015" | "1016" | "1020" | "1021" | "1022" | "1023" | "1024" | "1025" | "1026" | "1030" | "1031" | "1032" | "1033" | "1034" | "1035" | "1036" | "1040" | "1041" | "1042" | "1043" | "1044" | "1045" | "1046" | "1050" | "1051" | "1052" | "1053" | "1054" | "1055" | "1056" | "1060" | "1061" | "1062" | "1063" | "1064" | "1065" | "1066" | "1100" | "1101" | "1102" | "1103" | "1104" | "1105" | "1106" | "1110" | "1111" | "1112" | "1113" | "1114" | "1115" | "1116" | "1120" | "1121" | "1122" | "1123" | "1124" | "1125" | "1126" | "1130" | "1131" | "1132" | "1133" | "1134" | "1135" | "1136" | "1140" | "1141" | "1142" | "1143" | "1144" | "1145" | "1146" | "1150" | "1151" | "1152" | "1153" | "1154" | "1155" | "1156" | "1160" | "1161" | "1162" | "1163" | "1164" | "1165" | "1166" | "1200" | "1201" | "1202" | "1203" | "1204" | "1205" | "1206" | "1210" | "1211" | "1212" | "1213" | "1214" | "1215" | "1216" | "1220" | "1221" | "1222" | "1223" | "1224" | "1225" | "1226" | "1230" | "1231" | "1232" | "1233" | "1234" | "1235" | "1236" | "1240" | "1241" | "1242" | "1243" | "1244" | "1245" | "1246" | "1250" | "1251" | "1252" | "1253" | "1254" | "1255" | "1256" | "1260" | "1261" | "1262" | "1263" | "1264" | "1265" | "1266" | "1300" | "1301" | "1302" | "1303" | "1304" | "1305" | "1306" | "1310" | "1311" | "1312" | "1313" | "1314" | "1315" | "1316" | "1320" | "1321" | "1322" | "1323" | "1324" | "1325" | "1326" | "1330" | "1331" | "1332" | "1333" | "1334" | "1335" | "1336" | "1340" | "1341" | "1342" | "1343" | "1344" | "1345" | "1346" | "1350" | "1351" | "1352" | "1353" | "1354" | "1355" | "1356" | "1360" | "1361" | "1362" | "1363" | "1364" | "1365" | "1366" | "1400" | "1401" | "1402" | "1403" | "1404" | "1405" | "1406" | "1410" | "1411" | "1412" | "1413" | "1414" | "1415" | "1416" | "1420" | "1421" | "1422" | "1423" | "1424" | "1425" | "1426" | "1430" | "1431" | "1432" | "1433" | "1434" | "1435" | "1436" | "1440" | "1441" | "1442" | "1443" | "1444" | "1445" | "1446" | "1450" | "1451" | "1452" | "1453" | "1454" | "1455" | "1456" | "1460" | "1461" | "1462" | "1463" | "1464" | "1465" | "1466" | "1500" | "1501" | "1502" | "1503" | "1504" | "1505" | "1506" | "1510" | "1511" | "1512" | "1513" | "1514" | "1515" | "1516" | "1520" | "1521" | "1522" | "1523" | "1524" | "1525" | "1526" | "1530" | "1531" | "1532" | "1533" | "1534" | "1535" | "1536" | "1540" | "1541" | "1542" | "1543" | "1544" | "1545" | "1546" | "1550" | "1551" | "1552" | "1553" | "1554" | "1555" | "1556" | "1560" | "1561" | "1562" | "1563" | "1564" | "1565" | "1566" | "1600" | "1601" | "1602" | "1603" | "1604" | "1605" | "1606" | "1610" | "1611" | "1612" | "1613" | "1614" | "1615" | "1616" | "1620" | "1621" | "1622" | "1623" | "1624" | "1625" | "1626" | "1630" | "1631" | "1632" | "1633" | "1634" | "1635" | "1636" | "1640" | "1641" | "1642" | "1643" | "1644" | "1645" | "1646" | "1650" | "1651" | "1652" | "1653" | "1654" | "1655" | "1656" | "1660" | "1661" | "1662" | "1663" | "1664" | "1665" | "1666" | "2000" | "2001" | "2002" | "2003" | "2004" | "2005" | "2006" | "2010" | "2011" | "2012" | "2013" | "2014" | "2015" | "2016" | "2020" | "2021" | "2022" | "2023" | "2024" | "2025" | "2026" | "2030" | "2031" | "2032" | "2033" | "2034" | "2035" | "2036" | "2040" | "2041" | "2042" | "2043" | "2044" | "2045" | "2046" | "2050" | "2051" | "2052" | "2053" | "2054" | "2055" | "2056" | "2060" | "2061" | "2062" | "2063" | "2064" | "2065" | "2066" | "2100" | "2101" | "2102" | "2103" | "2104" | "2105" | "2106" | "2110" | "2111" | "2112" | "2113" | "2114" | "2115" | "2116" | "2120" | "2121" | "2122" | "2123" | "2124" | "2125" | "2126" | "2130" | "2131" | "2132" | "2133" | "2134" | "2135" | "2136" | "2140" | "2141" | "2142" | "2143" | "2144" | "2145" | "2146" | "2150" | "2151" | "2152" | "2153" | "2154" | "2155" | "2156" | "2160" | "2161" | "2162" | "2163" | "2164" | "2165" | "2166" | "2200" | "2201" | "2202" | "2203" | "2204" | "2205" | "2206" | "2210" | "2211" | "2212" | "2213" | "2214" | "2215" | "2216" | "2220" | "2221" | "2222" | "2223" | "2224" | "2225" | "2226" | "2230" | "2231" | "2232" | "2233" | "2234" | "2235" | "2236" | "2240" | "2241" | "2242" | "2243" | "2244" | "2245" | "2246" | "2250" | "2251" | "2252" | "2253" | "2254" | "2255" | "2256" | "2260" | "2261" | "2262" | "2263" | "2264" | "2265" | "2266" | "2300" | "2301" | "2302" | "2303" | "2304" | "2305" | "2306" | "2310" | "2311" | "2312" | "2313" | "2314" | "2315" | "2316" | "2320" | "2321" | "2322" | "2323" | "2324" | "2325" | "2326" | "2330" | "2331" | "2332" | "2333" | "2334" | "2335" | "2336" | "2340" | "2341" | "2342" | "2343" | "2344" | "2345" | "2346" | "2350" | "2351" | "2352" | "2353" | "2354" | "2355" | "2356" | "2360" | "2361" | "2362" | "2363" | "2364" | "2365" | "2366" | "2400" | "2401" | "2402" | "2403" | "2404" | "2405" | "2406" | "2410" | "2411" | "2412" | "2413" | "2414" | "2415" | "2416" | "2420" | "2421" | "2422" | "2423" | "2424" | "2425" | "2426" | "2430" | "2431" | "2432" | "2433" | "2434" | "2435" | "2436" | "2440" | "2441" | "2442" | "2443" | "2444" | "2445" | "2446" | "2450" | "2451" | "2452" | "2453" | "2454" | "2455" | "2456" | "2460" | "2461" | "2462" | "2463" | "2464" | "2465" | "2466" | "2500" | "2501" | "2502" | "2503" | "2504" | "2505" | "2506" | "2510" | "2511" | "2512" | "2513" | "2514" | "2515" | "2516" | "2520" | "2521" | "2522" | "2523" | "2524" | "2525" | "2526" | "2530" | "2531" | "2532" | "2533" | "2534" | "2535" | "2536" | "2540" | "2541" | "2542" | "2543" | "2544" | "2545" | "2546" | "2550" | "2551" | "2552" | "2553" | "2554" | "2555" | "2556" | "2560" | "2561" | "2562" | "2563" | "2564" | "2565" | "2566" | "2600" | "2601" | "2602" | "2603" | "2604" | "2605" | "2606" | "2610" | "2611" | "2612" | "2613" | "2614" | "2615" | "2616" | "2620" | "2621" | "2622" | "2623" | "2624" | "2625" | "2626" | "2630" | "2631" | "2632" | "2633" | "2634" | "2635" | "2636" | "2640" | "2641" | "2642" | "2643" | "2644" | "2645" | "2646" | "2650" | "2651" | "2652" | "2653" | "2654" | "2655" | "2656" | "2660" | "2661" | "2662" | "2663" | "2664" | "2665" | "2666" | "3000" | "3001" | "3002" | "3003" | "3004" | "3005" | "3006" | "3010" | "3011" | "3012" | "3013" | "3014" | "3015" | "3016" | "3020" | "3021" | "3022" | "3023" | "3024" | "3025" | "3026" | "3030" | "3031" | "3032" | "3033" | "3034" | "3035" | "3036" | "3040" | "3041" | "3042" | "3043" | "3044" | "3045" | "3046" | "3050" | "3051" | "3052" | "3053" | "3054" | "3055" | "3056" | "3060" | "3061" | "3062" | "3063" | "3064" | "3065" | "3066" | "3100" | "3101" | "3102" | "3103" | "3104" | "3105" | "3106" | "3110" | "3111" | "3112" | "3113" | "3114" | "3115" | "3116" | "3120" | "3121" | "3122" | "3123" | "3124" | "3125" | "3126" | "3130" | "3131" | "3132" | "3133" | "3134" | "3135" | "3136" | "3140" | "3141" | "3142" | "3143" | "3144" | "3145" | "3146" | "3150" | "3151" | "3152" | "3153" | "3154" | "3155" | "3156" | "3160" | "3161" | "3162" | "3163" | "3164" | "3165" | "3166" | "3200" | "3201" | "3202" | "3203" | "3204" | "3205" | "3206" | "3210" | "3211" | "3212" | "3213" | "3214" | "3215" | "3216" | "3220" | "3221" | "3222" | "3223" | "3224" | "3225" | "3226" | "3230" | "3231" | "3232" | "3233" | "3234" | "3235" | "3236" | "3240" | "3241" | "3242" | "3243" | "3244" | "3245" | "3246" | "3250" | "3251" | "3252" | "3253" | "3254" | "3255" | "3256" | "3260" | "3261" | "3262" | "3263" | "3264" | "3265" | "3266" | "3300" | "3301" | "3302" | "3303" | "3304" | "3305" | "3306" | "3310" | "3311" | "3312" | "3313" | "3314" | "3315" | "3316" | "3320" | "3321" | "3322" | "3323" | "3324" | "3325" | "3326" | "3330" | "3331" | "3332" | "3333" | "3334" | "3335" | "3336" | "3340" | "3341" | "3342" | "3343" | "3344" | "3345" | "3346" | "3350" | "3351" | "3352" | "3353" | "3354" | "3355" | "3356" | "3360" | "3361" | "3362" | "3363" | "3364" | "3365" | "3366" | "3400" | "3401" | "3402" | "3403" | "3404" | "3405" | "3406" | "3410" | "3411" | "3412" | "3413" | "3414" | "3415" | "3416" | "3420" | "3421" | "3422" | "3423" | "3424" | "3425" | "3426" | "3430" | "3431" | "3432" | "3433" | "3434" | "3435" | "3436" | "3440" | "3441" | "3442" | "3443" | "3444" | "3445" | "3446" | "3450" | "3451" | "3452" | "3453" | "3454" | "3455" | "3456" | "3460" | "3461" | "3462" | "3463" | "3464" | "3465" | "3466" | "3500" | "3501" | "3502" | "3503" | "3504" | "3505" | "3506" | "3510" | "3511" | "3512" | "3513" | "3514" | "3515" | "3516" | "3520" | "3521" | "3522" | "3523" | "3524" | "3525" | "3526" | "3530" | "3531" | "3532" | "3533" | "3534" | "3535" | "3536" | "3540" | "3541" | "3542" | "3543" | "3544" | "3545" | "3546" | "3550" | "3551" | "3552" | "3553" | "3554" | "3555" | "3556" | "3560" | "3561" | "3562" | "3563" | "3564" | "3565" | "3566" | "3600" | "3601" | "3602" | "3603" | "3604" | "3605" | "3606" | "3610" | "3611" | "3612" | "3613" | "3614" | "3615" | "3616" | "3620" | "3621" | "3622" | "3623" | "3624" | "3625" | "3626" | "3630" | "3631" | "3632" | "3633" | "3634" | "3635" | "3636" | "3640" | "3641" | "3642" | "3643" | "3644" | "3645" | "3646" | "3650" | "3651" | "3652" | "3653" | "3654" | "3655" | "3656" | "3660" | "3661" | "3662" | "3663" | "3664" | "3665" | "3666" | "4000" | "4001" | "4002" | "4003" | "4004" | "4005" | "4006" | "4010" | "4011" | "4012" | "4013" | "4014" | "4015" | "4016" | "4020" | "4021" | "4022" | "4023" | "4024" | "4025" | "4026" | "4030" | "4031" | "4032" | "4033" | "4034" | "4035" | "4036" | "4040" | "4041" | "4042" | "4043" | "4044" | "4045" | "4046" | "4050" | "4051" | "4052" | "4053" | "4054" | "4055" | "4056" | "4060" | "4061" | "4062" | "4063" | "4064" | "4065" | "4066" | "4100" | "4101" | "4102" | "4103" | "4104" | "4105" | "4106" | "4110" | "4111" | "4112" | "4113" | "4114" | "4115" | "4116" | "4120" | "4121" | "4122" | "4123" | "4124" | "4125" | "4126" | "4130" | "4131" | "4132" | "4133" | "4134" | "4135" | "4136" | "4140" | "4141" | "4142" | "4143" | "4144" | "4145" | "4146" | "4150" | "4151" | "4152" | "4153" | "4154" | "4155" | "4156" | "4160" | "4161" | "4162" | "4163" | "4164" | "4165" | "4166" | "4200" | "4201" | "4202" | "4203" | "4204" | "4205" | "4206" | "4210" | "4211" | "4212" | "4213" | "4214" | "4215" | "4216" | "4220" | "4221" | "4222" | "4223" | "4224" | "4225" | "4226" | "4230" | "4231" | "4232" | "4233" | "4234" | "4235" | "4236" | "4240" | "4241" | "4242" | "4243" | "4244" | "4245" | "4246" | "4250" | "4251" | "4252" | "4253" | "4254" | "4255" | "4256" | "4260" | "4261" | "4262" | "4263" | "4264" | "4265" | "4266" | "4300" | "4301" | "4302" | "4303" | "4304" | "4305" | "4306" | "4310" | "4311" | "4312" | "4313" | "4314" | "4315" | "4316" | "4320" | "4321" | "4322" | "4323" | "4324" | "4325" | "4326" | "4330" | "4331" | "4332" | "4333" | "4334" | "4335" | "4336" | "4340" | "4341" | "4342" | "4343" | "4344" | "4345" | "4346" | "4350" | "4351" | "4352" | "4353" | "4354" | "4355" | "4356" | "4360" | "4361" | "4362" | "4363" | "4364" | "4365" | "4366" | "4400" | "4401" | "4402" | "4403" | "4404" | "4405" | "4406" | "4410" | "4411" | "4412" | "4413" | "4414" | "4415" | "4416" | "4420" | "4421" | "4422" | "4423" | "4424" | "4425" | "4426" | "4430" | "4431" | "4432" | "4433" | "4434" | "4435" | "4436" | "4440" | "4441" | "4442" | "4443" | "4444" | "4445" | "4446" | "4450" | "4451" | "4452" | "4453" | "4454" | "4455" | "4456" | "4460" | "4461" | "4462" | "4463" | "4464" | "4465" | "4466" | "4500" | "4501" | "4502" | "4503" | "4504" | "4505" | "4506" | "4510" | "4511" | "4512" | "4513" | "4514" | "4515" | "4516" | "4520" | "4521" | "4522" | "4523" | "4524" | "4525" | "4526" | "4530" | "4531" | "4532" | "4533" | "4534" | "4535" | "4536" | "4540" | "4541" | "4542" | "4543" | "4544" | "4545" | "4546" | "4550" | "4551" | "4552" | "4553" | "4554" | "4555" | "4556" | "4560" | "4561" | "4562" | "4563" | "4564" | "4565" | "4566" | "4600" | "4601" | "4602" | "4603" | "4604" | "4605" | "4606" | "4610" | "4611" | "4612" | "4613" | "4614" | "4615" | "4616" | "4620" | "4621" | "4622" | "4623" | "4624" | "4625" | "4626" | "4630" | "4631" | "4632" | "4633" | "4634" | "4635" | "4636" | "4640" | "4641" | "4642" | "4643" | "4644" | "4645" | "4646" | "4650" | "4651" | "4652" | "4653" | "4654" | "4655" | "4656" | "4660" | "4661" | "4662" | "4663" | "4664" | "4665" | "4666" | undefined) & T2 +>x : T1 | null +>y5 : ("0000" | "0001" | "0002" | "0003" | "0004" | "0005" | "0006" | "0010" | "0011" | "0012" | "0013" | "0014" | "0015" | "0016" | "0020" | "0021" | "0022" | "0023" | "0024" | "0025" | "0026" | "0030" | "0031" | "0032" | "0033" | "0034" | "0035" | "0036" | "0040" | "0041" | "0042" | "0043" | "0044" | "0045" | "0046" | "0050" | "0051" | "0052" | "0053" | "0054" | "0055" | "0056" | "0060" | "0061" | "0062" | "0063" | "0064" | "0065" | "0066" | "0100" | "0101" | "0102" | "0103" | "0104" | "0105" | "0106" | "0110" | "0111" | "0112" | "0113" | "0114" | "0115" | "0116" | "0120" | "0121" | "0122" | "0123" | "0124" | "0125" | "0126" | "0130" | "0131" | "0132" | "0133" | "0134" | "0135" | "0136" | "0140" | "0141" | "0142" | "0143" | "0144" | "0145" | "0146" | "0150" | "0151" | "0152" | "0153" | "0154" | "0155" | "0156" | "0160" | "0161" | "0162" | "0163" | "0164" | "0165" | "0166" | "0200" | "0201" | "0202" | "0203" | "0204" | "0205" | "0206" | "0210" | "0211" | "0212" | "0213" | "0214" | "0215" | "0216" | "0220" | "0221" | "0222" | "0223" | "0224" | "0225" | "0226" | "0230" | "0231" | "0232" | "0233" | "0234" | "0235" | "0236" | "0240" | "0241" | "0242" | "0243" | "0244" | "0245" | "0246" | "0250" | "0251" | "0252" | "0253" | "0254" | "0255" | "0256" | "0260" | "0261" | "0262" | "0263" | "0264" | "0265" | "0266" | "0300" | "0301" | "0302" | "0303" | "0304" | "0305" | "0306" | "0310" | "0311" | "0312" | "0313" | "0314" | "0315" | "0316" | "0320" | "0321" | "0322" | "0323" | "0324" | "0325" | "0326" | "0330" | "0331" | "0332" | "0333" | "0334" | "0335" | "0336" | "0340" | "0341" | "0342" | "0343" | "0344" | "0345" | "0346" | "0350" | "0351" | "0352" | "0353" | "0354" | "0355" | "0356" | "0360" | "0361" | "0362" | "0363" | "0364" | "0365" | "0366" | "0400" | "0401" | "0402" | "0403" | "0404" | "0405" | "0406" | "0410" | "0411" | "0412" | "0413" | "0414" | "0415" | "0416" | "0420" | "0421" | "0422" | "0423" | "0424" | "0425" | "0426" | "0430" | "0431" | "0432" | "0433" | "0434" | "0435" | "0436" | "0440" | "0441" | "0442" | "0443" | "0444" | "0445" | "0446" | "0450" | "0451" | "0452" | "0453" | "0454" | "0455" | "0456" | "0460" | "0461" | "0462" | "0463" | "0464" | "0465" | "0466" | "0500" | "0501" | "0502" | "0503" | "0504" | "0505" | "0506" | "0510" | "0511" | "0512" | "0513" | "0514" | "0515" | "0516" | "0520" | "0521" | "0522" | "0523" | "0524" | "0525" | "0526" | "0530" | "0531" | "0532" | "0533" | "0534" | "0535" | "0536" | "0540" | "0541" | "0542" | "0543" | "0544" | "0545" | "0546" | "0550" | "0551" | "0552" | "0553" | "0554" | "0555" | "0556" | "0560" | "0561" | "0562" | "0563" | "0564" | "0565" | "0566" | "0600" | "0601" | "0602" | "0603" | "0604" | "0605" | "0606" | "0610" | "0611" | "0612" | "0613" | "0614" | "0615" | "0616" | "0620" | "0621" | "0622" | "0623" | "0624" | "0625" | "0626" | "0630" | "0631" | "0632" | "0633" | "0634" | "0635" | "0636" | "0640" | "0641" | "0642" | "0643" | "0644" | "0645" | "0646" | "0650" | "0651" | "0652" | "0653" | "0654" | "0655" | "0656" | "0660" | "0661" | "0662" | "0663" | "0664" | "0665" | "0666" | "1000" | "1001" | "1002" | "1003" | "1004" | "1005" | "1006" | "1010" | "1011" | "1012" | "1013" | "1014" | "1015" | "1016" | "1020" | "1021" | "1022" | "1023" | "1024" | "1025" | "1026" | "1030" | "1031" | "1032" | "1033" | "1034" | "1035" | "1036" | "1040" | "1041" | "1042" | "1043" | "1044" | "1045" | "1046" | "1050" | "1051" | "1052" | "1053" | "1054" | "1055" | "1056" | "1060" | "1061" | "1062" | "1063" | "1064" | "1065" | "1066" | "1100" | "1101" | "1102" | "1103" | "1104" | "1105" | "1106" | "1110" | "1111" | "1112" | "1113" | "1114" | "1115" | "1116" | "1120" | "1121" | "1122" | "1123" | "1124" | "1125" | "1126" | "1130" | "1131" | "1132" | "1133" | "1134" | "1135" | "1136" | "1140" | "1141" | "1142" | "1143" | "1144" | "1145" | "1146" | "1150" | "1151" | "1152" | "1153" | "1154" | "1155" | "1156" | "1160" | "1161" | "1162" | "1163" | "1164" | "1165" | "1166" | "1200" | "1201" | "1202" | "1203" | "1204" | "1205" | "1206" | "1210" | "1211" | "1212" | "1213" | "1214" | "1215" | "1216" | "1220" | "1221" | "1222" | "1223" | "1224" | "1225" | "1226" | "1230" | "1231" | "1232" | "1233" | "1234" | "1235" | "1236" | "1240" | "1241" | "1242" | "1243" | "1244" | "1245" | "1246" | "1250" | "1251" | "1252" | "1253" | "1254" | "1255" | "1256" | "1260" | "1261" | "1262" | "1263" | "1264" | "1265" | "1266" | "1300" | "1301" | "1302" | "1303" | "1304" | "1305" | "1306" | "1310" | "1311" | "1312" | "1313" | "1314" | "1315" | "1316" | "1320" | "1321" | "1322" | "1323" | "1324" | "1325" | "1326" | "1330" | "1331" | "1332" | "1333" | "1334" | "1335" | "1336" | "1340" | "1341" | "1342" | "1343" | "1344" | "1345" | "1346" | "1350" | "1351" | "1352" | "1353" | "1354" | "1355" | "1356" | "1360" | "1361" | "1362" | "1363" | "1364" | "1365" | "1366" | "1400" | "1401" | "1402" | "1403" | "1404" | "1405" | "1406" | "1410" | "1411" | "1412" | "1413" | "1414" | "1415" | "1416" | "1420" | "1421" | "1422" | "1423" | "1424" | "1425" | "1426" | "1430" | "1431" | "1432" | "1433" | "1434" | "1435" | "1436" | "1440" | "1441" | "1442" | "1443" | "1444" | "1445" | "1446" | "1450" | "1451" | "1452" | "1453" | "1454" | "1455" | "1456" | "1460" | "1461" | "1462" | "1463" | "1464" | "1465" | "1466" | "1500" | "1501" | "1502" | "1503" | "1504" | "1505" | "1506" | "1510" | "1511" | "1512" | "1513" | "1514" | "1515" | "1516" | "1520" | "1521" | "1522" | "1523" | "1524" | "1525" | "1526" | "1530" | "1531" | "1532" | "1533" | "1534" | "1535" | "1536" | "1540" | "1541" | "1542" | "1543" | "1544" | "1545" | "1546" | "1550" | "1551" | "1552" | "1553" | "1554" | "1555" | "1556" | "1560" | "1561" | "1562" | "1563" | "1564" | "1565" | "1566" | "1600" | "1601" | "1602" | "1603" | "1604" | "1605" | "1606" | "1610" | "1611" | "1612" | "1613" | "1614" | "1615" | "1616" | "1620" | "1621" | "1622" | "1623" | "1624" | "1625" | "1626" | "1630" | "1631" | "1632" | "1633" | "1634" | "1635" | "1636" | "1640" | "1641" | "1642" | "1643" | "1644" | "1645" | "1646" | "1650" | "1651" | "1652" | "1653" | "1654" | "1655" | "1656" | "1660" | "1661" | "1662" | "1663" | "1664" | "1665" | "1666" | "2000" | "2001" | "2002" | "2003" | "2004" | "2005" | "2006" | "2010" | "2011" | "2012" | "2013" | "2014" | "2015" | "2016" | "2020" | "2021" | "2022" | "2023" | "2024" | "2025" | "2026" | "2030" | "2031" | "2032" | "2033" | "2034" | "2035" | "2036" | "2040" | "2041" | "2042" | "2043" | "2044" | "2045" | "2046" | "2050" | "2051" | "2052" | "2053" | "2054" | "2055" | "2056" | "2060" | "2061" | "2062" | "2063" | "2064" | "2065" | "2066" | "2100" | "2101" | "2102" | "2103" | "2104" | "2105" | "2106" | "2110" | "2111" | "2112" | "2113" | "2114" | "2115" | "2116" | "2120" | "2121" | "2122" | "2123" | "2124" | "2125" | "2126" | "2130" | "2131" | "2132" | "2133" | "2134" | "2135" | "2136" | "2140" | "2141" | "2142" | "2143" | "2144" | "2145" | "2146" | "2150" | "2151" | "2152" | "2153" | "2154" | "2155" | "2156" | "2160" | "2161" | "2162" | "2163" | "2164" | "2165" | "2166" | "2200" | "2201" | "2202" | "2203" | "2204" | "2205" | "2206" | "2210" | "2211" | "2212" | "2213" | "2214" | "2215" | "2216" | "2220" | "2221" | "2222" | "2223" | "2224" | "2225" | "2226" | "2230" | "2231" | "2232" | "2233" | "2234" | "2235" | "2236" | "2240" | "2241" | "2242" | "2243" | "2244" | "2245" | "2246" | "2250" | "2251" | "2252" | "2253" | "2254" | "2255" | "2256" | "2260" | "2261" | "2262" | "2263" | "2264" | "2265" | "2266" | "2300" | "2301" | "2302" | "2303" | "2304" | "2305" | "2306" | "2310" | "2311" | "2312" | "2313" | "2314" | "2315" | "2316" | "2320" | "2321" | "2322" | "2323" | "2324" | "2325" | "2326" | "2330" | "2331" | "2332" | "2333" | "2334" | "2335" | "2336" | "2340" | "2341" | "2342" | "2343" | "2344" | "2345" | "2346" | "2350" | "2351" | "2352" | "2353" | "2354" | "2355" | "2356" | "2360" | "2361" | "2362" | "2363" | "2364" | "2365" | "2366" | "2400" | "2401" | "2402" | "2403" | "2404" | "2405" | "2406" | "2410" | "2411" | "2412" | "2413" | "2414" | "2415" | "2416" | "2420" | "2421" | "2422" | "2423" | "2424" | "2425" | "2426" | "2430" | "2431" | "2432" | "2433" | "2434" | "2435" | "2436" | "2440" | "2441" | "2442" | "2443" | "2444" | "2445" | "2446" | "2450" | "2451" | "2452" | "2453" | "2454" | "2455" | "2456" | "2460" | "2461" | "2462" | "2463" | "2464" | "2465" | "2466" | "2500" | "2501" | "2502" | "2503" | "2504" | "2505" | "2506" | "2510" | "2511" | "2512" | "2513" | "2514" | "2515" | "2516" | "2520" | "2521" | "2522" | "2523" | "2524" | "2525" | "2526" | "2530" | "2531" | "2532" | "2533" | "2534" | "2535" | "2536" | "2540" | "2541" | "2542" | "2543" | "2544" | "2545" | "2546" | "2550" | "2551" | "2552" | "2553" | "2554" | "2555" | "2556" | "2560" | "2561" | "2562" | "2563" | "2564" | "2565" | "2566" | "2600" | "2601" | "2602" | "2603" | "2604" | "2605" | "2606" | "2610" | "2611" | "2612" | "2613" | "2614" | "2615" | "2616" | "2620" | "2621" | "2622" | "2623" | "2624" | "2625" | "2626" | "2630" | "2631" | "2632" | "2633" | "2634" | "2635" | "2636" | "2640" | "2641" | "2642" | "2643" | "2644" | "2645" | "2646" | "2650" | "2651" | "2652" | "2653" | "2654" | "2655" | "2656" | "2660" | "2661" | "2662" | "2663" | "2664" | "2665" | "2666" | "3000" | "3001" | "3002" | "3003" | "3004" | "3005" | "3006" | "3010" | "3011" | "3012" | "3013" | "3014" | "3015" | "3016" | "3020" | "3021" | "3022" | "3023" | "3024" | "3025" | "3026" | "3030" | "3031" | "3032" | "3033" | "3034" | "3035" | "3036" | "3040" | "3041" | "3042" | "3043" | "3044" | "3045" | "3046" | "3050" | "3051" | "3052" | "3053" | "3054" | "3055" | "3056" | "3060" | "3061" | "3062" | "3063" | "3064" | "3065" | "3066" | "3100" | "3101" | "3102" | "3103" | "3104" | "3105" | "3106" | "3110" | "3111" | "3112" | "3113" | "3114" | "3115" | "3116" | "3120" | "3121" | "3122" | "3123" | "3124" | "3125" | "3126" | "3130" | "3131" | "3132" | "3133" | "3134" | "3135" | "3136" | "3140" | "3141" | "3142" | "3143" | "3144" | "3145" | "3146" | "3150" | "3151" | "3152" | "3153" | "3154" | "3155" | "3156" | "3160" | "3161" | "3162" | "3163" | "3164" | "3165" | "3166" | "3200" | "3201" | "3202" | "3203" | "3204" | "3205" | "3206" | "3210" | "3211" | "3212" | "3213" | "3214" | "3215" | "3216" | "3220" | "3221" | "3222" | "3223" | "3224" | "3225" | "3226" | "3230" | "3231" | "3232" | "3233" | "3234" | "3235" | "3236" | "3240" | "3241" | "3242" | "3243" | "3244" | "3245" | "3246" | "3250" | "3251" | "3252" | "3253" | "3254" | "3255" | "3256" | "3260" | "3261" | "3262" | "3263" | "3264" | "3265" | "3266" | "3300" | "3301" | "3302" | "3303" | "3304" | "3305" | "3306" | "3310" | "3311" | "3312" | "3313" | "3314" | "3315" | "3316" | "3320" | "3321" | "3322" | "3323" | "3324" | "3325" | "3326" | "3330" | "3331" | "3332" | "3333" | "3334" | "3335" | "3336" | "3340" | "3341" | "3342" | "3343" | "3344" | "3345" | "3346" | "3350" | "3351" | "3352" | "3353" | "3354" | "3355" | "3356" | "3360" | "3361" | "3362" | "3363" | "3364" | "3365" | "3366" | "3400" | "3401" | "3402" | "3403" | "3404" | "3405" | "3406" | "3410" | "3411" | "3412" | "3413" | "3414" | "3415" | "3416" | "3420" | "3421" | "3422" | "3423" | "3424" | "3425" | "3426" | "3430" | "3431" | "3432" | "3433" | "3434" | "3435" | "3436" | "3440" | "3441" | "3442" | "3443" | "3444" | "3445" | "3446" | "3450" | "3451" | "3452" | "3453" | "3454" | "3455" | "3456" | "3460" | "3461" | "3462" | "3463" | "3464" | "3465" | "3466" | "3500" | "3501" | "3502" | "3503" | "3504" | "3505" | "3506" | "3510" | "3511" | "3512" | "3513" | "3514" | "3515" | "3516" | "3520" | "3521" | "3522" | "3523" | "3524" | "3525" | "3526" | "3530" | "3531" | "3532" | "3533" | "3534" | "3535" | "3536" | "3540" | "3541" | "3542" | "3543" | "3544" | "3545" | "3546" | "3550" | "3551" | "3552" | "3553" | "3554" | "3555" | "3556" | "3560" | "3561" | "3562" | "3563" | "3564" | "3565" | "3566" | "3600" | "3601" | "3602" | "3603" | "3604" | "3605" | "3606" | "3610" | "3611" | "3612" | "3613" | "3614" | "3615" | "3616" | "3620" | "3621" | "3622" | "3623" | "3624" | "3625" | "3626" | "3630" | "3631" | "3632" | "3633" | "3634" | "3635" | "3636" | "3640" | "3641" | "3642" | "3643" | "3644" | "3645" | "3646" | "3650" | "3651" | "3652" | "3653" | "3654" | "3655" | "3656" | "3660" | "3661" | "3662" | "3663" | "3664" | "3665" | "3666" | "4000" | "4001" | "4002" | "4003" | "4004" | "4005" | "4006" | "4010" | "4011" | "4012" | "4013" | "4014" | "4015" | "4016" | "4020" | "4021" | "4022" | "4023" | "4024" | "4025" | "4026" | "4030" | "4031" | "4032" | "4033" | "4034" | "4035" | "4036" | "4040" | "4041" | "4042" | "4043" | "4044" | "4045" | "4046" | "4050" | "4051" | "4052" | "4053" | "4054" | "4055" | "4056" | "4060" | "4061" | "4062" | "4063" | "4064" | "4065" | "4066" | "4100" | "4101" | "4102" | "4103" | "4104" | "4105" | "4106" | "4110" | "4111" | "4112" | "4113" | "4114" | "4115" | "4116" | "4120" | "4121" | "4122" | "4123" | "4124" | "4125" | "4126" | "4130" | "4131" | "4132" | "4133" | "4134" | "4135" | "4136" | "4140" | "4141" | "4142" | "4143" | "4144" | "4145" | "4146" | "4150" | "4151" | "4152" | "4153" | "4154" | "4155" | "4156" | "4160" | "4161" | "4162" | "4163" | "4164" | "4165" | "4166" | "4200" | "4201" | "4202" | "4203" | "4204" | "4205" | "4206" | "4210" | "4211" | "4212" | "4213" | "4214" | "4215" | "4216" | "4220" | "4221" | "4222" | "4223" | "4224" | "4225" | "4226" | "4230" | "4231" | "4232" | "4233" | "4234" | "4235" | "4236" | "4240" | "4241" | "4242" | "4243" | "4244" | "4245" | "4246" | "4250" | "4251" | "4252" | "4253" | "4254" | "4255" | "4256" | "4260" | "4261" | "4262" | "4263" | "4264" | "4265" | "4266" | "4300" | "4301" | "4302" | "4303" | "4304" | "4305" | "4306" | "4310" | "4311" | "4312" | "4313" | "4314" | "4315" | "4316" | "4320" | "4321" | "4322" | "4323" | "4324" | "4325" | "4326" | "4330" | "4331" | "4332" | "4333" | "4334" | "4335" | "4336" | "4340" | "4341" | "4342" | "4343" | "4344" | "4345" | "4346" | "4350" | "4351" | "4352" | "4353" | "4354" | "4355" | "4356" | "4360" | "4361" | "4362" | "4363" | "4364" | "4365" | "4366" | "4400" | "4401" | "4402" | "4403" | "4404" | "4405" | "4406" | "4410" | "4411" | "4412" | "4413" | "4414" | "4415" | "4416" | "4420" | "4421" | "4422" | "4423" | "4424" | "4425" | "4426" | "4430" | "4431" | "4432" | "4433" | "4434" | "4435" | "4436" | "4440" | "4441" | "4442" | "4443" | "4444" | "4445" | "4446" | "4450" | "4451" | "4452" | "4453" | "4454" | "4455" | "4456" | "4460" | "4461" | "4462" | "4463" | "4464" | "4465" | "4466" | "4500" | "4501" | "4502" | "4503" | "4504" | "4505" | "4506" | "4510" | "4511" | "4512" | "4513" | "4514" | "4515" | "4516" | "4520" | "4521" | "4522" | "4523" | "4524" | "4525" | "4526" | "4530" | "4531" | "4532" | "4533" | "4534" | "4535" | "4536" | "4540" | "4541" | "4542" | "4543" | "4544" | "4545" | "4546" | "4550" | "4551" | "4552" | "4553" | "4554" | "4555" | "4556" | "4560" | "4561" | "4562" | "4563" | "4564" | "4565" | "4566" | "4600" | "4601" | "4602" | "4603" | "4604" | "4605" | "4606" | "4610" | "4611" | "4612" | "4613" | "4614" | "4615" | "4616" | "4620" | "4621" | "4622" | "4623" | "4624" | "4625" | "4626" | "4630" | "4631" | "4632" | "4633" | "4634" | "4635" | "4636" | "4640" | "4641" | "4642" | "4643" | "4644" | "4645" | "4646" | "4650" | "4651" | "4652" | "4653" | "4654" | "4655" | "4656" | "4660" | "4661" | "4662" | "4663" | "4664" | "4665" | "4666" | undefined) & T2 + +declare const y6: (`${'0' | '1' | '2' | '3' | '4' | '5'}${D}${D}${D}` | undefined) & T2; +>y6 : ("0000" | "0001" | "0002" | "0003" | "0004" | "0005" | "0006" | "0010" | "0011" | "0012" | "0013" | "0014" | "0015" | "0016" | "0020" | "0021" | "0022" | "0023" | "0024" | "0025" | "0026" | "0030" | "0031" | "0032" | "0033" | "0034" | "0035" | "0036" | "0040" | "0041" | "0042" | "0043" | "0044" | "0045" | "0046" | "0050" | "0051" | "0052" | "0053" | "0054" | "0055" | "0056" | "0060" | "0061" | "0062" | "0063" | "0064" | "0065" | "0066" | "0100" | "0101" | "0102" | "0103" | "0104" | "0105" | "0106" | "0110" | "0111" | "0112" | "0113" | "0114" | "0115" | "0116" | "0120" | "0121" | "0122" | "0123" | "0124" | "0125" | "0126" | "0130" | "0131" | "0132" | "0133" | "0134" | "0135" | "0136" | "0140" | "0141" | "0142" | "0143" | "0144" | "0145" | "0146" | "0150" | "0151" | "0152" | "0153" | "0154" | "0155" | "0156" | "0160" | "0161" | "0162" | "0163" | "0164" | "0165" | "0166" | "0200" | "0201" | "0202" | "0203" | "0204" | "0205" | "0206" | "0210" | "0211" | "0212" | "0213" | "0214" | "0215" | "0216" | "0220" | "0221" | "0222" | "0223" | "0224" | "0225" | "0226" | "0230" | "0231" | "0232" | "0233" | "0234" | "0235" | "0236" | "0240" | "0241" | "0242" | "0243" | "0244" | "0245" | "0246" | "0250" | "0251" | "0252" | "0253" | "0254" | "0255" | "0256" | "0260" | "0261" | "0262" | "0263" | "0264" | "0265" | "0266" | "0300" | "0301" | "0302" | "0303" | "0304" | "0305" | "0306" | "0310" | "0311" | "0312" | "0313" | "0314" | "0315" | "0316" | "0320" | "0321" | "0322" | "0323" | "0324" | "0325" | "0326" | "0330" | "0331" | "0332" | "0333" | "0334" | "0335" | "0336" | "0340" | "0341" | "0342" | "0343" | "0344" | "0345" | "0346" | "0350" | "0351" | "0352" | "0353" | "0354" | "0355" | "0356" | "0360" | "0361" | "0362" | "0363" | "0364" | "0365" | "0366" | "0400" | "0401" | "0402" | "0403" | "0404" | "0405" | "0406" | "0410" | "0411" | "0412" | "0413" | "0414" | "0415" | "0416" | "0420" | "0421" | "0422" | "0423" | "0424" | "0425" | "0426" | "0430" | "0431" | "0432" | "0433" | "0434" | "0435" | "0436" | "0440" | "0441" | "0442" | "0443" | "0444" | "0445" | "0446" | "0450" | "0451" | "0452" | "0453" | "0454" | "0455" | "0456" | "0460" | "0461" | "0462" | "0463" | "0464" | "0465" | "0466" | "0500" | "0501" | "0502" | "0503" | "0504" | "0505" | "0506" | "0510" | "0511" | "0512" | "0513" | "0514" | "0515" | "0516" | "0520" | "0521" | "0522" | "0523" | "0524" | "0525" | "0526" | "0530" | "0531" | "0532" | "0533" | "0534" | "0535" | "0536" | "0540" | "0541" | "0542" | "0543" | "0544" | "0545" | "0546" | "0550" | "0551" | "0552" | "0553" | "0554" | "0555" | "0556" | "0560" | "0561" | "0562" | "0563" | "0564" | "0565" | "0566" | "0600" | "0601" | "0602" | "0603" | "0604" | "0605" | "0606" | "0610" | "0611" | "0612" | "0613" | "0614" | "0615" | "0616" | "0620" | "0621" | "0622" | "0623" | "0624" | "0625" | "0626" | "0630" | "0631" | "0632" | "0633" | "0634" | "0635" | "0636" | "0640" | "0641" | "0642" | "0643" | "0644" | "0645" | "0646" | "0650" | "0651" | "0652" | "0653" | "0654" | "0655" | "0656" | "0660" | "0661" | "0662" | "0663" | "0664" | "0665" | "0666" | "1000" | "1001" | "1002" | "1003" | "1004" | "1005" | "1006" | "1010" | "1011" | "1012" | "1013" | "1014" | "1015" | "1016" | "1020" | "1021" | "1022" | "1023" | "1024" | "1025" | "1026" | "1030" | "1031" | "1032" | "1033" | "1034" | "1035" | "1036" | "1040" | "1041" | "1042" | "1043" | "1044" | "1045" | "1046" | "1050" | "1051" | "1052" | "1053" | "1054" | "1055" | "1056" | "1060" | "1061" | "1062" | "1063" | "1064" | "1065" | "1066" | "1100" | "1101" | "1102" | "1103" | "1104" | "1105" | "1106" | "1110" | "1111" | "1112" | "1113" | "1114" | "1115" | "1116" | "1120" | "1121" | "1122" | "1123" | "1124" | "1125" | "1126" | "1130" | "1131" | "1132" | "1133" | "1134" | "1135" | "1136" | "1140" | "1141" | "1142" | "1143" | "1144" | "1145" | "1146" | "1150" | "1151" | "1152" | "1153" | "1154" | "1155" | "1156" | "1160" | "1161" | "1162" | "1163" | "1164" | "1165" | "1166" | "1200" | "1201" | "1202" | "1203" | "1204" | "1205" | "1206" | "1210" | "1211" | "1212" | "1213" | "1214" | "1215" | "1216" | "1220" | "1221" | "1222" | "1223" | "1224" | "1225" | "1226" | "1230" | "1231" | "1232" | "1233" | "1234" | "1235" | "1236" | "1240" | "1241" | "1242" | "1243" | "1244" | "1245" | "1246" | "1250" | "1251" | "1252" | "1253" | "1254" | "1255" | "1256" | "1260" | "1261" | "1262" | "1263" | "1264" | "1265" | "1266" | "1300" | "1301" | "1302" | "1303" | "1304" | "1305" | "1306" | "1310" | "1311" | "1312" | "1313" | "1314" | "1315" | "1316" | "1320" | "1321" | "1322" | "1323" | "1324" | "1325" | "1326" | "1330" | "1331" | "1332" | "1333" | "1334" | "1335" | "1336" | "1340" | "1341" | "1342" | "1343" | "1344" | "1345" | "1346" | "1350" | "1351" | "1352" | "1353" | "1354" | "1355" | "1356" | "1360" | "1361" | "1362" | "1363" | "1364" | "1365" | "1366" | "1400" | "1401" | "1402" | "1403" | "1404" | "1405" | "1406" | "1410" | "1411" | "1412" | "1413" | "1414" | "1415" | "1416" | "1420" | "1421" | "1422" | "1423" | "1424" | "1425" | "1426" | "1430" | "1431" | "1432" | "1433" | "1434" | "1435" | "1436" | "1440" | "1441" | "1442" | "1443" | "1444" | "1445" | "1446" | "1450" | "1451" | "1452" | "1453" | "1454" | "1455" | "1456" | "1460" | "1461" | "1462" | "1463" | "1464" | "1465" | "1466" | "1500" | "1501" | "1502" | "1503" | "1504" | "1505" | "1506" | "1510" | "1511" | "1512" | "1513" | "1514" | "1515" | "1516" | "1520" | "1521" | "1522" | "1523" | "1524" | "1525" | "1526" | "1530" | "1531" | "1532" | "1533" | "1534" | "1535" | "1536" | "1540" | "1541" | "1542" | "1543" | "1544" | "1545" | "1546" | "1550" | "1551" | "1552" | "1553" | "1554" | "1555" | "1556" | "1560" | "1561" | "1562" | "1563" | "1564" | "1565" | "1566" | "1600" | "1601" | "1602" | "1603" | "1604" | "1605" | "1606" | "1610" | "1611" | "1612" | "1613" | "1614" | "1615" | "1616" | "1620" | "1621" | "1622" | "1623" | "1624" | "1625" | "1626" | "1630" | "1631" | "1632" | "1633" | "1634" | "1635" | "1636" | "1640" | "1641" | "1642" | "1643" | "1644" | "1645" | "1646" | "1650" | "1651" | "1652" | "1653" | "1654" | "1655" | "1656" | "1660" | "1661" | "1662" | "1663" | "1664" | "1665" | "1666" | "2000" | "2001" | "2002" | "2003" | "2004" | "2005" | "2006" | "2010" | "2011" | "2012" | "2013" | "2014" | "2015" | "2016" | "2020" | "2021" | "2022" | "2023" | "2024" | "2025" | "2026" | "2030" | "2031" | "2032" | "2033" | "2034" | "2035" | "2036" | "2040" | "2041" | "2042" | "2043" | "2044" | "2045" | "2046" | "2050" | "2051" | "2052" | "2053" | "2054" | "2055" | "2056" | "2060" | "2061" | "2062" | "2063" | "2064" | "2065" | "2066" | "2100" | "2101" | "2102" | "2103" | "2104" | "2105" | "2106" | "2110" | "2111" | "2112" | "2113" | "2114" | "2115" | "2116" | "2120" | "2121" | "2122" | "2123" | "2124" | "2125" | "2126" | "2130" | "2131" | "2132" | "2133" | "2134" | "2135" | "2136" | "2140" | "2141" | "2142" | "2143" | "2144" | "2145" | "2146" | "2150" | "2151" | "2152" | "2153" | "2154" | "2155" | "2156" | "2160" | "2161" | "2162" | "2163" | "2164" | "2165" | "2166" | "2200" | "2201" | "2202" | "2203" | "2204" | "2205" | "2206" | "2210" | "2211" | "2212" | "2213" | "2214" | "2215" | "2216" | "2220" | "2221" | "2222" | "2223" | "2224" | "2225" | "2226" | "2230" | "2231" | "2232" | "2233" | "2234" | "2235" | "2236" | "2240" | "2241" | "2242" | "2243" | "2244" | "2245" | "2246" | "2250" | "2251" | "2252" | "2253" | "2254" | "2255" | "2256" | "2260" | "2261" | "2262" | "2263" | "2264" | "2265" | "2266" | "2300" | "2301" | "2302" | "2303" | "2304" | "2305" | "2306" | "2310" | "2311" | "2312" | "2313" | "2314" | "2315" | "2316" | "2320" | "2321" | "2322" | "2323" | "2324" | "2325" | "2326" | "2330" | "2331" | "2332" | "2333" | "2334" | "2335" | "2336" | "2340" | "2341" | "2342" | "2343" | "2344" | "2345" | "2346" | "2350" | "2351" | "2352" | "2353" | "2354" | "2355" | "2356" | "2360" | "2361" | "2362" | "2363" | "2364" | "2365" | "2366" | "2400" | "2401" | "2402" | "2403" | "2404" | "2405" | "2406" | "2410" | "2411" | "2412" | "2413" | "2414" | "2415" | "2416" | "2420" | "2421" | "2422" | "2423" | "2424" | "2425" | "2426" | "2430" | "2431" | "2432" | "2433" | "2434" | "2435" | "2436" | "2440" | "2441" | "2442" | "2443" | "2444" | "2445" | "2446" | "2450" | "2451" | "2452" | "2453" | "2454" | "2455" | "2456" | "2460" | "2461" | "2462" | "2463" | "2464" | "2465" | "2466" | "2500" | "2501" | "2502" | "2503" | "2504" | "2505" | "2506" | "2510" | "2511" | "2512" | "2513" | "2514" | "2515" | "2516" | "2520" | "2521" | "2522" | "2523" | "2524" | "2525" | "2526" | "2530" | "2531" | "2532" | "2533" | "2534" | "2535" | "2536" | "2540" | "2541" | "2542" | "2543" | "2544" | "2545" | "2546" | "2550" | "2551" | "2552" | "2553" | "2554" | "2555" | "2556" | "2560" | "2561" | "2562" | "2563" | "2564" | "2565" | "2566" | "2600" | "2601" | "2602" | "2603" | "2604" | "2605" | "2606" | "2610" | "2611" | "2612" | "2613" | "2614" | "2615" | "2616" | "2620" | "2621" | "2622" | "2623" | "2624" | "2625" | "2626" | "2630" | "2631" | "2632" | "2633" | "2634" | "2635" | "2636" | "2640" | "2641" | "2642" | "2643" | "2644" | "2645" | "2646" | "2650" | "2651" | "2652" | "2653" | "2654" | "2655" | "2656" | "2660" | "2661" | "2662" | "2663" | "2664" | "2665" | "2666" | "3000" | "3001" | "3002" | "3003" | "3004" | "3005" | "3006" | "3010" | "3011" | "3012" | "3013" | "3014" | "3015" | "3016" | "3020" | "3021" | "3022" | "3023" | "3024" | "3025" | "3026" | "3030" | "3031" | "3032" | "3033" | "3034" | "3035" | "3036" | "3040" | "3041" | "3042" | "3043" | "3044" | "3045" | "3046" | "3050" | "3051" | "3052" | "3053" | "3054" | "3055" | "3056" | "3060" | "3061" | "3062" | "3063" | "3064" | "3065" | "3066" | "3100" | "3101" | "3102" | "3103" | "3104" | "3105" | "3106" | "3110" | "3111" | "3112" | "3113" | "3114" | "3115" | "3116" | "3120" | "3121" | "3122" | "3123" | "3124" | "3125" | "3126" | "3130" | "3131" | "3132" | "3133" | "3134" | "3135" | "3136" | "3140" | "3141" | "3142" | "3143" | "3144" | "3145" | "3146" | "3150" | "3151" | "3152" | "3153" | "3154" | "3155" | "3156" | "3160" | "3161" | "3162" | "3163" | "3164" | "3165" | "3166" | "3200" | "3201" | "3202" | "3203" | "3204" | "3205" | "3206" | "3210" | "3211" | "3212" | "3213" | "3214" | "3215" | "3216" | "3220" | "3221" | "3222" | "3223" | "3224" | "3225" | "3226" | "3230" | "3231" | "3232" | "3233" | "3234" | "3235" | "3236" | "3240" | "3241" | "3242" | "3243" | "3244" | "3245" | "3246" | "3250" | "3251" | "3252" | "3253" | "3254" | "3255" | "3256" | "3260" | "3261" | "3262" | "3263" | "3264" | "3265" | "3266" | "3300" | "3301" | "3302" | "3303" | "3304" | "3305" | "3306" | "3310" | "3311" | "3312" | "3313" | "3314" | "3315" | "3316" | "3320" | "3321" | "3322" | "3323" | "3324" | "3325" | "3326" | "3330" | "3331" | "3332" | "3333" | "3334" | "3335" | "3336" | "3340" | "3341" | "3342" | "3343" | "3344" | "3345" | "3346" | "3350" | "3351" | "3352" | "3353" | "3354" | "3355" | "3356" | "3360" | "3361" | "3362" | "3363" | "3364" | "3365" | "3366" | "3400" | "3401" | "3402" | "3403" | "3404" | "3405" | "3406" | "3410" | "3411" | "3412" | "3413" | "3414" | "3415" | "3416" | "3420" | "3421" | "3422" | "3423" | "3424" | "3425" | "3426" | "3430" | "3431" | "3432" | "3433" | "3434" | "3435" | "3436" | "3440" | "3441" | "3442" | "3443" | "3444" | "3445" | "3446" | "3450" | "3451" | "3452" | "3453" | "3454" | "3455" | "3456" | "3460" | "3461" | "3462" | "3463" | "3464" | "3465" | "3466" | "3500" | "3501" | "3502" | "3503" | "3504" | "3505" | "3506" | "3510" | "3511" | "3512" | "3513" | "3514" | "3515" | "3516" | "3520" | "3521" | "3522" | "3523" | "3524" | "3525" | "3526" | "3530" | "3531" | "3532" | "3533" | "3534" | "3535" | "3536" | "3540" | "3541" | "3542" | "3543" | "3544" | "3545" | "3546" | "3550" | "3551" | "3552" | "3553" | "3554" | "3555" | "3556" | "3560" | "3561" | "3562" | "3563" | "3564" | "3565" | "3566" | "3600" | "3601" | "3602" | "3603" | "3604" | "3605" | "3606" | "3610" | "3611" | "3612" | "3613" | "3614" | "3615" | "3616" | "3620" | "3621" | "3622" | "3623" | "3624" | "3625" | "3626" | "3630" | "3631" | "3632" | "3633" | "3634" | "3635" | "3636" | "3640" | "3641" | "3642" | "3643" | "3644" | "3645" | "3646" | "3650" | "3651" | "3652" | "3653" | "3654" | "3655" | "3656" | "3660" | "3661" | "3662" | "3663" | "3664" | "3665" | "3666" | "4000" | "4001" | "4002" | "4003" | "4004" | "4005" | "4006" | "4010" | "4011" | "4012" | "4013" | "4014" | "4015" | "4016" | "4020" | "4021" | "4022" | "4023" | "4024" | "4025" | "4026" | "4030" | "4031" | "4032" | "4033" | "4034" | "4035" | "4036" | "4040" | "4041" | "4042" | "4043" | "4044" | "4045" | "4046" | "4050" | "4051" | "4052" | "4053" | "4054" | "4055" | "4056" | "4060" | "4061" | "4062" | "4063" | "4064" | "4065" | "4066" | "4100" | "4101" | "4102" | "4103" | "4104" | "4105" | "4106" | "4110" | "4111" | "4112" | "4113" | "4114" | "4115" | "4116" | "4120" | "4121" | "4122" | "4123" | "4124" | "4125" | "4126" | "4130" | "4131" | "4132" | "4133" | "4134" | "4135" | "4136" | "4140" | "4141" | "4142" | "4143" | "4144" | "4145" | "4146" | "4150" | "4151" | "4152" | "4153" | "4154" | "4155" | "4156" | "4160" | "4161" | "4162" | "4163" | "4164" | "4165" | "4166" | "4200" | "4201" | "4202" | "4203" | "4204" | "4205" | "4206" | "4210" | "4211" | "4212" | "4213" | "4214" | "4215" | "4216" | "4220" | "4221" | "4222" | "4223" | "4224" | "4225" | "4226" | "4230" | "4231" | "4232" | "4233" | "4234" | "4235" | "4236" | "4240" | "4241" | "4242" | "4243" | "4244" | "4245" | "4246" | "4250" | "4251" | "4252" | "4253" | "4254" | "4255" | "4256" | "4260" | "4261" | "4262" | "4263" | "4264" | "4265" | "4266" | "4300" | "4301" | "4302" | "4303" | "4304" | "4305" | "4306" | "4310" | "4311" | "4312" | "4313" | "4314" | "4315" | "4316" | "4320" | "4321" | "4322" | "4323" | "4324" | "4325" | "4326" | "4330" | "4331" | "4332" | "4333" | "4334" | "4335" | "4336" | "4340" | "4341" | "4342" | "4343" | "4344" | "4345" | "4346" | "4350" | "4351" | "4352" | "4353" | "4354" | "4355" | "4356" | "4360" | "4361" | "4362" | "4363" | "4364" | "4365" | "4366" | "4400" | "4401" | "4402" | "4403" | "4404" | "4405" | "4406" | "4410" | "4411" | "4412" | "4413" | "4414" | "4415" | "4416" | "4420" | "4421" | "4422" | "4423" | "4424" | "4425" | "4426" | "4430" | "4431" | "4432" | "4433" | "4434" | "4435" | "4436" | "4440" | "4441" | "4442" | "4443" | "4444" | "4445" | "4446" | "4450" | "4451" | "4452" | "4453" | "4454" | "4455" | "4456" | "4460" | "4461" | "4462" | "4463" | "4464" | "4465" | "4466" | "4500" | "4501" | "4502" | "4503" | "4504" | "4505" | "4506" | "4510" | "4511" | "4512" | "4513" | "4514" | "4515" | "4516" | "4520" | "4521" | "4522" | "4523" | "4524" | "4525" | "4526" | "4530" | "4531" | "4532" | "4533" | "4534" | "4535" | "4536" | "4540" | "4541" | "4542" | "4543" | "4544" | "4545" | "4546" | "4550" | "4551" | "4552" | "4553" | "4554" | "4555" | "4556" | "4560" | "4561" | "4562" | "4563" | "4564" | "4565" | "4566" | "4600" | "4601" | "4602" | "4603" | "4604" | "4605" | "4606" | "4610" | "4611" | "4612" | "4613" | "4614" | "4615" | "4616" | "4620" | "4621" | "4622" | "4623" | "4624" | "4625" | "4626" | "4630" | "4631" | "4632" | "4633" | "4634" | "4635" | "4636" | "4640" | "4641" | "4642" | "4643" | "4644" | "4645" | "4646" | "4650" | "4651" | "4652" | "4653" | "4654" | "4655" | "4656" | "4660" | "4661" | "4662" | "4663" | "4664" | "4665" | "4666" | "5000" | "5001" | "5002" | "5003" | "5004" | "5005" | "5006" | "5010" | "5011" | "5012" | "5013" | "5014" | "5015" | "5016" | "5020" | "5021" | "5022" | "5023" | "5024" | "5025" | "5026" | "5030" | "5031" | "5032" | "5033" | "5034" | "5035" | "5036" | "5040" | "5041" | "5042" | "5043" | "5044" | "5045" | "5046" | "5050" | "5051" | "5052" | "5053" | "5054" | "5055" | "5056" | "5060" | "5061" | "5062" | "5063" | "5064" | "5065" | "5066" | "5100" | "5101" | "5102" | "5103" | "5104" | "5105" | "5106" | "5110" | "5111" | "5112" | "5113" | "5114" | "5115" | "5116" | "5120" | "5121" | "5122" | "5123" | "5124" | "5125" | "5126" | "5130" | "5131" | "5132" | "5133" | "5134" | "5135" | "5136" | "5140" | "5141" | "5142" | "5143" | "5144" | "5145" | "5146" | "5150" | "5151" | "5152" | "5153" | "5154" | "5155" | "5156" | "5160" | "5161" | "5162" | "5163" | "5164" | "5165" | "5166" | "5200" | "5201" | "5202" | "5203" | "5204" | "5205" | "5206" | "5210" | "5211" | "5212" | "5213" | "5214" | "5215" | "5216" | "5220" | "5221" | "5222" | "5223" | "5224" | "5225" | "5226" | "5230" | "5231" | "5232" | "5233" | "5234" | "5235" | "5236" | "5240" | "5241" | "5242" | "5243" | "5244" | "5245" | "5246" | "5250" | "5251" | "5252" | "5253" | "5254" | "5255" | "5256" | "5260" | "5261" | "5262" | "5263" | "5264" | "5265" | "5266" | "5300" | "5301" | "5302" | "5303" | "5304" | "5305" | "5306" | "5310" | "5311" | "5312" | "5313" | "5314" | "5315" | "5316" | "5320" | "5321" | "5322" | "5323" | "5324" | "5325" | "5326" | "5330" | "5331" | "5332" | "5333" | "5334" | "5335" | "5336" | "5340" | "5341" | "5342" | "5343" | "5344" | "5345" | "5346" | "5350" | "5351" | "5352" | "5353" | "5354" | "5355" | "5356" | "5360" | "5361" | "5362" | "5363" | "5364" | "5365" | "5366" | "5400" | "5401" | "5402" | "5403" | "5404" | "5405" | "5406" | "5410" | "5411" | "5412" | "5413" | "5414" | "5415" | "5416" | "5420" | "5421" | "5422" | "5423" | "5424" | "5425" | "5426" | "5430" | "5431" | "5432" | "5433" | "5434" | "5435" | "5436" | "5440" | "5441" | "5442" | "5443" | "5444" | "5445" | "5446" | "5450" | "5451" | "5452" | "5453" | "5454" | "5455" | "5456" | "5460" | "5461" | "5462" | "5463" | "5464" | "5465" | "5466" | "5500" | "5501" | "5502" | "5503" | "5504" | "5505" | "5506" | "5510" | "5511" | "5512" | "5513" | "5514" | "5515" | "5516" | "5520" | "5521" | "5522" | "5523" | "5524" | "5525" | "5526" | "5530" | "5531" | "5532" | "5533" | "5534" | "5535" | "5536" | "5540" | "5541" | "5542" | "5543" | "5544" | "5545" | "5546" | "5550" | "5551" | "5552" | "5553" | "5554" | "5555" | "5556" | "5560" | "5561" | "5562" | "5563" | "5564" | "5565" | "5566" | "5600" | "5601" | "5602" | "5603" | "5604" | "5605" | "5606" | "5610" | "5611" | "5612" | "5613" | "5614" | "5615" | "5616" | "5620" | "5621" | "5622" | "5623" | "5624" | "5625" | "5626" | "5630" | "5631" | "5632" | "5633" | "5634" | "5635" | "5636" | "5640" | "5641" | "5642" | "5643" | "5644" | "5645" | "5646" | "5650" | "5651" | "5652" | "5653" | "5654" | "5655" | "5656" | "5660" | "5661" | "5662" | "5663" | "5664" | "5665" | "5666" | undefined) & T2 + +x = y6; +>x = y6 : ("0000" | "0001" | "0002" | "0003" | "0004" | "0005" | "0006" | "0010" | "0011" | "0012" | "0013" | "0014" | "0015" | "0016" | "0020" | "0021" | "0022" | "0023" | "0024" | "0025" | "0026" | "0030" | "0031" | "0032" | "0033" | "0034" | "0035" | "0036" | "0040" | "0041" | "0042" | "0043" | "0044" | "0045" | "0046" | "0050" | "0051" | "0052" | "0053" | "0054" | "0055" | "0056" | "0060" | "0061" | "0062" | "0063" | "0064" | "0065" | "0066" | "0100" | "0101" | "0102" | "0103" | "0104" | "0105" | "0106" | "0110" | "0111" | "0112" | "0113" | "0114" | "0115" | "0116" | "0120" | "0121" | "0122" | "0123" | "0124" | "0125" | "0126" | "0130" | "0131" | "0132" | "0133" | "0134" | "0135" | "0136" | "0140" | "0141" | "0142" | "0143" | "0144" | "0145" | "0146" | "0150" | "0151" | "0152" | "0153" | "0154" | "0155" | "0156" | "0160" | "0161" | "0162" | "0163" | "0164" | "0165" | "0166" | "0200" | "0201" | "0202" | "0203" | "0204" | "0205" | "0206" | "0210" | "0211" | "0212" | "0213" | "0214" | "0215" | "0216" | "0220" | "0221" | "0222" | "0223" | "0224" | "0225" | "0226" | "0230" | "0231" | "0232" | "0233" | "0234" | "0235" | "0236" | "0240" | "0241" | "0242" | "0243" | "0244" | "0245" | "0246" | "0250" | "0251" | "0252" | "0253" | "0254" | "0255" | "0256" | "0260" | "0261" | "0262" | "0263" | "0264" | "0265" | "0266" | "0300" | "0301" | "0302" | "0303" | "0304" | "0305" | "0306" | "0310" | "0311" | "0312" | "0313" | "0314" | "0315" | "0316" | "0320" | "0321" | "0322" | "0323" | "0324" | "0325" | "0326" | "0330" | "0331" | "0332" | "0333" | "0334" | "0335" | "0336" | "0340" | "0341" | "0342" | "0343" | "0344" | "0345" | "0346" | "0350" | "0351" | "0352" | "0353" | "0354" | "0355" | "0356" | "0360" | "0361" | "0362" | "0363" | "0364" | "0365" | "0366" | "0400" | "0401" | "0402" | "0403" | "0404" | "0405" | "0406" | "0410" | "0411" | "0412" | "0413" | "0414" | "0415" | "0416" | "0420" | "0421" | "0422" | "0423" | "0424" | "0425" | "0426" | "0430" | "0431" | "0432" | "0433" | "0434" | "0435" | "0436" | "0440" | "0441" | "0442" | "0443" | "0444" | "0445" | "0446" | "0450" | "0451" | "0452" | "0453" | "0454" | "0455" | "0456" | "0460" | "0461" | "0462" | "0463" | "0464" | "0465" | "0466" | "0500" | "0501" | "0502" | "0503" | "0504" | "0505" | "0506" | "0510" | "0511" | "0512" | "0513" | "0514" | "0515" | "0516" | "0520" | "0521" | "0522" | "0523" | "0524" | "0525" | "0526" | "0530" | "0531" | "0532" | "0533" | "0534" | "0535" | "0536" | "0540" | "0541" | "0542" | "0543" | "0544" | "0545" | "0546" | "0550" | "0551" | "0552" | "0553" | "0554" | "0555" | "0556" | "0560" | "0561" | "0562" | "0563" | "0564" | "0565" | "0566" | "0600" | "0601" | "0602" | "0603" | "0604" | "0605" | "0606" | "0610" | "0611" | "0612" | "0613" | "0614" | "0615" | "0616" | "0620" | "0621" | "0622" | "0623" | "0624" | "0625" | "0626" | "0630" | "0631" | "0632" | "0633" | "0634" | "0635" | "0636" | "0640" | "0641" | "0642" | "0643" | "0644" | "0645" | "0646" | "0650" | "0651" | "0652" | "0653" | "0654" | "0655" | "0656" | "0660" | "0661" | "0662" | "0663" | "0664" | "0665" | "0666" | "1000" | "1001" | "1002" | "1003" | "1004" | "1005" | "1006" | "1010" | "1011" | "1012" | "1013" | "1014" | "1015" | "1016" | "1020" | "1021" | "1022" | "1023" | "1024" | "1025" | "1026" | "1030" | "1031" | "1032" | "1033" | "1034" | "1035" | "1036" | "1040" | "1041" | "1042" | "1043" | "1044" | "1045" | "1046" | "1050" | "1051" | "1052" | "1053" | "1054" | "1055" | "1056" | "1060" | "1061" | "1062" | "1063" | "1064" | "1065" | "1066" | "1100" | "1101" | "1102" | "1103" | "1104" | "1105" | "1106" | "1110" | "1111" | "1112" | "1113" | "1114" | "1115" | "1116" | "1120" | "1121" | "1122" | "1123" | "1124" | "1125" | "1126" | "1130" | "1131" | "1132" | "1133" | "1134" | "1135" | "1136" | "1140" | "1141" | "1142" | "1143" | "1144" | "1145" | "1146" | "1150" | "1151" | "1152" | "1153" | "1154" | "1155" | "1156" | "1160" | "1161" | "1162" | "1163" | "1164" | "1165" | "1166" | "1200" | "1201" | "1202" | "1203" | "1204" | "1205" | "1206" | "1210" | "1211" | "1212" | "1213" | "1214" | "1215" | "1216" | "1220" | "1221" | "1222" | "1223" | "1224" | "1225" | "1226" | "1230" | "1231" | "1232" | "1233" | "1234" | "1235" | "1236" | "1240" | "1241" | "1242" | "1243" | "1244" | "1245" | "1246" | "1250" | "1251" | "1252" | "1253" | "1254" | "1255" | "1256" | "1260" | "1261" | "1262" | "1263" | "1264" | "1265" | "1266" | "1300" | "1301" | "1302" | "1303" | "1304" | "1305" | "1306" | "1310" | "1311" | "1312" | "1313" | "1314" | "1315" | "1316" | "1320" | "1321" | "1322" | "1323" | "1324" | "1325" | "1326" | "1330" | "1331" | "1332" | "1333" | "1334" | "1335" | "1336" | "1340" | "1341" | "1342" | "1343" | "1344" | "1345" | "1346" | "1350" | "1351" | "1352" | "1353" | "1354" | "1355" | "1356" | "1360" | "1361" | "1362" | "1363" | "1364" | "1365" | "1366" | "1400" | "1401" | "1402" | "1403" | "1404" | "1405" | "1406" | "1410" | "1411" | "1412" | "1413" | "1414" | "1415" | "1416" | "1420" | "1421" | "1422" | "1423" | "1424" | "1425" | "1426" | "1430" | "1431" | "1432" | "1433" | "1434" | "1435" | "1436" | "1440" | "1441" | "1442" | "1443" | "1444" | "1445" | "1446" | "1450" | "1451" | "1452" | "1453" | "1454" | "1455" | "1456" | "1460" | "1461" | "1462" | "1463" | "1464" | "1465" | "1466" | "1500" | "1501" | "1502" | "1503" | "1504" | "1505" | "1506" | "1510" | "1511" | "1512" | "1513" | "1514" | "1515" | "1516" | "1520" | "1521" | "1522" | "1523" | "1524" | "1525" | "1526" | "1530" | "1531" | "1532" | "1533" | "1534" | "1535" | "1536" | "1540" | "1541" | "1542" | "1543" | "1544" | "1545" | "1546" | "1550" | "1551" | "1552" | "1553" | "1554" | "1555" | "1556" | "1560" | "1561" | "1562" | "1563" | "1564" | "1565" | "1566" | "1600" | "1601" | "1602" | "1603" | "1604" | "1605" | "1606" | "1610" | "1611" | "1612" | "1613" | "1614" | "1615" | "1616" | "1620" | "1621" | "1622" | "1623" | "1624" | "1625" | "1626" | "1630" | "1631" | "1632" | "1633" | "1634" | "1635" | "1636" | "1640" | "1641" | "1642" | "1643" | "1644" | "1645" | "1646" | "1650" | "1651" | "1652" | "1653" | "1654" | "1655" | "1656" | "1660" | "1661" | "1662" | "1663" | "1664" | "1665" | "1666" | "2000" | "2001" | "2002" | "2003" | "2004" | "2005" | "2006" | "2010" | "2011" | "2012" | "2013" | "2014" | "2015" | "2016" | "2020" | "2021" | "2022" | "2023" | "2024" | "2025" | "2026" | "2030" | "2031" | "2032" | "2033" | "2034" | "2035" | "2036" | "2040" | "2041" | "2042" | "2043" | "2044" | "2045" | "2046" | "2050" | "2051" | "2052" | "2053" | "2054" | "2055" | "2056" | "2060" | "2061" | "2062" | "2063" | "2064" | "2065" | "2066" | "2100" | "2101" | "2102" | "2103" | "2104" | "2105" | "2106" | "2110" | "2111" | "2112" | "2113" | "2114" | "2115" | "2116" | "2120" | "2121" | "2122" | "2123" | "2124" | "2125" | "2126" | "2130" | "2131" | "2132" | "2133" | "2134" | "2135" | "2136" | "2140" | "2141" | "2142" | "2143" | "2144" | "2145" | "2146" | "2150" | "2151" | "2152" | "2153" | "2154" | "2155" | "2156" | "2160" | "2161" | "2162" | "2163" | "2164" | "2165" | "2166" | "2200" | "2201" | "2202" | "2203" | "2204" | "2205" | "2206" | "2210" | "2211" | "2212" | "2213" | "2214" | "2215" | "2216" | "2220" | "2221" | "2222" | "2223" | "2224" | "2225" | "2226" | "2230" | "2231" | "2232" | "2233" | "2234" | "2235" | "2236" | "2240" | "2241" | "2242" | "2243" | "2244" | "2245" | "2246" | "2250" | "2251" | "2252" | "2253" | "2254" | "2255" | "2256" | "2260" | "2261" | "2262" | "2263" | "2264" | "2265" | "2266" | "2300" | "2301" | "2302" | "2303" | "2304" | "2305" | "2306" | "2310" | "2311" | "2312" | "2313" | "2314" | "2315" | "2316" | "2320" | "2321" | "2322" | "2323" | "2324" | "2325" | "2326" | "2330" | "2331" | "2332" | "2333" | "2334" | "2335" | "2336" | "2340" | "2341" | "2342" | "2343" | "2344" | "2345" | "2346" | "2350" | "2351" | "2352" | "2353" | "2354" | "2355" | "2356" | "2360" | "2361" | "2362" | "2363" | "2364" | "2365" | "2366" | "2400" | "2401" | "2402" | "2403" | "2404" | "2405" | "2406" | "2410" | "2411" | "2412" | "2413" | "2414" | "2415" | "2416" | "2420" | "2421" | "2422" | "2423" | "2424" | "2425" | "2426" | "2430" | "2431" | "2432" | "2433" | "2434" | "2435" | "2436" | "2440" | "2441" | "2442" | "2443" | "2444" | "2445" | "2446" | "2450" | "2451" | "2452" | "2453" | "2454" | "2455" | "2456" | "2460" | "2461" | "2462" | "2463" | "2464" | "2465" | "2466" | "2500" | "2501" | "2502" | "2503" | "2504" | "2505" | "2506" | "2510" | "2511" | "2512" | "2513" | "2514" | "2515" | "2516" | "2520" | "2521" | "2522" | "2523" | "2524" | "2525" | "2526" | "2530" | "2531" | "2532" | "2533" | "2534" | "2535" | "2536" | "2540" | "2541" | "2542" | "2543" | "2544" | "2545" | "2546" | "2550" | "2551" | "2552" | "2553" | "2554" | "2555" | "2556" | "2560" | "2561" | "2562" | "2563" | "2564" | "2565" | "2566" | "2600" | "2601" | "2602" | "2603" | "2604" | "2605" | "2606" | "2610" | "2611" | "2612" | "2613" | "2614" | "2615" | "2616" | "2620" | "2621" | "2622" | "2623" | "2624" | "2625" | "2626" | "2630" | "2631" | "2632" | "2633" | "2634" | "2635" | "2636" | "2640" | "2641" | "2642" | "2643" | "2644" | "2645" | "2646" | "2650" | "2651" | "2652" | "2653" | "2654" | "2655" | "2656" | "2660" | "2661" | "2662" | "2663" | "2664" | "2665" | "2666" | "3000" | "3001" | "3002" | "3003" | "3004" | "3005" | "3006" | "3010" | "3011" | "3012" | "3013" | "3014" | "3015" | "3016" | "3020" | "3021" | "3022" | "3023" | "3024" | "3025" | "3026" | "3030" | "3031" | "3032" | "3033" | "3034" | "3035" | "3036" | "3040" | "3041" | "3042" | "3043" | "3044" | "3045" | "3046" | "3050" | "3051" | "3052" | "3053" | "3054" | "3055" | "3056" | "3060" | "3061" | "3062" | "3063" | "3064" | "3065" | "3066" | "3100" | "3101" | "3102" | "3103" | "3104" | "3105" | "3106" | "3110" | "3111" | "3112" | "3113" | "3114" | "3115" | "3116" | "3120" | "3121" | "3122" | "3123" | "3124" | "3125" | "3126" | "3130" | "3131" | "3132" | "3133" | "3134" | "3135" | "3136" | "3140" | "3141" | "3142" | "3143" | "3144" | "3145" | "3146" | "3150" | "3151" | "3152" | "3153" | "3154" | "3155" | "3156" | "3160" | "3161" | "3162" | "3163" | "3164" | "3165" | "3166" | "3200" | "3201" | "3202" | "3203" | "3204" | "3205" | "3206" | "3210" | "3211" | "3212" | "3213" | "3214" | "3215" | "3216" | "3220" | "3221" | "3222" | "3223" | "3224" | "3225" | "3226" | "3230" | "3231" | "3232" | "3233" | "3234" | "3235" | "3236" | "3240" | "3241" | "3242" | "3243" | "3244" | "3245" | "3246" | "3250" | "3251" | "3252" | "3253" | "3254" | "3255" | "3256" | "3260" | "3261" | "3262" | "3263" | "3264" | "3265" | "3266" | "3300" | "3301" | "3302" | "3303" | "3304" | "3305" | "3306" | "3310" | "3311" | "3312" | "3313" | "3314" | "3315" | "3316" | "3320" | "3321" | "3322" | "3323" | "3324" | "3325" | "3326" | "3330" | "3331" | "3332" | "3333" | "3334" | "3335" | "3336" | "3340" | "3341" | "3342" | "3343" | "3344" | "3345" | "3346" | "3350" | "3351" | "3352" | "3353" | "3354" | "3355" | "3356" | "3360" | "3361" | "3362" | "3363" | "3364" | "3365" | "3366" | "3400" | "3401" | "3402" | "3403" | "3404" | "3405" | "3406" | "3410" | "3411" | "3412" | "3413" | "3414" | "3415" | "3416" | "3420" | "3421" | "3422" | "3423" | "3424" | "3425" | "3426" | "3430" | "3431" | "3432" | "3433" | "3434" | "3435" | "3436" | "3440" | "3441" | "3442" | "3443" | "3444" | "3445" | "3446" | "3450" | "3451" | "3452" | "3453" | "3454" | "3455" | "3456" | "3460" | "3461" | "3462" | "3463" | "3464" | "3465" | "3466" | "3500" | "3501" | "3502" | "3503" | "3504" | "3505" | "3506" | "3510" | "3511" | "3512" | "3513" | "3514" | "3515" | "3516" | "3520" | "3521" | "3522" | "3523" | "3524" | "3525" | "3526" | "3530" | "3531" | "3532" | "3533" | "3534" | "3535" | "3536" | "3540" | "3541" | "3542" | "3543" | "3544" | "3545" | "3546" | "3550" | "3551" | "3552" | "3553" | "3554" | "3555" | "3556" | "3560" | "3561" | "3562" | "3563" | "3564" | "3565" | "3566" | "3600" | "3601" | "3602" | "3603" | "3604" | "3605" | "3606" | "3610" | "3611" | "3612" | "3613" | "3614" | "3615" | "3616" | "3620" | "3621" | "3622" | "3623" | "3624" | "3625" | "3626" | "3630" | "3631" | "3632" | "3633" | "3634" | "3635" | "3636" | "3640" | "3641" | "3642" | "3643" | "3644" | "3645" | "3646" | "3650" | "3651" | "3652" | "3653" | "3654" | "3655" | "3656" | "3660" | "3661" | "3662" | "3663" | "3664" | "3665" | "3666" | "4000" | "4001" | "4002" | "4003" | "4004" | "4005" | "4006" | "4010" | "4011" | "4012" | "4013" | "4014" | "4015" | "4016" | "4020" | "4021" | "4022" | "4023" | "4024" | "4025" | "4026" | "4030" | "4031" | "4032" | "4033" | "4034" | "4035" | "4036" | "4040" | "4041" | "4042" | "4043" | "4044" | "4045" | "4046" | "4050" | "4051" | "4052" | "4053" | "4054" | "4055" | "4056" | "4060" | "4061" | "4062" | "4063" | "4064" | "4065" | "4066" | "4100" | "4101" | "4102" | "4103" | "4104" | "4105" | "4106" | "4110" | "4111" | "4112" | "4113" | "4114" | "4115" | "4116" | "4120" | "4121" | "4122" | "4123" | "4124" | "4125" | "4126" | "4130" | "4131" | "4132" | "4133" | "4134" | "4135" | "4136" | "4140" | "4141" | "4142" | "4143" | "4144" | "4145" | "4146" | "4150" | "4151" | "4152" | "4153" | "4154" | "4155" | "4156" | "4160" | "4161" | "4162" | "4163" | "4164" | "4165" | "4166" | "4200" | "4201" | "4202" | "4203" | "4204" | "4205" | "4206" | "4210" | "4211" | "4212" | "4213" | "4214" | "4215" | "4216" | "4220" | "4221" | "4222" | "4223" | "4224" | "4225" | "4226" | "4230" | "4231" | "4232" | "4233" | "4234" | "4235" | "4236" | "4240" | "4241" | "4242" | "4243" | "4244" | "4245" | "4246" | "4250" | "4251" | "4252" | "4253" | "4254" | "4255" | "4256" | "4260" | "4261" | "4262" | "4263" | "4264" | "4265" | "4266" | "4300" | "4301" | "4302" | "4303" | "4304" | "4305" | "4306" | "4310" | "4311" | "4312" | "4313" | "4314" | "4315" | "4316" | "4320" | "4321" | "4322" | "4323" | "4324" | "4325" | "4326" | "4330" | "4331" | "4332" | "4333" | "4334" | "4335" | "4336" | "4340" | "4341" | "4342" | "4343" | "4344" | "4345" | "4346" | "4350" | "4351" | "4352" | "4353" | "4354" | "4355" | "4356" | "4360" | "4361" | "4362" | "4363" | "4364" | "4365" | "4366" | "4400" | "4401" | "4402" | "4403" | "4404" | "4405" | "4406" | "4410" | "4411" | "4412" | "4413" | "4414" | "4415" | "4416" | "4420" | "4421" | "4422" | "4423" | "4424" | "4425" | "4426" | "4430" | "4431" | "4432" | "4433" | "4434" | "4435" | "4436" | "4440" | "4441" | "4442" | "4443" | "4444" | "4445" | "4446" | "4450" | "4451" | "4452" | "4453" | "4454" | "4455" | "4456" | "4460" | "4461" | "4462" | "4463" | "4464" | "4465" | "4466" | "4500" | "4501" | "4502" | "4503" | "4504" | "4505" | "4506" | "4510" | "4511" | "4512" | "4513" | "4514" | "4515" | "4516" | "4520" | "4521" | "4522" | "4523" | "4524" | "4525" | "4526" | "4530" | "4531" | "4532" | "4533" | "4534" | "4535" | "4536" | "4540" | "4541" | "4542" | "4543" | "4544" | "4545" | "4546" | "4550" | "4551" | "4552" | "4553" | "4554" | "4555" | "4556" | "4560" | "4561" | "4562" | "4563" | "4564" | "4565" | "4566" | "4600" | "4601" | "4602" | "4603" | "4604" | "4605" | "4606" | "4610" | "4611" | "4612" | "4613" | "4614" | "4615" | "4616" | "4620" | "4621" | "4622" | "4623" | "4624" | "4625" | "4626" | "4630" | "4631" | "4632" | "4633" | "4634" | "4635" | "4636" | "4640" | "4641" | "4642" | "4643" | "4644" | "4645" | "4646" | "4650" | "4651" | "4652" | "4653" | "4654" | "4655" | "4656" | "4660" | "4661" | "4662" | "4663" | "4664" | "4665" | "4666" | "5000" | "5001" | "5002" | "5003" | "5004" | "5005" | "5006" | "5010" | "5011" | "5012" | "5013" | "5014" | "5015" | "5016" | "5020" | "5021" | "5022" | "5023" | "5024" | "5025" | "5026" | "5030" | "5031" | "5032" | "5033" | "5034" | "5035" | "5036" | "5040" | "5041" | "5042" | "5043" | "5044" | "5045" | "5046" | "5050" | "5051" | "5052" | "5053" | "5054" | "5055" | "5056" | "5060" | "5061" | "5062" | "5063" | "5064" | "5065" | "5066" | "5100" | "5101" | "5102" | "5103" | "5104" | "5105" | "5106" | "5110" | "5111" | "5112" | "5113" | "5114" | "5115" | "5116" | "5120" | "5121" | "5122" | "5123" | "5124" | "5125" | "5126" | "5130" | "5131" | "5132" | "5133" | "5134" | "5135" | "5136" | "5140" | "5141" | "5142" | "5143" | "5144" | "5145" | "5146" | "5150" | "5151" | "5152" | "5153" | "5154" | "5155" | "5156" | "5160" | "5161" | "5162" | "5163" | "5164" | "5165" | "5166" | "5200" | "5201" | "5202" | "5203" | "5204" | "5205" | "5206" | "5210" | "5211" | "5212" | "5213" | "5214" | "5215" | "5216" | "5220" | "5221" | "5222" | "5223" | "5224" | "5225" | "5226" | "5230" | "5231" | "5232" | "5233" | "5234" | "5235" | "5236" | "5240" | "5241" | "5242" | "5243" | "5244" | "5245" | "5246" | "5250" | "5251" | "5252" | "5253" | "5254" | "5255" | "5256" | "5260" | "5261" | "5262" | "5263" | "5264" | "5265" | "5266" | "5300" | "5301" | "5302" | "5303" | "5304" | "5305" | "5306" | "5310" | "5311" | "5312" | "5313" | "5314" | "5315" | "5316" | "5320" | "5321" | "5322" | "5323" | "5324" | "5325" | "5326" | "5330" | "5331" | "5332" | "5333" | "5334" | "5335" | "5336" | "5340" | "5341" | "5342" | "5343" | "5344" | "5345" | "5346" | "5350" | "5351" | "5352" | "5353" | "5354" | "5355" | "5356" | "5360" | "5361" | "5362" | "5363" | "5364" | "5365" | "5366" | "5400" | "5401" | "5402" | "5403" | "5404" | "5405" | "5406" | "5410" | "5411" | "5412" | "5413" | "5414" | "5415" | "5416" | "5420" | "5421" | "5422" | "5423" | "5424" | "5425" | "5426" | "5430" | "5431" | "5432" | "5433" | "5434" | "5435" | "5436" | "5440" | "5441" | "5442" | "5443" | "5444" | "5445" | "5446" | "5450" | "5451" | "5452" | "5453" | "5454" | "5455" | "5456" | "5460" | "5461" | "5462" | "5463" | "5464" | "5465" | "5466" | "5500" | "5501" | "5502" | "5503" | "5504" | "5505" | "5506" | "5510" | "5511" | "5512" | "5513" | "5514" | "5515" | "5516" | "5520" | "5521" | "5522" | "5523" | "5524" | "5525" | "5526" | "5530" | "5531" | "5532" | "5533" | "5534" | "5535" | "5536" | "5540" | "5541" | "5542" | "5543" | "5544" | "5545" | "5546" | "5550" | "5551" | "5552" | "5553" | "5554" | "5555" | "5556" | "5560" | "5561" | "5562" | "5563" | "5564" | "5565" | "5566" | "5600" | "5601" | "5602" | "5603" | "5604" | "5605" | "5606" | "5610" | "5611" | "5612" | "5613" | "5614" | "5615" | "5616" | "5620" | "5621" | "5622" | "5623" | "5624" | "5625" | "5626" | "5630" | "5631" | "5632" | "5633" | "5634" | "5635" | "5636" | "5640" | "5641" | "5642" | "5643" | "5644" | "5645" | "5646" | "5650" | "5651" | "5652" | "5653" | "5654" | "5655" | "5656" | "5660" | "5661" | "5662" | "5663" | "5664" | "5665" | "5666" | undefined) & T2 +>x : T1 | null +>y6 : ("0000" | "0001" | "0002" | "0003" | "0004" | "0005" | "0006" | "0010" | "0011" | "0012" | "0013" | "0014" | "0015" | "0016" | "0020" | "0021" | "0022" | "0023" | "0024" | "0025" | "0026" | "0030" | "0031" | "0032" | "0033" | "0034" | "0035" | "0036" | "0040" | "0041" | "0042" | "0043" | "0044" | "0045" | "0046" | "0050" | "0051" | "0052" | "0053" | "0054" | "0055" | "0056" | "0060" | "0061" | "0062" | "0063" | "0064" | "0065" | "0066" | "0100" | "0101" | "0102" | "0103" | "0104" | "0105" | "0106" | "0110" | "0111" | "0112" | "0113" | "0114" | "0115" | "0116" | "0120" | "0121" | "0122" | "0123" | "0124" | "0125" | "0126" | "0130" | "0131" | "0132" | "0133" | "0134" | "0135" | "0136" | "0140" | "0141" | "0142" | "0143" | "0144" | "0145" | "0146" | "0150" | "0151" | "0152" | "0153" | "0154" | "0155" | "0156" | "0160" | "0161" | "0162" | "0163" | "0164" | "0165" | "0166" | "0200" | "0201" | "0202" | "0203" | "0204" | "0205" | "0206" | "0210" | "0211" | "0212" | "0213" | "0214" | "0215" | "0216" | "0220" | "0221" | "0222" | "0223" | "0224" | "0225" | "0226" | "0230" | "0231" | "0232" | "0233" | "0234" | "0235" | "0236" | "0240" | "0241" | "0242" | "0243" | "0244" | "0245" | "0246" | "0250" | "0251" | "0252" | "0253" | "0254" | "0255" | "0256" | "0260" | "0261" | "0262" | "0263" | "0264" | "0265" | "0266" | "0300" | "0301" | "0302" | "0303" | "0304" | "0305" | "0306" | "0310" | "0311" | "0312" | "0313" | "0314" | "0315" | "0316" | "0320" | "0321" | "0322" | "0323" | "0324" | "0325" | "0326" | "0330" | "0331" | "0332" | "0333" | "0334" | "0335" | "0336" | "0340" | "0341" | "0342" | "0343" | "0344" | "0345" | "0346" | "0350" | "0351" | "0352" | "0353" | "0354" | "0355" | "0356" | "0360" | "0361" | "0362" | "0363" | "0364" | "0365" | "0366" | "0400" | "0401" | "0402" | "0403" | "0404" | "0405" | "0406" | "0410" | "0411" | "0412" | "0413" | "0414" | "0415" | "0416" | "0420" | "0421" | "0422" | "0423" | "0424" | "0425" | "0426" | "0430" | "0431" | "0432" | "0433" | "0434" | "0435" | "0436" | "0440" | "0441" | "0442" | "0443" | "0444" | "0445" | "0446" | "0450" | "0451" | "0452" | "0453" | "0454" | "0455" | "0456" | "0460" | "0461" | "0462" | "0463" | "0464" | "0465" | "0466" | "0500" | "0501" | "0502" | "0503" | "0504" | "0505" | "0506" | "0510" | "0511" | "0512" | "0513" | "0514" | "0515" | "0516" | "0520" | "0521" | "0522" | "0523" | "0524" | "0525" | "0526" | "0530" | "0531" | "0532" | "0533" | "0534" | "0535" | "0536" | "0540" | "0541" | "0542" | "0543" | "0544" | "0545" | "0546" | "0550" | "0551" | "0552" | "0553" | "0554" | "0555" | "0556" | "0560" | "0561" | "0562" | "0563" | "0564" | "0565" | "0566" | "0600" | "0601" | "0602" | "0603" | "0604" | "0605" | "0606" | "0610" | "0611" | "0612" | "0613" | "0614" | "0615" | "0616" | "0620" | "0621" | "0622" | "0623" | "0624" | "0625" | "0626" | "0630" | "0631" | "0632" | "0633" | "0634" | "0635" | "0636" | "0640" | "0641" | "0642" | "0643" | "0644" | "0645" | "0646" | "0650" | "0651" | "0652" | "0653" | "0654" | "0655" | "0656" | "0660" | "0661" | "0662" | "0663" | "0664" | "0665" | "0666" | "1000" | "1001" | "1002" | "1003" | "1004" | "1005" | "1006" | "1010" | "1011" | "1012" | "1013" | "1014" | "1015" | "1016" | "1020" | "1021" | "1022" | "1023" | "1024" | "1025" | "1026" | "1030" | "1031" | "1032" | "1033" | "1034" | "1035" | "1036" | "1040" | "1041" | "1042" | "1043" | "1044" | "1045" | "1046" | "1050" | "1051" | "1052" | "1053" | "1054" | "1055" | "1056" | "1060" | "1061" | "1062" | "1063" | "1064" | "1065" | "1066" | "1100" | "1101" | "1102" | "1103" | "1104" | "1105" | "1106" | "1110" | "1111" | "1112" | "1113" | "1114" | "1115" | "1116" | "1120" | "1121" | "1122" | "1123" | "1124" | "1125" | "1126" | "1130" | "1131" | "1132" | "1133" | "1134" | "1135" | "1136" | "1140" | "1141" | "1142" | "1143" | "1144" | "1145" | "1146" | "1150" | "1151" | "1152" | "1153" | "1154" | "1155" | "1156" | "1160" | "1161" | "1162" | "1163" | "1164" | "1165" | "1166" | "1200" | "1201" | "1202" | "1203" | "1204" | "1205" | "1206" | "1210" | "1211" | "1212" | "1213" | "1214" | "1215" | "1216" | "1220" | "1221" | "1222" | "1223" | "1224" | "1225" | "1226" | "1230" | "1231" | "1232" | "1233" | "1234" | "1235" | "1236" | "1240" | "1241" | "1242" | "1243" | "1244" | "1245" | "1246" | "1250" | "1251" | "1252" | "1253" | "1254" | "1255" | "1256" | "1260" | "1261" | "1262" | "1263" | "1264" | "1265" | "1266" | "1300" | "1301" | "1302" | "1303" | "1304" | "1305" | "1306" | "1310" | "1311" | "1312" | "1313" | "1314" | "1315" | "1316" | "1320" | "1321" | "1322" | "1323" | "1324" | "1325" | "1326" | "1330" | "1331" | "1332" | "1333" | "1334" | "1335" | "1336" | "1340" | "1341" | "1342" | "1343" | "1344" | "1345" | "1346" | "1350" | "1351" | "1352" | "1353" | "1354" | "1355" | "1356" | "1360" | "1361" | "1362" | "1363" | "1364" | "1365" | "1366" | "1400" | "1401" | "1402" | "1403" | "1404" | "1405" | "1406" | "1410" | "1411" | "1412" | "1413" | "1414" | "1415" | "1416" | "1420" | "1421" | "1422" | "1423" | "1424" | "1425" | "1426" | "1430" | "1431" | "1432" | "1433" | "1434" | "1435" | "1436" | "1440" | "1441" | "1442" | "1443" | "1444" | "1445" | "1446" | "1450" | "1451" | "1452" | "1453" | "1454" | "1455" | "1456" | "1460" | "1461" | "1462" | "1463" | "1464" | "1465" | "1466" | "1500" | "1501" | "1502" | "1503" | "1504" | "1505" | "1506" | "1510" | "1511" | "1512" | "1513" | "1514" | "1515" | "1516" | "1520" | "1521" | "1522" | "1523" | "1524" | "1525" | "1526" | "1530" | "1531" | "1532" | "1533" | "1534" | "1535" | "1536" | "1540" | "1541" | "1542" | "1543" | "1544" | "1545" | "1546" | "1550" | "1551" | "1552" | "1553" | "1554" | "1555" | "1556" | "1560" | "1561" | "1562" | "1563" | "1564" | "1565" | "1566" | "1600" | "1601" | "1602" | "1603" | "1604" | "1605" | "1606" | "1610" | "1611" | "1612" | "1613" | "1614" | "1615" | "1616" | "1620" | "1621" | "1622" | "1623" | "1624" | "1625" | "1626" | "1630" | "1631" | "1632" | "1633" | "1634" | "1635" | "1636" | "1640" | "1641" | "1642" | "1643" | "1644" | "1645" | "1646" | "1650" | "1651" | "1652" | "1653" | "1654" | "1655" | "1656" | "1660" | "1661" | "1662" | "1663" | "1664" | "1665" | "1666" | "2000" | "2001" | "2002" | "2003" | "2004" | "2005" | "2006" | "2010" | "2011" | "2012" | "2013" | "2014" | "2015" | "2016" | "2020" | "2021" | "2022" | "2023" | "2024" | "2025" | "2026" | "2030" | "2031" | "2032" | "2033" | "2034" | "2035" | "2036" | "2040" | "2041" | "2042" | "2043" | "2044" | "2045" | "2046" | "2050" | "2051" | "2052" | "2053" | "2054" | "2055" | "2056" | "2060" | "2061" | "2062" | "2063" | "2064" | "2065" | "2066" | "2100" | "2101" | "2102" | "2103" | "2104" | "2105" | "2106" | "2110" | "2111" | "2112" | "2113" | "2114" | "2115" | "2116" | "2120" | "2121" | "2122" | "2123" | "2124" | "2125" | "2126" | "2130" | "2131" | "2132" | "2133" | "2134" | "2135" | "2136" | "2140" | "2141" | "2142" | "2143" | "2144" | "2145" | "2146" | "2150" | "2151" | "2152" | "2153" | "2154" | "2155" | "2156" | "2160" | "2161" | "2162" | "2163" | "2164" | "2165" | "2166" | "2200" | "2201" | "2202" | "2203" | "2204" | "2205" | "2206" | "2210" | "2211" | "2212" | "2213" | "2214" | "2215" | "2216" | "2220" | "2221" | "2222" | "2223" | "2224" | "2225" | "2226" | "2230" | "2231" | "2232" | "2233" | "2234" | "2235" | "2236" | "2240" | "2241" | "2242" | "2243" | "2244" | "2245" | "2246" | "2250" | "2251" | "2252" | "2253" | "2254" | "2255" | "2256" | "2260" | "2261" | "2262" | "2263" | "2264" | "2265" | "2266" | "2300" | "2301" | "2302" | "2303" | "2304" | "2305" | "2306" | "2310" | "2311" | "2312" | "2313" | "2314" | "2315" | "2316" | "2320" | "2321" | "2322" | "2323" | "2324" | "2325" | "2326" | "2330" | "2331" | "2332" | "2333" | "2334" | "2335" | "2336" | "2340" | "2341" | "2342" | "2343" | "2344" | "2345" | "2346" | "2350" | "2351" | "2352" | "2353" | "2354" | "2355" | "2356" | "2360" | "2361" | "2362" | "2363" | "2364" | "2365" | "2366" | "2400" | "2401" | "2402" | "2403" | "2404" | "2405" | "2406" | "2410" | "2411" | "2412" | "2413" | "2414" | "2415" | "2416" | "2420" | "2421" | "2422" | "2423" | "2424" | "2425" | "2426" | "2430" | "2431" | "2432" | "2433" | "2434" | "2435" | "2436" | "2440" | "2441" | "2442" | "2443" | "2444" | "2445" | "2446" | "2450" | "2451" | "2452" | "2453" | "2454" | "2455" | "2456" | "2460" | "2461" | "2462" | "2463" | "2464" | "2465" | "2466" | "2500" | "2501" | "2502" | "2503" | "2504" | "2505" | "2506" | "2510" | "2511" | "2512" | "2513" | "2514" | "2515" | "2516" | "2520" | "2521" | "2522" | "2523" | "2524" | "2525" | "2526" | "2530" | "2531" | "2532" | "2533" | "2534" | "2535" | "2536" | "2540" | "2541" | "2542" | "2543" | "2544" | "2545" | "2546" | "2550" | "2551" | "2552" | "2553" | "2554" | "2555" | "2556" | "2560" | "2561" | "2562" | "2563" | "2564" | "2565" | "2566" | "2600" | "2601" | "2602" | "2603" | "2604" | "2605" | "2606" | "2610" | "2611" | "2612" | "2613" | "2614" | "2615" | "2616" | "2620" | "2621" | "2622" | "2623" | "2624" | "2625" | "2626" | "2630" | "2631" | "2632" | "2633" | "2634" | "2635" | "2636" | "2640" | "2641" | "2642" | "2643" | "2644" | "2645" | "2646" | "2650" | "2651" | "2652" | "2653" | "2654" | "2655" | "2656" | "2660" | "2661" | "2662" | "2663" | "2664" | "2665" | "2666" | "3000" | "3001" | "3002" | "3003" | "3004" | "3005" | "3006" | "3010" | "3011" | "3012" | "3013" | "3014" | "3015" | "3016" | "3020" | "3021" | "3022" | "3023" | "3024" | "3025" | "3026" | "3030" | "3031" | "3032" | "3033" | "3034" | "3035" | "3036" | "3040" | "3041" | "3042" | "3043" | "3044" | "3045" | "3046" | "3050" | "3051" | "3052" | "3053" | "3054" | "3055" | "3056" | "3060" | "3061" | "3062" | "3063" | "3064" | "3065" | "3066" | "3100" | "3101" | "3102" | "3103" | "3104" | "3105" | "3106" | "3110" | "3111" | "3112" | "3113" | "3114" | "3115" | "3116" | "3120" | "3121" | "3122" | "3123" | "3124" | "3125" | "3126" | "3130" | "3131" | "3132" | "3133" | "3134" | "3135" | "3136" | "3140" | "3141" | "3142" | "3143" | "3144" | "3145" | "3146" | "3150" | "3151" | "3152" | "3153" | "3154" | "3155" | "3156" | "3160" | "3161" | "3162" | "3163" | "3164" | "3165" | "3166" | "3200" | "3201" | "3202" | "3203" | "3204" | "3205" | "3206" | "3210" | "3211" | "3212" | "3213" | "3214" | "3215" | "3216" | "3220" | "3221" | "3222" | "3223" | "3224" | "3225" | "3226" | "3230" | "3231" | "3232" | "3233" | "3234" | "3235" | "3236" | "3240" | "3241" | "3242" | "3243" | "3244" | "3245" | "3246" | "3250" | "3251" | "3252" | "3253" | "3254" | "3255" | "3256" | "3260" | "3261" | "3262" | "3263" | "3264" | "3265" | "3266" | "3300" | "3301" | "3302" | "3303" | "3304" | "3305" | "3306" | "3310" | "3311" | "3312" | "3313" | "3314" | "3315" | "3316" | "3320" | "3321" | "3322" | "3323" | "3324" | "3325" | "3326" | "3330" | "3331" | "3332" | "3333" | "3334" | "3335" | "3336" | "3340" | "3341" | "3342" | "3343" | "3344" | "3345" | "3346" | "3350" | "3351" | "3352" | "3353" | "3354" | "3355" | "3356" | "3360" | "3361" | "3362" | "3363" | "3364" | "3365" | "3366" | "3400" | "3401" | "3402" | "3403" | "3404" | "3405" | "3406" | "3410" | "3411" | "3412" | "3413" | "3414" | "3415" | "3416" | "3420" | "3421" | "3422" | "3423" | "3424" | "3425" | "3426" | "3430" | "3431" | "3432" | "3433" | "3434" | "3435" | "3436" | "3440" | "3441" | "3442" | "3443" | "3444" | "3445" | "3446" | "3450" | "3451" | "3452" | "3453" | "3454" | "3455" | "3456" | "3460" | "3461" | "3462" | "3463" | "3464" | "3465" | "3466" | "3500" | "3501" | "3502" | "3503" | "3504" | "3505" | "3506" | "3510" | "3511" | "3512" | "3513" | "3514" | "3515" | "3516" | "3520" | "3521" | "3522" | "3523" | "3524" | "3525" | "3526" | "3530" | "3531" | "3532" | "3533" | "3534" | "3535" | "3536" | "3540" | "3541" | "3542" | "3543" | "3544" | "3545" | "3546" | "3550" | "3551" | "3552" | "3553" | "3554" | "3555" | "3556" | "3560" | "3561" | "3562" | "3563" | "3564" | "3565" | "3566" | "3600" | "3601" | "3602" | "3603" | "3604" | "3605" | "3606" | "3610" | "3611" | "3612" | "3613" | "3614" | "3615" | "3616" | "3620" | "3621" | "3622" | "3623" | "3624" | "3625" | "3626" | "3630" | "3631" | "3632" | "3633" | "3634" | "3635" | "3636" | "3640" | "3641" | "3642" | "3643" | "3644" | "3645" | "3646" | "3650" | "3651" | "3652" | "3653" | "3654" | "3655" | "3656" | "3660" | "3661" | "3662" | "3663" | "3664" | "3665" | "3666" | "4000" | "4001" | "4002" | "4003" | "4004" | "4005" | "4006" | "4010" | "4011" | "4012" | "4013" | "4014" | "4015" | "4016" | "4020" | "4021" | "4022" | "4023" | "4024" | "4025" | "4026" | "4030" | "4031" | "4032" | "4033" | "4034" | "4035" | "4036" | "4040" | "4041" | "4042" | "4043" | "4044" | "4045" | "4046" | "4050" | "4051" | "4052" | "4053" | "4054" | "4055" | "4056" | "4060" | "4061" | "4062" | "4063" | "4064" | "4065" | "4066" | "4100" | "4101" | "4102" | "4103" | "4104" | "4105" | "4106" | "4110" | "4111" | "4112" | "4113" | "4114" | "4115" | "4116" | "4120" | "4121" | "4122" | "4123" | "4124" | "4125" | "4126" | "4130" | "4131" | "4132" | "4133" | "4134" | "4135" | "4136" | "4140" | "4141" | "4142" | "4143" | "4144" | "4145" | "4146" | "4150" | "4151" | "4152" | "4153" | "4154" | "4155" | "4156" | "4160" | "4161" | "4162" | "4163" | "4164" | "4165" | "4166" | "4200" | "4201" | "4202" | "4203" | "4204" | "4205" | "4206" | "4210" | "4211" | "4212" | "4213" | "4214" | "4215" | "4216" | "4220" | "4221" | "4222" | "4223" | "4224" | "4225" | "4226" | "4230" | "4231" | "4232" | "4233" | "4234" | "4235" | "4236" | "4240" | "4241" | "4242" | "4243" | "4244" | "4245" | "4246" | "4250" | "4251" | "4252" | "4253" | "4254" | "4255" | "4256" | "4260" | "4261" | "4262" | "4263" | "4264" | "4265" | "4266" | "4300" | "4301" | "4302" | "4303" | "4304" | "4305" | "4306" | "4310" | "4311" | "4312" | "4313" | "4314" | "4315" | "4316" | "4320" | "4321" | "4322" | "4323" | "4324" | "4325" | "4326" | "4330" | "4331" | "4332" | "4333" | "4334" | "4335" | "4336" | "4340" | "4341" | "4342" | "4343" | "4344" | "4345" | "4346" | "4350" | "4351" | "4352" | "4353" | "4354" | "4355" | "4356" | "4360" | "4361" | "4362" | "4363" | "4364" | "4365" | "4366" | "4400" | "4401" | "4402" | "4403" | "4404" | "4405" | "4406" | "4410" | "4411" | "4412" | "4413" | "4414" | "4415" | "4416" | "4420" | "4421" | "4422" | "4423" | "4424" | "4425" | "4426" | "4430" | "4431" | "4432" | "4433" | "4434" | "4435" | "4436" | "4440" | "4441" | "4442" | "4443" | "4444" | "4445" | "4446" | "4450" | "4451" | "4452" | "4453" | "4454" | "4455" | "4456" | "4460" | "4461" | "4462" | "4463" | "4464" | "4465" | "4466" | "4500" | "4501" | "4502" | "4503" | "4504" | "4505" | "4506" | "4510" | "4511" | "4512" | "4513" | "4514" | "4515" | "4516" | "4520" | "4521" | "4522" | "4523" | "4524" | "4525" | "4526" | "4530" | "4531" | "4532" | "4533" | "4534" | "4535" | "4536" | "4540" | "4541" | "4542" | "4543" | "4544" | "4545" | "4546" | "4550" | "4551" | "4552" | "4553" | "4554" | "4555" | "4556" | "4560" | "4561" | "4562" | "4563" | "4564" | "4565" | "4566" | "4600" | "4601" | "4602" | "4603" | "4604" | "4605" | "4606" | "4610" | "4611" | "4612" | "4613" | "4614" | "4615" | "4616" | "4620" | "4621" | "4622" | "4623" | "4624" | "4625" | "4626" | "4630" | "4631" | "4632" | "4633" | "4634" | "4635" | "4636" | "4640" | "4641" | "4642" | "4643" | "4644" | "4645" | "4646" | "4650" | "4651" | "4652" | "4653" | "4654" | "4655" | "4656" | "4660" | "4661" | "4662" | "4663" | "4664" | "4665" | "4666" | "5000" | "5001" | "5002" | "5003" | "5004" | "5005" | "5006" | "5010" | "5011" | "5012" | "5013" | "5014" | "5015" | "5016" | "5020" | "5021" | "5022" | "5023" | "5024" | "5025" | "5026" | "5030" | "5031" | "5032" | "5033" | "5034" | "5035" | "5036" | "5040" | "5041" | "5042" | "5043" | "5044" | "5045" | "5046" | "5050" | "5051" | "5052" | "5053" | "5054" | "5055" | "5056" | "5060" | "5061" | "5062" | "5063" | "5064" | "5065" | "5066" | "5100" | "5101" | "5102" | "5103" | "5104" | "5105" | "5106" | "5110" | "5111" | "5112" | "5113" | "5114" | "5115" | "5116" | "5120" | "5121" | "5122" | "5123" | "5124" | "5125" | "5126" | "5130" | "5131" | "5132" | "5133" | "5134" | "5135" | "5136" | "5140" | "5141" | "5142" | "5143" | "5144" | "5145" | "5146" | "5150" | "5151" | "5152" | "5153" | "5154" | "5155" | "5156" | "5160" | "5161" | "5162" | "5163" | "5164" | "5165" | "5166" | "5200" | "5201" | "5202" | "5203" | "5204" | "5205" | "5206" | "5210" | "5211" | "5212" | "5213" | "5214" | "5215" | "5216" | "5220" | "5221" | "5222" | "5223" | "5224" | "5225" | "5226" | "5230" | "5231" | "5232" | "5233" | "5234" | "5235" | "5236" | "5240" | "5241" | "5242" | "5243" | "5244" | "5245" | "5246" | "5250" | "5251" | "5252" | "5253" | "5254" | "5255" | "5256" | "5260" | "5261" | "5262" | "5263" | "5264" | "5265" | "5266" | "5300" | "5301" | "5302" | "5303" | "5304" | "5305" | "5306" | "5310" | "5311" | "5312" | "5313" | "5314" | "5315" | "5316" | "5320" | "5321" | "5322" | "5323" | "5324" | "5325" | "5326" | "5330" | "5331" | "5332" | "5333" | "5334" | "5335" | "5336" | "5340" | "5341" | "5342" | "5343" | "5344" | "5345" | "5346" | "5350" | "5351" | "5352" | "5353" | "5354" | "5355" | "5356" | "5360" | "5361" | "5362" | "5363" | "5364" | "5365" | "5366" | "5400" | "5401" | "5402" | "5403" | "5404" | "5405" | "5406" | "5410" | "5411" | "5412" | "5413" | "5414" | "5415" | "5416" | "5420" | "5421" | "5422" | "5423" | "5424" | "5425" | "5426" | "5430" | "5431" | "5432" | "5433" | "5434" | "5435" | "5436" | "5440" | "5441" | "5442" | "5443" | "5444" | "5445" | "5446" | "5450" | "5451" | "5452" | "5453" | "5454" | "5455" | "5456" | "5460" | "5461" | "5462" | "5463" | "5464" | "5465" | "5466" | "5500" | "5501" | "5502" | "5503" | "5504" | "5505" | "5506" | "5510" | "5511" | "5512" | "5513" | "5514" | "5515" | "5516" | "5520" | "5521" | "5522" | "5523" | "5524" | "5525" | "5526" | "5530" | "5531" | "5532" | "5533" | "5534" | "5535" | "5536" | "5540" | "5541" | "5542" | "5543" | "5544" | "5545" | "5546" | "5550" | "5551" | "5552" | "5553" | "5554" | "5555" | "5556" | "5560" | "5561" | "5562" | "5563" | "5564" | "5565" | "5566" | "5600" | "5601" | "5602" | "5603" | "5604" | "5605" | "5606" | "5610" | "5611" | "5612" | "5613" | "5614" | "5615" | "5616" | "5620" | "5621" | "5622" | "5623" | "5624" | "5625" | "5626" | "5630" | "5631" | "5632" | "5633" | "5634" | "5635" | "5636" | "5640" | "5641" | "5642" | "5643" | "5644" | "5645" | "5646" | "5650" | "5651" | "5652" | "5653" | "5654" | "5655" | "5656" | "5660" | "5661" | "5662" | "5663" | "5664" | "5665" | "5666" | undefined) & T2 + +declare const y: T1 & T2; +>y : T1 & T2 + +x = y; +>x = y : T1 & T2 +>x : T1 | null +>y : T1 & T2 + diff --git a/tsc/testdata/baselines/reference/compiler/relationCycleNonMonotoneCheckOrder(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/relationCycleNonMonotoneCheckOrder(checkorder=default).errors.txt new file mode 100644 index 0000000000000..e733a24979f0e --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/relationCycleNonMonotoneCheckOrder(checkorder=default).errors.txt @@ -0,0 +1,104 @@ +relationCycleNonMonotoneCheckOrder.ts(43,9): error TS2322: Type 'S2' is not assignable to type 'G2'. + Type '"d" | undefined' is not assignable to type '"d" | G1'. + Type 'undefined' is not assignable to type '"d" | G1'. + + +==== relationCycleNonMonotoneCheckOrder.ts (1 errors) ==== + // 'S' relates to 'G' only if inferring 'T' from 'A' fails the constraint + // 'C', so that 'T' falls back to 'C'. Relating 'A' to 'C' compares 'S' to + // 'G' again, but 'A' fails 'C' on 'z' regardless. 'S' must relate to 'G' + // whether or not 'A' was compared to 'C' first. + namespace inferenceConstraint { + type A = { k?: "c"; f: S | G; z: number }; + type C = { [s: string]: "c" | G | number; f: G; z: 1 }; + type S = (x: T) => T["k"]; + type G = (x: A) => "c" | G | number; + + declare let r1: S extends G ? true : false; + declare let r2: A extends C ? true : false; + } + + // As above, with method signatures, which are compared bivariantly. + namespace inferenceConstraintMethod { + type A = { k?: "c"; f: S | G; z: number }; + type C = { [s: string]: "c" | G | number; f: G; z: 1 }; + type S = { m(x: T): T["k"] }; + type G = { m(x: A): "c" | G | number }; + + declare let r1: S extends G ? true : false; + declare let r2: A extends C ? true : false; + } + + // 'S1' relates to 'G1' only if 'S2' does not relate to 'G2', and the + // reverse, so no answer is consistent for both. Each is answered as if + // compared first, assuming itself while relating the other, regardless + // of which assignment is checked first. + namespace inferenceConstraintMutual { + type A1 = { k?: "c"; f: S2 | G2 }; + type C1 = { [s: string]: "c" | G2; f: G2 }; + type S1 = (x: T) => T["k"]; + type G1 = (x: A1) => "c" | G2; + type A2 = { k?: "d"; f: S1 | G1 }; + type C2 = { [s: string]: "d" | G1; f: G1 }; + type S2 = (x: T) => T["k"]; + type G2 = (x: A2) => "d" | G1; + + declare let s1: S1; + declare let s2: S2; + let g1: G1 = s1; + let g2: G2 = s2; + ~~ +!!! error TS2322: Type 'S2' is not assignable to type 'G2'. +!!! error TS2322: Type '"d" | undefined' is not assignable to type '"d" | G1'. +!!! error TS2322: Type 'undefined' is not assignable to type '"d" | G1'. + declare let r1: S1 extends G1 ? true : false; + declare let r2: S2 extends G2 ? true : false; + } + + // 'Src' relates to the union 'Tgt' by discriminating on 'd'. The member + // '{ d: Y; y: number }' matches 'd: X' only if 'X' relates to 'Y', and + // relating 'X' to 'Y' compares 'Src' to 'Tgt' again before failing on + // 'q'. 'Src' must relate to 'Tgt' whether or not 'X' was compared to 'Y' + // first. + namespace discriminated { + interface X { p: Src; q: number } + interface Y { p: Tgt; q: 1 } + type Src = { d: "a" | X; y: string }; + type Tgt = { d: "a"; y: string } | { d: X; y: string } | { d: Y; y: number }; + + declare let r1: Src extends Tgt ? true : false; + declare let r2: X extends Y ? true : false; + } + + // The excess property check of the object literal keeps the members of + // 'Outer' whose 'e' the literal's 'e' relates to, so 'w' is known only + // if 'Src' relates to 'Tgt' as above. + namespace excessPropertyDiscriminant { + interface X { p: Src; q: number } + interface Y { p: Tgt; q: 1 } + type Src = { d: "a" | X; y: string }; + type Tgt = { d: "a"; y: string } | { d: X; y: string } | { d: Y; y: number }; + type Outer = { e: "z" } | { e: Tgt; w: number } | { e: Src }; + + declare let src: Src; + let o: Outer = { e: src, w: 1 }; + declare let r2: X extends Y ? true : false; + } + + // Subtype reduction drops 'F' if it is a strict subtype of 'G'. Its + // optional parameter relates only if 'P' is not a strict subtype of 'Q', + // and relating 'P' to 'Q' compares 'F' to 'G' again before failing on + // 'z'. 'F' must be dropped whether or not 'P' was compared to 'Q' first. + namespace strictArity { + type P = { f: F | G; z: number }; + type Q = { f: G; z: 1 }; + type F = (x?: P) => 1; + type G = (x: Q | undefined) => number; + type WP = { a: P; b: string }; + type WQ = { a: Q }; + + declare let f: F, g: G, wp: WP, wq: WQ; + let a1 = [f, g]; + let a2 = [wp, wq]; + } + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/relationCycleNonMonotoneCheckOrder(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/relationCycleNonMonotoneCheckOrder(checkorder=default).symbols new file mode 100644 index 0000000000000..3bc451c9c78bc --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/relationCycleNonMonotoneCheckOrder(checkorder=default).symbols @@ -0,0 +1,361 @@ +//// [tests/cases/compiler/relationCycleNonMonotoneCheckOrder.ts] //// + +=== relationCycleNonMonotoneCheckOrder.ts === +// 'S' relates to 'G' only if inferring 'T' from 'A' fails the constraint +// 'C', so that 'T' falls back to 'C'. Relating 'A' to 'C' compares 'S' to +// 'G' again, but 'A' fails 'C' on 'z' regardless. 'S' must relate to 'G' +// whether or not 'A' was compared to 'C' first. +namespace inferenceConstraint { +>inferenceConstraint : Symbol(inferenceConstraint, Decl(relationCycleNonMonotoneCheckOrder.ts, 0, 0)) + + type A = { k?: "c"; f: S | G; z: number }; +>A : Symbol(A, Decl(relationCycleNonMonotoneCheckOrder.ts, 4, 31)) +>k : Symbol(k, Decl(relationCycleNonMonotoneCheckOrder.ts, 5, 14)) +>f : Symbol(f, Decl(relationCycleNonMonotoneCheckOrder.ts, 5, 23)) +>S : Symbol(S, Decl(relationCycleNonMonotoneCheckOrder.ts, 6, 59)) +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 7, 43)) +>z : Symbol(z, Decl(relationCycleNonMonotoneCheckOrder.ts, 5, 33)) + + type C = { [s: string]: "c" | G | number; f: G; z: 1 }; +>C : Symbol(C, Decl(relationCycleNonMonotoneCheckOrder.ts, 5, 46)) +>s : Symbol(s, Decl(relationCycleNonMonotoneCheckOrder.ts, 6, 16)) +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 7, 43)) +>f : Symbol(f, Decl(relationCycleNonMonotoneCheckOrder.ts, 6, 45)) +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 7, 43)) +>z : Symbol(z, Decl(relationCycleNonMonotoneCheckOrder.ts, 6, 51)) + + type S = (x: T) => T["k"]; +>S : Symbol(S, Decl(relationCycleNonMonotoneCheckOrder.ts, 6, 59)) +>T : Symbol(T, Decl(relationCycleNonMonotoneCheckOrder.ts, 7, 14)) +>C : Symbol(C, Decl(relationCycleNonMonotoneCheckOrder.ts, 5, 46)) +>x : Symbol(x, Decl(relationCycleNonMonotoneCheckOrder.ts, 7, 27)) +>T : Symbol(T, Decl(relationCycleNonMonotoneCheckOrder.ts, 7, 14)) +>T : Symbol(T, Decl(relationCycleNonMonotoneCheckOrder.ts, 7, 14)) + + type G = (x: A) => "c" | G | number; +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 7, 43)) +>x : Symbol(x, Decl(relationCycleNonMonotoneCheckOrder.ts, 8, 14)) +>A : Symbol(A, Decl(relationCycleNonMonotoneCheckOrder.ts, 4, 31)) +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 7, 43)) + + declare let r1: S extends G ? true : false; +>r1 : Symbol(r1, Decl(relationCycleNonMonotoneCheckOrder.ts, 10, 15)) +>S : Symbol(S, Decl(relationCycleNonMonotoneCheckOrder.ts, 6, 59)) +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 7, 43)) + + declare let r2: A extends C ? true : false; +>r2 : Symbol(r2, Decl(relationCycleNonMonotoneCheckOrder.ts, 11, 15)) +>A : Symbol(A, Decl(relationCycleNonMonotoneCheckOrder.ts, 4, 31)) +>C : Symbol(C, Decl(relationCycleNonMonotoneCheckOrder.ts, 5, 46)) +} + +// As above, with method signatures, which are compared bivariantly. +namespace inferenceConstraintMethod { +>inferenceConstraintMethod : Symbol(inferenceConstraintMethod, Decl(relationCycleNonMonotoneCheckOrder.ts, 12, 1)) + + type A = { k?: "c"; f: S | G; z: number }; +>A : Symbol(A, Decl(relationCycleNonMonotoneCheckOrder.ts, 15, 37)) +>k : Symbol(k, Decl(relationCycleNonMonotoneCheckOrder.ts, 16, 14)) +>f : Symbol(f, Decl(relationCycleNonMonotoneCheckOrder.ts, 16, 23)) +>S : Symbol(S, Decl(relationCycleNonMonotoneCheckOrder.ts, 17, 59)) +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 18, 46)) +>z : Symbol(z, Decl(relationCycleNonMonotoneCheckOrder.ts, 16, 33)) + + type C = { [s: string]: "c" | G | number; f: G; z: 1 }; +>C : Symbol(C, Decl(relationCycleNonMonotoneCheckOrder.ts, 16, 46)) +>s : Symbol(s, Decl(relationCycleNonMonotoneCheckOrder.ts, 17, 16)) +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 18, 46)) +>f : Symbol(f, Decl(relationCycleNonMonotoneCheckOrder.ts, 17, 45)) +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 18, 46)) +>z : Symbol(z, Decl(relationCycleNonMonotoneCheckOrder.ts, 17, 51)) + + type S = { m(x: T): T["k"] }; +>S : Symbol(S, Decl(relationCycleNonMonotoneCheckOrder.ts, 17, 59)) +>m : Symbol(m, Decl(relationCycleNonMonotoneCheckOrder.ts, 18, 14)) +>T : Symbol(T, Decl(relationCycleNonMonotoneCheckOrder.ts, 18, 17)) +>C : Symbol(C, Decl(relationCycleNonMonotoneCheckOrder.ts, 16, 46)) +>x : Symbol(x, Decl(relationCycleNonMonotoneCheckOrder.ts, 18, 30)) +>T : Symbol(T, Decl(relationCycleNonMonotoneCheckOrder.ts, 18, 17)) +>T : Symbol(T, Decl(relationCycleNonMonotoneCheckOrder.ts, 18, 17)) + + type G = { m(x: A): "c" | G | number }; +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 18, 46)) +>m : Symbol(m, Decl(relationCycleNonMonotoneCheckOrder.ts, 19, 14)) +>x : Symbol(x, Decl(relationCycleNonMonotoneCheckOrder.ts, 19, 17)) +>A : Symbol(A, Decl(relationCycleNonMonotoneCheckOrder.ts, 15, 37)) +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 18, 46)) + + declare let r1: S extends G ? true : false; +>r1 : Symbol(r1, Decl(relationCycleNonMonotoneCheckOrder.ts, 21, 15)) +>S : Symbol(S, Decl(relationCycleNonMonotoneCheckOrder.ts, 17, 59)) +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 18, 46)) + + declare let r2: A extends C ? true : false; +>r2 : Symbol(r2, Decl(relationCycleNonMonotoneCheckOrder.ts, 22, 15)) +>A : Symbol(A, Decl(relationCycleNonMonotoneCheckOrder.ts, 15, 37)) +>C : Symbol(C, Decl(relationCycleNonMonotoneCheckOrder.ts, 16, 46)) +} + +// 'S1' relates to 'G1' only if 'S2' does not relate to 'G2', and the +// reverse, so no answer is consistent for both. Each is answered as if +// compared first, assuming itself while relating the other, regardless +// of which assignment is checked first. +namespace inferenceConstraintMutual { +>inferenceConstraintMutual : Symbol(inferenceConstraintMutual, Decl(relationCycleNonMonotoneCheckOrder.ts, 23, 1)) + + type A1 = { k?: "c"; f: S2 | G2 }; +>A1 : Symbol(A1, Decl(relationCycleNonMonotoneCheckOrder.ts, 29, 37)) +>k : Symbol(k, Decl(relationCycleNonMonotoneCheckOrder.ts, 30, 15)) +>f : Symbol(f, Decl(relationCycleNonMonotoneCheckOrder.ts, 30, 24)) +>S2 : Symbol(S2, Decl(relationCycleNonMonotoneCheckOrder.ts, 35, 47)) +>G2 : Symbol(G2, Decl(relationCycleNonMonotoneCheckOrder.ts, 36, 45)) + + type C1 = { [s: string]: "c" | G2; f: G2 }; +>C1 : Symbol(C1, Decl(relationCycleNonMonotoneCheckOrder.ts, 30, 38)) +>s : Symbol(s, Decl(relationCycleNonMonotoneCheckOrder.ts, 31, 17)) +>G2 : Symbol(G2, Decl(relationCycleNonMonotoneCheckOrder.ts, 36, 45)) +>f : Symbol(f, Decl(relationCycleNonMonotoneCheckOrder.ts, 31, 38)) +>G2 : Symbol(G2, Decl(relationCycleNonMonotoneCheckOrder.ts, 36, 45)) + + type S1 = (x: T) => T["k"]; +>S1 : Symbol(S1, Decl(relationCycleNonMonotoneCheckOrder.ts, 31, 47)) +>T : Symbol(T, Decl(relationCycleNonMonotoneCheckOrder.ts, 32, 15)) +>C1 : Symbol(C1, Decl(relationCycleNonMonotoneCheckOrder.ts, 30, 38)) +>x : Symbol(x, Decl(relationCycleNonMonotoneCheckOrder.ts, 32, 29)) +>T : Symbol(T, Decl(relationCycleNonMonotoneCheckOrder.ts, 32, 15)) +>T : Symbol(T, Decl(relationCycleNonMonotoneCheckOrder.ts, 32, 15)) + + type G1 = (x: A1) => "c" | G2; +>G1 : Symbol(G1, Decl(relationCycleNonMonotoneCheckOrder.ts, 32, 45)) +>x : Symbol(x, Decl(relationCycleNonMonotoneCheckOrder.ts, 33, 15)) +>A1 : Symbol(A1, Decl(relationCycleNonMonotoneCheckOrder.ts, 29, 37)) +>G2 : Symbol(G2, Decl(relationCycleNonMonotoneCheckOrder.ts, 36, 45)) + + type A2 = { k?: "d"; f: S1 | G1 }; +>A2 : Symbol(A2, Decl(relationCycleNonMonotoneCheckOrder.ts, 33, 34)) +>k : Symbol(k, Decl(relationCycleNonMonotoneCheckOrder.ts, 34, 15)) +>f : Symbol(f, Decl(relationCycleNonMonotoneCheckOrder.ts, 34, 24)) +>S1 : Symbol(S1, Decl(relationCycleNonMonotoneCheckOrder.ts, 31, 47)) +>G1 : Symbol(G1, Decl(relationCycleNonMonotoneCheckOrder.ts, 32, 45)) + + type C2 = { [s: string]: "d" | G1; f: G1 }; +>C2 : Symbol(C2, Decl(relationCycleNonMonotoneCheckOrder.ts, 34, 38)) +>s : Symbol(s, Decl(relationCycleNonMonotoneCheckOrder.ts, 35, 17)) +>G1 : Symbol(G1, Decl(relationCycleNonMonotoneCheckOrder.ts, 32, 45)) +>f : Symbol(f, Decl(relationCycleNonMonotoneCheckOrder.ts, 35, 38)) +>G1 : Symbol(G1, Decl(relationCycleNonMonotoneCheckOrder.ts, 32, 45)) + + type S2 = (x: T) => T["k"]; +>S2 : Symbol(S2, Decl(relationCycleNonMonotoneCheckOrder.ts, 35, 47)) +>T : Symbol(T, Decl(relationCycleNonMonotoneCheckOrder.ts, 36, 15)) +>C2 : Symbol(C2, Decl(relationCycleNonMonotoneCheckOrder.ts, 34, 38)) +>x : Symbol(x, Decl(relationCycleNonMonotoneCheckOrder.ts, 36, 29)) +>T : Symbol(T, Decl(relationCycleNonMonotoneCheckOrder.ts, 36, 15)) +>T : Symbol(T, Decl(relationCycleNonMonotoneCheckOrder.ts, 36, 15)) + + type G2 = (x: A2) => "d" | G1; +>G2 : Symbol(G2, Decl(relationCycleNonMonotoneCheckOrder.ts, 36, 45)) +>x : Symbol(x, Decl(relationCycleNonMonotoneCheckOrder.ts, 37, 15)) +>A2 : Symbol(A2, Decl(relationCycleNonMonotoneCheckOrder.ts, 33, 34)) +>G1 : Symbol(G1, Decl(relationCycleNonMonotoneCheckOrder.ts, 32, 45)) + + declare let s1: S1; +>s1 : Symbol(s1, Decl(relationCycleNonMonotoneCheckOrder.ts, 39, 15)) +>S1 : Symbol(S1, Decl(relationCycleNonMonotoneCheckOrder.ts, 31, 47)) + + declare let s2: S2; +>s2 : Symbol(s2, Decl(relationCycleNonMonotoneCheckOrder.ts, 40, 15)) +>S2 : Symbol(S2, Decl(relationCycleNonMonotoneCheckOrder.ts, 35, 47)) + + let g1: G1 = s1; +>g1 : Symbol(g1, Decl(relationCycleNonMonotoneCheckOrder.ts, 41, 7)) +>G1 : Symbol(G1, Decl(relationCycleNonMonotoneCheckOrder.ts, 32, 45)) +>s1 : Symbol(s1, Decl(relationCycleNonMonotoneCheckOrder.ts, 39, 15)) + + let g2: G2 = s2; +>g2 : Symbol(g2, Decl(relationCycleNonMonotoneCheckOrder.ts, 42, 7)) +>G2 : Symbol(G2, Decl(relationCycleNonMonotoneCheckOrder.ts, 36, 45)) +>s2 : Symbol(s2, Decl(relationCycleNonMonotoneCheckOrder.ts, 40, 15)) + + declare let r1: S1 extends G1 ? true : false; +>r1 : Symbol(r1, Decl(relationCycleNonMonotoneCheckOrder.ts, 43, 15)) +>S1 : Symbol(S1, Decl(relationCycleNonMonotoneCheckOrder.ts, 31, 47)) +>G1 : Symbol(G1, Decl(relationCycleNonMonotoneCheckOrder.ts, 32, 45)) + + declare let r2: S2 extends G2 ? true : false; +>r2 : Symbol(r2, Decl(relationCycleNonMonotoneCheckOrder.ts, 44, 15)) +>S2 : Symbol(S2, Decl(relationCycleNonMonotoneCheckOrder.ts, 35, 47)) +>G2 : Symbol(G2, Decl(relationCycleNonMonotoneCheckOrder.ts, 36, 45)) +} + +// 'Src' relates to the union 'Tgt' by discriminating on 'd'. The member +// '{ d: Y; y: number }' matches 'd: X' only if 'X' relates to 'Y', and +// relating 'X' to 'Y' compares 'Src' to 'Tgt' again before failing on +// 'q'. 'Src' must relate to 'Tgt' whether or not 'X' was compared to 'Y' +// first. +namespace discriminated { +>discriminated : Symbol(discriminated, Decl(relationCycleNonMonotoneCheckOrder.ts, 45, 1)) + + interface X { p: Src; q: number } +>X : Symbol(X, Decl(relationCycleNonMonotoneCheckOrder.ts, 52, 25)) +>p : Symbol(X.p, Decl(relationCycleNonMonotoneCheckOrder.ts, 53, 17)) +>Src : Symbol(Src, Decl(relationCycleNonMonotoneCheckOrder.ts, 54, 32)) +>q : Symbol(X.q, Decl(relationCycleNonMonotoneCheckOrder.ts, 53, 25)) + + interface Y { p: Tgt; q: 1 } +>Y : Symbol(Y, Decl(relationCycleNonMonotoneCheckOrder.ts, 53, 37)) +>p : Symbol(Y.p, Decl(relationCycleNonMonotoneCheckOrder.ts, 54, 17)) +>Tgt : Symbol(Tgt, Decl(relationCycleNonMonotoneCheckOrder.ts, 55, 41)) +>q : Symbol(Y.q, Decl(relationCycleNonMonotoneCheckOrder.ts, 54, 25)) + + type Src = { d: "a" | X; y: string }; +>Src : Symbol(Src, Decl(relationCycleNonMonotoneCheckOrder.ts, 54, 32)) +>d : Symbol(d, Decl(relationCycleNonMonotoneCheckOrder.ts, 55, 16)) +>X : Symbol(X, Decl(relationCycleNonMonotoneCheckOrder.ts, 52, 25)) +>y : Symbol(y, Decl(relationCycleNonMonotoneCheckOrder.ts, 55, 28)) + + type Tgt = { d: "a"; y: string } | { d: X; y: string } | { d: Y; y: number }; +>Tgt : Symbol(Tgt, Decl(relationCycleNonMonotoneCheckOrder.ts, 55, 41)) +>d : Symbol(d, Decl(relationCycleNonMonotoneCheckOrder.ts, 56, 16)) +>y : Symbol(y, Decl(relationCycleNonMonotoneCheckOrder.ts, 56, 24)) +>d : Symbol(d, Decl(relationCycleNonMonotoneCheckOrder.ts, 56, 40)) +>X : Symbol(X, Decl(relationCycleNonMonotoneCheckOrder.ts, 52, 25)) +>y : Symbol(y, Decl(relationCycleNonMonotoneCheckOrder.ts, 56, 46)) +>d : Symbol(d, Decl(relationCycleNonMonotoneCheckOrder.ts, 56, 62)) +>Y : Symbol(Y, Decl(relationCycleNonMonotoneCheckOrder.ts, 53, 37)) +>y : Symbol(y, Decl(relationCycleNonMonotoneCheckOrder.ts, 56, 68)) + + declare let r1: Src extends Tgt ? true : false; +>r1 : Symbol(r1, Decl(relationCycleNonMonotoneCheckOrder.ts, 58, 15)) +>Src : Symbol(Src, Decl(relationCycleNonMonotoneCheckOrder.ts, 54, 32)) +>Tgt : Symbol(Tgt, Decl(relationCycleNonMonotoneCheckOrder.ts, 55, 41)) + + declare let r2: X extends Y ? true : false; +>r2 : Symbol(r2, Decl(relationCycleNonMonotoneCheckOrder.ts, 59, 15)) +>X : Symbol(X, Decl(relationCycleNonMonotoneCheckOrder.ts, 52, 25)) +>Y : Symbol(Y, Decl(relationCycleNonMonotoneCheckOrder.ts, 53, 37)) +} + +// The excess property check of the object literal keeps the members of +// 'Outer' whose 'e' the literal's 'e' relates to, so 'w' is known only +// if 'Src' relates to 'Tgt' as above. +namespace excessPropertyDiscriminant { +>excessPropertyDiscriminant : Symbol(excessPropertyDiscriminant, Decl(relationCycleNonMonotoneCheckOrder.ts, 60, 1)) + + interface X { p: Src; q: number } +>X : Symbol(X, Decl(relationCycleNonMonotoneCheckOrder.ts, 65, 38)) +>p : Symbol(X.p, Decl(relationCycleNonMonotoneCheckOrder.ts, 66, 17)) +>Src : Symbol(Src, Decl(relationCycleNonMonotoneCheckOrder.ts, 67, 32)) +>q : Symbol(X.q, Decl(relationCycleNonMonotoneCheckOrder.ts, 66, 25)) + + interface Y { p: Tgt; q: 1 } +>Y : Symbol(Y, Decl(relationCycleNonMonotoneCheckOrder.ts, 66, 37)) +>p : Symbol(Y.p, Decl(relationCycleNonMonotoneCheckOrder.ts, 67, 17)) +>Tgt : Symbol(Tgt, Decl(relationCycleNonMonotoneCheckOrder.ts, 68, 41)) +>q : Symbol(Y.q, Decl(relationCycleNonMonotoneCheckOrder.ts, 67, 25)) + + type Src = { d: "a" | X; y: string }; +>Src : Symbol(Src, Decl(relationCycleNonMonotoneCheckOrder.ts, 67, 32)) +>d : Symbol(d, Decl(relationCycleNonMonotoneCheckOrder.ts, 68, 16)) +>X : Symbol(X, Decl(relationCycleNonMonotoneCheckOrder.ts, 65, 38)) +>y : Symbol(y, Decl(relationCycleNonMonotoneCheckOrder.ts, 68, 28)) + + type Tgt = { d: "a"; y: string } | { d: X; y: string } | { d: Y; y: number }; +>Tgt : Symbol(Tgt, Decl(relationCycleNonMonotoneCheckOrder.ts, 68, 41)) +>d : Symbol(d, Decl(relationCycleNonMonotoneCheckOrder.ts, 69, 16)) +>y : Symbol(y, Decl(relationCycleNonMonotoneCheckOrder.ts, 69, 24)) +>d : Symbol(d, Decl(relationCycleNonMonotoneCheckOrder.ts, 69, 40)) +>X : Symbol(X, Decl(relationCycleNonMonotoneCheckOrder.ts, 65, 38)) +>y : Symbol(y, Decl(relationCycleNonMonotoneCheckOrder.ts, 69, 46)) +>d : Symbol(d, Decl(relationCycleNonMonotoneCheckOrder.ts, 69, 62)) +>Y : Symbol(Y, Decl(relationCycleNonMonotoneCheckOrder.ts, 66, 37)) +>y : Symbol(y, Decl(relationCycleNonMonotoneCheckOrder.ts, 69, 68)) + + type Outer = { e: "z" } | { e: Tgt; w: number } | { e: Src }; +>Outer : Symbol(Outer, Decl(relationCycleNonMonotoneCheckOrder.ts, 69, 81)) +>e : Symbol(e, Decl(relationCycleNonMonotoneCheckOrder.ts, 70, 18)) +>e : Symbol(e, Decl(relationCycleNonMonotoneCheckOrder.ts, 70, 31)) +>Tgt : Symbol(Tgt, Decl(relationCycleNonMonotoneCheckOrder.ts, 68, 41)) +>w : Symbol(w, Decl(relationCycleNonMonotoneCheckOrder.ts, 70, 39)) +>e : Symbol(e, Decl(relationCycleNonMonotoneCheckOrder.ts, 70, 55)) +>Src : Symbol(Src, Decl(relationCycleNonMonotoneCheckOrder.ts, 67, 32)) + + declare let src: Src; +>src : Symbol(src, Decl(relationCycleNonMonotoneCheckOrder.ts, 72, 15)) +>Src : Symbol(Src, Decl(relationCycleNonMonotoneCheckOrder.ts, 67, 32)) + + let o: Outer = { e: src, w: 1 }; +>o : Symbol(o, Decl(relationCycleNonMonotoneCheckOrder.ts, 73, 7)) +>Outer : Symbol(Outer, Decl(relationCycleNonMonotoneCheckOrder.ts, 69, 81)) +>e : Symbol(e, Decl(relationCycleNonMonotoneCheckOrder.ts, 73, 20)) +>src : Symbol(src, Decl(relationCycleNonMonotoneCheckOrder.ts, 72, 15)) +>w : Symbol(w, Decl(relationCycleNonMonotoneCheckOrder.ts, 73, 28)) + + declare let r2: X extends Y ? true : false; +>r2 : Symbol(r2, Decl(relationCycleNonMonotoneCheckOrder.ts, 74, 15)) +>X : Symbol(X, Decl(relationCycleNonMonotoneCheckOrder.ts, 65, 38)) +>Y : Symbol(Y, Decl(relationCycleNonMonotoneCheckOrder.ts, 66, 37)) +} + +// Subtype reduction drops 'F' if it is a strict subtype of 'G'. Its +// optional parameter relates only if 'P' is not a strict subtype of 'Q', +// and relating 'P' to 'Q' compares 'F' to 'G' again before failing on +// 'z'. 'F' must be dropped whether or not 'P' was compared to 'Q' first. +namespace strictArity { +>strictArity : Symbol(strictArity, Decl(relationCycleNonMonotoneCheckOrder.ts, 75, 1)) + + type P = { f: F | G; z: number }; +>P : Symbol(P, Decl(relationCycleNonMonotoneCheckOrder.ts, 81, 23)) +>f : Symbol(f, Decl(relationCycleNonMonotoneCheckOrder.ts, 82, 14)) +>F : Symbol(F, Decl(relationCycleNonMonotoneCheckOrder.ts, 83, 28)) +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 84, 26)) +>z : Symbol(z, Decl(relationCycleNonMonotoneCheckOrder.ts, 82, 24)) + + type Q = { f: G; z: 1 }; +>Q : Symbol(Q, Decl(relationCycleNonMonotoneCheckOrder.ts, 82, 37)) +>f : Symbol(f, Decl(relationCycleNonMonotoneCheckOrder.ts, 83, 14)) +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 84, 26)) +>z : Symbol(z, Decl(relationCycleNonMonotoneCheckOrder.ts, 83, 20)) + + type F = (x?: P) => 1; +>F : Symbol(F, Decl(relationCycleNonMonotoneCheckOrder.ts, 83, 28)) +>x : Symbol(x, Decl(relationCycleNonMonotoneCheckOrder.ts, 84, 14)) +>P : Symbol(P, Decl(relationCycleNonMonotoneCheckOrder.ts, 81, 23)) + + type G = (x: Q | undefined) => number; +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 84, 26)) +>x : Symbol(x, Decl(relationCycleNonMonotoneCheckOrder.ts, 85, 14)) +>Q : Symbol(Q, Decl(relationCycleNonMonotoneCheckOrder.ts, 82, 37)) + + type WP = { a: P; b: string }; +>WP : Symbol(WP, Decl(relationCycleNonMonotoneCheckOrder.ts, 85, 42)) +>a : Symbol(a, Decl(relationCycleNonMonotoneCheckOrder.ts, 86, 15)) +>P : Symbol(P, Decl(relationCycleNonMonotoneCheckOrder.ts, 81, 23)) +>b : Symbol(b, Decl(relationCycleNonMonotoneCheckOrder.ts, 86, 21)) + + type WQ = { a: Q }; +>WQ : Symbol(WQ, Decl(relationCycleNonMonotoneCheckOrder.ts, 86, 34)) +>a : Symbol(a, Decl(relationCycleNonMonotoneCheckOrder.ts, 87, 15)) +>Q : Symbol(Q, Decl(relationCycleNonMonotoneCheckOrder.ts, 82, 37)) + + declare let f: F, g: G, wp: WP, wq: WQ; +>f : Symbol(f, Decl(relationCycleNonMonotoneCheckOrder.ts, 89, 15)) +>F : Symbol(F, Decl(relationCycleNonMonotoneCheckOrder.ts, 83, 28)) +>g : Symbol(g, Decl(relationCycleNonMonotoneCheckOrder.ts, 89, 21)) +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 84, 26)) +>wp : Symbol(wp, Decl(relationCycleNonMonotoneCheckOrder.ts, 89, 27)) +>WP : Symbol(WP, Decl(relationCycleNonMonotoneCheckOrder.ts, 85, 42)) +>wq : Symbol(wq, Decl(relationCycleNonMonotoneCheckOrder.ts, 89, 35)) +>WQ : Symbol(WQ, Decl(relationCycleNonMonotoneCheckOrder.ts, 86, 34)) + + let a1 = [f, g]; +>a1 : Symbol(a1, Decl(relationCycleNonMonotoneCheckOrder.ts, 90, 7)) +>f : Symbol(f, Decl(relationCycleNonMonotoneCheckOrder.ts, 89, 15)) +>g : Symbol(g, Decl(relationCycleNonMonotoneCheckOrder.ts, 89, 21)) + + let a2 = [wp, wq]; +>a2 : Symbol(a2, Decl(relationCycleNonMonotoneCheckOrder.ts, 91, 7)) +>wp : Symbol(wp, Decl(relationCycleNonMonotoneCheckOrder.ts, 89, 27)) +>wq : Symbol(wq, Decl(relationCycleNonMonotoneCheckOrder.ts, 89, 35)) +} + diff --git a/tsc/testdata/baselines/reference/compiler/relationCycleNonMonotoneCheckOrder(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/relationCycleNonMonotoneCheckOrder(checkorder=default).types new file mode 100644 index 0000000000000..ae7cfe7fe54a9 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/relationCycleNonMonotoneCheckOrder(checkorder=default).types @@ -0,0 +1,292 @@ +//// [tests/cases/compiler/relationCycleNonMonotoneCheckOrder.ts] //// + +=== relationCycleNonMonotoneCheckOrder.ts === +// 'S' relates to 'G' only if inferring 'T' from 'A' fails the constraint +// 'C', so that 'T' falls back to 'C'. Relating 'A' to 'C' compares 'S' to +// 'G' again, but 'A' fails 'C' on 'z' regardless. 'S' must relate to 'G' +// whether or not 'A' was compared to 'C' first. +namespace inferenceConstraint { +>inferenceConstraint : typeof inferenceConstraint + + type A = { k?: "c"; f: S | G; z: number }; +>A : A +>k : "c" | undefined +>f : G | S +>z : number + + type C = { [s: string]: "c" | G | number; f: G; z: 1 }; +>C : C +>s : string +>f : G +>z : 1 + + type S = (x: T) => T["k"]; +>S : S +>x : T + + type G = (x: A) => "c" | G | number; +>G : G +>x : A + + declare let r1: S extends G ? true : false; +>r1 : true +>true : true +>false : false + + declare let r2: A extends C ? true : false; +>r2 : false +>true : true +>false : false +} + +// As above, with method signatures, which are compared bivariantly. +namespace inferenceConstraintMethod { +>inferenceConstraintMethod : typeof inferenceConstraintMethod + + type A = { k?: "c"; f: S | G; z: number }; +>A : A +>k : "c" | undefined +>f : G | S +>z : number + + type C = { [s: string]: "c" | G | number; f: G; z: 1 }; +>C : C +>s : string +>f : G +>z : 1 + + type S = { m(x: T): T["k"] }; +>S : S +>m : (x: T) => T["k"] +>x : T + + type G = { m(x: A): "c" | G | number }; +>G : G +>m : (x: A) => "c" | G | number +>x : A + + declare let r1: S extends G ? true : false; +>r1 : true +>true : true +>false : false + + declare let r2: A extends C ? true : false; +>r2 : false +>true : true +>false : false +} + +// 'S1' relates to 'G1' only if 'S2' does not relate to 'G2', and the +// reverse, so no answer is consistent for both. Each is answered as if +// compared first, assuming itself while relating the other, regardless +// of which assignment is checked first. +namespace inferenceConstraintMutual { +>inferenceConstraintMutual : typeof inferenceConstraintMutual + + type A1 = { k?: "c"; f: S2 | G2 }; +>A1 : A1 +>k : "c" | undefined +>f : G2 | S2 + + type C1 = { [s: string]: "c" | G2; f: G2 }; +>C1 : C1 +>s : string +>f : G2 + + type S1 = (x: T) => T["k"]; +>S1 : S1 +>x : T + + type G1 = (x: A1) => "c" | G2; +>G1 : G1 +>x : A1 + + type A2 = { k?: "d"; f: S1 | G1 }; +>A2 : A2 +>k : "d" | undefined +>f : G1 | S1 + + type C2 = { [s: string]: "d" | G1; f: G1 }; +>C2 : C2 +>s : string +>f : G1 + + type S2 = (x: T) => T["k"]; +>S2 : S2 +>x : T + + type G2 = (x: A2) => "d" | G1; +>G2 : G2 +>x : A2 + + declare let s1: S1; +>s1 : S1 + + declare let s2: S2; +>s2 : S2 + + let g1: G1 = s1; +>g1 : G1 +>s1 : S1 + + let g2: G2 = s2; +>g2 : G2 +>s2 : S2 + + declare let r1: S1 extends G1 ? true : false; +>r1 : true +>true : true +>false : false + + declare let r2: S2 extends G2 ? true : false; +>r2 : false +>true : true +>false : false +} + +// 'Src' relates to the union 'Tgt' by discriminating on 'd'. The member +// '{ d: Y; y: number }' matches 'd: X' only if 'X' relates to 'Y', and +// relating 'X' to 'Y' compares 'Src' to 'Tgt' again before failing on +// 'q'. 'Src' must relate to 'Tgt' whether or not 'X' was compared to 'Y' +// first. +namespace discriminated { +>discriminated : typeof discriminated + + interface X { p: Src; q: number } +>p : Src +>q : number + + interface Y { p: Tgt; q: 1 } +>p : Tgt +>q : 1 + + type Src = { d: "a" | X; y: string }; +>Src : Src +>d : "a" | X +>y : string + + type Tgt = { d: "a"; y: string } | { d: X; y: string } | { d: Y; y: number }; +>Tgt : Tgt +>d : "a" +>y : string +>d : X +>y : string +>d : Y +>y : number + + declare let r1: Src extends Tgt ? true : false; +>r1 : true +>true : true +>false : false + + declare let r2: X extends Y ? true : false; +>r2 : false +>true : true +>false : false +} + +// The excess property check of the object literal keeps the members of +// 'Outer' whose 'e' the literal's 'e' relates to, so 'w' is known only +// if 'Src' relates to 'Tgt' as above. +namespace excessPropertyDiscriminant { +>excessPropertyDiscriminant : typeof excessPropertyDiscriminant + + interface X { p: Src; q: number } +>p : Src +>q : number + + interface Y { p: Tgt; q: 1 } +>p : Tgt +>q : 1 + + type Src = { d: "a" | X; y: string }; +>Src : Src +>d : "a" | X +>y : string + + type Tgt = { d: "a"; y: string } | { d: X; y: string } | { d: Y; y: number }; +>Tgt : Tgt +>d : "a" +>y : string +>d : X +>y : string +>d : Y +>y : number + + type Outer = { e: "z" } | { e: Tgt; w: number } | { e: Src }; +>Outer : Outer +>e : "z" +>e : Tgt +>w : number +>e : Src + + declare let src: Src; +>src : Src + + let o: Outer = { e: src, w: 1 }; +>o : Outer +>{ e: src, w: 1 } : { e: Src; w: number; } +>e : Src +>src : Src +>w : number +>1 : 1 + + declare let r2: X extends Y ? true : false; +>r2 : false +>true : true +>false : false +} + +// Subtype reduction drops 'F' if it is a strict subtype of 'G'. Its +// optional parameter relates only if 'P' is not a strict subtype of 'Q', +// and relating 'P' to 'Q' compares 'F' to 'G' again before failing on +// 'z'. 'F' must be dropped whether or not 'P' was compared to 'Q' first. +namespace strictArity { +>strictArity : typeof strictArity + + type P = { f: F | G; z: number }; +>P : P +>f : F | G +>z : number + + type Q = { f: G; z: 1 }; +>Q : Q +>f : G +>z : 1 + + type F = (x?: P) => 1; +>F : F +>x : P | undefined + + type G = (x: Q | undefined) => number; +>G : G +>x : Q | undefined + + type WP = { a: P; b: string }; +>WP : WP +>a : P +>b : string + + type WQ = { a: Q }; +>WQ : WQ +>a : Q + + declare let f: F, g: G, wp: WP, wq: WQ; +>f : F +>g : G +>wp : WP +>wq : WQ + + let a1 = [f, g]; +>a1 : G[] +>[f, g] : G[] +>f : F +>g : G + + let a2 = [wp, wq]; +>a2 : (WP | WQ)[] +>[wp, wq] : (WP | WQ)[] +>wp : WP +>wq : WQ +} + diff --git a/tsc/testdata/baselines/reference/compiler/relationCycleNonMonotoneCheckOrder(checkorder=editorfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/relationCycleNonMonotoneCheckOrder(checkorder=editorfirst).errors.txt new file mode 100644 index 0000000000000..286101cc10b43 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/relationCycleNonMonotoneCheckOrder(checkorder=editorfirst).errors.txt @@ -0,0 +1,107 @@ +relationCycleNonMonotoneCheckOrder.ts(42,9): error TS2322: Type 'S1' is not assignable to type 'G1'. + Type '"c" | undefined' is not assignable to type '"c" | G2'. + Type 'undefined' is not assignable to type '"c" | G2'. +relationCycleNonMonotoneCheckOrder.ts(74,30): error TS2353: Object literal may only specify known properties, and 'w' does not exist in type '{ e: Src; }'. + + +==== relationCycleNonMonotoneCheckOrder.ts (2 errors) ==== + // 'S' relates to 'G' only if inferring 'T' from 'A' fails the constraint + // 'C', so that 'T' falls back to 'C'. Relating 'A' to 'C' compares 'S' to + // 'G' again, but 'A' fails 'C' on 'z' regardless. 'S' must relate to 'G' + // whether or not 'A' was compared to 'C' first. + namespace inferenceConstraint { + type A = { k?: "c"; f: S | G; z: number }; + type C = { [s: string]: "c" | G | number; f: G; z: 1 }; + type S = (x: T) => T["k"]; + type G = (x: A) => "c" | G | number; + + declare let r1: S extends G ? true : false; + declare let r2: A extends C ? true : false; + } + + // As above, with method signatures, which are compared bivariantly. + namespace inferenceConstraintMethod { + type A = { k?: "c"; f: S | G; z: number }; + type C = { [s: string]: "c" | G | number; f: G; z: 1 }; + type S = { m(x: T): T["k"] }; + type G = { m(x: A): "c" | G | number }; + + declare let r1: S extends G ? true : false; + declare let r2: A extends C ? true : false; + } + + // 'S1' relates to 'G1' only if 'S2' does not relate to 'G2', and the + // reverse, so no answer is consistent for both. Each is answered as if + // compared first, assuming itself while relating the other, regardless + // of which assignment is checked first. + namespace inferenceConstraintMutual { + type A1 = { k?: "c"; f: S2 | G2 }; + type C1 = { [s: string]: "c" | G2; f: G2 }; + type S1 = (x: T) => T["k"]; + type G1 = (x: A1) => "c" | G2; + type A2 = { k?: "d"; f: S1 | G1 }; + type C2 = { [s: string]: "d" | G1; f: G1 }; + type S2 = (x: T) => T["k"]; + type G2 = (x: A2) => "d" | G1; + + declare let s1: S1; + declare let s2: S2; + let g1: G1 = s1; + ~~ +!!! error TS2322: Type 'S1' is not assignable to type 'G1'. +!!! error TS2322: Type '"c" | undefined' is not assignable to type '"c" | G2'. +!!! error TS2322: Type 'undefined' is not assignable to type '"c" | G2'. + let g2: G2 = s2; + declare let r1: S1 extends G1 ? true : false; + declare let r2: S2 extends G2 ? true : false; + } + + // 'Src' relates to the union 'Tgt' by discriminating on 'd'. The member + // '{ d: Y; y: number }' matches 'd: X' only if 'X' relates to 'Y', and + // relating 'X' to 'Y' compares 'Src' to 'Tgt' again before failing on + // 'q'. 'Src' must relate to 'Tgt' whether or not 'X' was compared to 'Y' + // first. + namespace discriminated { + interface X { p: Src; q: number } + interface Y { p: Tgt; q: 1 } + type Src = { d: "a" | X; y: string }; + type Tgt = { d: "a"; y: string } | { d: X; y: string } | { d: Y; y: number }; + + declare let r1: Src extends Tgt ? true : false; + declare let r2: X extends Y ? true : false; + } + + // The excess property check of the object literal keeps the members of + // 'Outer' whose 'e' the literal's 'e' relates to, so 'w' is known only + // if 'Src' relates to 'Tgt' as above. + namespace excessPropertyDiscriminant { + interface X { p: Src; q: number } + interface Y { p: Tgt; q: 1 } + type Src = { d: "a" | X; y: string }; + type Tgt = { d: "a"; y: string } | { d: X; y: string } | { d: Y; y: number }; + type Outer = { e: "z" } | { e: Tgt; w: number } | { e: Src }; + + declare let src: Src; + let o: Outer = { e: src, w: 1 }; + ~ +!!! error TS2353: Object literal may only specify known properties, and 'w' does not exist in type '{ e: Src; }'. + declare let r2: X extends Y ? true : false; + } + + // Subtype reduction drops 'F' if it is a strict subtype of 'G'. Its + // optional parameter relates only if 'P' is not a strict subtype of 'Q', + // and relating 'P' to 'Q' compares 'F' to 'G' again before failing on + // 'z'. 'F' must be dropped whether or not 'P' was compared to 'Q' first. + namespace strictArity { + type P = { f: F | G; z: number }; + type Q = { f: G; z: 1 }; + type F = (x?: P) => 1; + type G = (x: Q | undefined) => number; + type WP = { a: P; b: string }; + type WQ = { a: Q }; + + declare let f: F, g: G, wp: WP, wq: WQ; + let a1 = [f, g]; + let a2 = [wp, wq]; + } + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/relationCycleNonMonotoneCheckOrder(checkorder=editorfirst).symbols b/tsc/testdata/baselines/reference/compiler/relationCycleNonMonotoneCheckOrder(checkorder=editorfirst).symbols new file mode 100644 index 0000000000000..3bc451c9c78bc --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/relationCycleNonMonotoneCheckOrder(checkorder=editorfirst).symbols @@ -0,0 +1,361 @@ +//// [tests/cases/compiler/relationCycleNonMonotoneCheckOrder.ts] //// + +=== relationCycleNonMonotoneCheckOrder.ts === +// 'S' relates to 'G' only if inferring 'T' from 'A' fails the constraint +// 'C', so that 'T' falls back to 'C'. Relating 'A' to 'C' compares 'S' to +// 'G' again, but 'A' fails 'C' on 'z' regardless. 'S' must relate to 'G' +// whether or not 'A' was compared to 'C' first. +namespace inferenceConstraint { +>inferenceConstraint : Symbol(inferenceConstraint, Decl(relationCycleNonMonotoneCheckOrder.ts, 0, 0)) + + type A = { k?: "c"; f: S | G; z: number }; +>A : Symbol(A, Decl(relationCycleNonMonotoneCheckOrder.ts, 4, 31)) +>k : Symbol(k, Decl(relationCycleNonMonotoneCheckOrder.ts, 5, 14)) +>f : Symbol(f, Decl(relationCycleNonMonotoneCheckOrder.ts, 5, 23)) +>S : Symbol(S, Decl(relationCycleNonMonotoneCheckOrder.ts, 6, 59)) +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 7, 43)) +>z : Symbol(z, Decl(relationCycleNonMonotoneCheckOrder.ts, 5, 33)) + + type C = { [s: string]: "c" | G | number; f: G; z: 1 }; +>C : Symbol(C, Decl(relationCycleNonMonotoneCheckOrder.ts, 5, 46)) +>s : Symbol(s, Decl(relationCycleNonMonotoneCheckOrder.ts, 6, 16)) +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 7, 43)) +>f : Symbol(f, Decl(relationCycleNonMonotoneCheckOrder.ts, 6, 45)) +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 7, 43)) +>z : Symbol(z, Decl(relationCycleNonMonotoneCheckOrder.ts, 6, 51)) + + type S = (x: T) => T["k"]; +>S : Symbol(S, Decl(relationCycleNonMonotoneCheckOrder.ts, 6, 59)) +>T : Symbol(T, Decl(relationCycleNonMonotoneCheckOrder.ts, 7, 14)) +>C : Symbol(C, Decl(relationCycleNonMonotoneCheckOrder.ts, 5, 46)) +>x : Symbol(x, Decl(relationCycleNonMonotoneCheckOrder.ts, 7, 27)) +>T : Symbol(T, Decl(relationCycleNonMonotoneCheckOrder.ts, 7, 14)) +>T : Symbol(T, Decl(relationCycleNonMonotoneCheckOrder.ts, 7, 14)) + + type G = (x: A) => "c" | G | number; +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 7, 43)) +>x : Symbol(x, Decl(relationCycleNonMonotoneCheckOrder.ts, 8, 14)) +>A : Symbol(A, Decl(relationCycleNonMonotoneCheckOrder.ts, 4, 31)) +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 7, 43)) + + declare let r1: S extends G ? true : false; +>r1 : Symbol(r1, Decl(relationCycleNonMonotoneCheckOrder.ts, 10, 15)) +>S : Symbol(S, Decl(relationCycleNonMonotoneCheckOrder.ts, 6, 59)) +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 7, 43)) + + declare let r2: A extends C ? true : false; +>r2 : Symbol(r2, Decl(relationCycleNonMonotoneCheckOrder.ts, 11, 15)) +>A : Symbol(A, Decl(relationCycleNonMonotoneCheckOrder.ts, 4, 31)) +>C : Symbol(C, Decl(relationCycleNonMonotoneCheckOrder.ts, 5, 46)) +} + +// As above, with method signatures, which are compared bivariantly. +namespace inferenceConstraintMethod { +>inferenceConstraintMethod : Symbol(inferenceConstraintMethod, Decl(relationCycleNonMonotoneCheckOrder.ts, 12, 1)) + + type A = { k?: "c"; f: S | G; z: number }; +>A : Symbol(A, Decl(relationCycleNonMonotoneCheckOrder.ts, 15, 37)) +>k : Symbol(k, Decl(relationCycleNonMonotoneCheckOrder.ts, 16, 14)) +>f : Symbol(f, Decl(relationCycleNonMonotoneCheckOrder.ts, 16, 23)) +>S : Symbol(S, Decl(relationCycleNonMonotoneCheckOrder.ts, 17, 59)) +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 18, 46)) +>z : Symbol(z, Decl(relationCycleNonMonotoneCheckOrder.ts, 16, 33)) + + type C = { [s: string]: "c" | G | number; f: G; z: 1 }; +>C : Symbol(C, Decl(relationCycleNonMonotoneCheckOrder.ts, 16, 46)) +>s : Symbol(s, Decl(relationCycleNonMonotoneCheckOrder.ts, 17, 16)) +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 18, 46)) +>f : Symbol(f, Decl(relationCycleNonMonotoneCheckOrder.ts, 17, 45)) +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 18, 46)) +>z : Symbol(z, Decl(relationCycleNonMonotoneCheckOrder.ts, 17, 51)) + + type S = { m(x: T): T["k"] }; +>S : Symbol(S, Decl(relationCycleNonMonotoneCheckOrder.ts, 17, 59)) +>m : Symbol(m, Decl(relationCycleNonMonotoneCheckOrder.ts, 18, 14)) +>T : Symbol(T, Decl(relationCycleNonMonotoneCheckOrder.ts, 18, 17)) +>C : Symbol(C, Decl(relationCycleNonMonotoneCheckOrder.ts, 16, 46)) +>x : Symbol(x, Decl(relationCycleNonMonotoneCheckOrder.ts, 18, 30)) +>T : Symbol(T, Decl(relationCycleNonMonotoneCheckOrder.ts, 18, 17)) +>T : Symbol(T, Decl(relationCycleNonMonotoneCheckOrder.ts, 18, 17)) + + type G = { m(x: A): "c" | G | number }; +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 18, 46)) +>m : Symbol(m, Decl(relationCycleNonMonotoneCheckOrder.ts, 19, 14)) +>x : Symbol(x, Decl(relationCycleNonMonotoneCheckOrder.ts, 19, 17)) +>A : Symbol(A, Decl(relationCycleNonMonotoneCheckOrder.ts, 15, 37)) +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 18, 46)) + + declare let r1: S extends G ? true : false; +>r1 : Symbol(r1, Decl(relationCycleNonMonotoneCheckOrder.ts, 21, 15)) +>S : Symbol(S, Decl(relationCycleNonMonotoneCheckOrder.ts, 17, 59)) +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 18, 46)) + + declare let r2: A extends C ? true : false; +>r2 : Symbol(r2, Decl(relationCycleNonMonotoneCheckOrder.ts, 22, 15)) +>A : Symbol(A, Decl(relationCycleNonMonotoneCheckOrder.ts, 15, 37)) +>C : Symbol(C, Decl(relationCycleNonMonotoneCheckOrder.ts, 16, 46)) +} + +// 'S1' relates to 'G1' only if 'S2' does not relate to 'G2', and the +// reverse, so no answer is consistent for both. Each is answered as if +// compared first, assuming itself while relating the other, regardless +// of which assignment is checked first. +namespace inferenceConstraintMutual { +>inferenceConstraintMutual : Symbol(inferenceConstraintMutual, Decl(relationCycleNonMonotoneCheckOrder.ts, 23, 1)) + + type A1 = { k?: "c"; f: S2 | G2 }; +>A1 : Symbol(A1, Decl(relationCycleNonMonotoneCheckOrder.ts, 29, 37)) +>k : Symbol(k, Decl(relationCycleNonMonotoneCheckOrder.ts, 30, 15)) +>f : Symbol(f, Decl(relationCycleNonMonotoneCheckOrder.ts, 30, 24)) +>S2 : Symbol(S2, Decl(relationCycleNonMonotoneCheckOrder.ts, 35, 47)) +>G2 : Symbol(G2, Decl(relationCycleNonMonotoneCheckOrder.ts, 36, 45)) + + type C1 = { [s: string]: "c" | G2; f: G2 }; +>C1 : Symbol(C1, Decl(relationCycleNonMonotoneCheckOrder.ts, 30, 38)) +>s : Symbol(s, Decl(relationCycleNonMonotoneCheckOrder.ts, 31, 17)) +>G2 : Symbol(G2, Decl(relationCycleNonMonotoneCheckOrder.ts, 36, 45)) +>f : Symbol(f, Decl(relationCycleNonMonotoneCheckOrder.ts, 31, 38)) +>G2 : Symbol(G2, Decl(relationCycleNonMonotoneCheckOrder.ts, 36, 45)) + + type S1 = (x: T) => T["k"]; +>S1 : Symbol(S1, Decl(relationCycleNonMonotoneCheckOrder.ts, 31, 47)) +>T : Symbol(T, Decl(relationCycleNonMonotoneCheckOrder.ts, 32, 15)) +>C1 : Symbol(C1, Decl(relationCycleNonMonotoneCheckOrder.ts, 30, 38)) +>x : Symbol(x, Decl(relationCycleNonMonotoneCheckOrder.ts, 32, 29)) +>T : Symbol(T, Decl(relationCycleNonMonotoneCheckOrder.ts, 32, 15)) +>T : Symbol(T, Decl(relationCycleNonMonotoneCheckOrder.ts, 32, 15)) + + type G1 = (x: A1) => "c" | G2; +>G1 : Symbol(G1, Decl(relationCycleNonMonotoneCheckOrder.ts, 32, 45)) +>x : Symbol(x, Decl(relationCycleNonMonotoneCheckOrder.ts, 33, 15)) +>A1 : Symbol(A1, Decl(relationCycleNonMonotoneCheckOrder.ts, 29, 37)) +>G2 : Symbol(G2, Decl(relationCycleNonMonotoneCheckOrder.ts, 36, 45)) + + type A2 = { k?: "d"; f: S1 | G1 }; +>A2 : Symbol(A2, Decl(relationCycleNonMonotoneCheckOrder.ts, 33, 34)) +>k : Symbol(k, Decl(relationCycleNonMonotoneCheckOrder.ts, 34, 15)) +>f : Symbol(f, Decl(relationCycleNonMonotoneCheckOrder.ts, 34, 24)) +>S1 : Symbol(S1, Decl(relationCycleNonMonotoneCheckOrder.ts, 31, 47)) +>G1 : Symbol(G1, Decl(relationCycleNonMonotoneCheckOrder.ts, 32, 45)) + + type C2 = { [s: string]: "d" | G1; f: G1 }; +>C2 : Symbol(C2, Decl(relationCycleNonMonotoneCheckOrder.ts, 34, 38)) +>s : Symbol(s, Decl(relationCycleNonMonotoneCheckOrder.ts, 35, 17)) +>G1 : Symbol(G1, Decl(relationCycleNonMonotoneCheckOrder.ts, 32, 45)) +>f : Symbol(f, Decl(relationCycleNonMonotoneCheckOrder.ts, 35, 38)) +>G1 : Symbol(G1, Decl(relationCycleNonMonotoneCheckOrder.ts, 32, 45)) + + type S2 = (x: T) => T["k"]; +>S2 : Symbol(S2, Decl(relationCycleNonMonotoneCheckOrder.ts, 35, 47)) +>T : Symbol(T, Decl(relationCycleNonMonotoneCheckOrder.ts, 36, 15)) +>C2 : Symbol(C2, Decl(relationCycleNonMonotoneCheckOrder.ts, 34, 38)) +>x : Symbol(x, Decl(relationCycleNonMonotoneCheckOrder.ts, 36, 29)) +>T : Symbol(T, Decl(relationCycleNonMonotoneCheckOrder.ts, 36, 15)) +>T : Symbol(T, Decl(relationCycleNonMonotoneCheckOrder.ts, 36, 15)) + + type G2 = (x: A2) => "d" | G1; +>G2 : Symbol(G2, Decl(relationCycleNonMonotoneCheckOrder.ts, 36, 45)) +>x : Symbol(x, Decl(relationCycleNonMonotoneCheckOrder.ts, 37, 15)) +>A2 : Symbol(A2, Decl(relationCycleNonMonotoneCheckOrder.ts, 33, 34)) +>G1 : Symbol(G1, Decl(relationCycleNonMonotoneCheckOrder.ts, 32, 45)) + + declare let s1: S1; +>s1 : Symbol(s1, Decl(relationCycleNonMonotoneCheckOrder.ts, 39, 15)) +>S1 : Symbol(S1, Decl(relationCycleNonMonotoneCheckOrder.ts, 31, 47)) + + declare let s2: S2; +>s2 : Symbol(s2, Decl(relationCycleNonMonotoneCheckOrder.ts, 40, 15)) +>S2 : Symbol(S2, Decl(relationCycleNonMonotoneCheckOrder.ts, 35, 47)) + + let g1: G1 = s1; +>g1 : Symbol(g1, Decl(relationCycleNonMonotoneCheckOrder.ts, 41, 7)) +>G1 : Symbol(G1, Decl(relationCycleNonMonotoneCheckOrder.ts, 32, 45)) +>s1 : Symbol(s1, Decl(relationCycleNonMonotoneCheckOrder.ts, 39, 15)) + + let g2: G2 = s2; +>g2 : Symbol(g2, Decl(relationCycleNonMonotoneCheckOrder.ts, 42, 7)) +>G2 : Symbol(G2, Decl(relationCycleNonMonotoneCheckOrder.ts, 36, 45)) +>s2 : Symbol(s2, Decl(relationCycleNonMonotoneCheckOrder.ts, 40, 15)) + + declare let r1: S1 extends G1 ? true : false; +>r1 : Symbol(r1, Decl(relationCycleNonMonotoneCheckOrder.ts, 43, 15)) +>S1 : Symbol(S1, Decl(relationCycleNonMonotoneCheckOrder.ts, 31, 47)) +>G1 : Symbol(G1, Decl(relationCycleNonMonotoneCheckOrder.ts, 32, 45)) + + declare let r2: S2 extends G2 ? true : false; +>r2 : Symbol(r2, Decl(relationCycleNonMonotoneCheckOrder.ts, 44, 15)) +>S2 : Symbol(S2, Decl(relationCycleNonMonotoneCheckOrder.ts, 35, 47)) +>G2 : Symbol(G2, Decl(relationCycleNonMonotoneCheckOrder.ts, 36, 45)) +} + +// 'Src' relates to the union 'Tgt' by discriminating on 'd'. The member +// '{ d: Y; y: number }' matches 'd: X' only if 'X' relates to 'Y', and +// relating 'X' to 'Y' compares 'Src' to 'Tgt' again before failing on +// 'q'. 'Src' must relate to 'Tgt' whether or not 'X' was compared to 'Y' +// first. +namespace discriminated { +>discriminated : Symbol(discriminated, Decl(relationCycleNonMonotoneCheckOrder.ts, 45, 1)) + + interface X { p: Src; q: number } +>X : Symbol(X, Decl(relationCycleNonMonotoneCheckOrder.ts, 52, 25)) +>p : Symbol(X.p, Decl(relationCycleNonMonotoneCheckOrder.ts, 53, 17)) +>Src : Symbol(Src, Decl(relationCycleNonMonotoneCheckOrder.ts, 54, 32)) +>q : Symbol(X.q, Decl(relationCycleNonMonotoneCheckOrder.ts, 53, 25)) + + interface Y { p: Tgt; q: 1 } +>Y : Symbol(Y, Decl(relationCycleNonMonotoneCheckOrder.ts, 53, 37)) +>p : Symbol(Y.p, Decl(relationCycleNonMonotoneCheckOrder.ts, 54, 17)) +>Tgt : Symbol(Tgt, Decl(relationCycleNonMonotoneCheckOrder.ts, 55, 41)) +>q : Symbol(Y.q, Decl(relationCycleNonMonotoneCheckOrder.ts, 54, 25)) + + type Src = { d: "a" | X; y: string }; +>Src : Symbol(Src, Decl(relationCycleNonMonotoneCheckOrder.ts, 54, 32)) +>d : Symbol(d, Decl(relationCycleNonMonotoneCheckOrder.ts, 55, 16)) +>X : Symbol(X, Decl(relationCycleNonMonotoneCheckOrder.ts, 52, 25)) +>y : Symbol(y, Decl(relationCycleNonMonotoneCheckOrder.ts, 55, 28)) + + type Tgt = { d: "a"; y: string } | { d: X; y: string } | { d: Y; y: number }; +>Tgt : Symbol(Tgt, Decl(relationCycleNonMonotoneCheckOrder.ts, 55, 41)) +>d : Symbol(d, Decl(relationCycleNonMonotoneCheckOrder.ts, 56, 16)) +>y : Symbol(y, Decl(relationCycleNonMonotoneCheckOrder.ts, 56, 24)) +>d : Symbol(d, Decl(relationCycleNonMonotoneCheckOrder.ts, 56, 40)) +>X : Symbol(X, Decl(relationCycleNonMonotoneCheckOrder.ts, 52, 25)) +>y : Symbol(y, Decl(relationCycleNonMonotoneCheckOrder.ts, 56, 46)) +>d : Symbol(d, Decl(relationCycleNonMonotoneCheckOrder.ts, 56, 62)) +>Y : Symbol(Y, Decl(relationCycleNonMonotoneCheckOrder.ts, 53, 37)) +>y : Symbol(y, Decl(relationCycleNonMonotoneCheckOrder.ts, 56, 68)) + + declare let r1: Src extends Tgt ? true : false; +>r1 : Symbol(r1, Decl(relationCycleNonMonotoneCheckOrder.ts, 58, 15)) +>Src : Symbol(Src, Decl(relationCycleNonMonotoneCheckOrder.ts, 54, 32)) +>Tgt : Symbol(Tgt, Decl(relationCycleNonMonotoneCheckOrder.ts, 55, 41)) + + declare let r2: X extends Y ? true : false; +>r2 : Symbol(r2, Decl(relationCycleNonMonotoneCheckOrder.ts, 59, 15)) +>X : Symbol(X, Decl(relationCycleNonMonotoneCheckOrder.ts, 52, 25)) +>Y : Symbol(Y, Decl(relationCycleNonMonotoneCheckOrder.ts, 53, 37)) +} + +// The excess property check of the object literal keeps the members of +// 'Outer' whose 'e' the literal's 'e' relates to, so 'w' is known only +// if 'Src' relates to 'Tgt' as above. +namespace excessPropertyDiscriminant { +>excessPropertyDiscriminant : Symbol(excessPropertyDiscriminant, Decl(relationCycleNonMonotoneCheckOrder.ts, 60, 1)) + + interface X { p: Src; q: number } +>X : Symbol(X, Decl(relationCycleNonMonotoneCheckOrder.ts, 65, 38)) +>p : Symbol(X.p, Decl(relationCycleNonMonotoneCheckOrder.ts, 66, 17)) +>Src : Symbol(Src, Decl(relationCycleNonMonotoneCheckOrder.ts, 67, 32)) +>q : Symbol(X.q, Decl(relationCycleNonMonotoneCheckOrder.ts, 66, 25)) + + interface Y { p: Tgt; q: 1 } +>Y : Symbol(Y, Decl(relationCycleNonMonotoneCheckOrder.ts, 66, 37)) +>p : Symbol(Y.p, Decl(relationCycleNonMonotoneCheckOrder.ts, 67, 17)) +>Tgt : Symbol(Tgt, Decl(relationCycleNonMonotoneCheckOrder.ts, 68, 41)) +>q : Symbol(Y.q, Decl(relationCycleNonMonotoneCheckOrder.ts, 67, 25)) + + type Src = { d: "a" | X; y: string }; +>Src : Symbol(Src, Decl(relationCycleNonMonotoneCheckOrder.ts, 67, 32)) +>d : Symbol(d, Decl(relationCycleNonMonotoneCheckOrder.ts, 68, 16)) +>X : Symbol(X, Decl(relationCycleNonMonotoneCheckOrder.ts, 65, 38)) +>y : Symbol(y, Decl(relationCycleNonMonotoneCheckOrder.ts, 68, 28)) + + type Tgt = { d: "a"; y: string } | { d: X; y: string } | { d: Y; y: number }; +>Tgt : Symbol(Tgt, Decl(relationCycleNonMonotoneCheckOrder.ts, 68, 41)) +>d : Symbol(d, Decl(relationCycleNonMonotoneCheckOrder.ts, 69, 16)) +>y : Symbol(y, Decl(relationCycleNonMonotoneCheckOrder.ts, 69, 24)) +>d : Symbol(d, Decl(relationCycleNonMonotoneCheckOrder.ts, 69, 40)) +>X : Symbol(X, Decl(relationCycleNonMonotoneCheckOrder.ts, 65, 38)) +>y : Symbol(y, Decl(relationCycleNonMonotoneCheckOrder.ts, 69, 46)) +>d : Symbol(d, Decl(relationCycleNonMonotoneCheckOrder.ts, 69, 62)) +>Y : Symbol(Y, Decl(relationCycleNonMonotoneCheckOrder.ts, 66, 37)) +>y : Symbol(y, Decl(relationCycleNonMonotoneCheckOrder.ts, 69, 68)) + + type Outer = { e: "z" } | { e: Tgt; w: number } | { e: Src }; +>Outer : Symbol(Outer, Decl(relationCycleNonMonotoneCheckOrder.ts, 69, 81)) +>e : Symbol(e, Decl(relationCycleNonMonotoneCheckOrder.ts, 70, 18)) +>e : Symbol(e, Decl(relationCycleNonMonotoneCheckOrder.ts, 70, 31)) +>Tgt : Symbol(Tgt, Decl(relationCycleNonMonotoneCheckOrder.ts, 68, 41)) +>w : Symbol(w, Decl(relationCycleNonMonotoneCheckOrder.ts, 70, 39)) +>e : Symbol(e, Decl(relationCycleNonMonotoneCheckOrder.ts, 70, 55)) +>Src : Symbol(Src, Decl(relationCycleNonMonotoneCheckOrder.ts, 67, 32)) + + declare let src: Src; +>src : Symbol(src, Decl(relationCycleNonMonotoneCheckOrder.ts, 72, 15)) +>Src : Symbol(Src, Decl(relationCycleNonMonotoneCheckOrder.ts, 67, 32)) + + let o: Outer = { e: src, w: 1 }; +>o : Symbol(o, Decl(relationCycleNonMonotoneCheckOrder.ts, 73, 7)) +>Outer : Symbol(Outer, Decl(relationCycleNonMonotoneCheckOrder.ts, 69, 81)) +>e : Symbol(e, Decl(relationCycleNonMonotoneCheckOrder.ts, 73, 20)) +>src : Symbol(src, Decl(relationCycleNonMonotoneCheckOrder.ts, 72, 15)) +>w : Symbol(w, Decl(relationCycleNonMonotoneCheckOrder.ts, 73, 28)) + + declare let r2: X extends Y ? true : false; +>r2 : Symbol(r2, Decl(relationCycleNonMonotoneCheckOrder.ts, 74, 15)) +>X : Symbol(X, Decl(relationCycleNonMonotoneCheckOrder.ts, 65, 38)) +>Y : Symbol(Y, Decl(relationCycleNonMonotoneCheckOrder.ts, 66, 37)) +} + +// Subtype reduction drops 'F' if it is a strict subtype of 'G'. Its +// optional parameter relates only if 'P' is not a strict subtype of 'Q', +// and relating 'P' to 'Q' compares 'F' to 'G' again before failing on +// 'z'. 'F' must be dropped whether or not 'P' was compared to 'Q' first. +namespace strictArity { +>strictArity : Symbol(strictArity, Decl(relationCycleNonMonotoneCheckOrder.ts, 75, 1)) + + type P = { f: F | G; z: number }; +>P : Symbol(P, Decl(relationCycleNonMonotoneCheckOrder.ts, 81, 23)) +>f : Symbol(f, Decl(relationCycleNonMonotoneCheckOrder.ts, 82, 14)) +>F : Symbol(F, Decl(relationCycleNonMonotoneCheckOrder.ts, 83, 28)) +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 84, 26)) +>z : Symbol(z, Decl(relationCycleNonMonotoneCheckOrder.ts, 82, 24)) + + type Q = { f: G; z: 1 }; +>Q : Symbol(Q, Decl(relationCycleNonMonotoneCheckOrder.ts, 82, 37)) +>f : Symbol(f, Decl(relationCycleNonMonotoneCheckOrder.ts, 83, 14)) +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 84, 26)) +>z : Symbol(z, Decl(relationCycleNonMonotoneCheckOrder.ts, 83, 20)) + + type F = (x?: P) => 1; +>F : Symbol(F, Decl(relationCycleNonMonotoneCheckOrder.ts, 83, 28)) +>x : Symbol(x, Decl(relationCycleNonMonotoneCheckOrder.ts, 84, 14)) +>P : Symbol(P, Decl(relationCycleNonMonotoneCheckOrder.ts, 81, 23)) + + type G = (x: Q | undefined) => number; +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 84, 26)) +>x : Symbol(x, Decl(relationCycleNonMonotoneCheckOrder.ts, 85, 14)) +>Q : Symbol(Q, Decl(relationCycleNonMonotoneCheckOrder.ts, 82, 37)) + + type WP = { a: P; b: string }; +>WP : Symbol(WP, Decl(relationCycleNonMonotoneCheckOrder.ts, 85, 42)) +>a : Symbol(a, Decl(relationCycleNonMonotoneCheckOrder.ts, 86, 15)) +>P : Symbol(P, Decl(relationCycleNonMonotoneCheckOrder.ts, 81, 23)) +>b : Symbol(b, Decl(relationCycleNonMonotoneCheckOrder.ts, 86, 21)) + + type WQ = { a: Q }; +>WQ : Symbol(WQ, Decl(relationCycleNonMonotoneCheckOrder.ts, 86, 34)) +>a : Symbol(a, Decl(relationCycleNonMonotoneCheckOrder.ts, 87, 15)) +>Q : Symbol(Q, Decl(relationCycleNonMonotoneCheckOrder.ts, 82, 37)) + + declare let f: F, g: G, wp: WP, wq: WQ; +>f : Symbol(f, Decl(relationCycleNonMonotoneCheckOrder.ts, 89, 15)) +>F : Symbol(F, Decl(relationCycleNonMonotoneCheckOrder.ts, 83, 28)) +>g : Symbol(g, Decl(relationCycleNonMonotoneCheckOrder.ts, 89, 21)) +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 84, 26)) +>wp : Symbol(wp, Decl(relationCycleNonMonotoneCheckOrder.ts, 89, 27)) +>WP : Symbol(WP, Decl(relationCycleNonMonotoneCheckOrder.ts, 85, 42)) +>wq : Symbol(wq, Decl(relationCycleNonMonotoneCheckOrder.ts, 89, 35)) +>WQ : Symbol(WQ, Decl(relationCycleNonMonotoneCheckOrder.ts, 86, 34)) + + let a1 = [f, g]; +>a1 : Symbol(a1, Decl(relationCycleNonMonotoneCheckOrder.ts, 90, 7)) +>f : Symbol(f, Decl(relationCycleNonMonotoneCheckOrder.ts, 89, 15)) +>g : Symbol(g, Decl(relationCycleNonMonotoneCheckOrder.ts, 89, 21)) + + let a2 = [wp, wq]; +>a2 : Symbol(a2, Decl(relationCycleNonMonotoneCheckOrder.ts, 91, 7)) +>wp : Symbol(wp, Decl(relationCycleNonMonotoneCheckOrder.ts, 89, 27)) +>wq : Symbol(wq, Decl(relationCycleNonMonotoneCheckOrder.ts, 89, 35)) +} + diff --git a/tsc/testdata/baselines/reference/compiler/relationCycleNonMonotoneCheckOrder(checkorder=editorfirst).types b/tsc/testdata/baselines/reference/compiler/relationCycleNonMonotoneCheckOrder(checkorder=editorfirst).types new file mode 100644 index 0000000000000..41b84c9efc3b0 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/relationCycleNonMonotoneCheckOrder(checkorder=editorfirst).types @@ -0,0 +1,292 @@ +//// [tests/cases/compiler/relationCycleNonMonotoneCheckOrder.ts] //// + +=== relationCycleNonMonotoneCheckOrder.ts === +// 'S' relates to 'G' only if inferring 'T' from 'A' fails the constraint +// 'C', so that 'T' falls back to 'C'. Relating 'A' to 'C' compares 'S' to +// 'G' again, but 'A' fails 'C' on 'z' regardless. 'S' must relate to 'G' +// whether or not 'A' was compared to 'C' first. +namespace inferenceConstraint { +>inferenceConstraint : typeof inferenceConstraint + + type A = { k?: "c"; f: S | G; z: number }; +>A : A +>k : "c" | undefined +>f : G | S +>z : number + + type C = { [s: string]: "c" | G | number; f: G; z: 1 }; +>C : C +>s : string +>f : G +>z : 1 + + type S = (x: T) => T["k"]; +>S : S +>x : T + + type G = (x: A) => "c" | G | number; +>G : G +>x : A + + declare let r1: S extends G ? true : false; +>r1 : false +>true : true +>false : false + + declare let r2: A extends C ? true : false; +>r2 : false +>true : true +>false : false +} + +// As above, with method signatures, which are compared bivariantly. +namespace inferenceConstraintMethod { +>inferenceConstraintMethod : typeof inferenceConstraintMethod + + type A = { k?: "c"; f: S | G; z: number }; +>A : A +>k : "c" | undefined +>f : G | S +>z : number + + type C = { [s: string]: "c" | G | number; f: G; z: 1 }; +>C : C +>s : string +>f : G +>z : 1 + + type S = { m(x: T): T["k"] }; +>S : S +>m : (x: T) => T["k"] +>x : T + + type G = { m(x: A): "c" | G | number }; +>G : G +>m : (x: A) => "c" | G | number +>x : A + + declare let r1: S extends G ? true : false; +>r1 : false +>true : true +>false : false + + declare let r2: A extends C ? true : false; +>r2 : false +>true : true +>false : false +} + +// 'S1' relates to 'G1' only if 'S2' does not relate to 'G2', and the +// reverse, so no answer is consistent for both. Each is answered as if +// compared first, assuming itself while relating the other, regardless +// of which assignment is checked first. +namespace inferenceConstraintMutual { +>inferenceConstraintMutual : typeof inferenceConstraintMutual + + type A1 = { k?: "c"; f: S2 | G2 }; +>A1 : A1 +>k : "c" | undefined +>f : G2 | S2 + + type C1 = { [s: string]: "c" | G2; f: G2 }; +>C1 : C1 +>s : string +>f : G2 + + type S1 = (x: T) => T["k"]; +>S1 : S1 +>x : T + + type G1 = (x: A1) => "c" | G2; +>G1 : G1 +>x : A1 + + type A2 = { k?: "d"; f: S1 | G1 }; +>A2 : A2 +>k : "d" | undefined +>f : G1 | S1 + + type C2 = { [s: string]: "d" | G1; f: G1 }; +>C2 : C2 +>s : string +>f : G1 + + type S2 = (x: T) => T["k"]; +>S2 : S2 +>x : T + + type G2 = (x: A2) => "d" | G1; +>G2 : G2 +>x : A2 + + declare let s1: S1; +>s1 : S1 + + declare let s2: S2; +>s2 : S2 + + let g1: G1 = s1; +>g1 : G1 +>s1 : S1 + + let g2: G2 = s2; +>g2 : G2 +>s2 : S2 + + declare let r1: S1 extends G1 ? true : false; +>r1 : false +>true : true +>false : false + + declare let r2: S2 extends G2 ? true : false; +>r2 : true +>true : true +>false : false +} + +// 'Src' relates to the union 'Tgt' by discriminating on 'd'. The member +// '{ d: Y; y: number }' matches 'd: X' only if 'X' relates to 'Y', and +// relating 'X' to 'Y' compares 'Src' to 'Tgt' again before failing on +// 'q'. 'Src' must relate to 'Tgt' whether or not 'X' was compared to 'Y' +// first. +namespace discriminated { +>discriminated : typeof discriminated + + interface X { p: Src; q: number } +>p : Src +>q : number + + interface Y { p: Tgt; q: 1 } +>p : Tgt +>q : 1 + + type Src = { d: "a" | X; y: string }; +>Src : Src +>d : "a" | X +>y : string + + type Tgt = { d: "a"; y: string } | { d: X; y: string } | { d: Y; y: number }; +>Tgt : Tgt +>d : "a" +>y : string +>d : X +>y : string +>d : Y +>y : number + + declare let r1: Src extends Tgt ? true : false; +>r1 : false +>true : true +>false : false + + declare let r2: X extends Y ? true : false; +>r2 : false +>true : true +>false : false +} + +// The excess property check of the object literal keeps the members of +// 'Outer' whose 'e' the literal's 'e' relates to, so 'w' is known only +// if 'Src' relates to 'Tgt' as above. +namespace excessPropertyDiscriminant { +>excessPropertyDiscriminant : typeof excessPropertyDiscriminant + + interface X { p: Src; q: number } +>p : Src +>q : number + + interface Y { p: Tgt; q: 1 } +>p : Tgt +>q : 1 + + type Src = { d: "a" | X; y: string }; +>Src : Src +>d : "a" | X +>y : string + + type Tgt = { d: "a"; y: string } | { d: X; y: string } | { d: Y; y: number }; +>Tgt : Tgt +>d : "a" +>y : string +>d : X +>y : string +>d : Y +>y : number + + type Outer = { e: "z" } | { e: Tgt; w: number } | { e: Src }; +>Outer : Outer +>e : "z" +>e : Tgt +>w : number +>e : Src + + declare let src: Src; +>src : Src + + let o: Outer = { e: src, w: 1 }; +>o : Outer +>{ e: src, w: 1 } : { e: Src; w: number; } +>e : Src +>src : Src +>w : number +>1 : 1 + + declare let r2: X extends Y ? true : false; +>r2 : false +>true : true +>false : false +} + +// Subtype reduction drops 'F' if it is a strict subtype of 'G'. Its +// optional parameter relates only if 'P' is not a strict subtype of 'Q', +// and relating 'P' to 'Q' compares 'F' to 'G' again before failing on +// 'z'. 'F' must be dropped whether or not 'P' was compared to 'Q' first. +namespace strictArity { +>strictArity : typeof strictArity + + type P = { f: F | G; z: number }; +>P : P +>f : F | G +>z : number + + type Q = { f: G; z: 1 }; +>Q : Q +>f : G +>z : 1 + + type F = (x?: P) => 1; +>F : F +>x : P | undefined + + type G = (x: Q | undefined) => number; +>G : G +>x : Q | undefined + + type WP = { a: P; b: string }; +>WP : WP +>a : P +>b : string + + type WQ = { a: Q }; +>WQ : WQ +>a : Q + + declare let f: F, g: G, wp: WP, wq: WQ; +>f : F +>g : G +>wp : WP +>wq : WQ + + let a1 = [f, g]; +>a1 : G[] +>[f, g] : G[] +>f : F +>g : G + + let a2 = [wp, wq]; +>a2 : (WP | WQ)[] +>[wp, wq] : (WP | WQ)[] +>wp : WP +>wq : WQ +} + diff --git a/tsc/testdata/baselines/reference/compiler/relationCycleNonMonotoneCheckOrder(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/relationCycleNonMonotoneCheckOrder(checkorder=typesfirst).errors.txt new file mode 100644 index 0000000000000..286101cc10b43 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/relationCycleNonMonotoneCheckOrder(checkorder=typesfirst).errors.txt @@ -0,0 +1,107 @@ +relationCycleNonMonotoneCheckOrder.ts(42,9): error TS2322: Type 'S1' is not assignable to type 'G1'. + Type '"c" | undefined' is not assignable to type '"c" | G2'. + Type 'undefined' is not assignable to type '"c" | G2'. +relationCycleNonMonotoneCheckOrder.ts(74,30): error TS2353: Object literal may only specify known properties, and 'w' does not exist in type '{ e: Src; }'. + + +==== relationCycleNonMonotoneCheckOrder.ts (2 errors) ==== + // 'S' relates to 'G' only if inferring 'T' from 'A' fails the constraint + // 'C', so that 'T' falls back to 'C'. Relating 'A' to 'C' compares 'S' to + // 'G' again, but 'A' fails 'C' on 'z' regardless. 'S' must relate to 'G' + // whether or not 'A' was compared to 'C' first. + namespace inferenceConstraint { + type A = { k?: "c"; f: S | G; z: number }; + type C = { [s: string]: "c" | G | number; f: G; z: 1 }; + type S = (x: T) => T["k"]; + type G = (x: A) => "c" | G | number; + + declare let r1: S extends G ? true : false; + declare let r2: A extends C ? true : false; + } + + // As above, with method signatures, which are compared bivariantly. + namespace inferenceConstraintMethod { + type A = { k?: "c"; f: S | G; z: number }; + type C = { [s: string]: "c" | G | number; f: G; z: 1 }; + type S = { m(x: T): T["k"] }; + type G = { m(x: A): "c" | G | number }; + + declare let r1: S extends G ? true : false; + declare let r2: A extends C ? true : false; + } + + // 'S1' relates to 'G1' only if 'S2' does not relate to 'G2', and the + // reverse, so no answer is consistent for both. Each is answered as if + // compared first, assuming itself while relating the other, regardless + // of which assignment is checked first. + namespace inferenceConstraintMutual { + type A1 = { k?: "c"; f: S2 | G2 }; + type C1 = { [s: string]: "c" | G2; f: G2 }; + type S1 = (x: T) => T["k"]; + type G1 = (x: A1) => "c" | G2; + type A2 = { k?: "d"; f: S1 | G1 }; + type C2 = { [s: string]: "d" | G1; f: G1 }; + type S2 = (x: T) => T["k"]; + type G2 = (x: A2) => "d" | G1; + + declare let s1: S1; + declare let s2: S2; + let g1: G1 = s1; + ~~ +!!! error TS2322: Type 'S1' is not assignable to type 'G1'. +!!! error TS2322: Type '"c" | undefined' is not assignable to type '"c" | G2'. +!!! error TS2322: Type 'undefined' is not assignable to type '"c" | G2'. + let g2: G2 = s2; + declare let r1: S1 extends G1 ? true : false; + declare let r2: S2 extends G2 ? true : false; + } + + // 'Src' relates to the union 'Tgt' by discriminating on 'd'. The member + // '{ d: Y; y: number }' matches 'd: X' only if 'X' relates to 'Y', and + // relating 'X' to 'Y' compares 'Src' to 'Tgt' again before failing on + // 'q'. 'Src' must relate to 'Tgt' whether or not 'X' was compared to 'Y' + // first. + namespace discriminated { + interface X { p: Src; q: number } + interface Y { p: Tgt; q: 1 } + type Src = { d: "a" | X; y: string }; + type Tgt = { d: "a"; y: string } | { d: X; y: string } | { d: Y; y: number }; + + declare let r1: Src extends Tgt ? true : false; + declare let r2: X extends Y ? true : false; + } + + // The excess property check of the object literal keeps the members of + // 'Outer' whose 'e' the literal's 'e' relates to, so 'w' is known only + // if 'Src' relates to 'Tgt' as above. + namespace excessPropertyDiscriminant { + interface X { p: Src; q: number } + interface Y { p: Tgt; q: 1 } + type Src = { d: "a" | X; y: string }; + type Tgt = { d: "a"; y: string } | { d: X; y: string } | { d: Y; y: number }; + type Outer = { e: "z" } | { e: Tgt; w: number } | { e: Src }; + + declare let src: Src; + let o: Outer = { e: src, w: 1 }; + ~ +!!! error TS2353: Object literal may only specify known properties, and 'w' does not exist in type '{ e: Src; }'. + declare let r2: X extends Y ? true : false; + } + + // Subtype reduction drops 'F' if it is a strict subtype of 'G'. Its + // optional parameter relates only if 'P' is not a strict subtype of 'Q', + // and relating 'P' to 'Q' compares 'F' to 'G' again before failing on + // 'z'. 'F' must be dropped whether or not 'P' was compared to 'Q' first. + namespace strictArity { + type P = { f: F | G; z: number }; + type Q = { f: G; z: 1 }; + type F = (x?: P) => 1; + type G = (x: Q | undefined) => number; + type WP = { a: P; b: string }; + type WQ = { a: Q }; + + declare let f: F, g: G, wp: WP, wq: WQ; + let a1 = [f, g]; + let a2 = [wp, wq]; + } + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/relationCycleNonMonotoneCheckOrder(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/relationCycleNonMonotoneCheckOrder(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..3bc451c9c78bc --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/relationCycleNonMonotoneCheckOrder(checkorder=typesfirst).symbols @@ -0,0 +1,361 @@ +//// [tests/cases/compiler/relationCycleNonMonotoneCheckOrder.ts] //// + +=== relationCycleNonMonotoneCheckOrder.ts === +// 'S' relates to 'G' only if inferring 'T' from 'A' fails the constraint +// 'C', so that 'T' falls back to 'C'. Relating 'A' to 'C' compares 'S' to +// 'G' again, but 'A' fails 'C' on 'z' regardless. 'S' must relate to 'G' +// whether or not 'A' was compared to 'C' first. +namespace inferenceConstraint { +>inferenceConstraint : Symbol(inferenceConstraint, Decl(relationCycleNonMonotoneCheckOrder.ts, 0, 0)) + + type A = { k?: "c"; f: S | G; z: number }; +>A : Symbol(A, Decl(relationCycleNonMonotoneCheckOrder.ts, 4, 31)) +>k : Symbol(k, Decl(relationCycleNonMonotoneCheckOrder.ts, 5, 14)) +>f : Symbol(f, Decl(relationCycleNonMonotoneCheckOrder.ts, 5, 23)) +>S : Symbol(S, Decl(relationCycleNonMonotoneCheckOrder.ts, 6, 59)) +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 7, 43)) +>z : Symbol(z, Decl(relationCycleNonMonotoneCheckOrder.ts, 5, 33)) + + type C = { [s: string]: "c" | G | number; f: G; z: 1 }; +>C : Symbol(C, Decl(relationCycleNonMonotoneCheckOrder.ts, 5, 46)) +>s : Symbol(s, Decl(relationCycleNonMonotoneCheckOrder.ts, 6, 16)) +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 7, 43)) +>f : Symbol(f, Decl(relationCycleNonMonotoneCheckOrder.ts, 6, 45)) +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 7, 43)) +>z : Symbol(z, Decl(relationCycleNonMonotoneCheckOrder.ts, 6, 51)) + + type S = (x: T) => T["k"]; +>S : Symbol(S, Decl(relationCycleNonMonotoneCheckOrder.ts, 6, 59)) +>T : Symbol(T, Decl(relationCycleNonMonotoneCheckOrder.ts, 7, 14)) +>C : Symbol(C, Decl(relationCycleNonMonotoneCheckOrder.ts, 5, 46)) +>x : Symbol(x, Decl(relationCycleNonMonotoneCheckOrder.ts, 7, 27)) +>T : Symbol(T, Decl(relationCycleNonMonotoneCheckOrder.ts, 7, 14)) +>T : Symbol(T, Decl(relationCycleNonMonotoneCheckOrder.ts, 7, 14)) + + type G = (x: A) => "c" | G | number; +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 7, 43)) +>x : Symbol(x, Decl(relationCycleNonMonotoneCheckOrder.ts, 8, 14)) +>A : Symbol(A, Decl(relationCycleNonMonotoneCheckOrder.ts, 4, 31)) +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 7, 43)) + + declare let r1: S extends G ? true : false; +>r1 : Symbol(r1, Decl(relationCycleNonMonotoneCheckOrder.ts, 10, 15)) +>S : Symbol(S, Decl(relationCycleNonMonotoneCheckOrder.ts, 6, 59)) +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 7, 43)) + + declare let r2: A extends C ? true : false; +>r2 : Symbol(r2, Decl(relationCycleNonMonotoneCheckOrder.ts, 11, 15)) +>A : Symbol(A, Decl(relationCycleNonMonotoneCheckOrder.ts, 4, 31)) +>C : Symbol(C, Decl(relationCycleNonMonotoneCheckOrder.ts, 5, 46)) +} + +// As above, with method signatures, which are compared bivariantly. +namespace inferenceConstraintMethod { +>inferenceConstraintMethod : Symbol(inferenceConstraintMethod, Decl(relationCycleNonMonotoneCheckOrder.ts, 12, 1)) + + type A = { k?: "c"; f: S | G; z: number }; +>A : Symbol(A, Decl(relationCycleNonMonotoneCheckOrder.ts, 15, 37)) +>k : Symbol(k, Decl(relationCycleNonMonotoneCheckOrder.ts, 16, 14)) +>f : Symbol(f, Decl(relationCycleNonMonotoneCheckOrder.ts, 16, 23)) +>S : Symbol(S, Decl(relationCycleNonMonotoneCheckOrder.ts, 17, 59)) +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 18, 46)) +>z : Symbol(z, Decl(relationCycleNonMonotoneCheckOrder.ts, 16, 33)) + + type C = { [s: string]: "c" | G | number; f: G; z: 1 }; +>C : Symbol(C, Decl(relationCycleNonMonotoneCheckOrder.ts, 16, 46)) +>s : Symbol(s, Decl(relationCycleNonMonotoneCheckOrder.ts, 17, 16)) +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 18, 46)) +>f : Symbol(f, Decl(relationCycleNonMonotoneCheckOrder.ts, 17, 45)) +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 18, 46)) +>z : Symbol(z, Decl(relationCycleNonMonotoneCheckOrder.ts, 17, 51)) + + type S = { m(x: T): T["k"] }; +>S : Symbol(S, Decl(relationCycleNonMonotoneCheckOrder.ts, 17, 59)) +>m : Symbol(m, Decl(relationCycleNonMonotoneCheckOrder.ts, 18, 14)) +>T : Symbol(T, Decl(relationCycleNonMonotoneCheckOrder.ts, 18, 17)) +>C : Symbol(C, Decl(relationCycleNonMonotoneCheckOrder.ts, 16, 46)) +>x : Symbol(x, Decl(relationCycleNonMonotoneCheckOrder.ts, 18, 30)) +>T : Symbol(T, Decl(relationCycleNonMonotoneCheckOrder.ts, 18, 17)) +>T : Symbol(T, Decl(relationCycleNonMonotoneCheckOrder.ts, 18, 17)) + + type G = { m(x: A): "c" | G | number }; +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 18, 46)) +>m : Symbol(m, Decl(relationCycleNonMonotoneCheckOrder.ts, 19, 14)) +>x : Symbol(x, Decl(relationCycleNonMonotoneCheckOrder.ts, 19, 17)) +>A : Symbol(A, Decl(relationCycleNonMonotoneCheckOrder.ts, 15, 37)) +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 18, 46)) + + declare let r1: S extends G ? true : false; +>r1 : Symbol(r1, Decl(relationCycleNonMonotoneCheckOrder.ts, 21, 15)) +>S : Symbol(S, Decl(relationCycleNonMonotoneCheckOrder.ts, 17, 59)) +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 18, 46)) + + declare let r2: A extends C ? true : false; +>r2 : Symbol(r2, Decl(relationCycleNonMonotoneCheckOrder.ts, 22, 15)) +>A : Symbol(A, Decl(relationCycleNonMonotoneCheckOrder.ts, 15, 37)) +>C : Symbol(C, Decl(relationCycleNonMonotoneCheckOrder.ts, 16, 46)) +} + +// 'S1' relates to 'G1' only if 'S2' does not relate to 'G2', and the +// reverse, so no answer is consistent for both. Each is answered as if +// compared first, assuming itself while relating the other, regardless +// of which assignment is checked first. +namespace inferenceConstraintMutual { +>inferenceConstraintMutual : Symbol(inferenceConstraintMutual, Decl(relationCycleNonMonotoneCheckOrder.ts, 23, 1)) + + type A1 = { k?: "c"; f: S2 | G2 }; +>A1 : Symbol(A1, Decl(relationCycleNonMonotoneCheckOrder.ts, 29, 37)) +>k : Symbol(k, Decl(relationCycleNonMonotoneCheckOrder.ts, 30, 15)) +>f : Symbol(f, Decl(relationCycleNonMonotoneCheckOrder.ts, 30, 24)) +>S2 : Symbol(S2, Decl(relationCycleNonMonotoneCheckOrder.ts, 35, 47)) +>G2 : Symbol(G2, Decl(relationCycleNonMonotoneCheckOrder.ts, 36, 45)) + + type C1 = { [s: string]: "c" | G2; f: G2 }; +>C1 : Symbol(C1, Decl(relationCycleNonMonotoneCheckOrder.ts, 30, 38)) +>s : Symbol(s, Decl(relationCycleNonMonotoneCheckOrder.ts, 31, 17)) +>G2 : Symbol(G2, Decl(relationCycleNonMonotoneCheckOrder.ts, 36, 45)) +>f : Symbol(f, Decl(relationCycleNonMonotoneCheckOrder.ts, 31, 38)) +>G2 : Symbol(G2, Decl(relationCycleNonMonotoneCheckOrder.ts, 36, 45)) + + type S1 = (x: T) => T["k"]; +>S1 : Symbol(S1, Decl(relationCycleNonMonotoneCheckOrder.ts, 31, 47)) +>T : Symbol(T, Decl(relationCycleNonMonotoneCheckOrder.ts, 32, 15)) +>C1 : Symbol(C1, Decl(relationCycleNonMonotoneCheckOrder.ts, 30, 38)) +>x : Symbol(x, Decl(relationCycleNonMonotoneCheckOrder.ts, 32, 29)) +>T : Symbol(T, Decl(relationCycleNonMonotoneCheckOrder.ts, 32, 15)) +>T : Symbol(T, Decl(relationCycleNonMonotoneCheckOrder.ts, 32, 15)) + + type G1 = (x: A1) => "c" | G2; +>G1 : Symbol(G1, Decl(relationCycleNonMonotoneCheckOrder.ts, 32, 45)) +>x : Symbol(x, Decl(relationCycleNonMonotoneCheckOrder.ts, 33, 15)) +>A1 : Symbol(A1, Decl(relationCycleNonMonotoneCheckOrder.ts, 29, 37)) +>G2 : Symbol(G2, Decl(relationCycleNonMonotoneCheckOrder.ts, 36, 45)) + + type A2 = { k?: "d"; f: S1 | G1 }; +>A2 : Symbol(A2, Decl(relationCycleNonMonotoneCheckOrder.ts, 33, 34)) +>k : Symbol(k, Decl(relationCycleNonMonotoneCheckOrder.ts, 34, 15)) +>f : Symbol(f, Decl(relationCycleNonMonotoneCheckOrder.ts, 34, 24)) +>S1 : Symbol(S1, Decl(relationCycleNonMonotoneCheckOrder.ts, 31, 47)) +>G1 : Symbol(G1, Decl(relationCycleNonMonotoneCheckOrder.ts, 32, 45)) + + type C2 = { [s: string]: "d" | G1; f: G1 }; +>C2 : Symbol(C2, Decl(relationCycleNonMonotoneCheckOrder.ts, 34, 38)) +>s : Symbol(s, Decl(relationCycleNonMonotoneCheckOrder.ts, 35, 17)) +>G1 : Symbol(G1, Decl(relationCycleNonMonotoneCheckOrder.ts, 32, 45)) +>f : Symbol(f, Decl(relationCycleNonMonotoneCheckOrder.ts, 35, 38)) +>G1 : Symbol(G1, Decl(relationCycleNonMonotoneCheckOrder.ts, 32, 45)) + + type S2 = (x: T) => T["k"]; +>S2 : Symbol(S2, Decl(relationCycleNonMonotoneCheckOrder.ts, 35, 47)) +>T : Symbol(T, Decl(relationCycleNonMonotoneCheckOrder.ts, 36, 15)) +>C2 : Symbol(C2, Decl(relationCycleNonMonotoneCheckOrder.ts, 34, 38)) +>x : Symbol(x, Decl(relationCycleNonMonotoneCheckOrder.ts, 36, 29)) +>T : Symbol(T, Decl(relationCycleNonMonotoneCheckOrder.ts, 36, 15)) +>T : Symbol(T, Decl(relationCycleNonMonotoneCheckOrder.ts, 36, 15)) + + type G2 = (x: A2) => "d" | G1; +>G2 : Symbol(G2, Decl(relationCycleNonMonotoneCheckOrder.ts, 36, 45)) +>x : Symbol(x, Decl(relationCycleNonMonotoneCheckOrder.ts, 37, 15)) +>A2 : Symbol(A2, Decl(relationCycleNonMonotoneCheckOrder.ts, 33, 34)) +>G1 : Symbol(G1, Decl(relationCycleNonMonotoneCheckOrder.ts, 32, 45)) + + declare let s1: S1; +>s1 : Symbol(s1, Decl(relationCycleNonMonotoneCheckOrder.ts, 39, 15)) +>S1 : Symbol(S1, Decl(relationCycleNonMonotoneCheckOrder.ts, 31, 47)) + + declare let s2: S2; +>s2 : Symbol(s2, Decl(relationCycleNonMonotoneCheckOrder.ts, 40, 15)) +>S2 : Symbol(S2, Decl(relationCycleNonMonotoneCheckOrder.ts, 35, 47)) + + let g1: G1 = s1; +>g1 : Symbol(g1, Decl(relationCycleNonMonotoneCheckOrder.ts, 41, 7)) +>G1 : Symbol(G1, Decl(relationCycleNonMonotoneCheckOrder.ts, 32, 45)) +>s1 : Symbol(s1, Decl(relationCycleNonMonotoneCheckOrder.ts, 39, 15)) + + let g2: G2 = s2; +>g2 : Symbol(g2, Decl(relationCycleNonMonotoneCheckOrder.ts, 42, 7)) +>G2 : Symbol(G2, Decl(relationCycleNonMonotoneCheckOrder.ts, 36, 45)) +>s2 : Symbol(s2, Decl(relationCycleNonMonotoneCheckOrder.ts, 40, 15)) + + declare let r1: S1 extends G1 ? true : false; +>r1 : Symbol(r1, Decl(relationCycleNonMonotoneCheckOrder.ts, 43, 15)) +>S1 : Symbol(S1, Decl(relationCycleNonMonotoneCheckOrder.ts, 31, 47)) +>G1 : Symbol(G1, Decl(relationCycleNonMonotoneCheckOrder.ts, 32, 45)) + + declare let r2: S2 extends G2 ? true : false; +>r2 : Symbol(r2, Decl(relationCycleNonMonotoneCheckOrder.ts, 44, 15)) +>S2 : Symbol(S2, Decl(relationCycleNonMonotoneCheckOrder.ts, 35, 47)) +>G2 : Symbol(G2, Decl(relationCycleNonMonotoneCheckOrder.ts, 36, 45)) +} + +// 'Src' relates to the union 'Tgt' by discriminating on 'd'. The member +// '{ d: Y; y: number }' matches 'd: X' only if 'X' relates to 'Y', and +// relating 'X' to 'Y' compares 'Src' to 'Tgt' again before failing on +// 'q'. 'Src' must relate to 'Tgt' whether or not 'X' was compared to 'Y' +// first. +namespace discriminated { +>discriminated : Symbol(discriminated, Decl(relationCycleNonMonotoneCheckOrder.ts, 45, 1)) + + interface X { p: Src; q: number } +>X : Symbol(X, Decl(relationCycleNonMonotoneCheckOrder.ts, 52, 25)) +>p : Symbol(X.p, Decl(relationCycleNonMonotoneCheckOrder.ts, 53, 17)) +>Src : Symbol(Src, Decl(relationCycleNonMonotoneCheckOrder.ts, 54, 32)) +>q : Symbol(X.q, Decl(relationCycleNonMonotoneCheckOrder.ts, 53, 25)) + + interface Y { p: Tgt; q: 1 } +>Y : Symbol(Y, Decl(relationCycleNonMonotoneCheckOrder.ts, 53, 37)) +>p : Symbol(Y.p, Decl(relationCycleNonMonotoneCheckOrder.ts, 54, 17)) +>Tgt : Symbol(Tgt, Decl(relationCycleNonMonotoneCheckOrder.ts, 55, 41)) +>q : Symbol(Y.q, Decl(relationCycleNonMonotoneCheckOrder.ts, 54, 25)) + + type Src = { d: "a" | X; y: string }; +>Src : Symbol(Src, Decl(relationCycleNonMonotoneCheckOrder.ts, 54, 32)) +>d : Symbol(d, Decl(relationCycleNonMonotoneCheckOrder.ts, 55, 16)) +>X : Symbol(X, Decl(relationCycleNonMonotoneCheckOrder.ts, 52, 25)) +>y : Symbol(y, Decl(relationCycleNonMonotoneCheckOrder.ts, 55, 28)) + + type Tgt = { d: "a"; y: string } | { d: X; y: string } | { d: Y; y: number }; +>Tgt : Symbol(Tgt, Decl(relationCycleNonMonotoneCheckOrder.ts, 55, 41)) +>d : Symbol(d, Decl(relationCycleNonMonotoneCheckOrder.ts, 56, 16)) +>y : Symbol(y, Decl(relationCycleNonMonotoneCheckOrder.ts, 56, 24)) +>d : Symbol(d, Decl(relationCycleNonMonotoneCheckOrder.ts, 56, 40)) +>X : Symbol(X, Decl(relationCycleNonMonotoneCheckOrder.ts, 52, 25)) +>y : Symbol(y, Decl(relationCycleNonMonotoneCheckOrder.ts, 56, 46)) +>d : Symbol(d, Decl(relationCycleNonMonotoneCheckOrder.ts, 56, 62)) +>Y : Symbol(Y, Decl(relationCycleNonMonotoneCheckOrder.ts, 53, 37)) +>y : Symbol(y, Decl(relationCycleNonMonotoneCheckOrder.ts, 56, 68)) + + declare let r1: Src extends Tgt ? true : false; +>r1 : Symbol(r1, Decl(relationCycleNonMonotoneCheckOrder.ts, 58, 15)) +>Src : Symbol(Src, Decl(relationCycleNonMonotoneCheckOrder.ts, 54, 32)) +>Tgt : Symbol(Tgt, Decl(relationCycleNonMonotoneCheckOrder.ts, 55, 41)) + + declare let r2: X extends Y ? true : false; +>r2 : Symbol(r2, Decl(relationCycleNonMonotoneCheckOrder.ts, 59, 15)) +>X : Symbol(X, Decl(relationCycleNonMonotoneCheckOrder.ts, 52, 25)) +>Y : Symbol(Y, Decl(relationCycleNonMonotoneCheckOrder.ts, 53, 37)) +} + +// The excess property check of the object literal keeps the members of +// 'Outer' whose 'e' the literal's 'e' relates to, so 'w' is known only +// if 'Src' relates to 'Tgt' as above. +namespace excessPropertyDiscriminant { +>excessPropertyDiscriminant : Symbol(excessPropertyDiscriminant, Decl(relationCycleNonMonotoneCheckOrder.ts, 60, 1)) + + interface X { p: Src; q: number } +>X : Symbol(X, Decl(relationCycleNonMonotoneCheckOrder.ts, 65, 38)) +>p : Symbol(X.p, Decl(relationCycleNonMonotoneCheckOrder.ts, 66, 17)) +>Src : Symbol(Src, Decl(relationCycleNonMonotoneCheckOrder.ts, 67, 32)) +>q : Symbol(X.q, Decl(relationCycleNonMonotoneCheckOrder.ts, 66, 25)) + + interface Y { p: Tgt; q: 1 } +>Y : Symbol(Y, Decl(relationCycleNonMonotoneCheckOrder.ts, 66, 37)) +>p : Symbol(Y.p, Decl(relationCycleNonMonotoneCheckOrder.ts, 67, 17)) +>Tgt : Symbol(Tgt, Decl(relationCycleNonMonotoneCheckOrder.ts, 68, 41)) +>q : Symbol(Y.q, Decl(relationCycleNonMonotoneCheckOrder.ts, 67, 25)) + + type Src = { d: "a" | X; y: string }; +>Src : Symbol(Src, Decl(relationCycleNonMonotoneCheckOrder.ts, 67, 32)) +>d : Symbol(d, Decl(relationCycleNonMonotoneCheckOrder.ts, 68, 16)) +>X : Symbol(X, Decl(relationCycleNonMonotoneCheckOrder.ts, 65, 38)) +>y : Symbol(y, Decl(relationCycleNonMonotoneCheckOrder.ts, 68, 28)) + + type Tgt = { d: "a"; y: string } | { d: X; y: string } | { d: Y; y: number }; +>Tgt : Symbol(Tgt, Decl(relationCycleNonMonotoneCheckOrder.ts, 68, 41)) +>d : Symbol(d, Decl(relationCycleNonMonotoneCheckOrder.ts, 69, 16)) +>y : Symbol(y, Decl(relationCycleNonMonotoneCheckOrder.ts, 69, 24)) +>d : Symbol(d, Decl(relationCycleNonMonotoneCheckOrder.ts, 69, 40)) +>X : Symbol(X, Decl(relationCycleNonMonotoneCheckOrder.ts, 65, 38)) +>y : Symbol(y, Decl(relationCycleNonMonotoneCheckOrder.ts, 69, 46)) +>d : Symbol(d, Decl(relationCycleNonMonotoneCheckOrder.ts, 69, 62)) +>Y : Symbol(Y, Decl(relationCycleNonMonotoneCheckOrder.ts, 66, 37)) +>y : Symbol(y, Decl(relationCycleNonMonotoneCheckOrder.ts, 69, 68)) + + type Outer = { e: "z" } | { e: Tgt; w: number } | { e: Src }; +>Outer : Symbol(Outer, Decl(relationCycleNonMonotoneCheckOrder.ts, 69, 81)) +>e : Symbol(e, Decl(relationCycleNonMonotoneCheckOrder.ts, 70, 18)) +>e : Symbol(e, Decl(relationCycleNonMonotoneCheckOrder.ts, 70, 31)) +>Tgt : Symbol(Tgt, Decl(relationCycleNonMonotoneCheckOrder.ts, 68, 41)) +>w : Symbol(w, Decl(relationCycleNonMonotoneCheckOrder.ts, 70, 39)) +>e : Symbol(e, Decl(relationCycleNonMonotoneCheckOrder.ts, 70, 55)) +>Src : Symbol(Src, Decl(relationCycleNonMonotoneCheckOrder.ts, 67, 32)) + + declare let src: Src; +>src : Symbol(src, Decl(relationCycleNonMonotoneCheckOrder.ts, 72, 15)) +>Src : Symbol(Src, Decl(relationCycleNonMonotoneCheckOrder.ts, 67, 32)) + + let o: Outer = { e: src, w: 1 }; +>o : Symbol(o, Decl(relationCycleNonMonotoneCheckOrder.ts, 73, 7)) +>Outer : Symbol(Outer, Decl(relationCycleNonMonotoneCheckOrder.ts, 69, 81)) +>e : Symbol(e, Decl(relationCycleNonMonotoneCheckOrder.ts, 73, 20)) +>src : Symbol(src, Decl(relationCycleNonMonotoneCheckOrder.ts, 72, 15)) +>w : Symbol(w, Decl(relationCycleNonMonotoneCheckOrder.ts, 73, 28)) + + declare let r2: X extends Y ? true : false; +>r2 : Symbol(r2, Decl(relationCycleNonMonotoneCheckOrder.ts, 74, 15)) +>X : Symbol(X, Decl(relationCycleNonMonotoneCheckOrder.ts, 65, 38)) +>Y : Symbol(Y, Decl(relationCycleNonMonotoneCheckOrder.ts, 66, 37)) +} + +// Subtype reduction drops 'F' if it is a strict subtype of 'G'. Its +// optional parameter relates only if 'P' is not a strict subtype of 'Q', +// and relating 'P' to 'Q' compares 'F' to 'G' again before failing on +// 'z'. 'F' must be dropped whether or not 'P' was compared to 'Q' first. +namespace strictArity { +>strictArity : Symbol(strictArity, Decl(relationCycleNonMonotoneCheckOrder.ts, 75, 1)) + + type P = { f: F | G; z: number }; +>P : Symbol(P, Decl(relationCycleNonMonotoneCheckOrder.ts, 81, 23)) +>f : Symbol(f, Decl(relationCycleNonMonotoneCheckOrder.ts, 82, 14)) +>F : Symbol(F, Decl(relationCycleNonMonotoneCheckOrder.ts, 83, 28)) +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 84, 26)) +>z : Symbol(z, Decl(relationCycleNonMonotoneCheckOrder.ts, 82, 24)) + + type Q = { f: G; z: 1 }; +>Q : Symbol(Q, Decl(relationCycleNonMonotoneCheckOrder.ts, 82, 37)) +>f : Symbol(f, Decl(relationCycleNonMonotoneCheckOrder.ts, 83, 14)) +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 84, 26)) +>z : Symbol(z, Decl(relationCycleNonMonotoneCheckOrder.ts, 83, 20)) + + type F = (x?: P) => 1; +>F : Symbol(F, Decl(relationCycleNonMonotoneCheckOrder.ts, 83, 28)) +>x : Symbol(x, Decl(relationCycleNonMonotoneCheckOrder.ts, 84, 14)) +>P : Symbol(P, Decl(relationCycleNonMonotoneCheckOrder.ts, 81, 23)) + + type G = (x: Q | undefined) => number; +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 84, 26)) +>x : Symbol(x, Decl(relationCycleNonMonotoneCheckOrder.ts, 85, 14)) +>Q : Symbol(Q, Decl(relationCycleNonMonotoneCheckOrder.ts, 82, 37)) + + type WP = { a: P; b: string }; +>WP : Symbol(WP, Decl(relationCycleNonMonotoneCheckOrder.ts, 85, 42)) +>a : Symbol(a, Decl(relationCycleNonMonotoneCheckOrder.ts, 86, 15)) +>P : Symbol(P, Decl(relationCycleNonMonotoneCheckOrder.ts, 81, 23)) +>b : Symbol(b, Decl(relationCycleNonMonotoneCheckOrder.ts, 86, 21)) + + type WQ = { a: Q }; +>WQ : Symbol(WQ, Decl(relationCycleNonMonotoneCheckOrder.ts, 86, 34)) +>a : Symbol(a, Decl(relationCycleNonMonotoneCheckOrder.ts, 87, 15)) +>Q : Symbol(Q, Decl(relationCycleNonMonotoneCheckOrder.ts, 82, 37)) + + declare let f: F, g: G, wp: WP, wq: WQ; +>f : Symbol(f, Decl(relationCycleNonMonotoneCheckOrder.ts, 89, 15)) +>F : Symbol(F, Decl(relationCycleNonMonotoneCheckOrder.ts, 83, 28)) +>g : Symbol(g, Decl(relationCycleNonMonotoneCheckOrder.ts, 89, 21)) +>G : Symbol(G, Decl(relationCycleNonMonotoneCheckOrder.ts, 84, 26)) +>wp : Symbol(wp, Decl(relationCycleNonMonotoneCheckOrder.ts, 89, 27)) +>WP : Symbol(WP, Decl(relationCycleNonMonotoneCheckOrder.ts, 85, 42)) +>wq : Symbol(wq, Decl(relationCycleNonMonotoneCheckOrder.ts, 89, 35)) +>WQ : Symbol(WQ, Decl(relationCycleNonMonotoneCheckOrder.ts, 86, 34)) + + let a1 = [f, g]; +>a1 : Symbol(a1, Decl(relationCycleNonMonotoneCheckOrder.ts, 90, 7)) +>f : Symbol(f, Decl(relationCycleNonMonotoneCheckOrder.ts, 89, 15)) +>g : Symbol(g, Decl(relationCycleNonMonotoneCheckOrder.ts, 89, 21)) + + let a2 = [wp, wq]; +>a2 : Symbol(a2, Decl(relationCycleNonMonotoneCheckOrder.ts, 91, 7)) +>wp : Symbol(wp, Decl(relationCycleNonMonotoneCheckOrder.ts, 89, 27)) +>wq : Symbol(wq, Decl(relationCycleNonMonotoneCheckOrder.ts, 89, 35)) +} + diff --git a/tsc/testdata/baselines/reference/compiler/relationCycleNonMonotoneCheckOrder(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/relationCycleNonMonotoneCheckOrder(checkorder=typesfirst).types new file mode 100644 index 0000000000000..55c0f3952ae35 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/relationCycleNonMonotoneCheckOrder(checkorder=typesfirst).types @@ -0,0 +1,292 @@ +//// [tests/cases/compiler/relationCycleNonMonotoneCheckOrder.ts] //// + +=== relationCycleNonMonotoneCheckOrder.ts === +// 'S' relates to 'G' only if inferring 'T' from 'A' fails the constraint +// 'C', so that 'T' falls back to 'C'. Relating 'A' to 'C' compares 'S' to +// 'G' again, but 'A' fails 'C' on 'z' regardless. 'S' must relate to 'G' +// whether or not 'A' was compared to 'C' first. +namespace inferenceConstraint { +>inferenceConstraint : typeof inferenceConstraint + + type A = { k?: "c"; f: S | G; z: number }; +>A : A +>k : "c" | undefined +>f : G | S +>z : number + + type C = { [s: string]: "c" | G | number; f: G; z: 1 }; +>C : C +>s : string +>f : G +>z : 1 + + type S = (x: T) => T["k"]; +>S : S +>x : T + + type G = (x: A) => "c" | G | number; +>G : G +>x : A + + declare let r1: S extends G ? true : false; +>r1 : false +>true : true +>false : false + + declare let r2: A extends C ? true : false; +>r2 : false +>true : true +>false : false +} + +// As above, with method signatures, which are compared bivariantly. +namespace inferenceConstraintMethod { +>inferenceConstraintMethod : typeof inferenceConstraintMethod + + type A = { k?: "c"; f: S | G; z: number }; +>A : A +>k : "c" | undefined +>f : G | S +>z : number + + type C = { [s: string]: "c" | G | number; f: G; z: 1 }; +>C : C +>s : string +>f : G +>z : 1 + + type S = { m(x: T): T["k"] }; +>S : S +>m : (x: T) => T["k"] +>x : T + + type G = { m(x: A): "c" | G | number }; +>G : G +>m : (x: A) => "c" | G | number +>x : A + + declare let r1: S extends G ? true : false; +>r1 : false +>true : true +>false : false + + declare let r2: A extends C ? true : false; +>r2 : false +>true : true +>false : false +} + +// 'S1' relates to 'G1' only if 'S2' does not relate to 'G2', and the +// reverse, so no answer is consistent for both. Each is answered as if +// compared first, assuming itself while relating the other, regardless +// of which assignment is checked first. +namespace inferenceConstraintMutual { +>inferenceConstraintMutual : typeof inferenceConstraintMutual + + type A1 = { k?: "c"; f: S2 | G2 }; +>A1 : A1 +>k : "c" | undefined +>f : G2 | S2 + + type C1 = { [s: string]: "c" | G2; f: G2 }; +>C1 : C1 +>s : string +>f : G2 + + type S1 = (x: T) => T["k"]; +>S1 : S1 +>x : T + + type G1 = (x: A1) => "c" | G2; +>G1 : G1 +>x : A1 + + type A2 = { k?: "d"; f: S1 | G1 }; +>A2 : A2 +>k : "d" | undefined +>f : G1 | S1 + + type C2 = { [s: string]: "d" | G1; f: G1 }; +>C2 : C2 +>s : string +>f : G1 + + type S2 = (x: T) => T["k"]; +>S2 : S2 +>x : T + + type G2 = (x: A2) => "d" | G1; +>G2 : G2 +>x : A2 + + declare let s1: S1; +>s1 : S1 + + declare let s2: S2; +>s2 : S2 + + let g1: G1 = s1; +>g1 : G1 +>s1 : S1 + + let g2: G2 = s2; +>g2 : G2 +>s2 : S2 + + declare let r1: S1 extends G1 ? true : false; +>r1 : false +>true : true +>false : false + + declare let r2: S2 extends G2 ? true : false; +>r2 : true +>true : true +>false : false +} + +// 'Src' relates to the union 'Tgt' by discriminating on 'd'. The member +// '{ d: Y; y: number }' matches 'd: X' only if 'X' relates to 'Y', and +// relating 'X' to 'Y' compares 'Src' to 'Tgt' again before failing on +// 'q'. 'Src' must relate to 'Tgt' whether or not 'X' was compared to 'Y' +// first. +namespace discriminated { +>discriminated : typeof discriminated + + interface X { p: Src; q: number } +>p : Src +>q : number + + interface Y { p: Tgt; q: 1 } +>p : Tgt +>q : 1 + + type Src = { d: "a" | X; y: string }; +>Src : Src +>d : "a" | X +>y : string + + type Tgt = { d: "a"; y: string } | { d: X; y: string } | { d: Y; y: number }; +>Tgt : Tgt +>d : "a" +>y : string +>d : X +>y : string +>d : Y +>y : number + + declare let r1: Src extends Tgt ? true : false; +>r1 : false +>true : true +>false : false + + declare let r2: X extends Y ? true : false; +>r2 : false +>true : true +>false : false +} + +// The excess property check of the object literal keeps the members of +// 'Outer' whose 'e' the literal's 'e' relates to, so 'w' is known only +// if 'Src' relates to 'Tgt' as above. +namespace excessPropertyDiscriminant { +>excessPropertyDiscriminant : typeof excessPropertyDiscriminant + + interface X { p: Src; q: number } +>p : Src +>q : number + + interface Y { p: Tgt; q: 1 } +>p : Tgt +>q : 1 + + type Src = { d: "a" | X; y: string }; +>Src : Src +>d : "a" | X +>y : string + + type Tgt = { d: "a"; y: string } | { d: X; y: string } | { d: Y; y: number }; +>Tgt : Tgt +>d : "a" +>y : string +>d : X +>y : string +>d : Y +>y : number + + type Outer = { e: "z" } | { e: Tgt; w: number } | { e: Src }; +>Outer : Outer +>e : "z" +>e : Tgt +>w : number +>e : Src + + declare let src: Src; +>src : Src + + let o: Outer = { e: src, w: 1 }; +>o : Outer +>{ e: src, w: 1 } : { e: Src; w: number; } +>e : Src +>src : Src +>w : number +>1 : 1 + + declare let r2: X extends Y ? true : false; +>r2 : false +>true : true +>false : false +} + +// Subtype reduction drops 'F' if it is a strict subtype of 'G'. Its +// optional parameter relates only if 'P' is not a strict subtype of 'Q', +// and relating 'P' to 'Q' compares 'F' to 'G' again before failing on +// 'z'. 'F' must be dropped whether or not 'P' was compared to 'Q' first. +namespace strictArity { +>strictArity : typeof strictArity + + type P = { f: F | G; z: number }; +>P : P +>f : F | G +>z : number + + type Q = { f: G; z: 1 }; +>Q : Q +>f : G +>z : 1 + + type F = (x?: P) => 1; +>F : F +>x : P | undefined + + type G = (x: Q | undefined) => number; +>G : G +>x : Q | undefined + + type WP = { a: P; b: string }; +>WP : WP +>a : P +>b : string + + type WQ = { a: Q }; +>WQ : WQ +>a : Q + + declare let f: F, g: G, wp: WP, wq: WQ; +>f : F +>g : G +>wp : WP +>wq : WQ + + let a1 = [f, g]; +>a1 : (F | G)[] +>[f, g] : (F | G)[] +>f : F +>g : G + + let a2 = [wp, wq]; +>a2 : (WP | WQ)[] +>[wp, wq] : (WP | WQ)[] +>wp : WP +>wq : WQ +} + diff --git a/tsc/testdata/baselines/reference/compiler/relationDeeplyNestedCheckOrder.symbols b/tsc/testdata/baselines/reference/compiler/relationDeeplyNestedCheckOrder.symbols new file mode 100644 index 0000000000000..cdf23cc04d684 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/relationDeeplyNestedCheckOrder.symbols @@ -0,0 +1,54 @@ +//// [tests/cases/compiler/relationDeeplyNestedCheckOrder.ts] //// + +=== relationDeeplyNestedCheckOrder.ts === +// Relating 'B<{ a: string }>' to 'B<{ a: "lit" }>' eventually relates 'string' +// to '"lit"' through 'm0.m1.a.m0.m1', but only after measuring the variances +// of 'A', which gives up on deeply nested types. TypeScript reports an error +// for the 'B' assignment only when it is checked before the 'A' assignment; +// the result must not depend on which is checked first. + +type A = { m0: (x: B) => void; m1: { [K in keyof T]: B } }; +>A : Symbol(A, Decl(relationDeeplyNestedCheckOrder.ts, 0, 0)) +>T : Symbol(T, Decl(relationDeeplyNestedCheckOrder.ts, 6, 7)) +>m0 : Symbol(m0, Decl(relationDeeplyNestedCheckOrder.ts, 6, 13)) +>x : Symbol(x, Decl(relationDeeplyNestedCheckOrder.ts, 6, 19)) +>B : Symbol(B, Decl(relationDeeplyNestedCheckOrder.ts, 6, 71)) +>T : Symbol(T, Decl(relationDeeplyNestedCheckOrder.ts, 6, 7)) +>m1 : Symbol(m1, Decl(relationDeeplyNestedCheckOrder.ts, 6, 36)) +>K : Symbol(K, Decl(relationDeeplyNestedCheckOrder.ts, 6, 44)) +>T : Symbol(T, Decl(relationDeeplyNestedCheckOrder.ts, 6, 7)) +>B : Symbol(B, Decl(relationDeeplyNestedCheckOrder.ts, 6, 71)) +>T : Symbol(T, Decl(relationDeeplyNestedCheckOrder.ts, 6, 7)) +>K : Symbol(K, Decl(relationDeeplyNestedCheckOrder.ts, 6, 44)) + +type B = { m0: A }; +>B : Symbol(B, Decl(relationDeeplyNestedCheckOrder.ts, 6, 71)) +>T : Symbol(T, Decl(relationDeeplyNestedCheckOrder.ts, 7, 7)) +>m0 : Symbol(m0, Decl(relationDeeplyNestedCheckOrder.ts, 7, 13)) +>A : Symbol(A, Decl(relationDeeplyNestedCheckOrder.ts, 0, 0)) +>T : Symbol(T, Decl(relationDeeplyNestedCheckOrder.ts, 7, 7)) + +declare let a1: A<{ a: string }>, a2: A<{ a: "lit" }>; +>a1 : Symbol(a1, Decl(relationDeeplyNestedCheckOrder.ts, 9, 11)) +>A : Symbol(A, Decl(relationDeeplyNestedCheckOrder.ts, 0, 0)) +>a : Symbol(a, Decl(relationDeeplyNestedCheckOrder.ts, 9, 19)) +>a2 : Symbol(a2, Decl(relationDeeplyNestedCheckOrder.ts, 9, 33)) +>A : Symbol(A, Decl(relationDeeplyNestedCheckOrder.ts, 0, 0)) +>a : Symbol(a, Decl(relationDeeplyNestedCheckOrder.ts, 9, 41)) + +declare let b1: B<{ a: string }>, b2: B<{ a: "lit" }>; +>b1 : Symbol(b1, Decl(relationDeeplyNestedCheckOrder.ts, 10, 11)) +>B : Symbol(B, Decl(relationDeeplyNestedCheckOrder.ts, 6, 71)) +>a : Symbol(a, Decl(relationDeeplyNestedCheckOrder.ts, 10, 19)) +>b2 : Symbol(b2, Decl(relationDeeplyNestedCheckOrder.ts, 10, 33)) +>B : Symbol(B, Decl(relationDeeplyNestedCheckOrder.ts, 6, 71)) +>a : Symbol(a, Decl(relationDeeplyNestedCheckOrder.ts, 10, 41)) + +a2 = a1; +>a2 : Symbol(a2, Decl(relationDeeplyNestedCheckOrder.ts, 9, 33)) +>a1 : Symbol(a1, Decl(relationDeeplyNestedCheckOrder.ts, 9, 11)) + +b2 = b1; +>b2 : Symbol(b2, Decl(relationDeeplyNestedCheckOrder.ts, 10, 33)) +>b1 : Symbol(b1, Decl(relationDeeplyNestedCheckOrder.ts, 10, 11)) + diff --git a/tsc/testdata/baselines/reference/compiler/relationDeeplyNestedCheckOrder.types b/tsc/testdata/baselines/reference/compiler/relationDeeplyNestedCheckOrder.types new file mode 100644 index 0000000000000..fedd3a84c64f9 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/relationDeeplyNestedCheckOrder.types @@ -0,0 +1,41 @@ +//// [tests/cases/compiler/relationDeeplyNestedCheckOrder.ts] //// + +=== relationDeeplyNestedCheckOrder.ts === +// Relating 'B<{ a: string }>' to 'B<{ a: "lit" }>' eventually relates 'string' +// to '"lit"' through 'm0.m1.a.m0.m1', but only after measuring the variances +// of 'A', which gives up on deeply nested types. TypeScript reports an error +// for the 'B' assignment only when it is checked before the 'A' assignment; +// the result must not depend on which is checked first. + +type A = { m0: (x: B) => void; m1: { [K in keyof T]: B } }; +>A : A +>m0 : (x: B) => void +>x : B +>m1 : { [K in keyof T]: B; } + +type B = { m0: A }; +>B : B +>m0 : A + +declare let a1: A<{ a: string }>, a2: A<{ a: "lit" }>; +>a1 : A<{ a: string; }> +>a : string +>a2 : A<{ a: "lit"; }> +>a : "lit" + +declare let b1: B<{ a: string }>, b2: B<{ a: "lit" }>; +>b1 : B<{ a: string; }> +>a : string +>b2 : B<{ a: "lit"; }> +>a : "lit" + +a2 = a1; +>a2 = a1 : A<{ a: string; }> +>a2 : A<{ a: "lit"; }> +>a1 : A<{ a: string; }> + +b2 = b1; +>b2 = b1 : B<{ a: string; }> +>b2 : B<{ a: "lit"; }> +>b1 : B<{ a: string; }> + diff --git a/tsc/testdata/baselines/reference/compiler/relationDepthSharedCheckOrder(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/relationDepthSharedCheckOrder(checkorder=default).symbols new file mode 100644 index 0000000000000..89aebb5fd9f9a --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/relationDepthSharedCheckOrder(checkorder=default).symbols @@ -0,0 +1,1217 @@ +//// [tests/cases/compiler/relationDepthSharedCheckOrder.ts] //// + +=== relationDepthSharedCheckOrder.ts === +// Relating I0 to J0 fresh nests a comparison 100 levels deep, where it is +// cut short and so succeeds. In program order Mid has already found that +// I60 is not related to J60. Whether I0 is related to J0 must not depend +// on which comes first. Conditional types relate without reporting errors, +// which would compute the comparison again. + +interface I0 { next: I1 } +>I0 : Symbol(I0, Decl(relationDepthSharedCheckOrder.ts, 0, 0)) +>next : Symbol(I0.next, Decl(relationDepthSharedCheckOrder.ts, 6, 14)) +>I1 : Symbol(I1, Decl(relationDepthSharedCheckOrder.ts, 7, 25)) + +interface J0 { next: J1 } +>J0 : Symbol(J0, Decl(relationDepthSharedCheckOrder.ts, 6, 25)) +>next : Symbol(J0.next, Decl(relationDepthSharedCheckOrder.ts, 7, 14)) +>J1 : Symbol(J1, Decl(relationDepthSharedCheckOrder.ts, 8, 25)) + +interface I1 { next: I2 } +>I1 : Symbol(I1, Decl(relationDepthSharedCheckOrder.ts, 7, 25)) +>next : Symbol(I1.next, Decl(relationDepthSharedCheckOrder.ts, 8, 14)) +>I2 : Symbol(I2, Decl(relationDepthSharedCheckOrder.ts, 9, 25)) + +interface J1 { next: J2 } +>J1 : Symbol(J1, Decl(relationDepthSharedCheckOrder.ts, 8, 25)) +>next : Symbol(J1.next, Decl(relationDepthSharedCheckOrder.ts, 9, 14)) +>J2 : Symbol(J2, Decl(relationDepthSharedCheckOrder.ts, 10, 25)) + +interface I2 { next: I3 } +>I2 : Symbol(I2, Decl(relationDepthSharedCheckOrder.ts, 9, 25)) +>next : Symbol(I2.next, Decl(relationDepthSharedCheckOrder.ts, 10, 14)) +>I3 : Symbol(I3, Decl(relationDepthSharedCheckOrder.ts, 11, 25)) + +interface J2 { next: J3 } +>J2 : Symbol(J2, Decl(relationDepthSharedCheckOrder.ts, 10, 25)) +>next : Symbol(J2.next, Decl(relationDepthSharedCheckOrder.ts, 11, 14)) +>J3 : Symbol(J3, Decl(relationDepthSharedCheckOrder.ts, 12, 25)) + +interface I3 { next: I4 } +>I3 : Symbol(I3, Decl(relationDepthSharedCheckOrder.ts, 11, 25)) +>next : Symbol(I3.next, Decl(relationDepthSharedCheckOrder.ts, 12, 14)) +>I4 : Symbol(I4, Decl(relationDepthSharedCheckOrder.ts, 13, 25)) + +interface J3 { next: J4 } +>J3 : Symbol(J3, Decl(relationDepthSharedCheckOrder.ts, 12, 25)) +>next : Symbol(J3.next, Decl(relationDepthSharedCheckOrder.ts, 13, 14)) +>J4 : Symbol(J4, Decl(relationDepthSharedCheckOrder.ts, 14, 25)) + +interface I4 { next: I5 } +>I4 : Symbol(I4, Decl(relationDepthSharedCheckOrder.ts, 13, 25)) +>next : Symbol(I4.next, Decl(relationDepthSharedCheckOrder.ts, 14, 14)) +>I5 : Symbol(I5, Decl(relationDepthSharedCheckOrder.ts, 15, 25)) + +interface J4 { next: J5 } +>J4 : Symbol(J4, Decl(relationDepthSharedCheckOrder.ts, 14, 25)) +>next : Symbol(J4.next, Decl(relationDepthSharedCheckOrder.ts, 15, 14)) +>J5 : Symbol(J5, Decl(relationDepthSharedCheckOrder.ts, 16, 25)) + +interface I5 { next: I6 } +>I5 : Symbol(I5, Decl(relationDepthSharedCheckOrder.ts, 15, 25)) +>next : Symbol(I5.next, Decl(relationDepthSharedCheckOrder.ts, 16, 14)) +>I6 : Symbol(I6, Decl(relationDepthSharedCheckOrder.ts, 17, 25)) + +interface J5 { next: J6 } +>J5 : Symbol(J5, Decl(relationDepthSharedCheckOrder.ts, 16, 25)) +>next : Symbol(J5.next, Decl(relationDepthSharedCheckOrder.ts, 17, 14)) +>J6 : Symbol(J6, Decl(relationDepthSharedCheckOrder.ts, 18, 25)) + +interface I6 { next: I7 } +>I6 : Symbol(I6, Decl(relationDepthSharedCheckOrder.ts, 17, 25)) +>next : Symbol(I6.next, Decl(relationDepthSharedCheckOrder.ts, 18, 14)) +>I7 : Symbol(I7, Decl(relationDepthSharedCheckOrder.ts, 19, 25)) + +interface J6 { next: J7 } +>J6 : Symbol(J6, Decl(relationDepthSharedCheckOrder.ts, 18, 25)) +>next : Symbol(J6.next, Decl(relationDepthSharedCheckOrder.ts, 19, 14)) +>J7 : Symbol(J7, Decl(relationDepthSharedCheckOrder.ts, 20, 25)) + +interface I7 { next: I8 } +>I7 : Symbol(I7, Decl(relationDepthSharedCheckOrder.ts, 19, 25)) +>next : Symbol(I7.next, Decl(relationDepthSharedCheckOrder.ts, 20, 14)) +>I8 : Symbol(I8, Decl(relationDepthSharedCheckOrder.ts, 21, 25)) + +interface J7 { next: J8 } +>J7 : Symbol(J7, Decl(relationDepthSharedCheckOrder.ts, 20, 25)) +>next : Symbol(J7.next, Decl(relationDepthSharedCheckOrder.ts, 21, 14)) +>J8 : Symbol(J8, Decl(relationDepthSharedCheckOrder.ts, 22, 25)) + +interface I8 { next: I9 } +>I8 : Symbol(I8, Decl(relationDepthSharedCheckOrder.ts, 21, 25)) +>next : Symbol(I8.next, Decl(relationDepthSharedCheckOrder.ts, 22, 14)) +>I9 : Symbol(I9, Decl(relationDepthSharedCheckOrder.ts, 23, 25)) + +interface J8 { next: J9 } +>J8 : Symbol(J8, Decl(relationDepthSharedCheckOrder.ts, 22, 25)) +>next : Symbol(J8.next, Decl(relationDepthSharedCheckOrder.ts, 23, 14)) +>J9 : Symbol(J9, Decl(relationDepthSharedCheckOrder.ts, 24, 26)) + +interface I9 { next: I10 } +>I9 : Symbol(I9, Decl(relationDepthSharedCheckOrder.ts, 23, 25)) +>next : Symbol(I9.next, Decl(relationDepthSharedCheckOrder.ts, 24, 14)) +>I10 : Symbol(I10, Decl(relationDepthSharedCheckOrder.ts, 25, 26)) + +interface J9 { next: J10 } +>J9 : Symbol(J9, Decl(relationDepthSharedCheckOrder.ts, 24, 26)) +>next : Symbol(J9.next, Decl(relationDepthSharedCheckOrder.ts, 25, 14)) +>J10 : Symbol(J10, Decl(relationDepthSharedCheckOrder.ts, 26, 27)) + +interface I10 { next: I11 } +>I10 : Symbol(I10, Decl(relationDepthSharedCheckOrder.ts, 25, 26)) +>next : Symbol(I10.next, Decl(relationDepthSharedCheckOrder.ts, 26, 15)) +>I11 : Symbol(I11, Decl(relationDepthSharedCheckOrder.ts, 27, 27)) + +interface J10 { next: J11 } +>J10 : Symbol(J10, Decl(relationDepthSharedCheckOrder.ts, 26, 27)) +>next : Symbol(J10.next, Decl(relationDepthSharedCheckOrder.ts, 27, 15)) +>J11 : Symbol(J11, Decl(relationDepthSharedCheckOrder.ts, 28, 27)) + +interface I11 { next: I12 } +>I11 : Symbol(I11, Decl(relationDepthSharedCheckOrder.ts, 27, 27)) +>next : Symbol(I11.next, Decl(relationDepthSharedCheckOrder.ts, 28, 15)) +>I12 : Symbol(I12, Decl(relationDepthSharedCheckOrder.ts, 29, 27)) + +interface J11 { next: J12 } +>J11 : Symbol(J11, Decl(relationDepthSharedCheckOrder.ts, 28, 27)) +>next : Symbol(J11.next, Decl(relationDepthSharedCheckOrder.ts, 29, 15)) +>J12 : Symbol(J12, Decl(relationDepthSharedCheckOrder.ts, 30, 27)) + +interface I12 { next: I13 } +>I12 : Symbol(I12, Decl(relationDepthSharedCheckOrder.ts, 29, 27)) +>next : Symbol(I12.next, Decl(relationDepthSharedCheckOrder.ts, 30, 15)) +>I13 : Symbol(I13, Decl(relationDepthSharedCheckOrder.ts, 31, 27)) + +interface J12 { next: J13 } +>J12 : Symbol(J12, Decl(relationDepthSharedCheckOrder.ts, 30, 27)) +>next : Symbol(J12.next, Decl(relationDepthSharedCheckOrder.ts, 31, 15)) +>J13 : Symbol(J13, Decl(relationDepthSharedCheckOrder.ts, 32, 27)) + +interface I13 { next: I14 } +>I13 : Symbol(I13, Decl(relationDepthSharedCheckOrder.ts, 31, 27)) +>next : Symbol(I13.next, Decl(relationDepthSharedCheckOrder.ts, 32, 15)) +>I14 : Symbol(I14, Decl(relationDepthSharedCheckOrder.ts, 33, 27)) + +interface J13 { next: J14 } +>J13 : Symbol(J13, Decl(relationDepthSharedCheckOrder.ts, 32, 27)) +>next : Symbol(J13.next, Decl(relationDepthSharedCheckOrder.ts, 33, 15)) +>J14 : Symbol(J14, Decl(relationDepthSharedCheckOrder.ts, 34, 27)) + +interface I14 { next: I15 } +>I14 : Symbol(I14, Decl(relationDepthSharedCheckOrder.ts, 33, 27)) +>next : Symbol(I14.next, Decl(relationDepthSharedCheckOrder.ts, 34, 15)) +>I15 : Symbol(I15, Decl(relationDepthSharedCheckOrder.ts, 35, 27)) + +interface J14 { next: J15 } +>J14 : Symbol(J14, Decl(relationDepthSharedCheckOrder.ts, 34, 27)) +>next : Symbol(J14.next, Decl(relationDepthSharedCheckOrder.ts, 35, 15)) +>J15 : Symbol(J15, Decl(relationDepthSharedCheckOrder.ts, 36, 27)) + +interface I15 { next: I16 } +>I15 : Symbol(I15, Decl(relationDepthSharedCheckOrder.ts, 35, 27)) +>next : Symbol(I15.next, Decl(relationDepthSharedCheckOrder.ts, 36, 15)) +>I16 : Symbol(I16, Decl(relationDepthSharedCheckOrder.ts, 37, 27)) + +interface J15 { next: J16 } +>J15 : Symbol(J15, Decl(relationDepthSharedCheckOrder.ts, 36, 27)) +>next : Symbol(J15.next, Decl(relationDepthSharedCheckOrder.ts, 37, 15)) +>J16 : Symbol(J16, Decl(relationDepthSharedCheckOrder.ts, 38, 27)) + +interface I16 { next: I17 } +>I16 : Symbol(I16, Decl(relationDepthSharedCheckOrder.ts, 37, 27)) +>next : Symbol(I16.next, Decl(relationDepthSharedCheckOrder.ts, 38, 15)) +>I17 : Symbol(I17, Decl(relationDepthSharedCheckOrder.ts, 39, 27)) + +interface J16 { next: J17 } +>J16 : Symbol(J16, Decl(relationDepthSharedCheckOrder.ts, 38, 27)) +>next : Symbol(J16.next, Decl(relationDepthSharedCheckOrder.ts, 39, 15)) +>J17 : Symbol(J17, Decl(relationDepthSharedCheckOrder.ts, 40, 27)) + +interface I17 { next: I18 } +>I17 : Symbol(I17, Decl(relationDepthSharedCheckOrder.ts, 39, 27)) +>next : Symbol(I17.next, Decl(relationDepthSharedCheckOrder.ts, 40, 15)) +>I18 : Symbol(I18, Decl(relationDepthSharedCheckOrder.ts, 41, 27)) + +interface J17 { next: J18 } +>J17 : Symbol(J17, Decl(relationDepthSharedCheckOrder.ts, 40, 27)) +>next : Symbol(J17.next, Decl(relationDepthSharedCheckOrder.ts, 41, 15)) +>J18 : Symbol(J18, Decl(relationDepthSharedCheckOrder.ts, 42, 27)) + +interface I18 { next: I19 } +>I18 : Symbol(I18, Decl(relationDepthSharedCheckOrder.ts, 41, 27)) +>next : Symbol(I18.next, Decl(relationDepthSharedCheckOrder.ts, 42, 15)) +>I19 : Symbol(I19, Decl(relationDepthSharedCheckOrder.ts, 43, 27)) + +interface J18 { next: J19 } +>J18 : Symbol(J18, Decl(relationDepthSharedCheckOrder.ts, 42, 27)) +>next : Symbol(J18.next, Decl(relationDepthSharedCheckOrder.ts, 43, 15)) +>J19 : Symbol(J19, Decl(relationDepthSharedCheckOrder.ts, 44, 27)) + +interface I19 { next: I20 } +>I19 : Symbol(I19, Decl(relationDepthSharedCheckOrder.ts, 43, 27)) +>next : Symbol(I19.next, Decl(relationDepthSharedCheckOrder.ts, 44, 15)) +>I20 : Symbol(I20, Decl(relationDepthSharedCheckOrder.ts, 45, 27)) + +interface J19 { next: J20 } +>J19 : Symbol(J19, Decl(relationDepthSharedCheckOrder.ts, 44, 27)) +>next : Symbol(J19.next, Decl(relationDepthSharedCheckOrder.ts, 45, 15)) +>J20 : Symbol(J20, Decl(relationDepthSharedCheckOrder.ts, 46, 27)) + +interface I20 { next: I21 } +>I20 : Symbol(I20, Decl(relationDepthSharedCheckOrder.ts, 45, 27)) +>next : Symbol(I20.next, Decl(relationDepthSharedCheckOrder.ts, 46, 15)) +>I21 : Symbol(I21, Decl(relationDepthSharedCheckOrder.ts, 47, 27)) + +interface J20 { next: J21 } +>J20 : Symbol(J20, Decl(relationDepthSharedCheckOrder.ts, 46, 27)) +>next : Symbol(J20.next, Decl(relationDepthSharedCheckOrder.ts, 47, 15)) +>J21 : Symbol(J21, Decl(relationDepthSharedCheckOrder.ts, 48, 27)) + +interface I21 { next: I22 } +>I21 : Symbol(I21, Decl(relationDepthSharedCheckOrder.ts, 47, 27)) +>next : Symbol(I21.next, Decl(relationDepthSharedCheckOrder.ts, 48, 15)) +>I22 : Symbol(I22, Decl(relationDepthSharedCheckOrder.ts, 49, 27)) + +interface J21 { next: J22 } +>J21 : Symbol(J21, Decl(relationDepthSharedCheckOrder.ts, 48, 27)) +>next : Symbol(J21.next, Decl(relationDepthSharedCheckOrder.ts, 49, 15)) +>J22 : Symbol(J22, Decl(relationDepthSharedCheckOrder.ts, 50, 27)) + +interface I22 { next: I23 } +>I22 : Symbol(I22, Decl(relationDepthSharedCheckOrder.ts, 49, 27)) +>next : Symbol(I22.next, Decl(relationDepthSharedCheckOrder.ts, 50, 15)) +>I23 : Symbol(I23, Decl(relationDepthSharedCheckOrder.ts, 51, 27)) + +interface J22 { next: J23 } +>J22 : Symbol(J22, Decl(relationDepthSharedCheckOrder.ts, 50, 27)) +>next : Symbol(J22.next, Decl(relationDepthSharedCheckOrder.ts, 51, 15)) +>J23 : Symbol(J23, Decl(relationDepthSharedCheckOrder.ts, 52, 27)) + +interface I23 { next: I24 } +>I23 : Symbol(I23, Decl(relationDepthSharedCheckOrder.ts, 51, 27)) +>next : Symbol(I23.next, Decl(relationDepthSharedCheckOrder.ts, 52, 15)) +>I24 : Symbol(I24, Decl(relationDepthSharedCheckOrder.ts, 53, 27)) + +interface J23 { next: J24 } +>J23 : Symbol(J23, Decl(relationDepthSharedCheckOrder.ts, 52, 27)) +>next : Symbol(J23.next, Decl(relationDepthSharedCheckOrder.ts, 53, 15)) +>J24 : Symbol(J24, Decl(relationDepthSharedCheckOrder.ts, 54, 27)) + +interface I24 { next: I25 } +>I24 : Symbol(I24, Decl(relationDepthSharedCheckOrder.ts, 53, 27)) +>next : Symbol(I24.next, Decl(relationDepthSharedCheckOrder.ts, 54, 15)) +>I25 : Symbol(I25, Decl(relationDepthSharedCheckOrder.ts, 55, 27)) + +interface J24 { next: J25 } +>J24 : Symbol(J24, Decl(relationDepthSharedCheckOrder.ts, 54, 27)) +>next : Symbol(J24.next, Decl(relationDepthSharedCheckOrder.ts, 55, 15)) +>J25 : Symbol(J25, Decl(relationDepthSharedCheckOrder.ts, 56, 27)) + +interface I25 { next: I26 } +>I25 : Symbol(I25, Decl(relationDepthSharedCheckOrder.ts, 55, 27)) +>next : Symbol(I25.next, Decl(relationDepthSharedCheckOrder.ts, 56, 15)) +>I26 : Symbol(I26, Decl(relationDepthSharedCheckOrder.ts, 57, 27)) + +interface J25 { next: J26 } +>J25 : Symbol(J25, Decl(relationDepthSharedCheckOrder.ts, 56, 27)) +>next : Symbol(J25.next, Decl(relationDepthSharedCheckOrder.ts, 57, 15)) +>J26 : Symbol(J26, Decl(relationDepthSharedCheckOrder.ts, 58, 27)) + +interface I26 { next: I27 } +>I26 : Symbol(I26, Decl(relationDepthSharedCheckOrder.ts, 57, 27)) +>next : Symbol(I26.next, Decl(relationDepthSharedCheckOrder.ts, 58, 15)) +>I27 : Symbol(I27, Decl(relationDepthSharedCheckOrder.ts, 59, 27)) + +interface J26 { next: J27 } +>J26 : Symbol(J26, Decl(relationDepthSharedCheckOrder.ts, 58, 27)) +>next : Symbol(J26.next, Decl(relationDepthSharedCheckOrder.ts, 59, 15)) +>J27 : Symbol(J27, Decl(relationDepthSharedCheckOrder.ts, 60, 27)) + +interface I27 { next: I28 } +>I27 : Symbol(I27, Decl(relationDepthSharedCheckOrder.ts, 59, 27)) +>next : Symbol(I27.next, Decl(relationDepthSharedCheckOrder.ts, 60, 15)) +>I28 : Symbol(I28, Decl(relationDepthSharedCheckOrder.ts, 61, 27)) + +interface J27 { next: J28 } +>J27 : Symbol(J27, Decl(relationDepthSharedCheckOrder.ts, 60, 27)) +>next : Symbol(J27.next, Decl(relationDepthSharedCheckOrder.ts, 61, 15)) +>J28 : Symbol(J28, Decl(relationDepthSharedCheckOrder.ts, 62, 27)) + +interface I28 { next: I29 } +>I28 : Symbol(I28, Decl(relationDepthSharedCheckOrder.ts, 61, 27)) +>next : Symbol(I28.next, Decl(relationDepthSharedCheckOrder.ts, 62, 15)) +>I29 : Symbol(I29, Decl(relationDepthSharedCheckOrder.ts, 63, 27)) + +interface J28 { next: J29 } +>J28 : Symbol(J28, Decl(relationDepthSharedCheckOrder.ts, 62, 27)) +>next : Symbol(J28.next, Decl(relationDepthSharedCheckOrder.ts, 63, 15)) +>J29 : Symbol(J29, Decl(relationDepthSharedCheckOrder.ts, 64, 27)) + +interface I29 { next: I30 } +>I29 : Symbol(I29, Decl(relationDepthSharedCheckOrder.ts, 63, 27)) +>next : Symbol(I29.next, Decl(relationDepthSharedCheckOrder.ts, 64, 15)) +>I30 : Symbol(I30, Decl(relationDepthSharedCheckOrder.ts, 65, 27)) + +interface J29 { next: J30 } +>J29 : Symbol(J29, Decl(relationDepthSharedCheckOrder.ts, 64, 27)) +>next : Symbol(J29.next, Decl(relationDepthSharedCheckOrder.ts, 65, 15)) +>J30 : Symbol(J30, Decl(relationDepthSharedCheckOrder.ts, 66, 27)) + +interface I30 { next: I31 } +>I30 : Symbol(I30, Decl(relationDepthSharedCheckOrder.ts, 65, 27)) +>next : Symbol(I30.next, Decl(relationDepthSharedCheckOrder.ts, 66, 15)) +>I31 : Symbol(I31, Decl(relationDepthSharedCheckOrder.ts, 67, 27)) + +interface J30 { next: J31 } +>J30 : Symbol(J30, Decl(relationDepthSharedCheckOrder.ts, 66, 27)) +>next : Symbol(J30.next, Decl(relationDepthSharedCheckOrder.ts, 67, 15)) +>J31 : Symbol(J31, Decl(relationDepthSharedCheckOrder.ts, 68, 27)) + +interface I31 { next: I32 } +>I31 : Symbol(I31, Decl(relationDepthSharedCheckOrder.ts, 67, 27)) +>next : Symbol(I31.next, Decl(relationDepthSharedCheckOrder.ts, 68, 15)) +>I32 : Symbol(I32, Decl(relationDepthSharedCheckOrder.ts, 69, 27)) + +interface J31 { next: J32 } +>J31 : Symbol(J31, Decl(relationDepthSharedCheckOrder.ts, 68, 27)) +>next : Symbol(J31.next, Decl(relationDepthSharedCheckOrder.ts, 69, 15)) +>J32 : Symbol(J32, Decl(relationDepthSharedCheckOrder.ts, 70, 27)) + +interface I32 { next: I33 } +>I32 : Symbol(I32, Decl(relationDepthSharedCheckOrder.ts, 69, 27)) +>next : Symbol(I32.next, Decl(relationDepthSharedCheckOrder.ts, 70, 15)) +>I33 : Symbol(I33, Decl(relationDepthSharedCheckOrder.ts, 71, 27)) + +interface J32 { next: J33 } +>J32 : Symbol(J32, Decl(relationDepthSharedCheckOrder.ts, 70, 27)) +>next : Symbol(J32.next, Decl(relationDepthSharedCheckOrder.ts, 71, 15)) +>J33 : Symbol(J33, Decl(relationDepthSharedCheckOrder.ts, 72, 27)) + +interface I33 { next: I34 } +>I33 : Symbol(I33, Decl(relationDepthSharedCheckOrder.ts, 71, 27)) +>next : Symbol(I33.next, Decl(relationDepthSharedCheckOrder.ts, 72, 15)) +>I34 : Symbol(I34, Decl(relationDepthSharedCheckOrder.ts, 73, 27)) + +interface J33 { next: J34 } +>J33 : Symbol(J33, Decl(relationDepthSharedCheckOrder.ts, 72, 27)) +>next : Symbol(J33.next, Decl(relationDepthSharedCheckOrder.ts, 73, 15)) +>J34 : Symbol(J34, Decl(relationDepthSharedCheckOrder.ts, 74, 27)) + +interface I34 { next: I35 } +>I34 : Symbol(I34, Decl(relationDepthSharedCheckOrder.ts, 73, 27)) +>next : Symbol(I34.next, Decl(relationDepthSharedCheckOrder.ts, 74, 15)) +>I35 : Symbol(I35, Decl(relationDepthSharedCheckOrder.ts, 75, 27)) + +interface J34 { next: J35 } +>J34 : Symbol(J34, Decl(relationDepthSharedCheckOrder.ts, 74, 27)) +>next : Symbol(J34.next, Decl(relationDepthSharedCheckOrder.ts, 75, 15)) +>J35 : Symbol(J35, Decl(relationDepthSharedCheckOrder.ts, 76, 27)) + +interface I35 { next: I36 } +>I35 : Symbol(I35, Decl(relationDepthSharedCheckOrder.ts, 75, 27)) +>next : Symbol(I35.next, Decl(relationDepthSharedCheckOrder.ts, 76, 15)) +>I36 : Symbol(I36, Decl(relationDepthSharedCheckOrder.ts, 77, 27)) + +interface J35 { next: J36 } +>J35 : Symbol(J35, Decl(relationDepthSharedCheckOrder.ts, 76, 27)) +>next : Symbol(J35.next, Decl(relationDepthSharedCheckOrder.ts, 77, 15)) +>J36 : Symbol(J36, Decl(relationDepthSharedCheckOrder.ts, 78, 27)) + +interface I36 { next: I37 } +>I36 : Symbol(I36, Decl(relationDepthSharedCheckOrder.ts, 77, 27)) +>next : Symbol(I36.next, Decl(relationDepthSharedCheckOrder.ts, 78, 15)) +>I37 : Symbol(I37, Decl(relationDepthSharedCheckOrder.ts, 79, 27)) + +interface J36 { next: J37 } +>J36 : Symbol(J36, Decl(relationDepthSharedCheckOrder.ts, 78, 27)) +>next : Symbol(J36.next, Decl(relationDepthSharedCheckOrder.ts, 79, 15)) +>J37 : Symbol(J37, Decl(relationDepthSharedCheckOrder.ts, 80, 27)) + +interface I37 { next: I38 } +>I37 : Symbol(I37, Decl(relationDepthSharedCheckOrder.ts, 79, 27)) +>next : Symbol(I37.next, Decl(relationDepthSharedCheckOrder.ts, 80, 15)) +>I38 : Symbol(I38, Decl(relationDepthSharedCheckOrder.ts, 81, 27)) + +interface J37 { next: J38 } +>J37 : Symbol(J37, Decl(relationDepthSharedCheckOrder.ts, 80, 27)) +>next : Symbol(J37.next, Decl(relationDepthSharedCheckOrder.ts, 81, 15)) +>J38 : Symbol(J38, Decl(relationDepthSharedCheckOrder.ts, 82, 27)) + +interface I38 { next: I39 } +>I38 : Symbol(I38, Decl(relationDepthSharedCheckOrder.ts, 81, 27)) +>next : Symbol(I38.next, Decl(relationDepthSharedCheckOrder.ts, 82, 15)) +>I39 : Symbol(I39, Decl(relationDepthSharedCheckOrder.ts, 83, 27)) + +interface J38 { next: J39 } +>J38 : Symbol(J38, Decl(relationDepthSharedCheckOrder.ts, 82, 27)) +>next : Symbol(J38.next, Decl(relationDepthSharedCheckOrder.ts, 83, 15)) +>J39 : Symbol(J39, Decl(relationDepthSharedCheckOrder.ts, 84, 27)) + +interface I39 { next: I40 } +>I39 : Symbol(I39, Decl(relationDepthSharedCheckOrder.ts, 83, 27)) +>next : Symbol(I39.next, Decl(relationDepthSharedCheckOrder.ts, 84, 15)) +>I40 : Symbol(I40, Decl(relationDepthSharedCheckOrder.ts, 85, 27)) + +interface J39 { next: J40 } +>J39 : Symbol(J39, Decl(relationDepthSharedCheckOrder.ts, 84, 27)) +>next : Symbol(J39.next, Decl(relationDepthSharedCheckOrder.ts, 85, 15)) +>J40 : Symbol(J40, Decl(relationDepthSharedCheckOrder.ts, 86, 27)) + +interface I40 { next: I41 } +>I40 : Symbol(I40, Decl(relationDepthSharedCheckOrder.ts, 85, 27)) +>next : Symbol(I40.next, Decl(relationDepthSharedCheckOrder.ts, 86, 15)) +>I41 : Symbol(I41, Decl(relationDepthSharedCheckOrder.ts, 87, 27)) + +interface J40 { next: J41 } +>J40 : Symbol(J40, Decl(relationDepthSharedCheckOrder.ts, 86, 27)) +>next : Symbol(J40.next, Decl(relationDepthSharedCheckOrder.ts, 87, 15)) +>J41 : Symbol(J41, Decl(relationDepthSharedCheckOrder.ts, 88, 27)) + +interface I41 { next: I42 } +>I41 : Symbol(I41, Decl(relationDepthSharedCheckOrder.ts, 87, 27)) +>next : Symbol(I41.next, Decl(relationDepthSharedCheckOrder.ts, 88, 15)) +>I42 : Symbol(I42, Decl(relationDepthSharedCheckOrder.ts, 89, 27)) + +interface J41 { next: J42 } +>J41 : Symbol(J41, Decl(relationDepthSharedCheckOrder.ts, 88, 27)) +>next : Symbol(J41.next, Decl(relationDepthSharedCheckOrder.ts, 89, 15)) +>J42 : Symbol(J42, Decl(relationDepthSharedCheckOrder.ts, 90, 27)) + +interface I42 { next: I43 } +>I42 : Symbol(I42, Decl(relationDepthSharedCheckOrder.ts, 89, 27)) +>next : Symbol(I42.next, Decl(relationDepthSharedCheckOrder.ts, 90, 15)) +>I43 : Symbol(I43, Decl(relationDepthSharedCheckOrder.ts, 91, 27)) + +interface J42 { next: J43 } +>J42 : Symbol(J42, Decl(relationDepthSharedCheckOrder.ts, 90, 27)) +>next : Symbol(J42.next, Decl(relationDepthSharedCheckOrder.ts, 91, 15)) +>J43 : Symbol(J43, Decl(relationDepthSharedCheckOrder.ts, 92, 27)) + +interface I43 { next: I44 } +>I43 : Symbol(I43, Decl(relationDepthSharedCheckOrder.ts, 91, 27)) +>next : Symbol(I43.next, Decl(relationDepthSharedCheckOrder.ts, 92, 15)) +>I44 : Symbol(I44, Decl(relationDepthSharedCheckOrder.ts, 93, 27)) + +interface J43 { next: J44 } +>J43 : Symbol(J43, Decl(relationDepthSharedCheckOrder.ts, 92, 27)) +>next : Symbol(J43.next, Decl(relationDepthSharedCheckOrder.ts, 93, 15)) +>J44 : Symbol(J44, Decl(relationDepthSharedCheckOrder.ts, 94, 27)) + +interface I44 { next: I45 } +>I44 : Symbol(I44, Decl(relationDepthSharedCheckOrder.ts, 93, 27)) +>next : Symbol(I44.next, Decl(relationDepthSharedCheckOrder.ts, 94, 15)) +>I45 : Symbol(I45, Decl(relationDepthSharedCheckOrder.ts, 95, 27)) + +interface J44 { next: J45 } +>J44 : Symbol(J44, Decl(relationDepthSharedCheckOrder.ts, 94, 27)) +>next : Symbol(J44.next, Decl(relationDepthSharedCheckOrder.ts, 95, 15)) +>J45 : Symbol(J45, Decl(relationDepthSharedCheckOrder.ts, 96, 27)) + +interface I45 { next: I46 } +>I45 : Symbol(I45, Decl(relationDepthSharedCheckOrder.ts, 95, 27)) +>next : Symbol(I45.next, Decl(relationDepthSharedCheckOrder.ts, 96, 15)) +>I46 : Symbol(I46, Decl(relationDepthSharedCheckOrder.ts, 97, 27)) + +interface J45 { next: J46 } +>J45 : Symbol(J45, Decl(relationDepthSharedCheckOrder.ts, 96, 27)) +>next : Symbol(J45.next, Decl(relationDepthSharedCheckOrder.ts, 97, 15)) +>J46 : Symbol(J46, Decl(relationDepthSharedCheckOrder.ts, 98, 27)) + +interface I46 { next: I47 } +>I46 : Symbol(I46, Decl(relationDepthSharedCheckOrder.ts, 97, 27)) +>next : Symbol(I46.next, Decl(relationDepthSharedCheckOrder.ts, 98, 15)) +>I47 : Symbol(I47, Decl(relationDepthSharedCheckOrder.ts, 99, 27)) + +interface J46 { next: J47 } +>J46 : Symbol(J46, Decl(relationDepthSharedCheckOrder.ts, 98, 27)) +>next : Symbol(J46.next, Decl(relationDepthSharedCheckOrder.ts, 99, 15)) +>J47 : Symbol(J47, Decl(relationDepthSharedCheckOrder.ts, 100, 27)) + +interface I47 { next: I48 } +>I47 : Symbol(I47, Decl(relationDepthSharedCheckOrder.ts, 99, 27)) +>next : Symbol(I47.next, Decl(relationDepthSharedCheckOrder.ts, 100, 15)) +>I48 : Symbol(I48, Decl(relationDepthSharedCheckOrder.ts, 101, 27)) + +interface J47 { next: J48 } +>J47 : Symbol(J47, Decl(relationDepthSharedCheckOrder.ts, 100, 27)) +>next : Symbol(J47.next, Decl(relationDepthSharedCheckOrder.ts, 101, 15)) +>J48 : Symbol(J48, Decl(relationDepthSharedCheckOrder.ts, 102, 27)) + +interface I48 { next: I49 } +>I48 : Symbol(I48, Decl(relationDepthSharedCheckOrder.ts, 101, 27)) +>next : Symbol(I48.next, Decl(relationDepthSharedCheckOrder.ts, 102, 15)) +>I49 : Symbol(I49, Decl(relationDepthSharedCheckOrder.ts, 103, 27)) + +interface J48 { next: J49 } +>J48 : Symbol(J48, Decl(relationDepthSharedCheckOrder.ts, 102, 27)) +>next : Symbol(J48.next, Decl(relationDepthSharedCheckOrder.ts, 103, 15)) +>J49 : Symbol(J49, Decl(relationDepthSharedCheckOrder.ts, 104, 27)) + +interface I49 { next: I50 } +>I49 : Symbol(I49, Decl(relationDepthSharedCheckOrder.ts, 103, 27)) +>next : Symbol(I49.next, Decl(relationDepthSharedCheckOrder.ts, 104, 15)) +>I50 : Symbol(I50, Decl(relationDepthSharedCheckOrder.ts, 105, 27)) + +interface J49 { next: J50 } +>J49 : Symbol(J49, Decl(relationDepthSharedCheckOrder.ts, 104, 27)) +>next : Symbol(J49.next, Decl(relationDepthSharedCheckOrder.ts, 105, 15)) +>J50 : Symbol(J50, Decl(relationDepthSharedCheckOrder.ts, 106, 27)) + +interface I50 { next: I51 } +>I50 : Symbol(I50, Decl(relationDepthSharedCheckOrder.ts, 105, 27)) +>next : Symbol(I50.next, Decl(relationDepthSharedCheckOrder.ts, 106, 15)) +>I51 : Symbol(I51, Decl(relationDepthSharedCheckOrder.ts, 107, 27)) + +interface J50 { next: J51 } +>J50 : Symbol(J50, Decl(relationDepthSharedCheckOrder.ts, 106, 27)) +>next : Symbol(J50.next, Decl(relationDepthSharedCheckOrder.ts, 107, 15)) +>J51 : Symbol(J51, Decl(relationDepthSharedCheckOrder.ts, 108, 27)) + +interface I51 { next: I52 } +>I51 : Symbol(I51, Decl(relationDepthSharedCheckOrder.ts, 107, 27)) +>next : Symbol(I51.next, Decl(relationDepthSharedCheckOrder.ts, 108, 15)) +>I52 : Symbol(I52, Decl(relationDepthSharedCheckOrder.ts, 109, 27)) + +interface J51 { next: J52 } +>J51 : Symbol(J51, Decl(relationDepthSharedCheckOrder.ts, 108, 27)) +>next : Symbol(J51.next, Decl(relationDepthSharedCheckOrder.ts, 109, 15)) +>J52 : Symbol(J52, Decl(relationDepthSharedCheckOrder.ts, 110, 27)) + +interface I52 { next: I53 } +>I52 : Symbol(I52, Decl(relationDepthSharedCheckOrder.ts, 109, 27)) +>next : Symbol(I52.next, Decl(relationDepthSharedCheckOrder.ts, 110, 15)) +>I53 : Symbol(I53, Decl(relationDepthSharedCheckOrder.ts, 111, 27)) + +interface J52 { next: J53 } +>J52 : Symbol(J52, Decl(relationDepthSharedCheckOrder.ts, 110, 27)) +>next : Symbol(J52.next, Decl(relationDepthSharedCheckOrder.ts, 111, 15)) +>J53 : Symbol(J53, Decl(relationDepthSharedCheckOrder.ts, 112, 27)) + +interface I53 { next: I54 } +>I53 : Symbol(I53, Decl(relationDepthSharedCheckOrder.ts, 111, 27)) +>next : Symbol(I53.next, Decl(relationDepthSharedCheckOrder.ts, 112, 15)) +>I54 : Symbol(I54, Decl(relationDepthSharedCheckOrder.ts, 113, 27)) + +interface J53 { next: J54 } +>J53 : Symbol(J53, Decl(relationDepthSharedCheckOrder.ts, 112, 27)) +>next : Symbol(J53.next, Decl(relationDepthSharedCheckOrder.ts, 113, 15)) +>J54 : Symbol(J54, Decl(relationDepthSharedCheckOrder.ts, 114, 27)) + +interface I54 { next: I55 } +>I54 : Symbol(I54, Decl(relationDepthSharedCheckOrder.ts, 113, 27)) +>next : Symbol(I54.next, Decl(relationDepthSharedCheckOrder.ts, 114, 15)) +>I55 : Symbol(I55, Decl(relationDepthSharedCheckOrder.ts, 115, 27)) + +interface J54 { next: J55 } +>J54 : Symbol(J54, Decl(relationDepthSharedCheckOrder.ts, 114, 27)) +>next : Symbol(J54.next, Decl(relationDepthSharedCheckOrder.ts, 115, 15)) +>J55 : Symbol(J55, Decl(relationDepthSharedCheckOrder.ts, 116, 27)) + +interface I55 { next: I56 } +>I55 : Symbol(I55, Decl(relationDepthSharedCheckOrder.ts, 115, 27)) +>next : Symbol(I55.next, Decl(relationDepthSharedCheckOrder.ts, 116, 15)) +>I56 : Symbol(I56, Decl(relationDepthSharedCheckOrder.ts, 117, 27)) + +interface J55 { next: J56 } +>J55 : Symbol(J55, Decl(relationDepthSharedCheckOrder.ts, 116, 27)) +>next : Symbol(J55.next, Decl(relationDepthSharedCheckOrder.ts, 117, 15)) +>J56 : Symbol(J56, Decl(relationDepthSharedCheckOrder.ts, 118, 27)) + +interface I56 { next: I57 } +>I56 : Symbol(I56, Decl(relationDepthSharedCheckOrder.ts, 117, 27)) +>next : Symbol(I56.next, Decl(relationDepthSharedCheckOrder.ts, 118, 15)) +>I57 : Symbol(I57, Decl(relationDepthSharedCheckOrder.ts, 119, 27)) + +interface J56 { next: J57 } +>J56 : Symbol(J56, Decl(relationDepthSharedCheckOrder.ts, 118, 27)) +>next : Symbol(J56.next, Decl(relationDepthSharedCheckOrder.ts, 119, 15)) +>J57 : Symbol(J57, Decl(relationDepthSharedCheckOrder.ts, 120, 27)) + +interface I57 { next: I58 } +>I57 : Symbol(I57, Decl(relationDepthSharedCheckOrder.ts, 119, 27)) +>next : Symbol(I57.next, Decl(relationDepthSharedCheckOrder.ts, 120, 15)) +>I58 : Symbol(I58, Decl(relationDepthSharedCheckOrder.ts, 121, 27)) + +interface J57 { next: J58 } +>J57 : Symbol(J57, Decl(relationDepthSharedCheckOrder.ts, 120, 27)) +>next : Symbol(J57.next, Decl(relationDepthSharedCheckOrder.ts, 121, 15)) +>J58 : Symbol(J58, Decl(relationDepthSharedCheckOrder.ts, 122, 27)) + +interface I58 { next: I59 } +>I58 : Symbol(I58, Decl(relationDepthSharedCheckOrder.ts, 121, 27)) +>next : Symbol(I58.next, Decl(relationDepthSharedCheckOrder.ts, 122, 15)) +>I59 : Symbol(I59, Decl(relationDepthSharedCheckOrder.ts, 123, 27)) + +interface J58 { next: J59 } +>J58 : Symbol(J58, Decl(relationDepthSharedCheckOrder.ts, 122, 27)) +>next : Symbol(J58.next, Decl(relationDepthSharedCheckOrder.ts, 123, 15)) +>J59 : Symbol(J59, Decl(relationDepthSharedCheckOrder.ts, 124, 27)) + +interface I59 { next: I60 } +>I59 : Symbol(I59, Decl(relationDepthSharedCheckOrder.ts, 123, 27)) +>next : Symbol(I59.next, Decl(relationDepthSharedCheckOrder.ts, 124, 15)) +>I60 : Symbol(I60, Decl(relationDepthSharedCheckOrder.ts, 125, 27)) + +interface J59 { next: J60 } +>J59 : Symbol(J59, Decl(relationDepthSharedCheckOrder.ts, 124, 27)) +>next : Symbol(J59.next, Decl(relationDepthSharedCheckOrder.ts, 125, 15)) +>J60 : Symbol(J60, Decl(relationDepthSharedCheckOrder.ts, 126, 27)) + +interface I60 { next: I61 } +>I60 : Symbol(I60, Decl(relationDepthSharedCheckOrder.ts, 125, 27)) +>next : Symbol(I60.next, Decl(relationDepthSharedCheckOrder.ts, 126, 15)) +>I61 : Symbol(I61, Decl(relationDepthSharedCheckOrder.ts, 127, 27)) + +interface J60 { next: J61 } +>J60 : Symbol(J60, Decl(relationDepthSharedCheckOrder.ts, 126, 27)) +>next : Symbol(J60.next, Decl(relationDepthSharedCheckOrder.ts, 127, 15)) +>J61 : Symbol(J61, Decl(relationDepthSharedCheckOrder.ts, 128, 27)) + +interface I61 { next: I62 } +>I61 : Symbol(I61, Decl(relationDepthSharedCheckOrder.ts, 127, 27)) +>next : Symbol(I61.next, Decl(relationDepthSharedCheckOrder.ts, 128, 15)) +>I62 : Symbol(I62, Decl(relationDepthSharedCheckOrder.ts, 129, 27)) + +interface J61 { next: J62 } +>J61 : Symbol(J61, Decl(relationDepthSharedCheckOrder.ts, 128, 27)) +>next : Symbol(J61.next, Decl(relationDepthSharedCheckOrder.ts, 129, 15)) +>J62 : Symbol(J62, Decl(relationDepthSharedCheckOrder.ts, 130, 27)) + +interface I62 { next: I63 } +>I62 : Symbol(I62, Decl(relationDepthSharedCheckOrder.ts, 129, 27)) +>next : Symbol(I62.next, Decl(relationDepthSharedCheckOrder.ts, 130, 15)) +>I63 : Symbol(I63, Decl(relationDepthSharedCheckOrder.ts, 131, 27)) + +interface J62 { next: J63 } +>J62 : Symbol(J62, Decl(relationDepthSharedCheckOrder.ts, 130, 27)) +>next : Symbol(J62.next, Decl(relationDepthSharedCheckOrder.ts, 131, 15)) +>J63 : Symbol(J63, Decl(relationDepthSharedCheckOrder.ts, 132, 27)) + +interface I63 { next: I64 } +>I63 : Symbol(I63, Decl(relationDepthSharedCheckOrder.ts, 131, 27)) +>next : Symbol(I63.next, Decl(relationDepthSharedCheckOrder.ts, 132, 15)) +>I64 : Symbol(I64, Decl(relationDepthSharedCheckOrder.ts, 133, 27)) + +interface J63 { next: J64 } +>J63 : Symbol(J63, Decl(relationDepthSharedCheckOrder.ts, 132, 27)) +>next : Symbol(J63.next, Decl(relationDepthSharedCheckOrder.ts, 133, 15)) +>J64 : Symbol(J64, Decl(relationDepthSharedCheckOrder.ts, 134, 27)) + +interface I64 { next: I65 } +>I64 : Symbol(I64, Decl(relationDepthSharedCheckOrder.ts, 133, 27)) +>next : Symbol(I64.next, Decl(relationDepthSharedCheckOrder.ts, 134, 15)) +>I65 : Symbol(I65, Decl(relationDepthSharedCheckOrder.ts, 135, 27)) + +interface J64 { next: J65 } +>J64 : Symbol(J64, Decl(relationDepthSharedCheckOrder.ts, 134, 27)) +>next : Symbol(J64.next, Decl(relationDepthSharedCheckOrder.ts, 135, 15)) +>J65 : Symbol(J65, Decl(relationDepthSharedCheckOrder.ts, 136, 27)) + +interface I65 { next: I66 } +>I65 : Symbol(I65, Decl(relationDepthSharedCheckOrder.ts, 135, 27)) +>next : Symbol(I65.next, Decl(relationDepthSharedCheckOrder.ts, 136, 15)) +>I66 : Symbol(I66, Decl(relationDepthSharedCheckOrder.ts, 137, 27)) + +interface J65 { next: J66 } +>J65 : Symbol(J65, Decl(relationDepthSharedCheckOrder.ts, 136, 27)) +>next : Symbol(J65.next, Decl(relationDepthSharedCheckOrder.ts, 137, 15)) +>J66 : Symbol(J66, Decl(relationDepthSharedCheckOrder.ts, 138, 27)) + +interface I66 { next: I67 } +>I66 : Symbol(I66, Decl(relationDepthSharedCheckOrder.ts, 137, 27)) +>next : Symbol(I66.next, Decl(relationDepthSharedCheckOrder.ts, 138, 15)) +>I67 : Symbol(I67, Decl(relationDepthSharedCheckOrder.ts, 139, 27)) + +interface J66 { next: J67 } +>J66 : Symbol(J66, Decl(relationDepthSharedCheckOrder.ts, 138, 27)) +>next : Symbol(J66.next, Decl(relationDepthSharedCheckOrder.ts, 139, 15)) +>J67 : Symbol(J67, Decl(relationDepthSharedCheckOrder.ts, 140, 27)) + +interface I67 { next: I68 } +>I67 : Symbol(I67, Decl(relationDepthSharedCheckOrder.ts, 139, 27)) +>next : Symbol(I67.next, Decl(relationDepthSharedCheckOrder.ts, 140, 15)) +>I68 : Symbol(I68, Decl(relationDepthSharedCheckOrder.ts, 141, 27)) + +interface J67 { next: J68 } +>J67 : Symbol(J67, Decl(relationDepthSharedCheckOrder.ts, 140, 27)) +>next : Symbol(J67.next, Decl(relationDepthSharedCheckOrder.ts, 141, 15)) +>J68 : Symbol(J68, Decl(relationDepthSharedCheckOrder.ts, 142, 27)) + +interface I68 { next: I69 } +>I68 : Symbol(I68, Decl(relationDepthSharedCheckOrder.ts, 141, 27)) +>next : Symbol(I68.next, Decl(relationDepthSharedCheckOrder.ts, 142, 15)) +>I69 : Symbol(I69, Decl(relationDepthSharedCheckOrder.ts, 143, 27)) + +interface J68 { next: J69 } +>J68 : Symbol(J68, Decl(relationDepthSharedCheckOrder.ts, 142, 27)) +>next : Symbol(J68.next, Decl(relationDepthSharedCheckOrder.ts, 143, 15)) +>J69 : Symbol(J69, Decl(relationDepthSharedCheckOrder.ts, 144, 27)) + +interface I69 { next: I70 } +>I69 : Symbol(I69, Decl(relationDepthSharedCheckOrder.ts, 143, 27)) +>next : Symbol(I69.next, Decl(relationDepthSharedCheckOrder.ts, 144, 15)) +>I70 : Symbol(I70, Decl(relationDepthSharedCheckOrder.ts, 145, 27)) + +interface J69 { next: J70 } +>J69 : Symbol(J69, Decl(relationDepthSharedCheckOrder.ts, 144, 27)) +>next : Symbol(J69.next, Decl(relationDepthSharedCheckOrder.ts, 145, 15)) +>J70 : Symbol(J70, Decl(relationDepthSharedCheckOrder.ts, 146, 27)) + +interface I70 { next: I71 } +>I70 : Symbol(I70, Decl(relationDepthSharedCheckOrder.ts, 145, 27)) +>next : Symbol(I70.next, Decl(relationDepthSharedCheckOrder.ts, 146, 15)) +>I71 : Symbol(I71, Decl(relationDepthSharedCheckOrder.ts, 147, 27)) + +interface J70 { next: J71 } +>J70 : Symbol(J70, Decl(relationDepthSharedCheckOrder.ts, 146, 27)) +>next : Symbol(J70.next, Decl(relationDepthSharedCheckOrder.ts, 147, 15)) +>J71 : Symbol(J71, Decl(relationDepthSharedCheckOrder.ts, 148, 27)) + +interface I71 { next: I72 } +>I71 : Symbol(I71, Decl(relationDepthSharedCheckOrder.ts, 147, 27)) +>next : Symbol(I71.next, Decl(relationDepthSharedCheckOrder.ts, 148, 15)) +>I72 : Symbol(I72, Decl(relationDepthSharedCheckOrder.ts, 149, 27)) + +interface J71 { next: J72 } +>J71 : Symbol(J71, Decl(relationDepthSharedCheckOrder.ts, 148, 27)) +>next : Symbol(J71.next, Decl(relationDepthSharedCheckOrder.ts, 149, 15)) +>J72 : Symbol(J72, Decl(relationDepthSharedCheckOrder.ts, 150, 27)) + +interface I72 { next: I73 } +>I72 : Symbol(I72, Decl(relationDepthSharedCheckOrder.ts, 149, 27)) +>next : Symbol(I72.next, Decl(relationDepthSharedCheckOrder.ts, 150, 15)) +>I73 : Symbol(I73, Decl(relationDepthSharedCheckOrder.ts, 151, 27)) + +interface J72 { next: J73 } +>J72 : Symbol(J72, Decl(relationDepthSharedCheckOrder.ts, 150, 27)) +>next : Symbol(J72.next, Decl(relationDepthSharedCheckOrder.ts, 151, 15)) +>J73 : Symbol(J73, Decl(relationDepthSharedCheckOrder.ts, 152, 27)) + +interface I73 { next: I74 } +>I73 : Symbol(I73, Decl(relationDepthSharedCheckOrder.ts, 151, 27)) +>next : Symbol(I73.next, Decl(relationDepthSharedCheckOrder.ts, 152, 15)) +>I74 : Symbol(I74, Decl(relationDepthSharedCheckOrder.ts, 153, 27)) + +interface J73 { next: J74 } +>J73 : Symbol(J73, Decl(relationDepthSharedCheckOrder.ts, 152, 27)) +>next : Symbol(J73.next, Decl(relationDepthSharedCheckOrder.ts, 153, 15)) +>J74 : Symbol(J74, Decl(relationDepthSharedCheckOrder.ts, 154, 27)) + +interface I74 { next: I75 } +>I74 : Symbol(I74, Decl(relationDepthSharedCheckOrder.ts, 153, 27)) +>next : Symbol(I74.next, Decl(relationDepthSharedCheckOrder.ts, 154, 15)) +>I75 : Symbol(I75, Decl(relationDepthSharedCheckOrder.ts, 155, 27)) + +interface J74 { next: J75 } +>J74 : Symbol(J74, Decl(relationDepthSharedCheckOrder.ts, 154, 27)) +>next : Symbol(J74.next, Decl(relationDepthSharedCheckOrder.ts, 155, 15)) +>J75 : Symbol(J75, Decl(relationDepthSharedCheckOrder.ts, 156, 27)) + +interface I75 { next: I76 } +>I75 : Symbol(I75, Decl(relationDepthSharedCheckOrder.ts, 155, 27)) +>next : Symbol(I75.next, Decl(relationDepthSharedCheckOrder.ts, 156, 15)) +>I76 : Symbol(I76, Decl(relationDepthSharedCheckOrder.ts, 157, 27)) + +interface J75 { next: J76 } +>J75 : Symbol(J75, Decl(relationDepthSharedCheckOrder.ts, 156, 27)) +>next : Symbol(J75.next, Decl(relationDepthSharedCheckOrder.ts, 157, 15)) +>J76 : Symbol(J76, Decl(relationDepthSharedCheckOrder.ts, 158, 27)) + +interface I76 { next: I77 } +>I76 : Symbol(I76, Decl(relationDepthSharedCheckOrder.ts, 157, 27)) +>next : Symbol(I76.next, Decl(relationDepthSharedCheckOrder.ts, 158, 15)) +>I77 : Symbol(I77, Decl(relationDepthSharedCheckOrder.ts, 159, 27)) + +interface J76 { next: J77 } +>J76 : Symbol(J76, Decl(relationDepthSharedCheckOrder.ts, 158, 27)) +>next : Symbol(J76.next, Decl(relationDepthSharedCheckOrder.ts, 159, 15)) +>J77 : Symbol(J77, Decl(relationDepthSharedCheckOrder.ts, 160, 27)) + +interface I77 { next: I78 } +>I77 : Symbol(I77, Decl(relationDepthSharedCheckOrder.ts, 159, 27)) +>next : Symbol(I77.next, Decl(relationDepthSharedCheckOrder.ts, 160, 15)) +>I78 : Symbol(I78, Decl(relationDepthSharedCheckOrder.ts, 161, 27)) + +interface J77 { next: J78 } +>J77 : Symbol(J77, Decl(relationDepthSharedCheckOrder.ts, 160, 27)) +>next : Symbol(J77.next, Decl(relationDepthSharedCheckOrder.ts, 161, 15)) +>J78 : Symbol(J78, Decl(relationDepthSharedCheckOrder.ts, 162, 27)) + +interface I78 { next: I79 } +>I78 : Symbol(I78, Decl(relationDepthSharedCheckOrder.ts, 161, 27)) +>next : Symbol(I78.next, Decl(relationDepthSharedCheckOrder.ts, 162, 15)) +>I79 : Symbol(I79, Decl(relationDepthSharedCheckOrder.ts, 163, 27)) + +interface J78 { next: J79 } +>J78 : Symbol(J78, Decl(relationDepthSharedCheckOrder.ts, 162, 27)) +>next : Symbol(J78.next, Decl(relationDepthSharedCheckOrder.ts, 163, 15)) +>J79 : Symbol(J79, Decl(relationDepthSharedCheckOrder.ts, 164, 27)) + +interface I79 { next: I80 } +>I79 : Symbol(I79, Decl(relationDepthSharedCheckOrder.ts, 163, 27)) +>next : Symbol(I79.next, Decl(relationDepthSharedCheckOrder.ts, 164, 15)) +>I80 : Symbol(I80, Decl(relationDepthSharedCheckOrder.ts, 165, 27)) + +interface J79 { next: J80 } +>J79 : Symbol(J79, Decl(relationDepthSharedCheckOrder.ts, 164, 27)) +>next : Symbol(J79.next, Decl(relationDepthSharedCheckOrder.ts, 165, 15)) +>J80 : Symbol(J80, Decl(relationDepthSharedCheckOrder.ts, 166, 27)) + +interface I80 { next: I81 } +>I80 : Symbol(I80, Decl(relationDepthSharedCheckOrder.ts, 165, 27)) +>next : Symbol(I80.next, Decl(relationDepthSharedCheckOrder.ts, 166, 15)) +>I81 : Symbol(I81, Decl(relationDepthSharedCheckOrder.ts, 167, 27)) + +interface J80 { next: J81 } +>J80 : Symbol(J80, Decl(relationDepthSharedCheckOrder.ts, 166, 27)) +>next : Symbol(J80.next, Decl(relationDepthSharedCheckOrder.ts, 167, 15)) +>J81 : Symbol(J81, Decl(relationDepthSharedCheckOrder.ts, 168, 27)) + +interface I81 { next: I82 } +>I81 : Symbol(I81, Decl(relationDepthSharedCheckOrder.ts, 167, 27)) +>next : Symbol(I81.next, Decl(relationDepthSharedCheckOrder.ts, 168, 15)) +>I82 : Symbol(I82, Decl(relationDepthSharedCheckOrder.ts, 169, 27)) + +interface J81 { next: J82 } +>J81 : Symbol(J81, Decl(relationDepthSharedCheckOrder.ts, 168, 27)) +>next : Symbol(J81.next, Decl(relationDepthSharedCheckOrder.ts, 169, 15)) +>J82 : Symbol(J82, Decl(relationDepthSharedCheckOrder.ts, 170, 27)) + +interface I82 { next: I83 } +>I82 : Symbol(I82, Decl(relationDepthSharedCheckOrder.ts, 169, 27)) +>next : Symbol(I82.next, Decl(relationDepthSharedCheckOrder.ts, 170, 15)) +>I83 : Symbol(I83, Decl(relationDepthSharedCheckOrder.ts, 171, 27)) + +interface J82 { next: J83 } +>J82 : Symbol(J82, Decl(relationDepthSharedCheckOrder.ts, 170, 27)) +>next : Symbol(J82.next, Decl(relationDepthSharedCheckOrder.ts, 171, 15)) +>J83 : Symbol(J83, Decl(relationDepthSharedCheckOrder.ts, 172, 27)) + +interface I83 { next: I84 } +>I83 : Symbol(I83, Decl(relationDepthSharedCheckOrder.ts, 171, 27)) +>next : Symbol(I83.next, Decl(relationDepthSharedCheckOrder.ts, 172, 15)) +>I84 : Symbol(I84, Decl(relationDepthSharedCheckOrder.ts, 173, 27)) + +interface J83 { next: J84 } +>J83 : Symbol(J83, Decl(relationDepthSharedCheckOrder.ts, 172, 27)) +>next : Symbol(J83.next, Decl(relationDepthSharedCheckOrder.ts, 173, 15)) +>J84 : Symbol(J84, Decl(relationDepthSharedCheckOrder.ts, 174, 27)) + +interface I84 { next: I85 } +>I84 : Symbol(I84, Decl(relationDepthSharedCheckOrder.ts, 173, 27)) +>next : Symbol(I84.next, Decl(relationDepthSharedCheckOrder.ts, 174, 15)) +>I85 : Symbol(I85, Decl(relationDepthSharedCheckOrder.ts, 175, 27)) + +interface J84 { next: J85 } +>J84 : Symbol(J84, Decl(relationDepthSharedCheckOrder.ts, 174, 27)) +>next : Symbol(J84.next, Decl(relationDepthSharedCheckOrder.ts, 175, 15)) +>J85 : Symbol(J85, Decl(relationDepthSharedCheckOrder.ts, 176, 27)) + +interface I85 { next: I86 } +>I85 : Symbol(I85, Decl(relationDepthSharedCheckOrder.ts, 175, 27)) +>next : Symbol(I85.next, Decl(relationDepthSharedCheckOrder.ts, 176, 15)) +>I86 : Symbol(I86, Decl(relationDepthSharedCheckOrder.ts, 177, 27)) + +interface J85 { next: J86 } +>J85 : Symbol(J85, Decl(relationDepthSharedCheckOrder.ts, 176, 27)) +>next : Symbol(J85.next, Decl(relationDepthSharedCheckOrder.ts, 177, 15)) +>J86 : Symbol(J86, Decl(relationDepthSharedCheckOrder.ts, 178, 27)) + +interface I86 { next: I87 } +>I86 : Symbol(I86, Decl(relationDepthSharedCheckOrder.ts, 177, 27)) +>next : Symbol(I86.next, Decl(relationDepthSharedCheckOrder.ts, 178, 15)) +>I87 : Symbol(I87, Decl(relationDepthSharedCheckOrder.ts, 179, 27)) + +interface J86 { next: J87 } +>J86 : Symbol(J86, Decl(relationDepthSharedCheckOrder.ts, 178, 27)) +>next : Symbol(J86.next, Decl(relationDepthSharedCheckOrder.ts, 179, 15)) +>J87 : Symbol(J87, Decl(relationDepthSharedCheckOrder.ts, 180, 27)) + +interface I87 { next: I88 } +>I87 : Symbol(I87, Decl(relationDepthSharedCheckOrder.ts, 179, 27)) +>next : Symbol(I87.next, Decl(relationDepthSharedCheckOrder.ts, 180, 15)) +>I88 : Symbol(I88, Decl(relationDepthSharedCheckOrder.ts, 181, 27)) + +interface J87 { next: J88 } +>J87 : Symbol(J87, Decl(relationDepthSharedCheckOrder.ts, 180, 27)) +>next : Symbol(J87.next, Decl(relationDepthSharedCheckOrder.ts, 181, 15)) +>J88 : Symbol(J88, Decl(relationDepthSharedCheckOrder.ts, 182, 27)) + +interface I88 { next: I89 } +>I88 : Symbol(I88, Decl(relationDepthSharedCheckOrder.ts, 181, 27)) +>next : Symbol(I88.next, Decl(relationDepthSharedCheckOrder.ts, 182, 15)) +>I89 : Symbol(I89, Decl(relationDepthSharedCheckOrder.ts, 183, 27)) + +interface J88 { next: J89 } +>J88 : Symbol(J88, Decl(relationDepthSharedCheckOrder.ts, 182, 27)) +>next : Symbol(J88.next, Decl(relationDepthSharedCheckOrder.ts, 183, 15)) +>J89 : Symbol(J89, Decl(relationDepthSharedCheckOrder.ts, 184, 27)) + +interface I89 { next: I90 } +>I89 : Symbol(I89, Decl(relationDepthSharedCheckOrder.ts, 183, 27)) +>next : Symbol(I89.next, Decl(relationDepthSharedCheckOrder.ts, 184, 15)) +>I90 : Symbol(I90, Decl(relationDepthSharedCheckOrder.ts, 185, 27)) + +interface J89 { next: J90 } +>J89 : Symbol(J89, Decl(relationDepthSharedCheckOrder.ts, 184, 27)) +>next : Symbol(J89.next, Decl(relationDepthSharedCheckOrder.ts, 185, 15)) +>J90 : Symbol(J90, Decl(relationDepthSharedCheckOrder.ts, 186, 27)) + +interface I90 { next: I91 } +>I90 : Symbol(I90, Decl(relationDepthSharedCheckOrder.ts, 185, 27)) +>next : Symbol(I90.next, Decl(relationDepthSharedCheckOrder.ts, 186, 15)) +>I91 : Symbol(I91, Decl(relationDepthSharedCheckOrder.ts, 187, 27)) + +interface J90 { next: J91 } +>J90 : Symbol(J90, Decl(relationDepthSharedCheckOrder.ts, 186, 27)) +>next : Symbol(J90.next, Decl(relationDepthSharedCheckOrder.ts, 187, 15)) +>J91 : Symbol(J91, Decl(relationDepthSharedCheckOrder.ts, 188, 27)) + +interface I91 { next: I92 } +>I91 : Symbol(I91, Decl(relationDepthSharedCheckOrder.ts, 187, 27)) +>next : Symbol(I91.next, Decl(relationDepthSharedCheckOrder.ts, 188, 15)) +>I92 : Symbol(I92, Decl(relationDepthSharedCheckOrder.ts, 189, 27)) + +interface J91 { next: J92 } +>J91 : Symbol(J91, Decl(relationDepthSharedCheckOrder.ts, 188, 27)) +>next : Symbol(J91.next, Decl(relationDepthSharedCheckOrder.ts, 189, 15)) +>J92 : Symbol(J92, Decl(relationDepthSharedCheckOrder.ts, 190, 27)) + +interface I92 { next: I93 } +>I92 : Symbol(I92, Decl(relationDepthSharedCheckOrder.ts, 189, 27)) +>next : Symbol(I92.next, Decl(relationDepthSharedCheckOrder.ts, 190, 15)) +>I93 : Symbol(I93, Decl(relationDepthSharedCheckOrder.ts, 191, 27)) + +interface J92 { next: J93 } +>J92 : Symbol(J92, Decl(relationDepthSharedCheckOrder.ts, 190, 27)) +>next : Symbol(J92.next, Decl(relationDepthSharedCheckOrder.ts, 191, 15)) +>J93 : Symbol(J93, Decl(relationDepthSharedCheckOrder.ts, 192, 27)) + +interface I93 { next: I94 } +>I93 : Symbol(I93, Decl(relationDepthSharedCheckOrder.ts, 191, 27)) +>next : Symbol(I93.next, Decl(relationDepthSharedCheckOrder.ts, 192, 15)) +>I94 : Symbol(I94, Decl(relationDepthSharedCheckOrder.ts, 193, 27)) + +interface J93 { next: J94 } +>J93 : Symbol(J93, Decl(relationDepthSharedCheckOrder.ts, 192, 27)) +>next : Symbol(J93.next, Decl(relationDepthSharedCheckOrder.ts, 193, 15)) +>J94 : Symbol(J94, Decl(relationDepthSharedCheckOrder.ts, 194, 27)) + +interface I94 { next: I95 } +>I94 : Symbol(I94, Decl(relationDepthSharedCheckOrder.ts, 193, 27)) +>next : Symbol(I94.next, Decl(relationDepthSharedCheckOrder.ts, 194, 15)) +>I95 : Symbol(I95, Decl(relationDepthSharedCheckOrder.ts, 195, 27)) + +interface J94 { next: J95 } +>J94 : Symbol(J94, Decl(relationDepthSharedCheckOrder.ts, 194, 27)) +>next : Symbol(J94.next, Decl(relationDepthSharedCheckOrder.ts, 195, 15)) +>J95 : Symbol(J95, Decl(relationDepthSharedCheckOrder.ts, 196, 27)) + +interface I95 { next: I96 } +>I95 : Symbol(I95, Decl(relationDepthSharedCheckOrder.ts, 195, 27)) +>next : Symbol(I95.next, Decl(relationDepthSharedCheckOrder.ts, 196, 15)) +>I96 : Symbol(I96, Decl(relationDepthSharedCheckOrder.ts, 197, 27)) + +interface J95 { next: J96 } +>J95 : Symbol(J95, Decl(relationDepthSharedCheckOrder.ts, 196, 27)) +>next : Symbol(J95.next, Decl(relationDepthSharedCheckOrder.ts, 197, 15)) +>J96 : Symbol(J96, Decl(relationDepthSharedCheckOrder.ts, 198, 27)) + +interface I96 { next: I97 } +>I96 : Symbol(I96, Decl(relationDepthSharedCheckOrder.ts, 197, 27)) +>next : Symbol(I96.next, Decl(relationDepthSharedCheckOrder.ts, 198, 15)) +>I97 : Symbol(I97, Decl(relationDepthSharedCheckOrder.ts, 199, 27)) + +interface J96 { next: J97 } +>J96 : Symbol(J96, Decl(relationDepthSharedCheckOrder.ts, 198, 27)) +>next : Symbol(J96.next, Decl(relationDepthSharedCheckOrder.ts, 199, 15)) +>J97 : Symbol(J97, Decl(relationDepthSharedCheckOrder.ts, 200, 27)) + +interface I97 { next: I98 } +>I97 : Symbol(I97, Decl(relationDepthSharedCheckOrder.ts, 199, 27)) +>next : Symbol(I97.next, Decl(relationDepthSharedCheckOrder.ts, 200, 15)) +>I98 : Symbol(I98, Decl(relationDepthSharedCheckOrder.ts, 201, 27)) + +interface J97 { next: J98 } +>J97 : Symbol(J97, Decl(relationDepthSharedCheckOrder.ts, 200, 27)) +>next : Symbol(J97.next, Decl(relationDepthSharedCheckOrder.ts, 201, 15)) +>J98 : Symbol(J98, Decl(relationDepthSharedCheckOrder.ts, 202, 27)) + +interface I98 { next: I99 } +>I98 : Symbol(I98, Decl(relationDepthSharedCheckOrder.ts, 201, 27)) +>next : Symbol(I98.next, Decl(relationDepthSharedCheckOrder.ts, 202, 15)) +>I99 : Symbol(I99, Decl(relationDepthSharedCheckOrder.ts, 203, 27)) + +interface J98 { next: J99 } +>J98 : Symbol(J98, Decl(relationDepthSharedCheckOrder.ts, 202, 27)) +>next : Symbol(J98.next, Decl(relationDepthSharedCheckOrder.ts, 203, 15)) +>J99 : Symbol(J99, Decl(relationDepthSharedCheckOrder.ts, 204, 28)) + +interface I99 { next: I100 } +>I99 : Symbol(I99, Decl(relationDepthSharedCheckOrder.ts, 203, 27)) +>next : Symbol(I99.next, Decl(relationDepthSharedCheckOrder.ts, 204, 15)) +>I100 : Symbol(I100, Decl(relationDepthSharedCheckOrder.ts, 205, 28)) + +interface J99 { next: J100 } +>J99 : Symbol(J99, Decl(relationDepthSharedCheckOrder.ts, 204, 28)) +>next : Symbol(J99.next, Decl(relationDepthSharedCheckOrder.ts, 205, 15)) +>J100 : Symbol(J100, Decl(relationDepthSharedCheckOrder.ts, 206, 29)) + +interface I100 { next: I101 } +>I100 : Symbol(I100, Decl(relationDepthSharedCheckOrder.ts, 205, 28)) +>next : Symbol(I100.next, Decl(relationDepthSharedCheckOrder.ts, 206, 16)) +>I101 : Symbol(I101, Decl(relationDepthSharedCheckOrder.ts, 207, 29)) + +interface J100 { next: J101 } +>J100 : Symbol(J100, Decl(relationDepthSharedCheckOrder.ts, 206, 29)) +>next : Symbol(J100.next, Decl(relationDepthSharedCheckOrder.ts, 207, 16)) +>J101 : Symbol(J101, Decl(relationDepthSharedCheckOrder.ts, 208, 29)) + +interface I101 { next: I102 } +>I101 : Symbol(I101, Decl(relationDepthSharedCheckOrder.ts, 207, 29)) +>next : Symbol(I101.next, Decl(relationDepthSharedCheckOrder.ts, 208, 16)) +>I102 : Symbol(I102, Decl(relationDepthSharedCheckOrder.ts, 209, 29)) + +interface J101 { next: J102 } +>J101 : Symbol(J101, Decl(relationDepthSharedCheckOrder.ts, 208, 29)) +>next : Symbol(J101.next, Decl(relationDepthSharedCheckOrder.ts, 209, 16)) +>J102 : Symbol(J102, Decl(relationDepthSharedCheckOrder.ts, 210, 29)) + +interface I102 { next: I103 } +>I102 : Symbol(I102, Decl(relationDepthSharedCheckOrder.ts, 209, 29)) +>next : Symbol(I102.next, Decl(relationDepthSharedCheckOrder.ts, 210, 16)) +>I103 : Symbol(I103, Decl(relationDepthSharedCheckOrder.ts, 211, 29)) + +interface J102 { next: J103 } +>J102 : Symbol(J102, Decl(relationDepthSharedCheckOrder.ts, 210, 29)) +>next : Symbol(J102.next, Decl(relationDepthSharedCheckOrder.ts, 211, 16)) +>J103 : Symbol(J103, Decl(relationDepthSharedCheckOrder.ts, 212, 29)) + +interface I103 { next: I104 } +>I103 : Symbol(I103, Decl(relationDepthSharedCheckOrder.ts, 211, 29)) +>next : Symbol(I103.next, Decl(relationDepthSharedCheckOrder.ts, 212, 16)) +>I104 : Symbol(I104, Decl(relationDepthSharedCheckOrder.ts, 213, 29)) + +interface J103 { next: J104 } +>J103 : Symbol(J103, Decl(relationDepthSharedCheckOrder.ts, 212, 29)) +>next : Symbol(J103.next, Decl(relationDepthSharedCheckOrder.ts, 213, 16)) +>J104 : Symbol(J104, Decl(relationDepthSharedCheckOrder.ts, 214, 29)) + +interface I104 { next: I105 } +>I104 : Symbol(I104, Decl(relationDepthSharedCheckOrder.ts, 213, 29)) +>next : Symbol(I104.next, Decl(relationDepthSharedCheckOrder.ts, 214, 16)) +>I105 : Symbol(I105, Decl(relationDepthSharedCheckOrder.ts, 215, 29)) + +interface J104 { next: J105 } +>J104 : Symbol(J104, Decl(relationDepthSharedCheckOrder.ts, 214, 29)) +>next : Symbol(J104.next, Decl(relationDepthSharedCheckOrder.ts, 215, 16)) +>J105 : Symbol(J105, Decl(relationDepthSharedCheckOrder.ts, 216, 29)) + +interface I105 { next: I106 } +>I105 : Symbol(I105, Decl(relationDepthSharedCheckOrder.ts, 215, 29)) +>next : Symbol(I105.next, Decl(relationDepthSharedCheckOrder.ts, 216, 16)) +>I106 : Symbol(I106, Decl(relationDepthSharedCheckOrder.ts, 217, 29)) + +interface J105 { next: J106 } +>J105 : Symbol(J105, Decl(relationDepthSharedCheckOrder.ts, 216, 29)) +>next : Symbol(J105.next, Decl(relationDepthSharedCheckOrder.ts, 217, 16)) +>J106 : Symbol(J106, Decl(relationDepthSharedCheckOrder.ts, 218, 29)) + +interface I106 { next: I107 } +>I106 : Symbol(I106, Decl(relationDepthSharedCheckOrder.ts, 217, 29)) +>next : Symbol(I106.next, Decl(relationDepthSharedCheckOrder.ts, 218, 16)) +>I107 : Symbol(I107, Decl(relationDepthSharedCheckOrder.ts, 219, 29)) + +interface J106 { next: J107 } +>J106 : Symbol(J106, Decl(relationDepthSharedCheckOrder.ts, 218, 29)) +>next : Symbol(J106.next, Decl(relationDepthSharedCheckOrder.ts, 219, 16)) +>J107 : Symbol(J107, Decl(relationDepthSharedCheckOrder.ts, 220, 29)) + +interface I107 { next: I108 } +>I107 : Symbol(I107, Decl(relationDepthSharedCheckOrder.ts, 219, 29)) +>next : Symbol(I107.next, Decl(relationDepthSharedCheckOrder.ts, 220, 16)) +>I108 : Symbol(I108, Decl(relationDepthSharedCheckOrder.ts, 221, 29)) + +interface J107 { next: J108 } +>J107 : Symbol(J107, Decl(relationDepthSharedCheckOrder.ts, 220, 29)) +>next : Symbol(J107.next, Decl(relationDepthSharedCheckOrder.ts, 221, 16)) +>J108 : Symbol(J108, Decl(relationDepthSharedCheckOrder.ts, 222, 29)) + +interface I108 { next: I109 } +>I108 : Symbol(I108, Decl(relationDepthSharedCheckOrder.ts, 221, 29)) +>next : Symbol(I108.next, Decl(relationDepthSharedCheckOrder.ts, 222, 16)) +>I109 : Symbol(I109, Decl(relationDepthSharedCheckOrder.ts, 223, 29)) + +interface J108 { next: J109 } +>J108 : Symbol(J108, Decl(relationDepthSharedCheckOrder.ts, 222, 29)) +>next : Symbol(J108.next, Decl(relationDepthSharedCheckOrder.ts, 223, 16)) +>J109 : Symbol(J109, Decl(relationDepthSharedCheckOrder.ts, 224, 29)) + +interface I109 { next: I110 } +>I109 : Symbol(I109, Decl(relationDepthSharedCheckOrder.ts, 223, 29)) +>next : Symbol(I109.next, Decl(relationDepthSharedCheckOrder.ts, 224, 16)) +>I110 : Symbol(I110, Decl(relationDepthSharedCheckOrder.ts, 225, 29)) + +interface J109 { next: J110 } +>J109 : Symbol(J109, Decl(relationDepthSharedCheckOrder.ts, 224, 29)) +>next : Symbol(J109.next, Decl(relationDepthSharedCheckOrder.ts, 225, 16)) +>J110 : Symbol(J110, Decl(relationDepthSharedCheckOrder.ts, 226, 29)) + +interface I110 { next: I111 } +>I110 : Symbol(I110, Decl(relationDepthSharedCheckOrder.ts, 225, 29)) +>next : Symbol(I110.next, Decl(relationDepthSharedCheckOrder.ts, 226, 16)) +>I111 : Symbol(I111, Decl(relationDepthSharedCheckOrder.ts, 227, 29)) + +interface J110 { next: J111 } +>J110 : Symbol(J110, Decl(relationDepthSharedCheckOrder.ts, 226, 29)) +>next : Symbol(J110.next, Decl(relationDepthSharedCheckOrder.ts, 227, 16)) +>J111 : Symbol(J111, Decl(relationDepthSharedCheckOrder.ts, 228, 29)) + +interface I111 { next: I112 } +>I111 : Symbol(I111, Decl(relationDepthSharedCheckOrder.ts, 227, 29)) +>next : Symbol(I111.next, Decl(relationDepthSharedCheckOrder.ts, 228, 16)) +>I112 : Symbol(I112, Decl(relationDepthSharedCheckOrder.ts, 229, 29)) + +interface J111 { next: J112 } +>J111 : Symbol(J111, Decl(relationDepthSharedCheckOrder.ts, 228, 29)) +>next : Symbol(J111.next, Decl(relationDepthSharedCheckOrder.ts, 229, 16)) +>J112 : Symbol(J112, Decl(relationDepthSharedCheckOrder.ts, 230, 29)) + +interface I112 { next: I113 } +>I112 : Symbol(I112, Decl(relationDepthSharedCheckOrder.ts, 229, 29)) +>next : Symbol(I112.next, Decl(relationDepthSharedCheckOrder.ts, 230, 16)) +>I113 : Symbol(I113, Decl(relationDepthSharedCheckOrder.ts, 231, 29)) + +interface J112 { next: J113 } +>J112 : Symbol(J112, Decl(relationDepthSharedCheckOrder.ts, 230, 29)) +>next : Symbol(J112.next, Decl(relationDepthSharedCheckOrder.ts, 231, 16)) +>J113 : Symbol(J113, Decl(relationDepthSharedCheckOrder.ts, 232, 29)) + +interface I113 { next: I114 } +>I113 : Symbol(I113, Decl(relationDepthSharedCheckOrder.ts, 231, 29)) +>next : Symbol(I113.next, Decl(relationDepthSharedCheckOrder.ts, 232, 16)) +>I114 : Symbol(I114, Decl(relationDepthSharedCheckOrder.ts, 233, 29)) + +interface J113 { next: J114 } +>J113 : Symbol(J113, Decl(relationDepthSharedCheckOrder.ts, 232, 29)) +>next : Symbol(J113.next, Decl(relationDepthSharedCheckOrder.ts, 233, 16)) +>J114 : Symbol(J114, Decl(relationDepthSharedCheckOrder.ts, 234, 29)) + +interface I114 { next: I115 } +>I114 : Symbol(I114, Decl(relationDepthSharedCheckOrder.ts, 233, 29)) +>next : Symbol(I114.next, Decl(relationDepthSharedCheckOrder.ts, 234, 16)) +>I115 : Symbol(I115, Decl(relationDepthSharedCheckOrder.ts, 235, 29)) + +interface J114 { next: J115 } +>J114 : Symbol(J114, Decl(relationDepthSharedCheckOrder.ts, 234, 29)) +>next : Symbol(J114.next, Decl(relationDepthSharedCheckOrder.ts, 235, 16)) +>J115 : Symbol(J115, Decl(relationDepthSharedCheckOrder.ts, 236, 29)) + +interface I115 { next: I116 } +>I115 : Symbol(I115, Decl(relationDepthSharedCheckOrder.ts, 235, 29)) +>next : Symbol(I115.next, Decl(relationDepthSharedCheckOrder.ts, 236, 16)) +>I116 : Symbol(I116, Decl(relationDepthSharedCheckOrder.ts, 237, 29)) + +interface J115 { next: J116 } +>J115 : Symbol(J115, Decl(relationDepthSharedCheckOrder.ts, 236, 29)) +>next : Symbol(J115.next, Decl(relationDepthSharedCheckOrder.ts, 237, 16)) +>J116 : Symbol(J116, Decl(relationDepthSharedCheckOrder.ts, 238, 29)) + +interface I116 { next: I117 } +>I116 : Symbol(I116, Decl(relationDepthSharedCheckOrder.ts, 237, 29)) +>next : Symbol(I116.next, Decl(relationDepthSharedCheckOrder.ts, 238, 16)) +>I117 : Symbol(I117, Decl(relationDepthSharedCheckOrder.ts, 239, 29)) + +interface J116 { next: J117 } +>J116 : Symbol(J116, Decl(relationDepthSharedCheckOrder.ts, 238, 29)) +>next : Symbol(J116.next, Decl(relationDepthSharedCheckOrder.ts, 239, 16)) +>J117 : Symbol(J117, Decl(relationDepthSharedCheckOrder.ts, 240, 29)) + +interface I117 { next: I118 } +>I117 : Symbol(I117, Decl(relationDepthSharedCheckOrder.ts, 239, 29)) +>next : Symbol(I117.next, Decl(relationDepthSharedCheckOrder.ts, 240, 16)) +>I118 : Symbol(I118, Decl(relationDepthSharedCheckOrder.ts, 241, 29)) + +interface J117 { next: J118 } +>J117 : Symbol(J117, Decl(relationDepthSharedCheckOrder.ts, 240, 29)) +>next : Symbol(J117.next, Decl(relationDepthSharedCheckOrder.ts, 241, 16)) +>J118 : Symbol(J118, Decl(relationDepthSharedCheckOrder.ts, 242, 29)) + +interface I118 { next: I119 } +>I118 : Symbol(I118, Decl(relationDepthSharedCheckOrder.ts, 241, 29)) +>next : Symbol(I118.next, Decl(relationDepthSharedCheckOrder.ts, 242, 16)) +>I119 : Symbol(I119, Decl(relationDepthSharedCheckOrder.ts, 243, 29)) + +interface J118 { next: J119 } +>J118 : Symbol(J118, Decl(relationDepthSharedCheckOrder.ts, 242, 29)) +>next : Symbol(J118.next, Decl(relationDepthSharedCheckOrder.ts, 243, 16)) +>J119 : Symbol(J119, Decl(relationDepthSharedCheckOrder.ts, 244, 31)) + +interface I119 { leaf: string } +>I119 : Symbol(I119, Decl(relationDepthSharedCheckOrder.ts, 243, 29)) +>leaf : Symbol(I119.leaf, Decl(relationDepthSharedCheckOrder.ts, 244, 16)) + +interface J119 { leaf: number } +>J119 : Symbol(J119, Decl(relationDepthSharedCheckOrder.ts, 244, 31)) +>leaf : Symbol(J119.leaf, Decl(relationDepthSharedCheckOrder.ts, 245, 16)) + +type Mid = I60 extends J60 ? true : false; +>Mid : Symbol(Mid, Decl(relationDepthSharedCheckOrder.ts, 245, 31)) +>I60 : Symbol(I60, Decl(relationDepthSharedCheckOrder.ts, 125, 27)) +>J60 : Symbol(J60, Decl(relationDepthSharedCheckOrder.ts, 126, 27)) + +type All = I0 extends J0 ? true : false; +>All : Symbol(All, Decl(relationDepthSharedCheckOrder.ts, 247, 42)) +>I0 : Symbol(I0, Decl(relationDepthSharedCheckOrder.ts, 0, 0)) +>J0 : Symbol(J0, Decl(relationDepthSharedCheckOrder.ts, 6, 25)) + diff --git a/tsc/testdata/baselines/reference/compiler/relationDepthSharedCheckOrder(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/relationDepthSharedCheckOrder(checkorder=default).types new file mode 100644 index 0000000000000..e24834758fb2e --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/relationDepthSharedCheckOrder(checkorder=default).types @@ -0,0 +1,739 @@ +//// [tests/cases/compiler/relationDepthSharedCheckOrder.ts] //// + +=== relationDepthSharedCheckOrder.ts === +// Relating I0 to J0 fresh nests a comparison 100 levels deep, where it is +// cut short and so succeeds. In program order Mid has already found that +// I60 is not related to J60. Whether I0 is related to J0 must not depend +// on which comes first. Conditional types relate without reporting errors, +// which would compute the comparison again. + +interface I0 { next: I1 } +>next : I1 + +interface J0 { next: J1 } +>next : J1 + +interface I1 { next: I2 } +>next : I2 + +interface J1 { next: J2 } +>next : J2 + +interface I2 { next: I3 } +>next : I3 + +interface J2 { next: J3 } +>next : J3 + +interface I3 { next: I4 } +>next : I4 + +interface J3 { next: J4 } +>next : J4 + +interface I4 { next: I5 } +>next : I5 + +interface J4 { next: J5 } +>next : J5 + +interface I5 { next: I6 } +>next : I6 + +interface J5 { next: J6 } +>next : J6 + +interface I6 { next: I7 } +>next : I7 + +interface J6 { next: J7 } +>next : J7 + +interface I7 { next: I8 } +>next : I8 + +interface J7 { next: J8 } +>next : J8 + +interface I8 { next: I9 } +>next : I9 + +interface J8 { next: J9 } +>next : J9 + +interface I9 { next: I10 } +>next : I10 + +interface J9 { next: J10 } +>next : J10 + +interface I10 { next: I11 } +>next : I11 + +interface J10 { next: J11 } +>next : J11 + +interface I11 { next: I12 } +>next : I12 + +interface J11 { next: J12 } +>next : J12 + +interface I12 { next: I13 } +>next : I13 + +interface J12 { next: J13 } +>next : J13 + +interface I13 { next: I14 } +>next : I14 + +interface J13 { next: J14 } +>next : J14 + +interface I14 { next: I15 } +>next : I15 + +interface J14 { next: J15 } +>next : J15 + +interface I15 { next: I16 } +>next : I16 + +interface J15 { next: J16 } +>next : J16 + +interface I16 { next: I17 } +>next : I17 + +interface J16 { next: J17 } +>next : J17 + +interface I17 { next: I18 } +>next : I18 + +interface J17 { next: J18 } +>next : J18 + +interface I18 { next: I19 } +>next : I19 + +interface J18 { next: J19 } +>next : J19 + +interface I19 { next: I20 } +>next : I20 + +interface J19 { next: J20 } +>next : J20 + +interface I20 { next: I21 } +>next : I21 + +interface J20 { next: J21 } +>next : J21 + +interface I21 { next: I22 } +>next : I22 + +interface J21 { next: J22 } +>next : J22 + +interface I22 { next: I23 } +>next : I23 + +interface J22 { next: J23 } +>next : J23 + +interface I23 { next: I24 } +>next : I24 + +interface J23 { next: J24 } +>next : J24 + +interface I24 { next: I25 } +>next : I25 + +interface J24 { next: J25 } +>next : J25 + +interface I25 { next: I26 } +>next : I26 + +interface J25 { next: J26 } +>next : J26 + +interface I26 { next: I27 } +>next : I27 + +interface J26 { next: J27 } +>next : J27 + +interface I27 { next: I28 } +>next : I28 + +interface J27 { next: J28 } +>next : J28 + +interface I28 { next: I29 } +>next : I29 + +interface J28 { next: J29 } +>next : J29 + +interface I29 { next: I30 } +>next : I30 + +interface J29 { next: J30 } +>next : J30 + +interface I30 { next: I31 } +>next : I31 + +interface J30 { next: J31 } +>next : J31 + +interface I31 { next: I32 } +>next : I32 + +interface J31 { next: J32 } +>next : J32 + +interface I32 { next: I33 } +>next : I33 + +interface J32 { next: J33 } +>next : J33 + +interface I33 { next: I34 } +>next : I34 + +interface J33 { next: J34 } +>next : J34 + +interface I34 { next: I35 } +>next : I35 + +interface J34 { next: J35 } +>next : J35 + +interface I35 { next: I36 } +>next : I36 + +interface J35 { next: J36 } +>next : J36 + +interface I36 { next: I37 } +>next : I37 + +interface J36 { next: J37 } +>next : J37 + +interface I37 { next: I38 } +>next : I38 + +interface J37 { next: J38 } +>next : J38 + +interface I38 { next: I39 } +>next : I39 + +interface J38 { next: J39 } +>next : J39 + +interface I39 { next: I40 } +>next : I40 + +interface J39 { next: J40 } +>next : J40 + +interface I40 { next: I41 } +>next : I41 + +interface J40 { next: J41 } +>next : J41 + +interface I41 { next: I42 } +>next : I42 + +interface J41 { next: J42 } +>next : J42 + +interface I42 { next: I43 } +>next : I43 + +interface J42 { next: J43 } +>next : J43 + +interface I43 { next: I44 } +>next : I44 + +interface J43 { next: J44 } +>next : J44 + +interface I44 { next: I45 } +>next : I45 + +interface J44 { next: J45 } +>next : J45 + +interface I45 { next: I46 } +>next : I46 + +interface J45 { next: J46 } +>next : J46 + +interface I46 { next: I47 } +>next : I47 + +interface J46 { next: J47 } +>next : J47 + +interface I47 { next: I48 } +>next : I48 + +interface J47 { next: J48 } +>next : J48 + +interface I48 { next: I49 } +>next : I49 + +interface J48 { next: J49 } +>next : J49 + +interface I49 { next: I50 } +>next : I50 + +interface J49 { next: J50 } +>next : J50 + +interface I50 { next: I51 } +>next : I51 + +interface J50 { next: J51 } +>next : J51 + +interface I51 { next: I52 } +>next : I52 + +interface J51 { next: J52 } +>next : J52 + +interface I52 { next: I53 } +>next : I53 + +interface J52 { next: J53 } +>next : J53 + +interface I53 { next: I54 } +>next : I54 + +interface J53 { next: J54 } +>next : J54 + +interface I54 { next: I55 } +>next : I55 + +interface J54 { next: J55 } +>next : J55 + +interface I55 { next: I56 } +>next : I56 + +interface J55 { next: J56 } +>next : J56 + +interface I56 { next: I57 } +>next : I57 + +interface J56 { next: J57 } +>next : J57 + +interface I57 { next: I58 } +>next : I58 + +interface J57 { next: J58 } +>next : J58 + +interface I58 { next: I59 } +>next : I59 + +interface J58 { next: J59 } +>next : J59 + +interface I59 { next: I60 } +>next : I60 + +interface J59 { next: J60 } +>next : J60 + +interface I60 { next: I61 } +>next : I61 + +interface J60 { next: J61 } +>next : J61 + +interface I61 { next: I62 } +>next : I62 + +interface J61 { next: J62 } +>next : J62 + +interface I62 { next: I63 } +>next : I63 + +interface J62 { next: J63 } +>next : J63 + +interface I63 { next: I64 } +>next : I64 + +interface J63 { next: J64 } +>next : J64 + +interface I64 { next: I65 } +>next : I65 + +interface J64 { next: J65 } +>next : J65 + +interface I65 { next: I66 } +>next : I66 + +interface J65 { next: J66 } +>next : J66 + +interface I66 { next: I67 } +>next : I67 + +interface J66 { next: J67 } +>next : J67 + +interface I67 { next: I68 } +>next : I68 + +interface J67 { next: J68 } +>next : J68 + +interface I68 { next: I69 } +>next : I69 + +interface J68 { next: J69 } +>next : J69 + +interface I69 { next: I70 } +>next : I70 + +interface J69 { next: J70 } +>next : J70 + +interface I70 { next: I71 } +>next : I71 + +interface J70 { next: J71 } +>next : J71 + +interface I71 { next: I72 } +>next : I72 + +interface J71 { next: J72 } +>next : J72 + +interface I72 { next: I73 } +>next : I73 + +interface J72 { next: J73 } +>next : J73 + +interface I73 { next: I74 } +>next : I74 + +interface J73 { next: J74 } +>next : J74 + +interface I74 { next: I75 } +>next : I75 + +interface J74 { next: J75 } +>next : J75 + +interface I75 { next: I76 } +>next : I76 + +interface J75 { next: J76 } +>next : J76 + +interface I76 { next: I77 } +>next : I77 + +interface J76 { next: J77 } +>next : J77 + +interface I77 { next: I78 } +>next : I78 + +interface J77 { next: J78 } +>next : J78 + +interface I78 { next: I79 } +>next : I79 + +interface J78 { next: J79 } +>next : J79 + +interface I79 { next: I80 } +>next : I80 + +interface J79 { next: J80 } +>next : J80 + +interface I80 { next: I81 } +>next : I81 + +interface J80 { next: J81 } +>next : J81 + +interface I81 { next: I82 } +>next : I82 + +interface J81 { next: J82 } +>next : J82 + +interface I82 { next: I83 } +>next : I83 + +interface J82 { next: J83 } +>next : J83 + +interface I83 { next: I84 } +>next : I84 + +interface J83 { next: J84 } +>next : J84 + +interface I84 { next: I85 } +>next : I85 + +interface J84 { next: J85 } +>next : J85 + +interface I85 { next: I86 } +>next : I86 + +interface J85 { next: J86 } +>next : J86 + +interface I86 { next: I87 } +>next : I87 + +interface J86 { next: J87 } +>next : J87 + +interface I87 { next: I88 } +>next : I88 + +interface J87 { next: J88 } +>next : J88 + +interface I88 { next: I89 } +>next : I89 + +interface J88 { next: J89 } +>next : J89 + +interface I89 { next: I90 } +>next : I90 + +interface J89 { next: J90 } +>next : J90 + +interface I90 { next: I91 } +>next : I91 + +interface J90 { next: J91 } +>next : J91 + +interface I91 { next: I92 } +>next : I92 + +interface J91 { next: J92 } +>next : J92 + +interface I92 { next: I93 } +>next : I93 + +interface J92 { next: J93 } +>next : J93 + +interface I93 { next: I94 } +>next : I94 + +interface J93 { next: J94 } +>next : J94 + +interface I94 { next: I95 } +>next : I95 + +interface J94 { next: J95 } +>next : J95 + +interface I95 { next: I96 } +>next : I96 + +interface J95 { next: J96 } +>next : J96 + +interface I96 { next: I97 } +>next : I97 + +interface J96 { next: J97 } +>next : J97 + +interface I97 { next: I98 } +>next : I98 + +interface J97 { next: J98 } +>next : J98 + +interface I98 { next: I99 } +>next : I99 + +interface J98 { next: J99 } +>next : J99 + +interface I99 { next: I100 } +>next : I100 + +interface J99 { next: J100 } +>next : J100 + +interface I100 { next: I101 } +>next : I101 + +interface J100 { next: J101 } +>next : J101 + +interface I101 { next: I102 } +>next : I102 + +interface J101 { next: J102 } +>next : J102 + +interface I102 { next: I103 } +>next : I103 + +interface J102 { next: J103 } +>next : J103 + +interface I103 { next: I104 } +>next : I104 + +interface J103 { next: J104 } +>next : J104 + +interface I104 { next: I105 } +>next : I105 + +interface J104 { next: J105 } +>next : J105 + +interface I105 { next: I106 } +>next : I106 + +interface J105 { next: J106 } +>next : J106 + +interface I106 { next: I107 } +>next : I107 + +interface J106 { next: J107 } +>next : J107 + +interface I107 { next: I108 } +>next : I108 + +interface J107 { next: J108 } +>next : J108 + +interface I108 { next: I109 } +>next : I109 + +interface J108 { next: J109 } +>next : J109 + +interface I109 { next: I110 } +>next : I110 + +interface J109 { next: J110 } +>next : J110 + +interface I110 { next: I111 } +>next : I111 + +interface J110 { next: J111 } +>next : J111 + +interface I111 { next: I112 } +>next : I112 + +interface J111 { next: J112 } +>next : J112 + +interface I112 { next: I113 } +>next : I113 + +interface J112 { next: J113 } +>next : J113 + +interface I113 { next: I114 } +>next : I114 + +interface J113 { next: J114 } +>next : J114 + +interface I114 { next: I115 } +>next : I115 + +interface J114 { next: J115 } +>next : J115 + +interface I115 { next: I116 } +>next : I116 + +interface J115 { next: J116 } +>next : J116 + +interface I116 { next: I117 } +>next : I117 + +interface J116 { next: J117 } +>next : J117 + +interface I117 { next: I118 } +>next : I118 + +interface J117 { next: J118 } +>next : J118 + +interface I118 { next: I119 } +>next : I119 + +interface J118 { next: J119 } +>next : J119 + +interface I119 { leaf: string } +>leaf : string + +interface J119 { leaf: number } +>leaf : number + +type Mid = I60 extends J60 ? true : false; +>Mid : false +>true : true +>false : false + +type All = I0 extends J0 ? true : false; +>All : false +>true : true +>false : false + diff --git a/tsc/testdata/baselines/reference/compiler/relationDepthSharedCheckOrder(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/relationDepthSharedCheckOrder(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..89aebb5fd9f9a --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/relationDepthSharedCheckOrder(checkorder=typesfirst).symbols @@ -0,0 +1,1217 @@ +//// [tests/cases/compiler/relationDepthSharedCheckOrder.ts] //// + +=== relationDepthSharedCheckOrder.ts === +// Relating I0 to J0 fresh nests a comparison 100 levels deep, where it is +// cut short and so succeeds. In program order Mid has already found that +// I60 is not related to J60. Whether I0 is related to J0 must not depend +// on which comes first. Conditional types relate without reporting errors, +// which would compute the comparison again. + +interface I0 { next: I1 } +>I0 : Symbol(I0, Decl(relationDepthSharedCheckOrder.ts, 0, 0)) +>next : Symbol(I0.next, Decl(relationDepthSharedCheckOrder.ts, 6, 14)) +>I1 : Symbol(I1, Decl(relationDepthSharedCheckOrder.ts, 7, 25)) + +interface J0 { next: J1 } +>J0 : Symbol(J0, Decl(relationDepthSharedCheckOrder.ts, 6, 25)) +>next : Symbol(J0.next, Decl(relationDepthSharedCheckOrder.ts, 7, 14)) +>J1 : Symbol(J1, Decl(relationDepthSharedCheckOrder.ts, 8, 25)) + +interface I1 { next: I2 } +>I1 : Symbol(I1, Decl(relationDepthSharedCheckOrder.ts, 7, 25)) +>next : Symbol(I1.next, Decl(relationDepthSharedCheckOrder.ts, 8, 14)) +>I2 : Symbol(I2, Decl(relationDepthSharedCheckOrder.ts, 9, 25)) + +interface J1 { next: J2 } +>J1 : Symbol(J1, Decl(relationDepthSharedCheckOrder.ts, 8, 25)) +>next : Symbol(J1.next, Decl(relationDepthSharedCheckOrder.ts, 9, 14)) +>J2 : Symbol(J2, Decl(relationDepthSharedCheckOrder.ts, 10, 25)) + +interface I2 { next: I3 } +>I2 : Symbol(I2, Decl(relationDepthSharedCheckOrder.ts, 9, 25)) +>next : Symbol(I2.next, Decl(relationDepthSharedCheckOrder.ts, 10, 14)) +>I3 : Symbol(I3, Decl(relationDepthSharedCheckOrder.ts, 11, 25)) + +interface J2 { next: J3 } +>J2 : Symbol(J2, Decl(relationDepthSharedCheckOrder.ts, 10, 25)) +>next : Symbol(J2.next, Decl(relationDepthSharedCheckOrder.ts, 11, 14)) +>J3 : Symbol(J3, Decl(relationDepthSharedCheckOrder.ts, 12, 25)) + +interface I3 { next: I4 } +>I3 : Symbol(I3, Decl(relationDepthSharedCheckOrder.ts, 11, 25)) +>next : Symbol(I3.next, Decl(relationDepthSharedCheckOrder.ts, 12, 14)) +>I4 : Symbol(I4, Decl(relationDepthSharedCheckOrder.ts, 13, 25)) + +interface J3 { next: J4 } +>J3 : Symbol(J3, Decl(relationDepthSharedCheckOrder.ts, 12, 25)) +>next : Symbol(J3.next, Decl(relationDepthSharedCheckOrder.ts, 13, 14)) +>J4 : Symbol(J4, Decl(relationDepthSharedCheckOrder.ts, 14, 25)) + +interface I4 { next: I5 } +>I4 : Symbol(I4, Decl(relationDepthSharedCheckOrder.ts, 13, 25)) +>next : Symbol(I4.next, Decl(relationDepthSharedCheckOrder.ts, 14, 14)) +>I5 : Symbol(I5, Decl(relationDepthSharedCheckOrder.ts, 15, 25)) + +interface J4 { next: J5 } +>J4 : Symbol(J4, Decl(relationDepthSharedCheckOrder.ts, 14, 25)) +>next : Symbol(J4.next, Decl(relationDepthSharedCheckOrder.ts, 15, 14)) +>J5 : Symbol(J5, Decl(relationDepthSharedCheckOrder.ts, 16, 25)) + +interface I5 { next: I6 } +>I5 : Symbol(I5, Decl(relationDepthSharedCheckOrder.ts, 15, 25)) +>next : Symbol(I5.next, Decl(relationDepthSharedCheckOrder.ts, 16, 14)) +>I6 : Symbol(I6, Decl(relationDepthSharedCheckOrder.ts, 17, 25)) + +interface J5 { next: J6 } +>J5 : Symbol(J5, Decl(relationDepthSharedCheckOrder.ts, 16, 25)) +>next : Symbol(J5.next, Decl(relationDepthSharedCheckOrder.ts, 17, 14)) +>J6 : Symbol(J6, Decl(relationDepthSharedCheckOrder.ts, 18, 25)) + +interface I6 { next: I7 } +>I6 : Symbol(I6, Decl(relationDepthSharedCheckOrder.ts, 17, 25)) +>next : Symbol(I6.next, Decl(relationDepthSharedCheckOrder.ts, 18, 14)) +>I7 : Symbol(I7, Decl(relationDepthSharedCheckOrder.ts, 19, 25)) + +interface J6 { next: J7 } +>J6 : Symbol(J6, Decl(relationDepthSharedCheckOrder.ts, 18, 25)) +>next : Symbol(J6.next, Decl(relationDepthSharedCheckOrder.ts, 19, 14)) +>J7 : Symbol(J7, Decl(relationDepthSharedCheckOrder.ts, 20, 25)) + +interface I7 { next: I8 } +>I7 : Symbol(I7, Decl(relationDepthSharedCheckOrder.ts, 19, 25)) +>next : Symbol(I7.next, Decl(relationDepthSharedCheckOrder.ts, 20, 14)) +>I8 : Symbol(I8, Decl(relationDepthSharedCheckOrder.ts, 21, 25)) + +interface J7 { next: J8 } +>J7 : Symbol(J7, Decl(relationDepthSharedCheckOrder.ts, 20, 25)) +>next : Symbol(J7.next, Decl(relationDepthSharedCheckOrder.ts, 21, 14)) +>J8 : Symbol(J8, Decl(relationDepthSharedCheckOrder.ts, 22, 25)) + +interface I8 { next: I9 } +>I8 : Symbol(I8, Decl(relationDepthSharedCheckOrder.ts, 21, 25)) +>next : Symbol(I8.next, Decl(relationDepthSharedCheckOrder.ts, 22, 14)) +>I9 : Symbol(I9, Decl(relationDepthSharedCheckOrder.ts, 23, 25)) + +interface J8 { next: J9 } +>J8 : Symbol(J8, Decl(relationDepthSharedCheckOrder.ts, 22, 25)) +>next : Symbol(J8.next, Decl(relationDepthSharedCheckOrder.ts, 23, 14)) +>J9 : Symbol(J9, Decl(relationDepthSharedCheckOrder.ts, 24, 26)) + +interface I9 { next: I10 } +>I9 : Symbol(I9, Decl(relationDepthSharedCheckOrder.ts, 23, 25)) +>next : Symbol(I9.next, Decl(relationDepthSharedCheckOrder.ts, 24, 14)) +>I10 : Symbol(I10, Decl(relationDepthSharedCheckOrder.ts, 25, 26)) + +interface J9 { next: J10 } +>J9 : Symbol(J9, Decl(relationDepthSharedCheckOrder.ts, 24, 26)) +>next : Symbol(J9.next, Decl(relationDepthSharedCheckOrder.ts, 25, 14)) +>J10 : Symbol(J10, Decl(relationDepthSharedCheckOrder.ts, 26, 27)) + +interface I10 { next: I11 } +>I10 : Symbol(I10, Decl(relationDepthSharedCheckOrder.ts, 25, 26)) +>next : Symbol(I10.next, Decl(relationDepthSharedCheckOrder.ts, 26, 15)) +>I11 : Symbol(I11, Decl(relationDepthSharedCheckOrder.ts, 27, 27)) + +interface J10 { next: J11 } +>J10 : Symbol(J10, Decl(relationDepthSharedCheckOrder.ts, 26, 27)) +>next : Symbol(J10.next, Decl(relationDepthSharedCheckOrder.ts, 27, 15)) +>J11 : Symbol(J11, Decl(relationDepthSharedCheckOrder.ts, 28, 27)) + +interface I11 { next: I12 } +>I11 : Symbol(I11, Decl(relationDepthSharedCheckOrder.ts, 27, 27)) +>next : Symbol(I11.next, Decl(relationDepthSharedCheckOrder.ts, 28, 15)) +>I12 : Symbol(I12, Decl(relationDepthSharedCheckOrder.ts, 29, 27)) + +interface J11 { next: J12 } +>J11 : Symbol(J11, Decl(relationDepthSharedCheckOrder.ts, 28, 27)) +>next : Symbol(J11.next, Decl(relationDepthSharedCheckOrder.ts, 29, 15)) +>J12 : Symbol(J12, Decl(relationDepthSharedCheckOrder.ts, 30, 27)) + +interface I12 { next: I13 } +>I12 : Symbol(I12, Decl(relationDepthSharedCheckOrder.ts, 29, 27)) +>next : Symbol(I12.next, Decl(relationDepthSharedCheckOrder.ts, 30, 15)) +>I13 : Symbol(I13, Decl(relationDepthSharedCheckOrder.ts, 31, 27)) + +interface J12 { next: J13 } +>J12 : Symbol(J12, Decl(relationDepthSharedCheckOrder.ts, 30, 27)) +>next : Symbol(J12.next, Decl(relationDepthSharedCheckOrder.ts, 31, 15)) +>J13 : Symbol(J13, Decl(relationDepthSharedCheckOrder.ts, 32, 27)) + +interface I13 { next: I14 } +>I13 : Symbol(I13, Decl(relationDepthSharedCheckOrder.ts, 31, 27)) +>next : Symbol(I13.next, Decl(relationDepthSharedCheckOrder.ts, 32, 15)) +>I14 : Symbol(I14, Decl(relationDepthSharedCheckOrder.ts, 33, 27)) + +interface J13 { next: J14 } +>J13 : Symbol(J13, Decl(relationDepthSharedCheckOrder.ts, 32, 27)) +>next : Symbol(J13.next, Decl(relationDepthSharedCheckOrder.ts, 33, 15)) +>J14 : Symbol(J14, Decl(relationDepthSharedCheckOrder.ts, 34, 27)) + +interface I14 { next: I15 } +>I14 : Symbol(I14, Decl(relationDepthSharedCheckOrder.ts, 33, 27)) +>next : Symbol(I14.next, Decl(relationDepthSharedCheckOrder.ts, 34, 15)) +>I15 : Symbol(I15, Decl(relationDepthSharedCheckOrder.ts, 35, 27)) + +interface J14 { next: J15 } +>J14 : Symbol(J14, Decl(relationDepthSharedCheckOrder.ts, 34, 27)) +>next : Symbol(J14.next, Decl(relationDepthSharedCheckOrder.ts, 35, 15)) +>J15 : Symbol(J15, Decl(relationDepthSharedCheckOrder.ts, 36, 27)) + +interface I15 { next: I16 } +>I15 : Symbol(I15, Decl(relationDepthSharedCheckOrder.ts, 35, 27)) +>next : Symbol(I15.next, Decl(relationDepthSharedCheckOrder.ts, 36, 15)) +>I16 : Symbol(I16, Decl(relationDepthSharedCheckOrder.ts, 37, 27)) + +interface J15 { next: J16 } +>J15 : Symbol(J15, Decl(relationDepthSharedCheckOrder.ts, 36, 27)) +>next : Symbol(J15.next, Decl(relationDepthSharedCheckOrder.ts, 37, 15)) +>J16 : Symbol(J16, Decl(relationDepthSharedCheckOrder.ts, 38, 27)) + +interface I16 { next: I17 } +>I16 : Symbol(I16, Decl(relationDepthSharedCheckOrder.ts, 37, 27)) +>next : Symbol(I16.next, Decl(relationDepthSharedCheckOrder.ts, 38, 15)) +>I17 : Symbol(I17, Decl(relationDepthSharedCheckOrder.ts, 39, 27)) + +interface J16 { next: J17 } +>J16 : Symbol(J16, Decl(relationDepthSharedCheckOrder.ts, 38, 27)) +>next : Symbol(J16.next, Decl(relationDepthSharedCheckOrder.ts, 39, 15)) +>J17 : Symbol(J17, Decl(relationDepthSharedCheckOrder.ts, 40, 27)) + +interface I17 { next: I18 } +>I17 : Symbol(I17, Decl(relationDepthSharedCheckOrder.ts, 39, 27)) +>next : Symbol(I17.next, Decl(relationDepthSharedCheckOrder.ts, 40, 15)) +>I18 : Symbol(I18, Decl(relationDepthSharedCheckOrder.ts, 41, 27)) + +interface J17 { next: J18 } +>J17 : Symbol(J17, Decl(relationDepthSharedCheckOrder.ts, 40, 27)) +>next : Symbol(J17.next, Decl(relationDepthSharedCheckOrder.ts, 41, 15)) +>J18 : Symbol(J18, Decl(relationDepthSharedCheckOrder.ts, 42, 27)) + +interface I18 { next: I19 } +>I18 : Symbol(I18, Decl(relationDepthSharedCheckOrder.ts, 41, 27)) +>next : Symbol(I18.next, Decl(relationDepthSharedCheckOrder.ts, 42, 15)) +>I19 : Symbol(I19, Decl(relationDepthSharedCheckOrder.ts, 43, 27)) + +interface J18 { next: J19 } +>J18 : Symbol(J18, Decl(relationDepthSharedCheckOrder.ts, 42, 27)) +>next : Symbol(J18.next, Decl(relationDepthSharedCheckOrder.ts, 43, 15)) +>J19 : Symbol(J19, Decl(relationDepthSharedCheckOrder.ts, 44, 27)) + +interface I19 { next: I20 } +>I19 : Symbol(I19, Decl(relationDepthSharedCheckOrder.ts, 43, 27)) +>next : Symbol(I19.next, Decl(relationDepthSharedCheckOrder.ts, 44, 15)) +>I20 : Symbol(I20, Decl(relationDepthSharedCheckOrder.ts, 45, 27)) + +interface J19 { next: J20 } +>J19 : Symbol(J19, Decl(relationDepthSharedCheckOrder.ts, 44, 27)) +>next : Symbol(J19.next, Decl(relationDepthSharedCheckOrder.ts, 45, 15)) +>J20 : Symbol(J20, Decl(relationDepthSharedCheckOrder.ts, 46, 27)) + +interface I20 { next: I21 } +>I20 : Symbol(I20, Decl(relationDepthSharedCheckOrder.ts, 45, 27)) +>next : Symbol(I20.next, Decl(relationDepthSharedCheckOrder.ts, 46, 15)) +>I21 : Symbol(I21, Decl(relationDepthSharedCheckOrder.ts, 47, 27)) + +interface J20 { next: J21 } +>J20 : Symbol(J20, Decl(relationDepthSharedCheckOrder.ts, 46, 27)) +>next : Symbol(J20.next, Decl(relationDepthSharedCheckOrder.ts, 47, 15)) +>J21 : Symbol(J21, Decl(relationDepthSharedCheckOrder.ts, 48, 27)) + +interface I21 { next: I22 } +>I21 : Symbol(I21, Decl(relationDepthSharedCheckOrder.ts, 47, 27)) +>next : Symbol(I21.next, Decl(relationDepthSharedCheckOrder.ts, 48, 15)) +>I22 : Symbol(I22, Decl(relationDepthSharedCheckOrder.ts, 49, 27)) + +interface J21 { next: J22 } +>J21 : Symbol(J21, Decl(relationDepthSharedCheckOrder.ts, 48, 27)) +>next : Symbol(J21.next, Decl(relationDepthSharedCheckOrder.ts, 49, 15)) +>J22 : Symbol(J22, Decl(relationDepthSharedCheckOrder.ts, 50, 27)) + +interface I22 { next: I23 } +>I22 : Symbol(I22, Decl(relationDepthSharedCheckOrder.ts, 49, 27)) +>next : Symbol(I22.next, Decl(relationDepthSharedCheckOrder.ts, 50, 15)) +>I23 : Symbol(I23, Decl(relationDepthSharedCheckOrder.ts, 51, 27)) + +interface J22 { next: J23 } +>J22 : Symbol(J22, Decl(relationDepthSharedCheckOrder.ts, 50, 27)) +>next : Symbol(J22.next, Decl(relationDepthSharedCheckOrder.ts, 51, 15)) +>J23 : Symbol(J23, Decl(relationDepthSharedCheckOrder.ts, 52, 27)) + +interface I23 { next: I24 } +>I23 : Symbol(I23, Decl(relationDepthSharedCheckOrder.ts, 51, 27)) +>next : Symbol(I23.next, Decl(relationDepthSharedCheckOrder.ts, 52, 15)) +>I24 : Symbol(I24, Decl(relationDepthSharedCheckOrder.ts, 53, 27)) + +interface J23 { next: J24 } +>J23 : Symbol(J23, Decl(relationDepthSharedCheckOrder.ts, 52, 27)) +>next : Symbol(J23.next, Decl(relationDepthSharedCheckOrder.ts, 53, 15)) +>J24 : Symbol(J24, Decl(relationDepthSharedCheckOrder.ts, 54, 27)) + +interface I24 { next: I25 } +>I24 : Symbol(I24, Decl(relationDepthSharedCheckOrder.ts, 53, 27)) +>next : Symbol(I24.next, Decl(relationDepthSharedCheckOrder.ts, 54, 15)) +>I25 : Symbol(I25, Decl(relationDepthSharedCheckOrder.ts, 55, 27)) + +interface J24 { next: J25 } +>J24 : Symbol(J24, Decl(relationDepthSharedCheckOrder.ts, 54, 27)) +>next : Symbol(J24.next, Decl(relationDepthSharedCheckOrder.ts, 55, 15)) +>J25 : Symbol(J25, Decl(relationDepthSharedCheckOrder.ts, 56, 27)) + +interface I25 { next: I26 } +>I25 : Symbol(I25, Decl(relationDepthSharedCheckOrder.ts, 55, 27)) +>next : Symbol(I25.next, Decl(relationDepthSharedCheckOrder.ts, 56, 15)) +>I26 : Symbol(I26, Decl(relationDepthSharedCheckOrder.ts, 57, 27)) + +interface J25 { next: J26 } +>J25 : Symbol(J25, Decl(relationDepthSharedCheckOrder.ts, 56, 27)) +>next : Symbol(J25.next, Decl(relationDepthSharedCheckOrder.ts, 57, 15)) +>J26 : Symbol(J26, Decl(relationDepthSharedCheckOrder.ts, 58, 27)) + +interface I26 { next: I27 } +>I26 : Symbol(I26, Decl(relationDepthSharedCheckOrder.ts, 57, 27)) +>next : Symbol(I26.next, Decl(relationDepthSharedCheckOrder.ts, 58, 15)) +>I27 : Symbol(I27, Decl(relationDepthSharedCheckOrder.ts, 59, 27)) + +interface J26 { next: J27 } +>J26 : Symbol(J26, Decl(relationDepthSharedCheckOrder.ts, 58, 27)) +>next : Symbol(J26.next, Decl(relationDepthSharedCheckOrder.ts, 59, 15)) +>J27 : Symbol(J27, Decl(relationDepthSharedCheckOrder.ts, 60, 27)) + +interface I27 { next: I28 } +>I27 : Symbol(I27, Decl(relationDepthSharedCheckOrder.ts, 59, 27)) +>next : Symbol(I27.next, Decl(relationDepthSharedCheckOrder.ts, 60, 15)) +>I28 : Symbol(I28, Decl(relationDepthSharedCheckOrder.ts, 61, 27)) + +interface J27 { next: J28 } +>J27 : Symbol(J27, Decl(relationDepthSharedCheckOrder.ts, 60, 27)) +>next : Symbol(J27.next, Decl(relationDepthSharedCheckOrder.ts, 61, 15)) +>J28 : Symbol(J28, Decl(relationDepthSharedCheckOrder.ts, 62, 27)) + +interface I28 { next: I29 } +>I28 : Symbol(I28, Decl(relationDepthSharedCheckOrder.ts, 61, 27)) +>next : Symbol(I28.next, Decl(relationDepthSharedCheckOrder.ts, 62, 15)) +>I29 : Symbol(I29, Decl(relationDepthSharedCheckOrder.ts, 63, 27)) + +interface J28 { next: J29 } +>J28 : Symbol(J28, Decl(relationDepthSharedCheckOrder.ts, 62, 27)) +>next : Symbol(J28.next, Decl(relationDepthSharedCheckOrder.ts, 63, 15)) +>J29 : Symbol(J29, Decl(relationDepthSharedCheckOrder.ts, 64, 27)) + +interface I29 { next: I30 } +>I29 : Symbol(I29, Decl(relationDepthSharedCheckOrder.ts, 63, 27)) +>next : Symbol(I29.next, Decl(relationDepthSharedCheckOrder.ts, 64, 15)) +>I30 : Symbol(I30, Decl(relationDepthSharedCheckOrder.ts, 65, 27)) + +interface J29 { next: J30 } +>J29 : Symbol(J29, Decl(relationDepthSharedCheckOrder.ts, 64, 27)) +>next : Symbol(J29.next, Decl(relationDepthSharedCheckOrder.ts, 65, 15)) +>J30 : Symbol(J30, Decl(relationDepthSharedCheckOrder.ts, 66, 27)) + +interface I30 { next: I31 } +>I30 : Symbol(I30, Decl(relationDepthSharedCheckOrder.ts, 65, 27)) +>next : Symbol(I30.next, Decl(relationDepthSharedCheckOrder.ts, 66, 15)) +>I31 : Symbol(I31, Decl(relationDepthSharedCheckOrder.ts, 67, 27)) + +interface J30 { next: J31 } +>J30 : Symbol(J30, Decl(relationDepthSharedCheckOrder.ts, 66, 27)) +>next : Symbol(J30.next, Decl(relationDepthSharedCheckOrder.ts, 67, 15)) +>J31 : Symbol(J31, Decl(relationDepthSharedCheckOrder.ts, 68, 27)) + +interface I31 { next: I32 } +>I31 : Symbol(I31, Decl(relationDepthSharedCheckOrder.ts, 67, 27)) +>next : Symbol(I31.next, Decl(relationDepthSharedCheckOrder.ts, 68, 15)) +>I32 : Symbol(I32, Decl(relationDepthSharedCheckOrder.ts, 69, 27)) + +interface J31 { next: J32 } +>J31 : Symbol(J31, Decl(relationDepthSharedCheckOrder.ts, 68, 27)) +>next : Symbol(J31.next, Decl(relationDepthSharedCheckOrder.ts, 69, 15)) +>J32 : Symbol(J32, Decl(relationDepthSharedCheckOrder.ts, 70, 27)) + +interface I32 { next: I33 } +>I32 : Symbol(I32, Decl(relationDepthSharedCheckOrder.ts, 69, 27)) +>next : Symbol(I32.next, Decl(relationDepthSharedCheckOrder.ts, 70, 15)) +>I33 : Symbol(I33, Decl(relationDepthSharedCheckOrder.ts, 71, 27)) + +interface J32 { next: J33 } +>J32 : Symbol(J32, Decl(relationDepthSharedCheckOrder.ts, 70, 27)) +>next : Symbol(J32.next, Decl(relationDepthSharedCheckOrder.ts, 71, 15)) +>J33 : Symbol(J33, Decl(relationDepthSharedCheckOrder.ts, 72, 27)) + +interface I33 { next: I34 } +>I33 : Symbol(I33, Decl(relationDepthSharedCheckOrder.ts, 71, 27)) +>next : Symbol(I33.next, Decl(relationDepthSharedCheckOrder.ts, 72, 15)) +>I34 : Symbol(I34, Decl(relationDepthSharedCheckOrder.ts, 73, 27)) + +interface J33 { next: J34 } +>J33 : Symbol(J33, Decl(relationDepthSharedCheckOrder.ts, 72, 27)) +>next : Symbol(J33.next, Decl(relationDepthSharedCheckOrder.ts, 73, 15)) +>J34 : Symbol(J34, Decl(relationDepthSharedCheckOrder.ts, 74, 27)) + +interface I34 { next: I35 } +>I34 : Symbol(I34, Decl(relationDepthSharedCheckOrder.ts, 73, 27)) +>next : Symbol(I34.next, Decl(relationDepthSharedCheckOrder.ts, 74, 15)) +>I35 : Symbol(I35, Decl(relationDepthSharedCheckOrder.ts, 75, 27)) + +interface J34 { next: J35 } +>J34 : Symbol(J34, Decl(relationDepthSharedCheckOrder.ts, 74, 27)) +>next : Symbol(J34.next, Decl(relationDepthSharedCheckOrder.ts, 75, 15)) +>J35 : Symbol(J35, Decl(relationDepthSharedCheckOrder.ts, 76, 27)) + +interface I35 { next: I36 } +>I35 : Symbol(I35, Decl(relationDepthSharedCheckOrder.ts, 75, 27)) +>next : Symbol(I35.next, Decl(relationDepthSharedCheckOrder.ts, 76, 15)) +>I36 : Symbol(I36, Decl(relationDepthSharedCheckOrder.ts, 77, 27)) + +interface J35 { next: J36 } +>J35 : Symbol(J35, Decl(relationDepthSharedCheckOrder.ts, 76, 27)) +>next : Symbol(J35.next, Decl(relationDepthSharedCheckOrder.ts, 77, 15)) +>J36 : Symbol(J36, Decl(relationDepthSharedCheckOrder.ts, 78, 27)) + +interface I36 { next: I37 } +>I36 : Symbol(I36, Decl(relationDepthSharedCheckOrder.ts, 77, 27)) +>next : Symbol(I36.next, Decl(relationDepthSharedCheckOrder.ts, 78, 15)) +>I37 : Symbol(I37, Decl(relationDepthSharedCheckOrder.ts, 79, 27)) + +interface J36 { next: J37 } +>J36 : Symbol(J36, Decl(relationDepthSharedCheckOrder.ts, 78, 27)) +>next : Symbol(J36.next, Decl(relationDepthSharedCheckOrder.ts, 79, 15)) +>J37 : Symbol(J37, Decl(relationDepthSharedCheckOrder.ts, 80, 27)) + +interface I37 { next: I38 } +>I37 : Symbol(I37, Decl(relationDepthSharedCheckOrder.ts, 79, 27)) +>next : Symbol(I37.next, Decl(relationDepthSharedCheckOrder.ts, 80, 15)) +>I38 : Symbol(I38, Decl(relationDepthSharedCheckOrder.ts, 81, 27)) + +interface J37 { next: J38 } +>J37 : Symbol(J37, Decl(relationDepthSharedCheckOrder.ts, 80, 27)) +>next : Symbol(J37.next, Decl(relationDepthSharedCheckOrder.ts, 81, 15)) +>J38 : Symbol(J38, Decl(relationDepthSharedCheckOrder.ts, 82, 27)) + +interface I38 { next: I39 } +>I38 : Symbol(I38, Decl(relationDepthSharedCheckOrder.ts, 81, 27)) +>next : Symbol(I38.next, Decl(relationDepthSharedCheckOrder.ts, 82, 15)) +>I39 : Symbol(I39, Decl(relationDepthSharedCheckOrder.ts, 83, 27)) + +interface J38 { next: J39 } +>J38 : Symbol(J38, Decl(relationDepthSharedCheckOrder.ts, 82, 27)) +>next : Symbol(J38.next, Decl(relationDepthSharedCheckOrder.ts, 83, 15)) +>J39 : Symbol(J39, Decl(relationDepthSharedCheckOrder.ts, 84, 27)) + +interface I39 { next: I40 } +>I39 : Symbol(I39, Decl(relationDepthSharedCheckOrder.ts, 83, 27)) +>next : Symbol(I39.next, Decl(relationDepthSharedCheckOrder.ts, 84, 15)) +>I40 : Symbol(I40, Decl(relationDepthSharedCheckOrder.ts, 85, 27)) + +interface J39 { next: J40 } +>J39 : Symbol(J39, Decl(relationDepthSharedCheckOrder.ts, 84, 27)) +>next : Symbol(J39.next, Decl(relationDepthSharedCheckOrder.ts, 85, 15)) +>J40 : Symbol(J40, Decl(relationDepthSharedCheckOrder.ts, 86, 27)) + +interface I40 { next: I41 } +>I40 : Symbol(I40, Decl(relationDepthSharedCheckOrder.ts, 85, 27)) +>next : Symbol(I40.next, Decl(relationDepthSharedCheckOrder.ts, 86, 15)) +>I41 : Symbol(I41, Decl(relationDepthSharedCheckOrder.ts, 87, 27)) + +interface J40 { next: J41 } +>J40 : Symbol(J40, Decl(relationDepthSharedCheckOrder.ts, 86, 27)) +>next : Symbol(J40.next, Decl(relationDepthSharedCheckOrder.ts, 87, 15)) +>J41 : Symbol(J41, Decl(relationDepthSharedCheckOrder.ts, 88, 27)) + +interface I41 { next: I42 } +>I41 : Symbol(I41, Decl(relationDepthSharedCheckOrder.ts, 87, 27)) +>next : Symbol(I41.next, Decl(relationDepthSharedCheckOrder.ts, 88, 15)) +>I42 : Symbol(I42, Decl(relationDepthSharedCheckOrder.ts, 89, 27)) + +interface J41 { next: J42 } +>J41 : Symbol(J41, Decl(relationDepthSharedCheckOrder.ts, 88, 27)) +>next : Symbol(J41.next, Decl(relationDepthSharedCheckOrder.ts, 89, 15)) +>J42 : Symbol(J42, Decl(relationDepthSharedCheckOrder.ts, 90, 27)) + +interface I42 { next: I43 } +>I42 : Symbol(I42, Decl(relationDepthSharedCheckOrder.ts, 89, 27)) +>next : Symbol(I42.next, Decl(relationDepthSharedCheckOrder.ts, 90, 15)) +>I43 : Symbol(I43, Decl(relationDepthSharedCheckOrder.ts, 91, 27)) + +interface J42 { next: J43 } +>J42 : Symbol(J42, Decl(relationDepthSharedCheckOrder.ts, 90, 27)) +>next : Symbol(J42.next, Decl(relationDepthSharedCheckOrder.ts, 91, 15)) +>J43 : Symbol(J43, Decl(relationDepthSharedCheckOrder.ts, 92, 27)) + +interface I43 { next: I44 } +>I43 : Symbol(I43, Decl(relationDepthSharedCheckOrder.ts, 91, 27)) +>next : Symbol(I43.next, Decl(relationDepthSharedCheckOrder.ts, 92, 15)) +>I44 : Symbol(I44, Decl(relationDepthSharedCheckOrder.ts, 93, 27)) + +interface J43 { next: J44 } +>J43 : Symbol(J43, Decl(relationDepthSharedCheckOrder.ts, 92, 27)) +>next : Symbol(J43.next, Decl(relationDepthSharedCheckOrder.ts, 93, 15)) +>J44 : Symbol(J44, Decl(relationDepthSharedCheckOrder.ts, 94, 27)) + +interface I44 { next: I45 } +>I44 : Symbol(I44, Decl(relationDepthSharedCheckOrder.ts, 93, 27)) +>next : Symbol(I44.next, Decl(relationDepthSharedCheckOrder.ts, 94, 15)) +>I45 : Symbol(I45, Decl(relationDepthSharedCheckOrder.ts, 95, 27)) + +interface J44 { next: J45 } +>J44 : Symbol(J44, Decl(relationDepthSharedCheckOrder.ts, 94, 27)) +>next : Symbol(J44.next, Decl(relationDepthSharedCheckOrder.ts, 95, 15)) +>J45 : Symbol(J45, Decl(relationDepthSharedCheckOrder.ts, 96, 27)) + +interface I45 { next: I46 } +>I45 : Symbol(I45, Decl(relationDepthSharedCheckOrder.ts, 95, 27)) +>next : Symbol(I45.next, Decl(relationDepthSharedCheckOrder.ts, 96, 15)) +>I46 : Symbol(I46, Decl(relationDepthSharedCheckOrder.ts, 97, 27)) + +interface J45 { next: J46 } +>J45 : Symbol(J45, Decl(relationDepthSharedCheckOrder.ts, 96, 27)) +>next : Symbol(J45.next, Decl(relationDepthSharedCheckOrder.ts, 97, 15)) +>J46 : Symbol(J46, Decl(relationDepthSharedCheckOrder.ts, 98, 27)) + +interface I46 { next: I47 } +>I46 : Symbol(I46, Decl(relationDepthSharedCheckOrder.ts, 97, 27)) +>next : Symbol(I46.next, Decl(relationDepthSharedCheckOrder.ts, 98, 15)) +>I47 : Symbol(I47, Decl(relationDepthSharedCheckOrder.ts, 99, 27)) + +interface J46 { next: J47 } +>J46 : Symbol(J46, Decl(relationDepthSharedCheckOrder.ts, 98, 27)) +>next : Symbol(J46.next, Decl(relationDepthSharedCheckOrder.ts, 99, 15)) +>J47 : Symbol(J47, Decl(relationDepthSharedCheckOrder.ts, 100, 27)) + +interface I47 { next: I48 } +>I47 : Symbol(I47, Decl(relationDepthSharedCheckOrder.ts, 99, 27)) +>next : Symbol(I47.next, Decl(relationDepthSharedCheckOrder.ts, 100, 15)) +>I48 : Symbol(I48, Decl(relationDepthSharedCheckOrder.ts, 101, 27)) + +interface J47 { next: J48 } +>J47 : Symbol(J47, Decl(relationDepthSharedCheckOrder.ts, 100, 27)) +>next : Symbol(J47.next, Decl(relationDepthSharedCheckOrder.ts, 101, 15)) +>J48 : Symbol(J48, Decl(relationDepthSharedCheckOrder.ts, 102, 27)) + +interface I48 { next: I49 } +>I48 : Symbol(I48, Decl(relationDepthSharedCheckOrder.ts, 101, 27)) +>next : Symbol(I48.next, Decl(relationDepthSharedCheckOrder.ts, 102, 15)) +>I49 : Symbol(I49, Decl(relationDepthSharedCheckOrder.ts, 103, 27)) + +interface J48 { next: J49 } +>J48 : Symbol(J48, Decl(relationDepthSharedCheckOrder.ts, 102, 27)) +>next : Symbol(J48.next, Decl(relationDepthSharedCheckOrder.ts, 103, 15)) +>J49 : Symbol(J49, Decl(relationDepthSharedCheckOrder.ts, 104, 27)) + +interface I49 { next: I50 } +>I49 : Symbol(I49, Decl(relationDepthSharedCheckOrder.ts, 103, 27)) +>next : Symbol(I49.next, Decl(relationDepthSharedCheckOrder.ts, 104, 15)) +>I50 : Symbol(I50, Decl(relationDepthSharedCheckOrder.ts, 105, 27)) + +interface J49 { next: J50 } +>J49 : Symbol(J49, Decl(relationDepthSharedCheckOrder.ts, 104, 27)) +>next : Symbol(J49.next, Decl(relationDepthSharedCheckOrder.ts, 105, 15)) +>J50 : Symbol(J50, Decl(relationDepthSharedCheckOrder.ts, 106, 27)) + +interface I50 { next: I51 } +>I50 : Symbol(I50, Decl(relationDepthSharedCheckOrder.ts, 105, 27)) +>next : Symbol(I50.next, Decl(relationDepthSharedCheckOrder.ts, 106, 15)) +>I51 : Symbol(I51, Decl(relationDepthSharedCheckOrder.ts, 107, 27)) + +interface J50 { next: J51 } +>J50 : Symbol(J50, Decl(relationDepthSharedCheckOrder.ts, 106, 27)) +>next : Symbol(J50.next, Decl(relationDepthSharedCheckOrder.ts, 107, 15)) +>J51 : Symbol(J51, Decl(relationDepthSharedCheckOrder.ts, 108, 27)) + +interface I51 { next: I52 } +>I51 : Symbol(I51, Decl(relationDepthSharedCheckOrder.ts, 107, 27)) +>next : Symbol(I51.next, Decl(relationDepthSharedCheckOrder.ts, 108, 15)) +>I52 : Symbol(I52, Decl(relationDepthSharedCheckOrder.ts, 109, 27)) + +interface J51 { next: J52 } +>J51 : Symbol(J51, Decl(relationDepthSharedCheckOrder.ts, 108, 27)) +>next : Symbol(J51.next, Decl(relationDepthSharedCheckOrder.ts, 109, 15)) +>J52 : Symbol(J52, Decl(relationDepthSharedCheckOrder.ts, 110, 27)) + +interface I52 { next: I53 } +>I52 : Symbol(I52, Decl(relationDepthSharedCheckOrder.ts, 109, 27)) +>next : Symbol(I52.next, Decl(relationDepthSharedCheckOrder.ts, 110, 15)) +>I53 : Symbol(I53, Decl(relationDepthSharedCheckOrder.ts, 111, 27)) + +interface J52 { next: J53 } +>J52 : Symbol(J52, Decl(relationDepthSharedCheckOrder.ts, 110, 27)) +>next : Symbol(J52.next, Decl(relationDepthSharedCheckOrder.ts, 111, 15)) +>J53 : Symbol(J53, Decl(relationDepthSharedCheckOrder.ts, 112, 27)) + +interface I53 { next: I54 } +>I53 : Symbol(I53, Decl(relationDepthSharedCheckOrder.ts, 111, 27)) +>next : Symbol(I53.next, Decl(relationDepthSharedCheckOrder.ts, 112, 15)) +>I54 : Symbol(I54, Decl(relationDepthSharedCheckOrder.ts, 113, 27)) + +interface J53 { next: J54 } +>J53 : Symbol(J53, Decl(relationDepthSharedCheckOrder.ts, 112, 27)) +>next : Symbol(J53.next, Decl(relationDepthSharedCheckOrder.ts, 113, 15)) +>J54 : Symbol(J54, Decl(relationDepthSharedCheckOrder.ts, 114, 27)) + +interface I54 { next: I55 } +>I54 : Symbol(I54, Decl(relationDepthSharedCheckOrder.ts, 113, 27)) +>next : Symbol(I54.next, Decl(relationDepthSharedCheckOrder.ts, 114, 15)) +>I55 : Symbol(I55, Decl(relationDepthSharedCheckOrder.ts, 115, 27)) + +interface J54 { next: J55 } +>J54 : Symbol(J54, Decl(relationDepthSharedCheckOrder.ts, 114, 27)) +>next : Symbol(J54.next, Decl(relationDepthSharedCheckOrder.ts, 115, 15)) +>J55 : Symbol(J55, Decl(relationDepthSharedCheckOrder.ts, 116, 27)) + +interface I55 { next: I56 } +>I55 : Symbol(I55, Decl(relationDepthSharedCheckOrder.ts, 115, 27)) +>next : Symbol(I55.next, Decl(relationDepthSharedCheckOrder.ts, 116, 15)) +>I56 : Symbol(I56, Decl(relationDepthSharedCheckOrder.ts, 117, 27)) + +interface J55 { next: J56 } +>J55 : Symbol(J55, Decl(relationDepthSharedCheckOrder.ts, 116, 27)) +>next : Symbol(J55.next, Decl(relationDepthSharedCheckOrder.ts, 117, 15)) +>J56 : Symbol(J56, Decl(relationDepthSharedCheckOrder.ts, 118, 27)) + +interface I56 { next: I57 } +>I56 : Symbol(I56, Decl(relationDepthSharedCheckOrder.ts, 117, 27)) +>next : Symbol(I56.next, Decl(relationDepthSharedCheckOrder.ts, 118, 15)) +>I57 : Symbol(I57, Decl(relationDepthSharedCheckOrder.ts, 119, 27)) + +interface J56 { next: J57 } +>J56 : Symbol(J56, Decl(relationDepthSharedCheckOrder.ts, 118, 27)) +>next : Symbol(J56.next, Decl(relationDepthSharedCheckOrder.ts, 119, 15)) +>J57 : Symbol(J57, Decl(relationDepthSharedCheckOrder.ts, 120, 27)) + +interface I57 { next: I58 } +>I57 : Symbol(I57, Decl(relationDepthSharedCheckOrder.ts, 119, 27)) +>next : Symbol(I57.next, Decl(relationDepthSharedCheckOrder.ts, 120, 15)) +>I58 : Symbol(I58, Decl(relationDepthSharedCheckOrder.ts, 121, 27)) + +interface J57 { next: J58 } +>J57 : Symbol(J57, Decl(relationDepthSharedCheckOrder.ts, 120, 27)) +>next : Symbol(J57.next, Decl(relationDepthSharedCheckOrder.ts, 121, 15)) +>J58 : Symbol(J58, Decl(relationDepthSharedCheckOrder.ts, 122, 27)) + +interface I58 { next: I59 } +>I58 : Symbol(I58, Decl(relationDepthSharedCheckOrder.ts, 121, 27)) +>next : Symbol(I58.next, Decl(relationDepthSharedCheckOrder.ts, 122, 15)) +>I59 : Symbol(I59, Decl(relationDepthSharedCheckOrder.ts, 123, 27)) + +interface J58 { next: J59 } +>J58 : Symbol(J58, Decl(relationDepthSharedCheckOrder.ts, 122, 27)) +>next : Symbol(J58.next, Decl(relationDepthSharedCheckOrder.ts, 123, 15)) +>J59 : Symbol(J59, Decl(relationDepthSharedCheckOrder.ts, 124, 27)) + +interface I59 { next: I60 } +>I59 : Symbol(I59, Decl(relationDepthSharedCheckOrder.ts, 123, 27)) +>next : Symbol(I59.next, Decl(relationDepthSharedCheckOrder.ts, 124, 15)) +>I60 : Symbol(I60, Decl(relationDepthSharedCheckOrder.ts, 125, 27)) + +interface J59 { next: J60 } +>J59 : Symbol(J59, Decl(relationDepthSharedCheckOrder.ts, 124, 27)) +>next : Symbol(J59.next, Decl(relationDepthSharedCheckOrder.ts, 125, 15)) +>J60 : Symbol(J60, Decl(relationDepthSharedCheckOrder.ts, 126, 27)) + +interface I60 { next: I61 } +>I60 : Symbol(I60, Decl(relationDepthSharedCheckOrder.ts, 125, 27)) +>next : Symbol(I60.next, Decl(relationDepthSharedCheckOrder.ts, 126, 15)) +>I61 : Symbol(I61, Decl(relationDepthSharedCheckOrder.ts, 127, 27)) + +interface J60 { next: J61 } +>J60 : Symbol(J60, Decl(relationDepthSharedCheckOrder.ts, 126, 27)) +>next : Symbol(J60.next, Decl(relationDepthSharedCheckOrder.ts, 127, 15)) +>J61 : Symbol(J61, Decl(relationDepthSharedCheckOrder.ts, 128, 27)) + +interface I61 { next: I62 } +>I61 : Symbol(I61, Decl(relationDepthSharedCheckOrder.ts, 127, 27)) +>next : Symbol(I61.next, Decl(relationDepthSharedCheckOrder.ts, 128, 15)) +>I62 : Symbol(I62, Decl(relationDepthSharedCheckOrder.ts, 129, 27)) + +interface J61 { next: J62 } +>J61 : Symbol(J61, Decl(relationDepthSharedCheckOrder.ts, 128, 27)) +>next : Symbol(J61.next, Decl(relationDepthSharedCheckOrder.ts, 129, 15)) +>J62 : Symbol(J62, Decl(relationDepthSharedCheckOrder.ts, 130, 27)) + +interface I62 { next: I63 } +>I62 : Symbol(I62, Decl(relationDepthSharedCheckOrder.ts, 129, 27)) +>next : Symbol(I62.next, Decl(relationDepthSharedCheckOrder.ts, 130, 15)) +>I63 : Symbol(I63, Decl(relationDepthSharedCheckOrder.ts, 131, 27)) + +interface J62 { next: J63 } +>J62 : Symbol(J62, Decl(relationDepthSharedCheckOrder.ts, 130, 27)) +>next : Symbol(J62.next, Decl(relationDepthSharedCheckOrder.ts, 131, 15)) +>J63 : Symbol(J63, Decl(relationDepthSharedCheckOrder.ts, 132, 27)) + +interface I63 { next: I64 } +>I63 : Symbol(I63, Decl(relationDepthSharedCheckOrder.ts, 131, 27)) +>next : Symbol(I63.next, Decl(relationDepthSharedCheckOrder.ts, 132, 15)) +>I64 : Symbol(I64, Decl(relationDepthSharedCheckOrder.ts, 133, 27)) + +interface J63 { next: J64 } +>J63 : Symbol(J63, Decl(relationDepthSharedCheckOrder.ts, 132, 27)) +>next : Symbol(J63.next, Decl(relationDepthSharedCheckOrder.ts, 133, 15)) +>J64 : Symbol(J64, Decl(relationDepthSharedCheckOrder.ts, 134, 27)) + +interface I64 { next: I65 } +>I64 : Symbol(I64, Decl(relationDepthSharedCheckOrder.ts, 133, 27)) +>next : Symbol(I64.next, Decl(relationDepthSharedCheckOrder.ts, 134, 15)) +>I65 : Symbol(I65, Decl(relationDepthSharedCheckOrder.ts, 135, 27)) + +interface J64 { next: J65 } +>J64 : Symbol(J64, Decl(relationDepthSharedCheckOrder.ts, 134, 27)) +>next : Symbol(J64.next, Decl(relationDepthSharedCheckOrder.ts, 135, 15)) +>J65 : Symbol(J65, Decl(relationDepthSharedCheckOrder.ts, 136, 27)) + +interface I65 { next: I66 } +>I65 : Symbol(I65, Decl(relationDepthSharedCheckOrder.ts, 135, 27)) +>next : Symbol(I65.next, Decl(relationDepthSharedCheckOrder.ts, 136, 15)) +>I66 : Symbol(I66, Decl(relationDepthSharedCheckOrder.ts, 137, 27)) + +interface J65 { next: J66 } +>J65 : Symbol(J65, Decl(relationDepthSharedCheckOrder.ts, 136, 27)) +>next : Symbol(J65.next, Decl(relationDepthSharedCheckOrder.ts, 137, 15)) +>J66 : Symbol(J66, Decl(relationDepthSharedCheckOrder.ts, 138, 27)) + +interface I66 { next: I67 } +>I66 : Symbol(I66, Decl(relationDepthSharedCheckOrder.ts, 137, 27)) +>next : Symbol(I66.next, Decl(relationDepthSharedCheckOrder.ts, 138, 15)) +>I67 : Symbol(I67, Decl(relationDepthSharedCheckOrder.ts, 139, 27)) + +interface J66 { next: J67 } +>J66 : Symbol(J66, Decl(relationDepthSharedCheckOrder.ts, 138, 27)) +>next : Symbol(J66.next, Decl(relationDepthSharedCheckOrder.ts, 139, 15)) +>J67 : Symbol(J67, Decl(relationDepthSharedCheckOrder.ts, 140, 27)) + +interface I67 { next: I68 } +>I67 : Symbol(I67, Decl(relationDepthSharedCheckOrder.ts, 139, 27)) +>next : Symbol(I67.next, Decl(relationDepthSharedCheckOrder.ts, 140, 15)) +>I68 : Symbol(I68, Decl(relationDepthSharedCheckOrder.ts, 141, 27)) + +interface J67 { next: J68 } +>J67 : Symbol(J67, Decl(relationDepthSharedCheckOrder.ts, 140, 27)) +>next : Symbol(J67.next, Decl(relationDepthSharedCheckOrder.ts, 141, 15)) +>J68 : Symbol(J68, Decl(relationDepthSharedCheckOrder.ts, 142, 27)) + +interface I68 { next: I69 } +>I68 : Symbol(I68, Decl(relationDepthSharedCheckOrder.ts, 141, 27)) +>next : Symbol(I68.next, Decl(relationDepthSharedCheckOrder.ts, 142, 15)) +>I69 : Symbol(I69, Decl(relationDepthSharedCheckOrder.ts, 143, 27)) + +interface J68 { next: J69 } +>J68 : Symbol(J68, Decl(relationDepthSharedCheckOrder.ts, 142, 27)) +>next : Symbol(J68.next, Decl(relationDepthSharedCheckOrder.ts, 143, 15)) +>J69 : Symbol(J69, Decl(relationDepthSharedCheckOrder.ts, 144, 27)) + +interface I69 { next: I70 } +>I69 : Symbol(I69, Decl(relationDepthSharedCheckOrder.ts, 143, 27)) +>next : Symbol(I69.next, Decl(relationDepthSharedCheckOrder.ts, 144, 15)) +>I70 : Symbol(I70, Decl(relationDepthSharedCheckOrder.ts, 145, 27)) + +interface J69 { next: J70 } +>J69 : Symbol(J69, Decl(relationDepthSharedCheckOrder.ts, 144, 27)) +>next : Symbol(J69.next, Decl(relationDepthSharedCheckOrder.ts, 145, 15)) +>J70 : Symbol(J70, Decl(relationDepthSharedCheckOrder.ts, 146, 27)) + +interface I70 { next: I71 } +>I70 : Symbol(I70, Decl(relationDepthSharedCheckOrder.ts, 145, 27)) +>next : Symbol(I70.next, Decl(relationDepthSharedCheckOrder.ts, 146, 15)) +>I71 : Symbol(I71, Decl(relationDepthSharedCheckOrder.ts, 147, 27)) + +interface J70 { next: J71 } +>J70 : Symbol(J70, Decl(relationDepthSharedCheckOrder.ts, 146, 27)) +>next : Symbol(J70.next, Decl(relationDepthSharedCheckOrder.ts, 147, 15)) +>J71 : Symbol(J71, Decl(relationDepthSharedCheckOrder.ts, 148, 27)) + +interface I71 { next: I72 } +>I71 : Symbol(I71, Decl(relationDepthSharedCheckOrder.ts, 147, 27)) +>next : Symbol(I71.next, Decl(relationDepthSharedCheckOrder.ts, 148, 15)) +>I72 : Symbol(I72, Decl(relationDepthSharedCheckOrder.ts, 149, 27)) + +interface J71 { next: J72 } +>J71 : Symbol(J71, Decl(relationDepthSharedCheckOrder.ts, 148, 27)) +>next : Symbol(J71.next, Decl(relationDepthSharedCheckOrder.ts, 149, 15)) +>J72 : Symbol(J72, Decl(relationDepthSharedCheckOrder.ts, 150, 27)) + +interface I72 { next: I73 } +>I72 : Symbol(I72, Decl(relationDepthSharedCheckOrder.ts, 149, 27)) +>next : Symbol(I72.next, Decl(relationDepthSharedCheckOrder.ts, 150, 15)) +>I73 : Symbol(I73, Decl(relationDepthSharedCheckOrder.ts, 151, 27)) + +interface J72 { next: J73 } +>J72 : Symbol(J72, Decl(relationDepthSharedCheckOrder.ts, 150, 27)) +>next : Symbol(J72.next, Decl(relationDepthSharedCheckOrder.ts, 151, 15)) +>J73 : Symbol(J73, Decl(relationDepthSharedCheckOrder.ts, 152, 27)) + +interface I73 { next: I74 } +>I73 : Symbol(I73, Decl(relationDepthSharedCheckOrder.ts, 151, 27)) +>next : Symbol(I73.next, Decl(relationDepthSharedCheckOrder.ts, 152, 15)) +>I74 : Symbol(I74, Decl(relationDepthSharedCheckOrder.ts, 153, 27)) + +interface J73 { next: J74 } +>J73 : Symbol(J73, Decl(relationDepthSharedCheckOrder.ts, 152, 27)) +>next : Symbol(J73.next, Decl(relationDepthSharedCheckOrder.ts, 153, 15)) +>J74 : Symbol(J74, Decl(relationDepthSharedCheckOrder.ts, 154, 27)) + +interface I74 { next: I75 } +>I74 : Symbol(I74, Decl(relationDepthSharedCheckOrder.ts, 153, 27)) +>next : Symbol(I74.next, Decl(relationDepthSharedCheckOrder.ts, 154, 15)) +>I75 : Symbol(I75, Decl(relationDepthSharedCheckOrder.ts, 155, 27)) + +interface J74 { next: J75 } +>J74 : Symbol(J74, Decl(relationDepthSharedCheckOrder.ts, 154, 27)) +>next : Symbol(J74.next, Decl(relationDepthSharedCheckOrder.ts, 155, 15)) +>J75 : Symbol(J75, Decl(relationDepthSharedCheckOrder.ts, 156, 27)) + +interface I75 { next: I76 } +>I75 : Symbol(I75, Decl(relationDepthSharedCheckOrder.ts, 155, 27)) +>next : Symbol(I75.next, Decl(relationDepthSharedCheckOrder.ts, 156, 15)) +>I76 : Symbol(I76, Decl(relationDepthSharedCheckOrder.ts, 157, 27)) + +interface J75 { next: J76 } +>J75 : Symbol(J75, Decl(relationDepthSharedCheckOrder.ts, 156, 27)) +>next : Symbol(J75.next, Decl(relationDepthSharedCheckOrder.ts, 157, 15)) +>J76 : Symbol(J76, Decl(relationDepthSharedCheckOrder.ts, 158, 27)) + +interface I76 { next: I77 } +>I76 : Symbol(I76, Decl(relationDepthSharedCheckOrder.ts, 157, 27)) +>next : Symbol(I76.next, Decl(relationDepthSharedCheckOrder.ts, 158, 15)) +>I77 : Symbol(I77, Decl(relationDepthSharedCheckOrder.ts, 159, 27)) + +interface J76 { next: J77 } +>J76 : Symbol(J76, Decl(relationDepthSharedCheckOrder.ts, 158, 27)) +>next : Symbol(J76.next, Decl(relationDepthSharedCheckOrder.ts, 159, 15)) +>J77 : Symbol(J77, Decl(relationDepthSharedCheckOrder.ts, 160, 27)) + +interface I77 { next: I78 } +>I77 : Symbol(I77, Decl(relationDepthSharedCheckOrder.ts, 159, 27)) +>next : Symbol(I77.next, Decl(relationDepthSharedCheckOrder.ts, 160, 15)) +>I78 : Symbol(I78, Decl(relationDepthSharedCheckOrder.ts, 161, 27)) + +interface J77 { next: J78 } +>J77 : Symbol(J77, Decl(relationDepthSharedCheckOrder.ts, 160, 27)) +>next : Symbol(J77.next, Decl(relationDepthSharedCheckOrder.ts, 161, 15)) +>J78 : Symbol(J78, Decl(relationDepthSharedCheckOrder.ts, 162, 27)) + +interface I78 { next: I79 } +>I78 : Symbol(I78, Decl(relationDepthSharedCheckOrder.ts, 161, 27)) +>next : Symbol(I78.next, Decl(relationDepthSharedCheckOrder.ts, 162, 15)) +>I79 : Symbol(I79, Decl(relationDepthSharedCheckOrder.ts, 163, 27)) + +interface J78 { next: J79 } +>J78 : Symbol(J78, Decl(relationDepthSharedCheckOrder.ts, 162, 27)) +>next : Symbol(J78.next, Decl(relationDepthSharedCheckOrder.ts, 163, 15)) +>J79 : Symbol(J79, Decl(relationDepthSharedCheckOrder.ts, 164, 27)) + +interface I79 { next: I80 } +>I79 : Symbol(I79, Decl(relationDepthSharedCheckOrder.ts, 163, 27)) +>next : Symbol(I79.next, Decl(relationDepthSharedCheckOrder.ts, 164, 15)) +>I80 : Symbol(I80, Decl(relationDepthSharedCheckOrder.ts, 165, 27)) + +interface J79 { next: J80 } +>J79 : Symbol(J79, Decl(relationDepthSharedCheckOrder.ts, 164, 27)) +>next : Symbol(J79.next, Decl(relationDepthSharedCheckOrder.ts, 165, 15)) +>J80 : Symbol(J80, Decl(relationDepthSharedCheckOrder.ts, 166, 27)) + +interface I80 { next: I81 } +>I80 : Symbol(I80, Decl(relationDepthSharedCheckOrder.ts, 165, 27)) +>next : Symbol(I80.next, Decl(relationDepthSharedCheckOrder.ts, 166, 15)) +>I81 : Symbol(I81, Decl(relationDepthSharedCheckOrder.ts, 167, 27)) + +interface J80 { next: J81 } +>J80 : Symbol(J80, Decl(relationDepthSharedCheckOrder.ts, 166, 27)) +>next : Symbol(J80.next, Decl(relationDepthSharedCheckOrder.ts, 167, 15)) +>J81 : Symbol(J81, Decl(relationDepthSharedCheckOrder.ts, 168, 27)) + +interface I81 { next: I82 } +>I81 : Symbol(I81, Decl(relationDepthSharedCheckOrder.ts, 167, 27)) +>next : Symbol(I81.next, Decl(relationDepthSharedCheckOrder.ts, 168, 15)) +>I82 : Symbol(I82, Decl(relationDepthSharedCheckOrder.ts, 169, 27)) + +interface J81 { next: J82 } +>J81 : Symbol(J81, Decl(relationDepthSharedCheckOrder.ts, 168, 27)) +>next : Symbol(J81.next, Decl(relationDepthSharedCheckOrder.ts, 169, 15)) +>J82 : Symbol(J82, Decl(relationDepthSharedCheckOrder.ts, 170, 27)) + +interface I82 { next: I83 } +>I82 : Symbol(I82, Decl(relationDepthSharedCheckOrder.ts, 169, 27)) +>next : Symbol(I82.next, Decl(relationDepthSharedCheckOrder.ts, 170, 15)) +>I83 : Symbol(I83, Decl(relationDepthSharedCheckOrder.ts, 171, 27)) + +interface J82 { next: J83 } +>J82 : Symbol(J82, Decl(relationDepthSharedCheckOrder.ts, 170, 27)) +>next : Symbol(J82.next, Decl(relationDepthSharedCheckOrder.ts, 171, 15)) +>J83 : Symbol(J83, Decl(relationDepthSharedCheckOrder.ts, 172, 27)) + +interface I83 { next: I84 } +>I83 : Symbol(I83, Decl(relationDepthSharedCheckOrder.ts, 171, 27)) +>next : Symbol(I83.next, Decl(relationDepthSharedCheckOrder.ts, 172, 15)) +>I84 : Symbol(I84, Decl(relationDepthSharedCheckOrder.ts, 173, 27)) + +interface J83 { next: J84 } +>J83 : Symbol(J83, Decl(relationDepthSharedCheckOrder.ts, 172, 27)) +>next : Symbol(J83.next, Decl(relationDepthSharedCheckOrder.ts, 173, 15)) +>J84 : Symbol(J84, Decl(relationDepthSharedCheckOrder.ts, 174, 27)) + +interface I84 { next: I85 } +>I84 : Symbol(I84, Decl(relationDepthSharedCheckOrder.ts, 173, 27)) +>next : Symbol(I84.next, Decl(relationDepthSharedCheckOrder.ts, 174, 15)) +>I85 : Symbol(I85, Decl(relationDepthSharedCheckOrder.ts, 175, 27)) + +interface J84 { next: J85 } +>J84 : Symbol(J84, Decl(relationDepthSharedCheckOrder.ts, 174, 27)) +>next : Symbol(J84.next, Decl(relationDepthSharedCheckOrder.ts, 175, 15)) +>J85 : Symbol(J85, Decl(relationDepthSharedCheckOrder.ts, 176, 27)) + +interface I85 { next: I86 } +>I85 : Symbol(I85, Decl(relationDepthSharedCheckOrder.ts, 175, 27)) +>next : Symbol(I85.next, Decl(relationDepthSharedCheckOrder.ts, 176, 15)) +>I86 : Symbol(I86, Decl(relationDepthSharedCheckOrder.ts, 177, 27)) + +interface J85 { next: J86 } +>J85 : Symbol(J85, Decl(relationDepthSharedCheckOrder.ts, 176, 27)) +>next : Symbol(J85.next, Decl(relationDepthSharedCheckOrder.ts, 177, 15)) +>J86 : Symbol(J86, Decl(relationDepthSharedCheckOrder.ts, 178, 27)) + +interface I86 { next: I87 } +>I86 : Symbol(I86, Decl(relationDepthSharedCheckOrder.ts, 177, 27)) +>next : Symbol(I86.next, Decl(relationDepthSharedCheckOrder.ts, 178, 15)) +>I87 : Symbol(I87, Decl(relationDepthSharedCheckOrder.ts, 179, 27)) + +interface J86 { next: J87 } +>J86 : Symbol(J86, Decl(relationDepthSharedCheckOrder.ts, 178, 27)) +>next : Symbol(J86.next, Decl(relationDepthSharedCheckOrder.ts, 179, 15)) +>J87 : Symbol(J87, Decl(relationDepthSharedCheckOrder.ts, 180, 27)) + +interface I87 { next: I88 } +>I87 : Symbol(I87, Decl(relationDepthSharedCheckOrder.ts, 179, 27)) +>next : Symbol(I87.next, Decl(relationDepthSharedCheckOrder.ts, 180, 15)) +>I88 : Symbol(I88, Decl(relationDepthSharedCheckOrder.ts, 181, 27)) + +interface J87 { next: J88 } +>J87 : Symbol(J87, Decl(relationDepthSharedCheckOrder.ts, 180, 27)) +>next : Symbol(J87.next, Decl(relationDepthSharedCheckOrder.ts, 181, 15)) +>J88 : Symbol(J88, Decl(relationDepthSharedCheckOrder.ts, 182, 27)) + +interface I88 { next: I89 } +>I88 : Symbol(I88, Decl(relationDepthSharedCheckOrder.ts, 181, 27)) +>next : Symbol(I88.next, Decl(relationDepthSharedCheckOrder.ts, 182, 15)) +>I89 : Symbol(I89, Decl(relationDepthSharedCheckOrder.ts, 183, 27)) + +interface J88 { next: J89 } +>J88 : Symbol(J88, Decl(relationDepthSharedCheckOrder.ts, 182, 27)) +>next : Symbol(J88.next, Decl(relationDepthSharedCheckOrder.ts, 183, 15)) +>J89 : Symbol(J89, Decl(relationDepthSharedCheckOrder.ts, 184, 27)) + +interface I89 { next: I90 } +>I89 : Symbol(I89, Decl(relationDepthSharedCheckOrder.ts, 183, 27)) +>next : Symbol(I89.next, Decl(relationDepthSharedCheckOrder.ts, 184, 15)) +>I90 : Symbol(I90, Decl(relationDepthSharedCheckOrder.ts, 185, 27)) + +interface J89 { next: J90 } +>J89 : Symbol(J89, Decl(relationDepthSharedCheckOrder.ts, 184, 27)) +>next : Symbol(J89.next, Decl(relationDepthSharedCheckOrder.ts, 185, 15)) +>J90 : Symbol(J90, Decl(relationDepthSharedCheckOrder.ts, 186, 27)) + +interface I90 { next: I91 } +>I90 : Symbol(I90, Decl(relationDepthSharedCheckOrder.ts, 185, 27)) +>next : Symbol(I90.next, Decl(relationDepthSharedCheckOrder.ts, 186, 15)) +>I91 : Symbol(I91, Decl(relationDepthSharedCheckOrder.ts, 187, 27)) + +interface J90 { next: J91 } +>J90 : Symbol(J90, Decl(relationDepthSharedCheckOrder.ts, 186, 27)) +>next : Symbol(J90.next, Decl(relationDepthSharedCheckOrder.ts, 187, 15)) +>J91 : Symbol(J91, Decl(relationDepthSharedCheckOrder.ts, 188, 27)) + +interface I91 { next: I92 } +>I91 : Symbol(I91, Decl(relationDepthSharedCheckOrder.ts, 187, 27)) +>next : Symbol(I91.next, Decl(relationDepthSharedCheckOrder.ts, 188, 15)) +>I92 : Symbol(I92, Decl(relationDepthSharedCheckOrder.ts, 189, 27)) + +interface J91 { next: J92 } +>J91 : Symbol(J91, Decl(relationDepthSharedCheckOrder.ts, 188, 27)) +>next : Symbol(J91.next, Decl(relationDepthSharedCheckOrder.ts, 189, 15)) +>J92 : Symbol(J92, Decl(relationDepthSharedCheckOrder.ts, 190, 27)) + +interface I92 { next: I93 } +>I92 : Symbol(I92, Decl(relationDepthSharedCheckOrder.ts, 189, 27)) +>next : Symbol(I92.next, Decl(relationDepthSharedCheckOrder.ts, 190, 15)) +>I93 : Symbol(I93, Decl(relationDepthSharedCheckOrder.ts, 191, 27)) + +interface J92 { next: J93 } +>J92 : Symbol(J92, Decl(relationDepthSharedCheckOrder.ts, 190, 27)) +>next : Symbol(J92.next, Decl(relationDepthSharedCheckOrder.ts, 191, 15)) +>J93 : Symbol(J93, Decl(relationDepthSharedCheckOrder.ts, 192, 27)) + +interface I93 { next: I94 } +>I93 : Symbol(I93, Decl(relationDepthSharedCheckOrder.ts, 191, 27)) +>next : Symbol(I93.next, Decl(relationDepthSharedCheckOrder.ts, 192, 15)) +>I94 : Symbol(I94, Decl(relationDepthSharedCheckOrder.ts, 193, 27)) + +interface J93 { next: J94 } +>J93 : Symbol(J93, Decl(relationDepthSharedCheckOrder.ts, 192, 27)) +>next : Symbol(J93.next, Decl(relationDepthSharedCheckOrder.ts, 193, 15)) +>J94 : Symbol(J94, Decl(relationDepthSharedCheckOrder.ts, 194, 27)) + +interface I94 { next: I95 } +>I94 : Symbol(I94, Decl(relationDepthSharedCheckOrder.ts, 193, 27)) +>next : Symbol(I94.next, Decl(relationDepthSharedCheckOrder.ts, 194, 15)) +>I95 : Symbol(I95, Decl(relationDepthSharedCheckOrder.ts, 195, 27)) + +interface J94 { next: J95 } +>J94 : Symbol(J94, Decl(relationDepthSharedCheckOrder.ts, 194, 27)) +>next : Symbol(J94.next, Decl(relationDepthSharedCheckOrder.ts, 195, 15)) +>J95 : Symbol(J95, Decl(relationDepthSharedCheckOrder.ts, 196, 27)) + +interface I95 { next: I96 } +>I95 : Symbol(I95, Decl(relationDepthSharedCheckOrder.ts, 195, 27)) +>next : Symbol(I95.next, Decl(relationDepthSharedCheckOrder.ts, 196, 15)) +>I96 : Symbol(I96, Decl(relationDepthSharedCheckOrder.ts, 197, 27)) + +interface J95 { next: J96 } +>J95 : Symbol(J95, Decl(relationDepthSharedCheckOrder.ts, 196, 27)) +>next : Symbol(J95.next, Decl(relationDepthSharedCheckOrder.ts, 197, 15)) +>J96 : Symbol(J96, Decl(relationDepthSharedCheckOrder.ts, 198, 27)) + +interface I96 { next: I97 } +>I96 : Symbol(I96, Decl(relationDepthSharedCheckOrder.ts, 197, 27)) +>next : Symbol(I96.next, Decl(relationDepthSharedCheckOrder.ts, 198, 15)) +>I97 : Symbol(I97, Decl(relationDepthSharedCheckOrder.ts, 199, 27)) + +interface J96 { next: J97 } +>J96 : Symbol(J96, Decl(relationDepthSharedCheckOrder.ts, 198, 27)) +>next : Symbol(J96.next, Decl(relationDepthSharedCheckOrder.ts, 199, 15)) +>J97 : Symbol(J97, Decl(relationDepthSharedCheckOrder.ts, 200, 27)) + +interface I97 { next: I98 } +>I97 : Symbol(I97, Decl(relationDepthSharedCheckOrder.ts, 199, 27)) +>next : Symbol(I97.next, Decl(relationDepthSharedCheckOrder.ts, 200, 15)) +>I98 : Symbol(I98, Decl(relationDepthSharedCheckOrder.ts, 201, 27)) + +interface J97 { next: J98 } +>J97 : Symbol(J97, Decl(relationDepthSharedCheckOrder.ts, 200, 27)) +>next : Symbol(J97.next, Decl(relationDepthSharedCheckOrder.ts, 201, 15)) +>J98 : Symbol(J98, Decl(relationDepthSharedCheckOrder.ts, 202, 27)) + +interface I98 { next: I99 } +>I98 : Symbol(I98, Decl(relationDepthSharedCheckOrder.ts, 201, 27)) +>next : Symbol(I98.next, Decl(relationDepthSharedCheckOrder.ts, 202, 15)) +>I99 : Symbol(I99, Decl(relationDepthSharedCheckOrder.ts, 203, 27)) + +interface J98 { next: J99 } +>J98 : Symbol(J98, Decl(relationDepthSharedCheckOrder.ts, 202, 27)) +>next : Symbol(J98.next, Decl(relationDepthSharedCheckOrder.ts, 203, 15)) +>J99 : Symbol(J99, Decl(relationDepthSharedCheckOrder.ts, 204, 28)) + +interface I99 { next: I100 } +>I99 : Symbol(I99, Decl(relationDepthSharedCheckOrder.ts, 203, 27)) +>next : Symbol(I99.next, Decl(relationDepthSharedCheckOrder.ts, 204, 15)) +>I100 : Symbol(I100, Decl(relationDepthSharedCheckOrder.ts, 205, 28)) + +interface J99 { next: J100 } +>J99 : Symbol(J99, Decl(relationDepthSharedCheckOrder.ts, 204, 28)) +>next : Symbol(J99.next, Decl(relationDepthSharedCheckOrder.ts, 205, 15)) +>J100 : Symbol(J100, Decl(relationDepthSharedCheckOrder.ts, 206, 29)) + +interface I100 { next: I101 } +>I100 : Symbol(I100, Decl(relationDepthSharedCheckOrder.ts, 205, 28)) +>next : Symbol(I100.next, Decl(relationDepthSharedCheckOrder.ts, 206, 16)) +>I101 : Symbol(I101, Decl(relationDepthSharedCheckOrder.ts, 207, 29)) + +interface J100 { next: J101 } +>J100 : Symbol(J100, Decl(relationDepthSharedCheckOrder.ts, 206, 29)) +>next : Symbol(J100.next, Decl(relationDepthSharedCheckOrder.ts, 207, 16)) +>J101 : Symbol(J101, Decl(relationDepthSharedCheckOrder.ts, 208, 29)) + +interface I101 { next: I102 } +>I101 : Symbol(I101, Decl(relationDepthSharedCheckOrder.ts, 207, 29)) +>next : Symbol(I101.next, Decl(relationDepthSharedCheckOrder.ts, 208, 16)) +>I102 : Symbol(I102, Decl(relationDepthSharedCheckOrder.ts, 209, 29)) + +interface J101 { next: J102 } +>J101 : Symbol(J101, Decl(relationDepthSharedCheckOrder.ts, 208, 29)) +>next : Symbol(J101.next, Decl(relationDepthSharedCheckOrder.ts, 209, 16)) +>J102 : Symbol(J102, Decl(relationDepthSharedCheckOrder.ts, 210, 29)) + +interface I102 { next: I103 } +>I102 : Symbol(I102, Decl(relationDepthSharedCheckOrder.ts, 209, 29)) +>next : Symbol(I102.next, Decl(relationDepthSharedCheckOrder.ts, 210, 16)) +>I103 : Symbol(I103, Decl(relationDepthSharedCheckOrder.ts, 211, 29)) + +interface J102 { next: J103 } +>J102 : Symbol(J102, Decl(relationDepthSharedCheckOrder.ts, 210, 29)) +>next : Symbol(J102.next, Decl(relationDepthSharedCheckOrder.ts, 211, 16)) +>J103 : Symbol(J103, Decl(relationDepthSharedCheckOrder.ts, 212, 29)) + +interface I103 { next: I104 } +>I103 : Symbol(I103, Decl(relationDepthSharedCheckOrder.ts, 211, 29)) +>next : Symbol(I103.next, Decl(relationDepthSharedCheckOrder.ts, 212, 16)) +>I104 : Symbol(I104, Decl(relationDepthSharedCheckOrder.ts, 213, 29)) + +interface J103 { next: J104 } +>J103 : Symbol(J103, Decl(relationDepthSharedCheckOrder.ts, 212, 29)) +>next : Symbol(J103.next, Decl(relationDepthSharedCheckOrder.ts, 213, 16)) +>J104 : Symbol(J104, Decl(relationDepthSharedCheckOrder.ts, 214, 29)) + +interface I104 { next: I105 } +>I104 : Symbol(I104, Decl(relationDepthSharedCheckOrder.ts, 213, 29)) +>next : Symbol(I104.next, Decl(relationDepthSharedCheckOrder.ts, 214, 16)) +>I105 : Symbol(I105, Decl(relationDepthSharedCheckOrder.ts, 215, 29)) + +interface J104 { next: J105 } +>J104 : Symbol(J104, Decl(relationDepthSharedCheckOrder.ts, 214, 29)) +>next : Symbol(J104.next, Decl(relationDepthSharedCheckOrder.ts, 215, 16)) +>J105 : Symbol(J105, Decl(relationDepthSharedCheckOrder.ts, 216, 29)) + +interface I105 { next: I106 } +>I105 : Symbol(I105, Decl(relationDepthSharedCheckOrder.ts, 215, 29)) +>next : Symbol(I105.next, Decl(relationDepthSharedCheckOrder.ts, 216, 16)) +>I106 : Symbol(I106, Decl(relationDepthSharedCheckOrder.ts, 217, 29)) + +interface J105 { next: J106 } +>J105 : Symbol(J105, Decl(relationDepthSharedCheckOrder.ts, 216, 29)) +>next : Symbol(J105.next, Decl(relationDepthSharedCheckOrder.ts, 217, 16)) +>J106 : Symbol(J106, Decl(relationDepthSharedCheckOrder.ts, 218, 29)) + +interface I106 { next: I107 } +>I106 : Symbol(I106, Decl(relationDepthSharedCheckOrder.ts, 217, 29)) +>next : Symbol(I106.next, Decl(relationDepthSharedCheckOrder.ts, 218, 16)) +>I107 : Symbol(I107, Decl(relationDepthSharedCheckOrder.ts, 219, 29)) + +interface J106 { next: J107 } +>J106 : Symbol(J106, Decl(relationDepthSharedCheckOrder.ts, 218, 29)) +>next : Symbol(J106.next, Decl(relationDepthSharedCheckOrder.ts, 219, 16)) +>J107 : Symbol(J107, Decl(relationDepthSharedCheckOrder.ts, 220, 29)) + +interface I107 { next: I108 } +>I107 : Symbol(I107, Decl(relationDepthSharedCheckOrder.ts, 219, 29)) +>next : Symbol(I107.next, Decl(relationDepthSharedCheckOrder.ts, 220, 16)) +>I108 : Symbol(I108, Decl(relationDepthSharedCheckOrder.ts, 221, 29)) + +interface J107 { next: J108 } +>J107 : Symbol(J107, Decl(relationDepthSharedCheckOrder.ts, 220, 29)) +>next : Symbol(J107.next, Decl(relationDepthSharedCheckOrder.ts, 221, 16)) +>J108 : Symbol(J108, Decl(relationDepthSharedCheckOrder.ts, 222, 29)) + +interface I108 { next: I109 } +>I108 : Symbol(I108, Decl(relationDepthSharedCheckOrder.ts, 221, 29)) +>next : Symbol(I108.next, Decl(relationDepthSharedCheckOrder.ts, 222, 16)) +>I109 : Symbol(I109, Decl(relationDepthSharedCheckOrder.ts, 223, 29)) + +interface J108 { next: J109 } +>J108 : Symbol(J108, Decl(relationDepthSharedCheckOrder.ts, 222, 29)) +>next : Symbol(J108.next, Decl(relationDepthSharedCheckOrder.ts, 223, 16)) +>J109 : Symbol(J109, Decl(relationDepthSharedCheckOrder.ts, 224, 29)) + +interface I109 { next: I110 } +>I109 : Symbol(I109, Decl(relationDepthSharedCheckOrder.ts, 223, 29)) +>next : Symbol(I109.next, Decl(relationDepthSharedCheckOrder.ts, 224, 16)) +>I110 : Symbol(I110, Decl(relationDepthSharedCheckOrder.ts, 225, 29)) + +interface J109 { next: J110 } +>J109 : Symbol(J109, Decl(relationDepthSharedCheckOrder.ts, 224, 29)) +>next : Symbol(J109.next, Decl(relationDepthSharedCheckOrder.ts, 225, 16)) +>J110 : Symbol(J110, Decl(relationDepthSharedCheckOrder.ts, 226, 29)) + +interface I110 { next: I111 } +>I110 : Symbol(I110, Decl(relationDepthSharedCheckOrder.ts, 225, 29)) +>next : Symbol(I110.next, Decl(relationDepthSharedCheckOrder.ts, 226, 16)) +>I111 : Symbol(I111, Decl(relationDepthSharedCheckOrder.ts, 227, 29)) + +interface J110 { next: J111 } +>J110 : Symbol(J110, Decl(relationDepthSharedCheckOrder.ts, 226, 29)) +>next : Symbol(J110.next, Decl(relationDepthSharedCheckOrder.ts, 227, 16)) +>J111 : Symbol(J111, Decl(relationDepthSharedCheckOrder.ts, 228, 29)) + +interface I111 { next: I112 } +>I111 : Symbol(I111, Decl(relationDepthSharedCheckOrder.ts, 227, 29)) +>next : Symbol(I111.next, Decl(relationDepthSharedCheckOrder.ts, 228, 16)) +>I112 : Symbol(I112, Decl(relationDepthSharedCheckOrder.ts, 229, 29)) + +interface J111 { next: J112 } +>J111 : Symbol(J111, Decl(relationDepthSharedCheckOrder.ts, 228, 29)) +>next : Symbol(J111.next, Decl(relationDepthSharedCheckOrder.ts, 229, 16)) +>J112 : Symbol(J112, Decl(relationDepthSharedCheckOrder.ts, 230, 29)) + +interface I112 { next: I113 } +>I112 : Symbol(I112, Decl(relationDepthSharedCheckOrder.ts, 229, 29)) +>next : Symbol(I112.next, Decl(relationDepthSharedCheckOrder.ts, 230, 16)) +>I113 : Symbol(I113, Decl(relationDepthSharedCheckOrder.ts, 231, 29)) + +interface J112 { next: J113 } +>J112 : Symbol(J112, Decl(relationDepthSharedCheckOrder.ts, 230, 29)) +>next : Symbol(J112.next, Decl(relationDepthSharedCheckOrder.ts, 231, 16)) +>J113 : Symbol(J113, Decl(relationDepthSharedCheckOrder.ts, 232, 29)) + +interface I113 { next: I114 } +>I113 : Symbol(I113, Decl(relationDepthSharedCheckOrder.ts, 231, 29)) +>next : Symbol(I113.next, Decl(relationDepthSharedCheckOrder.ts, 232, 16)) +>I114 : Symbol(I114, Decl(relationDepthSharedCheckOrder.ts, 233, 29)) + +interface J113 { next: J114 } +>J113 : Symbol(J113, Decl(relationDepthSharedCheckOrder.ts, 232, 29)) +>next : Symbol(J113.next, Decl(relationDepthSharedCheckOrder.ts, 233, 16)) +>J114 : Symbol(J114, Decl(relationDepthSharedCheckOrder.ts, 234, 29)) + +interface I114 { next: I115 } +>I114 : Symbol(I114, Decl(relationDepthSharedCheckOrder.ts, 233, 29)) +>next : Symbol(I114.next, Decl(relationDepthSharedCheckOrder.ts, 234, 16)) +>I115 : Symbol(I115, Decl(relationDepthSharedCheckOrder.ts, 235, 29)) + +interface J114 { next: J115 } +>J114 : Symbol(J114, Decl(relationDepthSharedCheckOrder.ts, 234, 29)) +>next : Symbol(J114.next, Decl(relationDepthSharedCheckOrder.ts, 235, 16)) +>J115 : Symbol(J115, Decl(relationDepthSharedCheckOrder.ts, 236, 29)) + +interface I115 { next: I116 } +>I115 : Symbol(I115, Decl(relationDepthSharedCheckOrder.ts, 235, 29)) +>next : Symbol(I115.next, Decl(relationDepthSharedCheckOrder.ts, 236, 16)) +>I116 : Symbol(I116, Decl(relationDepthSharedCheckOrder.ts, 237, 29)) + +interface J115 { next: J116 } +>J115 : Symbol(J115, Decl(relationDepthSharedCheckOrder.ts, 236, 29)) +>next : Symbol(J115.next, Decl(relationDepthSharedCheckOrder.ts, 237, 16)) +>J116 : Symbol(J116, Decl(relationDepthSharedCheckOrder.ts, 238, 29)) + +interface I116 { next: I117 } +>I116 : Symbol(I116, Decl(relationDepthSharedCheckOrder.ts, 237, 29)) +>next : Symbol(I116.next, Decl(relationDepthSharedCheckOrder.ts, 238, 16)) +>I117 : Symbol(I117, Decl(relationDepthSharedCheckOrder.ts, 239, 29)) + +interface J116 { next: J117 } +>J116 : Symbol(J116, Decl(relationDepthSharedCheckOrder.ts, 238, 29)) +>next : Symbol(J116.next, Decl(relationDepthSharedCheckOrder.ts, 239, 16)) +>J117 : Symbol(J117, Decl(relationDepthSharedCheckOrder.ts, 240, 29)) + +interface I117 { next: I118 } +>I117 : Symbol(I117, Decl(relationDepthSharedCheckOrder.ts, 239, 29)) +>next : Symbol(I117.next, Decl(relationDepthSharedCheckOrder.ts, 240, 16)) +>I118 : Symbol(I118, Decl(relationDepthSharedCheckOrder.ts, 241, 29)) + +interface J117 { next: J118 } +>J117 : Symbol(J117, Decl(relationDepthSharedCheckOrder.ts, 240, 29)) +>next : Symbol(J117.next, Decl(relationDepthSharedCheckOrder.ts, 241, 16)) +>J118 : Symbol(J118, Decl(relationDepthSharedCheckOrder.ts, 242, 29)) + +interface I118 { next: I119 } +>I118 : Symbol(I118, Decl(relationDepthSharedCheckOrder.ts, 241, 29)) +>next : Symbol(I118.next, Decl(relationDepthSharedCheckOrder.ts, 242, 16)) +>I119 : Symbol(I119, Decl(relationDepthSharedCheckOrder.ts, 243, 29)) + +interface J118 { next: J119 } +>J118 : Symbol(J118, Decl(relationDepthSharedCheckOrder.ts, 242, 29)) +>next : Symbol(J118.next, Decl(relationDepthSharedCheckOrder.ts, 243, 16)) +>J119 : Symbol(J119, Decl(relationDepthSharedCheckOrder.ts, 244, 31)) + +interface I119 { leaf: string } +>I119 : Symbol(I119, Decl(relationDepthSharedCheckOrder.ts, 243, 29)) +>leaf : Symbol(I119.leaf, Decl(relationDepthSharedCheckOrder.ts, 244, 16)) + +interface J119 { leaf: number } +>J119 : Symbol(J119, Decl(relationDepthSharedCheckOrder.ts, 244, 31)) +>leaf : Symbol(J119.leaf, Decl(relationDepthSharedCheckOrder.ts, 245, 16)) + +type Mid = I60 extends J60 ? true : false; +>Mid : Symbol(Mid, Decl(relationDepthSharedCheckOrder.ts, 245, 31)) +>I60 : Symbol(I60, Decl(relationDepthSharedCheckOrder.ts, 125, 27)) +>J60 : Symbol(J60, Decl(relationDepthSharedCheckOrder.ts, 126, 27)) + +type All = I0 extends J0 ? true : false; +>All : Symbol(All, Decl(relationDepthSharedCheckOrder.ts, 247, 42)) +>I0 : Symbol(I0, Decl(relationDepthSharedCheckOrder.ts, 0, 0)) +>J0 : Symbol(J0, Decl(relationDepthSharedCheckOrder.ts, 6, 25)) + diff --git a/tsc/testdata/baselines/reference/compiler/relationDepthSharedCheckOrder(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/relationDepthSharedCheckOrder(checkorder=typesfirst).types new file mode 100644 index 0000000000000..4d25be7bdfdba --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/relationDepthSharedCheckOrder(checkorder=typesfirst).types @@ -0,0 +1,739 @@ +//// [tests/cases/compiler/relationDepthSharedCheckOrder.ts] //// + +=== relationDepthSharedCheckOrder.ts === +// Relating I0 to J0 fresh nests a comparison 100 levels deep, where it is +// cut short and so succeeds. In program order Mid has already found that +// I60 is not related to J60. Whether I0 is related to J0 must not depend +// on which comes first. Conditional types relate without reporting errors, +// which would compute the comparison again. + +interface I0 { next: I1 } +>next : I1 + +interface J0 { next: J1 } +>next : J1 + +interface I1 { next: I2 } +>next : I2 + +interface J1 { next: J2 } +>next : J2 + +interface I2 { next: I3 } +>next : I3 + +interface J2 { next: J3 } +>next : J3 + +interface I3 { next: I4 } +>next : I4 + +interface J3 { next: J4 } +>next : J4 + +interface I4 { next: I5 } +>next : I5 + +interface J4 { next: J5 } +>next : J5 + +interface I5 { next: I6 } +>next : I6 + +interface J5 { next: J6 } +>next : J6 + +interface I6 { next: I7 } +>next : I7 + +interface J6 { next: J7 } +>next : J7 + +interface I7 { next: I8 } +>next : I8 + +interface J7 { next: J8 } +>next : J8 + +interface I8 { next: I9 } +>next : I9 + +interface J8 { next: J9 } +>next : J9 + +interface I9 { next: I10 } +>next : I10 + +interface J9 { next: J10 } +>next : J10 + +interface I10 { next: I11 } +>next : I11 + +interface J10 { next: J11 } +>next : J11 + +interface I11 { next: I12 } +>next : I12 + +interface J11 { next: J12 } +>next : J12 + +interface I12 { next: I13 } +>next : I13 + +interface J12 { next: J13 } +>next : J13 + +interface I13 { next: I14 } +>next : I14 + +interface J13 { next: J14 } +>next : J14 + +interface I14 { next: I15 } +>next : I15 + +interface J14 { next: J15 } +>next : J15 + +interface I15 { next: I16 } +>next : I16 + +interface J15 { next: J16 } +>next : J16 + +interface I16 { next: I17 } +>next : I17 + +interface J16 { next: J17 } +>next : J17 + +interface I17 { next: I18 } +>next : I18 + +interface J17 { next: J18 } +>next : J18 + +interface I18 { next: I19 } +>next : I19 + +interface J18 { next: J19 } +>next : J19 + +interface I19 { next: I20 } +>next : I20 + +interface J19 { next: J20 } +>next : J20 + +interface I20 { next: I21 } +>next : I21 + +interface J20 { next: J21 } +>next : J21 + +interface I21 { next: I22 } +>next : I22 + +interface J21 { next: J22 } +>next : J22 + +interface I22 { next: I23 } +>next : I23 + +interface J22 { next: J23 } +>next : J23 + +interface I23 { next: I24 } +>next : I24 + +interface J23 { next: J24 } +>next : J24 + +interface I24 { next: I25 } +>next : I25 + +interface J24 { next: J25 } +>next : J25 + +interface I25 { next: I26 } +>next : I26 + +interface J25 { next: J26 } +>next : J26 + +interface I26 { next: I27 } +>next : I27 + +interface J26 { next: J27 } +>next : J27 + +interface I27 { next: I28 } +>next : I28 + +interface J27 { next: J28 } +>next : J28 + +interface I28 { next: I29 } +>next : I29 + +interface J28 { next: J29 } +>next : J29 + +interface I29 { next: I30 } +>next : I30 + +interface J29 { next: J30 } +>next : J30 + +interface I30 { next: I31 } +>next : I31 + +interface J30 { next: J31 } +>next : J31 + +interface I31 { next: I32 } +>next : I32 + +interface J31 { next: J32 } +>next : J32 + +interface I32 { next: I33 } +>next : I33 + +interface J32 { next: J33 } +>next : J33 + +interface I33 { next: I34 } +>next : I34 + +interface J33 { next: J34 } +>next : J34 + +interface I34 { next: I35 } +>next : I35 + +interface J34 { next: J35 } +>next : J35 + +interface I35 { next: I36 } +>next : I36 + +interface J35 { next: J36 } +>next : J36 + +interface I36 { next: I37 } +>next : I37 + +interface J36 { next: J37 } +>next : J37 + +interface I37 { next: I38 } +>next : I38 + +interface J37 { next: J38 } +>next : J38 + +interface I38 { next: I39 } +>next : I39 + +interface J38 { next: J39 } +>next : J39 + +interface I39 { next: I40 } +>next : I40 + +interface J39 { next: J40 } +>next : J40 + +interface I40 { next: I41 } +>next : I41 + +interface J40 { next: J41 } +>next : J41 + +interface I41 { next: I42 } +>next : I42 + +interface J41 { next: J42 } +>next : J42 + +interface I42 { next: I43 } +>next : I43 + +interface J42 { next: J43 } +>next : J43 + +interface I43 { next: I44 } +>next : I44 + +interface J43 { next: J44 } +>next : J44 + +interface I44 { next: I45 } +>next : I45 + +interface J44 { next: J45 } +>next : J45 + +interface I45 { next: I46 } +>next : I46 + +interface J45 { next: J46 } +>next : J46 + +interface I46 { next: I47 } +>next : I47 + +interface J46 { next: J47 } +>next : J47 + +interface I47 { next: I48 } +>next : I48 + +interface J47 { next: J48 } +>next : J48 + +interface I48 { next: I49 } +>next : I49 + +interface J48 { next: J49 } +>next : J49 + +interface I49 { next: I50 } +>next : I50 + +interface J49 { next: J50 } +>next : J50 + +interface I50 { next: I51 } +>next : I51 + +interface J50 { next: J51 } +>next : J51 + +interface I51 { next: I52 } +>next : I52 + +interface J51 { next: J52 } +>next : J52 + +interface I52 { next: I53 } +>next : I53 + +interface J52 { next: J53 } +>next : J53 + +interface I53 { next: I54 } +>next : I54 + +interface J53 { next: J54 } +>next : J54 + +interface I54 { next: I55 } +>next : I55 + +interface J54 { next: J55 } +>next : J55 + +interface I55 { next: I56 } +>next : I56 + +interface J55 { next: J56 } +>next : J56 + +interface I56 { next: I57 } +>next : I57 + +interface J56 { next: J57 } +>next : J57 + +interface I57 { next: I58 } +>next : I58 + +interface J57 { next: J58 } +>next : J58 + +interface I58 { next: I59 } +>next : I59 + +interface J58 { next: J59 } +>next : J59 + +interface I59 { next: I60 } +>next : I60 + +interface J59 { next: J60 } +>next : J60 + +interface I60 { next: I61 } +>next : I61 + +interface J60 { next: J61 } +>next : J61 + +interface I61 { next: I62 } +>next : I62 + +interface J61 { next: J62 } +>next : J62 + +interface I62 { next: I63 } +>next : I63 + +interface J62 { next: J63 } +>next : J63 + +interface I63 { next: I64 } +>next : I64 + +interface J63 { next: J64 } +>next : J64 + +interface I64 { next: I65 } +>next : I65 + +interface J64 { next: J65 } +>next : J65 + +interface I65 { next: I66 } +>next : I66 + +interface J65 { next: J66 } +>next : J66 + +interface I66 { next: I67 } +>next : I67 + +interface J66 { next: J67 } +>next : J67 + +interface I67 { next: I68 } +>next : I68 + +interface J67 { next: J68 } +>next : J68 + +interface I68 { next: I69 } +>next : I69 + +interface J68 { next: J69 } +>next : J69 + +interface I69 { next: I70 } +>next : I70 + +interface J69 { next: J70 } +>next : J70 + +interface I70 { next: I71 } +>next : I71 + +interface J70 { next: J71 } +>next : J71 + +interface I71 { next: I72 } +>next : I72 + +interface J71 { next: J72 } +>next : J72 + +interface I72 { next: I73 } +>next : I73 + +interface J72 { next: J73 } +>next : J73 + +interface I73 { next: I74 } +>next : I74 + +interface J73 { next: J74 } +>next : J74 + +interface I74 { next: I75 } +>next : I75 + +interface J74 { next: J75 } +>next : J75 + +interface I75 { next: I76 } +>next : I76 + +interface J75 { next: J76 } +>next : J76 + +interface I76 { next: I77 } +>next : I77 + +interface J76 { next: J77 } +>next : J77 + +interface I77 { next: I78 } +>next : I78 + +interface J77 { next: J78 } +>next : J78 + +interface I78 { next: I79 } +>next : I79 + +interface J78 { next: J79 } +>next : J79 + +interface I79 { next: I80 } +>next : I80 + +interface J79 { next: J80 } +>next : J80 + +interface I80 { next: I81 } +>next : I81 + +interface J80 { next: J81 } +>next : J81 + +interface I81 { next: I82 } +>next : I82 + +interface J81 { next: J82 } +>next : J82 + +interface I82 { next: I83 } +>next : I83 + +interface J82 { next: J83 } +>next : J83 + +interface I83 { next: I84 } +>next : I84 + +interface J83 { next: J84 } +>next : J84 + +interface I84 { next: I85 } +>next : I85 + +interface J84 { next: J85 } +>next : J85 + +interface I85 { next: I86 } +>next : I86 + +interface J85 { next: J86 } +>next : J86 + +interface I86 { next: I87 } +>next : I87 + +interface J86 { next: J87 } +>next : J87 + +interface I87 { next: I88 } +>next : I88 + +interface J87 { next: J88 } +>next : J88 + +interface I88 { next: I89 } +>next : I89 + +interface J88 { next: J89 } +>next : J89 + +interface I89 { next: I90 } +>next : I90 + +interface J89 { next: J90 } +>next : J90 + +interface I90 { next: I91 } +>next : I91 + +interface J90 { next: J91 } +>next : J91 + +interface I91 { next: I92 } +>next : I92 + +interface J91 { next: J92 } +>next : J92 + +interface I92 { next: I93 } +>next : I93 + +interface J92 { next: J93 } +>next : J93 + +interface I93 { next: I94 } +>next : I94 + +interface J93 { next: J94 } +>next : J94 + +interface I94 { next: I95 } +>next : I95 + +interface J94 { next: J95 } +>next : J95 + +interface I95 { next: I96 } +>next : I96 + +interface J95 { next: J96 } +>next : J96 + +interface I96 { next: I97 } +>next : I97 + +interface J96 { next: J97 } +>next : J97 + +interface I97 { next: I98 } +>next : I98 + +interface J97 { next: J98 } +>next : J98 + +interface I98 { next: I99 } +>next : I99 + +interface J98 { next: J99 } +>next : J99 + +interface I99 { next: I100 } +>next : I100 + +interface J99 { next: J100 } +>next : J100 + +interface I100 { next: I101 } +>next : I101 + +interface J100 { next: J101 } +>next : J101 + +interface I101 { next: I102 } +>next : I102 + +interface J101 { next: J102 } +>next : J102 + +interface I102 { next: I103 } +>next : I103 + +interface J102 { next: J103 } +>next : J103 + +interface I103 { next: I104 } +>next : I104 + +interface J103 { next: J104 } +>next : J104 + +interface I104 { next: I105 } +>next : I105 + +interface J104 { next: J105 } +>next : J105 + +interface I105 { next: I106 } +>next : I106 + +interface J105 { next: J106 } +>next : J106 + +interface I106 { next: I107 } +>next : I107 + +interface J106 { next: J107 } +>next : J107 + +interface I107 { next: I108 } +>next : I108 + +interface J107 { next: J108 } +>next : J108 + +interface I108 { next: I109 } +>next : I109 + +interface J108 { next: J109 } +>next : J109 + +interface I109 { next: I110 } +>next : I110 + +interface J109 { next: J110 } +>next : J110 + +interface I110 { next: I111 } +>next : I111 + +interface J110 { next: J111 } +>next : J111 + +interface I111 { next: I112 } +>next : I112 + +interface J111 { next: J112 } +>next : J112 + +interface I112 { next: I113 } +>next : I113 + +interface J112 { next: J113 } +>next : J113 + +interface I113 { next: I114 } +>next : I114 + +interface J113 { next: J114 } +>next : J114 + +interface I114 { next: I115 } +>next : I115 + +interface J114 { next: J115 } +>next : J115 + +interface I115 { next: I116 } +>next : I116 + +interface J115 { next: J116 } +>next : J116 + +interface I116 { next: I117 } +>next : I117 + +interface J116 { next: J117 } +>next : J117 + +interface I117 { next: I118 } +>next : I118 + +interface J117 { next: J118 } +>next : J118 + +interface I118 { next: I119 } +>next : I119 + +interface J118 { next: J119 } +>next : J119 + +interface I119 { leaf: string } +>leaf : string + +interface J119 { leaf: number } +>leaf : number + +type Mid = I60 extends J60 ? true : false; +>Mid : true +>true : true +>false : false + +type All = I0 extends J0 ? true : false; +>All : true +>true : true +>false : false + diff --git a/tsc/testdata/baselines/reference/compiler/relationMaybeCheckOrder.errors.txt b/tsc/testdata/baselines/reference/compiler/relationMaybeCheckOrder.errors.txt new file mode 100644 index 0000000000000..88dee4e5a8f7e --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/relationMaybeCheckOrder.errors.txt @@ -0,0 +1,31 @@ +relationMaybeCheckOrder.ts(8,32): error TS2322: Type 'B' is not assignable to type 'string | number | symbol'. +relationMaybeCheckOrder.ts(18,11): error TS2322: Type '2' is not assignable to type '1'. + + +==== relationMaybeCheckOrder.ts (2 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); + ~ +!!! error TS2322: Type '2' is not assignable to type '1'. + } + + 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..ecbee15a795d4 --- /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) : 2 +>g : { (x: keyof M): 1; (x: unknown): 2; } +>a : A +} + +const w: 1 = h(a); +>w : 1 +>h(a) : 1 +>h : { (x: B): 1; (x: unknown): 2; } +>a : A + diff --git a/tsc/testdata/baselines/reference/compiler/relationNestingSharedCheckOrder(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/relationNestingSharedCheckOrder(checkorder=default).symbols new file mode 100644 index 0000000000000..337f9333d8214 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/relationNestingSharedCheckOrder(checkorder=default).symbols @@ -0,0 +1,38 @@ +//// [tests/cases/compiler/relationNestingSharedCheckOrder.ts] //// + +=== relationNestingSharedCheckOrder.ts === +// Relating S to R fresh is cut short at deeply nested +// types before reaching next.leaf, and so succeeds. In program order Inner +// has already found that S<[string]> is not related to R<[string]>. Whether +// Outer succeeds must not depend on which comes first. Conditional types +// relate without reporting errors, which would compute the comparison again. + +type S = { next: S<[T]>; leaf: T extends [[unknown]] ? number : T }; +>S : Symbol(S, Decl(relationNestingSharedCheckOrder.ts, 0, 0)) +>T : Symbol(T, Decl(relationNestingSharedCheckOrder.ts, 6, 7)) +>next : Symbol(next, Decl(relationNestingSharedCheckOrder.ts, 6, 13)) +>S : Symbol(S, Decl(relationNestingSharedCheckOrder.ts, 0, 0)) +>T : Symbol(T, Decl(relationNestingSharedCheckOrder.ts, 6, 7)) +>leaf : Symbol(leaf, Decl(relationNestingSharedCheckOrder.ts, 6, 27)) +>T : Symbol(T, Decl(relationNestingSharedCheckOrder.ts, 6, 7)) +>T : Symbol(T, Decl(relationNestingSharedCheckOrder.ts, 6, 7)) + +type R = { next: R<[T]>; leaf: T }; +>R : Symbol(R, Decl(relationNestingSharedCheckOrder.ts, 6, 71)) +>T : Symbol(T, Decl(relationNestingSharedCheckOrder.ts, 7, 7)) +>next : Symbol(next, Decl(relationNestingSharedCheckOrder.ts, 7, 13)) +>R : Symbol(R, Decl(relationNestingSharedCheckOrder.ts, 6, 71)) +>T : Symbol(T, Decl(relationNestingSharedCheckOrder.ts, 7, 7)) +>leaf : Symbol(leaf, Decl(relationNestingSharedCheckOrder.ts, 7, 27)) +>T : Symbol(T, Decl(relationNestingSharedCheckOrder.ts, 7, 7)) + +type Inner = S<[string]> extends R<[string]> ? true : false; +>Inner : Symbol(Inner, Decl(relationNestingSharedCheckOrder.ts, 7, 38)) +>S : Symbol(S, Decl(relationNestingSharedCheckOrder.ts, 0, 0)) +>R : Symbol(R, Decl(relationNestingSharedCheckOrder.ts, 6, 71)) + +type Outer = S extends R ? true : false; +>Outer : Symbol(Outer, Decl(relationNestingSharedCheckOrder.ts, 9, 60)) +>S : Symbol(S, Decl(relationNestingSharedCheckOrder.ts, 0, 0)) +>R : Symbol(R, Decl(relationNestingSharedCheckOrder.ts, 6, 71)) + diff --git a/tsc/testdata/baselines/reference/compiler/relationNestingSharedCheckOrder(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/relationNestingSharedCheckOrder(checkorder=default).types new file mode 100644 index 0000000000000..2eb3a955c4f06 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/relationNestingSharedCheckOrder(checkorder=default).types @@ -0,0 +1,29 @@ +//// [tests/cases/compiler/relationNestingSharedCheckOrder.ts] //// + +=== relationNestingSharedCheckOrder.ts === +// Relating S to R fresh is cut short at deeply nested +// types before reaching next.leaf, and so succeeds. In program order Inner +// has already found that S<[string]> is not related to R<[string]>. Whether +// Outer succeeds must not depend on which comes first. Conditional types +// relate without reporting errors, which would compute the comparison again. + +type S = { next: S<[T]>; leaf: T extends [[unknown]] ? number : T }; +>S : S +>next : S<[T]> +>leaf : T extends [[unknown]] ? number : T + +type R = { next: R<[T]>; leaf: T }; +>R : R +>next : R<[T]> +>leaf : T + +type Inner = S<[string]> extends R<[string]> ? true : false; +>Inner : false +>true : true +>false : false + +type Outer = S extends R ? true : false; +>Outer : false +>true : true +>false : false + diff --git a/tsc/testdata/baselines/reference/compiler/relationNestingSharedCheckOrder(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/relationNestingSharedCheckOrder(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..337f9333d8214 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/relationNestingSharedCheckOrder(checkorder=typesfirst).symbols @@ -0,0 +1,38 @@ +//// [tests/cases/compiler/relationNestingSharedCheckOrder.ts] //// + +=== relationNestingSharedCheckOrder.ts === +// Relating S to R fresh is cut short at deeply nested +// types before reaching next.leaf, and so succeeds. In program order Inner +// has already found that S<[string]> is not related to R<[string]>. Whether +// Outer succeeds must not depend on which comes first. Conditional types +// relate without reporting errors, which would compute the comparison again. + +type S = { next: S<[T]>; leaf: T extends [[unknown]] ? number : T }; +>S : Symbol(S, Decl(relationNestingSharedCheckOrder.ts, 0, 0)) +>T : Symbol(T, Decl(relationNestingSharedCheckOrder.ts, 6, 7)) +>next : Symbol(next, Decl(relationNestingSharedCheckOrder.ts, 6, 13)) +>S : Symbol(S, Decl(relationNestingSharedCheckOrder.ts, 0, 0)) +>T : Symbol(T, Decl(relationNestingSharedCheckOrder.ts, 6, 7)) +>leaf : Symbol(leaf, Decl(relationNestingSharedCheckOrder.ts, 6, 27)) +>T : Symbol(T, Decl(relationNestingSharedCheckOrder.ts, 6, 7)) +>T : Symbol(T, Decl(relationNestingSharedCheckOrder.ts, 6, 7)) + +type R = { next: R<[T]>; leaf: T }; +>R : Symbol(R, Decl(relationNestingSharedCheckOrder.ts, 6, 71)) +>T : Symbol(T, Decl(relationNestingSharedCheckOrder.ts, 7, 7)) +>next : Symbol(next, Decl(relationNestingSharedCheckOrder.ts, 7, 13)) +>R : Symbol(R, Decl(relationNestingSharedCheckOrder.ts, 6, 71)) +>T : Symbol(T, Decl(relationNestingSharedCheckOrder.ts, 7, 7)) +>leaf : Symbol(leaf, Decl(relationNestingSharedCheckOrder.ts, 7, 27)) +>T : Symbol(T, Decl(relationNestingSharedCheckOrder.ts, 7, 7)) + +type Inner = S<[string]> extends R<[string]> ? true : false; +>Inner : Symbol(Inner, Decl(relationNestingSharedCheckOrder.ts, 7, 38)) +>S : Symbol(S, Decl(relationNestingSharedCheckOrder.ts, 0, 0)) +>R : Symbol(R, Decl(relationNestingSharedCheckOrder.ts, 6, 71)) + +type Outer = S extends R ? true : false; +>Outer : Symbol(Outer, Decl(relationNestingSharedCheckOrder.ts, 9, 60)) +>S : Symbol(S, Decl(relationNestingSharedCheckOrder.ts, 0, 0)) +>R : Symbol(R, Decl(relationNestingSharedCheckOrder.ts, 6, 71)) + diff --git a/tsc/testdata/baselines/reference/compiler/relationNestingSharedCheckOrder(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/relationNestingSharedCheckOrder(checkorder=typesfirst).types new file mode 100644 index 0000000000000..fcc2fcc2b32aa --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/relationNestingSharedCheckOrder(checkorder=typesfirst).types @@ -0,0 +1,29 @@ +//// [tests/cases/compiler/relationNestingSharedCheckOrder.ts] //// + +=== relationNestingSharedCheckOrder.ts === +// Relating S to R fresh is cut short at deeply nested +// types before reaching next.leaf, and so succeeds. In program order Inner +// has already found that S<[string]> is not related to R<[string]>. Whether +// Outer succeeds must not depend on which comes first. Conditional types +// relate without reporting errors, which would compute the comparison again. + +type S = { next: S<[T]>; leaf: T extends [[unknown]] ? number : T }; +>S : S +>next : S<[T]> +>leaf : T extends [[unknown]] ? number : T + +type R = { next: R<[T]>; leaf: T }; +>R : R +>next : R<[T]> +>leaf : T + +type Inner = S<[string]> extends R<[string]> ? true : false; +>Inner : true +>true : true +>false : false + +type Outer = S extends R ? true : false; +>Outer : true +>true : true +>false : false + diff --git a/tsc/testdata/baselines/reference/compiler/relationTruncatedCacheCheckOrder(checkorder=default).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..343f53694e8da --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/relationTruncatedCacheCheckOrder(checkorder=typesfirst).errors.txt @@ -0,0 +1,32 @@ +relationTruncatedCacheCheckOrder.ts(13,1): error TS2322: Type 'S' is not assignable to type 'R'. + The types of 'next.next.leaf' are incompatible between these types. + Type 'number' is not assignable to type '[[string]]'. +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 (2 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; + ~ +!!! error TS2322: Type 'S' is not assignable to type 'R'. +!!! error TS2322: The types of 'next.next.leaf' are incompatible between these types. +!!! error TS2322: Type 'number' is not assignable to type '[[string]]'. + q = p; + ~ +!!! error TS2322: Type 'S<[string]>' is not assignable to type 'R<[string]>'. +!!! error TS2322: The types of 'next.leaf' are incompatible between these types. +!!! error TS2322: Type 'number' is not assignable to type '[[string]]'. + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/relationTruncatedCacheCheckOrder(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/relationTruncatedCacheCheckOrder(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..1a917a7da7f9f --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/relationTruncatedCacheCheckOrder(checkorder=typesfirst).symbols @@ -0,0 +1,48 @@ +//// [tests/cases/compiler/relationTruncatedCacheCheckOrder.ts] //// + +=== relationTruncatedCacheCheckOrder.ts === +// Relating 'S<[string]>' to 'R<[string]>' from scratch reaches 'next.leaf' +// before giving up on deeply nested types, and fails there. Inside the +// relation of 'S' to 'R' it is one level deeper and is cut +// short instead. That truncated result must not be cached, so the error for +// 'q = p' must be reported whether or not 'y = x' was checked first. + +type S = { next: S<[T]>; leaf: T extends [[unknown]] ? number : T }; +>S : Symbol(S, Decl(relationTruncatedCacheCheckOrder.ts, 0, 0)) +>T : Symbol(T, Decl(relationTruncatedCacheCheckOrder.ts, 6, 7)) +>next : Symbol(next, Decl(relationTruncatedCacheCheckOrder.ts, 6, 13)) +>S : Symbol(S, Decl(relationTruncatedCacheCheckOrder.ts, 0, 0)) +>T : Symbol(T, Decl(relationTruncatedCacheCheckOrder.ts, 6, 7)) +>leaf : Symbol(leaf, Decl(relationTruncatedCacheCheckOrder.ts, 6, 27)) +>T : Symbol(T, Decl(relationTruncatedCacheCheckOrder.ts, 6, 7)) +>T : Symbol(T, Decl(relationTruncatedCacheCheckOrder.ts, 6, 7)) + +type R = { next: R<[T]>; leaf: T }; +>R : Symbol(R, Decl(relationTruncatedCacheCheckOrder.ts, 6, 71)) +>T : Symbol(T, Decl(relationTruncatedCacheCheckOrder.ts, 7, 7)) +>next : Symbol(next, Decl(relationTruncatedCacheCheckOrder.ts, 7, 13)) +>R : Symbol(R, Decl(relationTruncatedCacheCheckOrder.ts, 6, 71)) +>T : Symbol(T, Decl(relationTruncatedCacheCheckOrder.ts, 7, 7)) +>leaf : Symbol(leaf, Decl(relationTruncatedCacheCheckOrder.ts, 7, 27)) +>T : Symbol(T, Decl(relationTruncatedCacheCheckOrder.ts, 7, 7)) + +declare let x: S, y: R; +>x : Symbol(x, Decl(relationTruncatedCacheCheckOrder.ts, 9, 11)) +>S : Symbol(S, Decl(relationTruncatedCacheCheckOrder.ts, 0, 0)) +>y : Symbol(y, Decl(relationTruncatedCacheCheckOrder.ts, 9, 25)) +>R : Symbol(R, Decl(relationTruncatedCacheCheckOrder.ts, 6, 71)) + +declare let p: S<[string]>, q: R<[string]>; +>p : Symbol(p, Decl(relationTruncatedCacheCheckOrder.ts, 10, 11)) +>S : Symbol(S, Decl(relationTruncatedCacheCheckOrder.ts, 0, 0)) +>q : Symbol(q, Decl(relationTruncatedCacheCheckOrder.ts, 10, 27)) +>R : Symbol(R, Decl(relationTruncatedCacheCheckOrder.ts, 6, 71)) + +y = x; +>y : Symbol(y, Decl(relationTruncatedCacheCheckOrder.ts, 9, 25)) +>x : Symbol(x, Decl(relationTruncatedCacheCheckOrder.ts, 9, 11)) + +q = p; +>q : Symbol(q, Decl(relationTruncatedCacheCheckOrder.ts, 10, 27)) +>p : Symbol(p, Decl(relationTruncatedCacheCheckOrder.ts, 10, 11)) + diff --git a/tsc/testdata/baselines/reference/compiler/relationTruncatedCacheCheckOrder(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/relationTruncatedCacheCheckOrder(checkorder=typesfirst).types new file mode 100644 index 0000000000000..61db4cbc7e0c8 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/relationTruncatedCacheCheckOrder(checkorder=typesfirst).types @@ -0,0 +1,37 @@ +//// [tests/cases/compiler/relationTruncatedCacheCheckOrder.ts] //// + +=== relationTruncatedCacheCheckOrder.ts === +// Relating 'S<[string]>' to 'R<[string]>' from scratch reaches 'next.leaf' +// before giving up on deeply nested types, and fails there. Inside the +// relation of 'S' to 'R' it is one level deeper and is cut +// short instead. That truncated result must not be cached, so the error for +// 'q = p' must be reported whether or not 'y = x' was checked first. + +type S = { next: S<[T]>; leaf: T extends [[unknown]] ? number : T }; +>S : S +>next : S<[T]> +>leaf : T extends [[unknown]] ? number : T + +type R = { next: R<[T]>; leaf: T }; +>R : R +>next : R<[T]> +>leaf : T + +declare let x: S, y: R; +>x : S +>y : R + +declare let p: S<[string]>, q: R<[string]>; +>p : S<[string]> +>q : R<[string]> + +y = x; +>y = x : S +>y : R +>x : S + +q = p; +>q = p : S<[string]> +>q : R<[string]> +>p : S<[string]> + diff --git a/tsc/testdata/baselines/reference/compiler/restrictiveInstantiationOfRestrictiveConditional.symbols b/tsc/testdata/baselines/reference/compiler/restrictiveInstantiationOfRestrictiveConditional.symbols new file mode 100644 index 0000000000000..bb4e995330087 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/restrictiveInstantiationOfRestrictiveConditional.symbols @@ -0,0 +1,682 @@ +//// [tests/cases/compiler/restrictiveInstantiationOfRestrictiveConditional.ts] //// + +=== arraySlice.d.ts === +export type {ArraySlice}; +>ArraySlice : Symbol(ArraySlice, Decl(arraySlice.d.ts, 0, 13)) + +declare const tag: unique symbol; +>tag : Symbol(tag, Decl(arraySlice.d.ts, 1, 13)) + +type IsNever = [T] extends [never] ? true : false; +>IsNever : Symbol(IsNever, Decl(arraySlice.d.ts, 1, 33)) +>T : Symbol(T, Decl(arraySlice.d.ts, 2, 13)) +>T : Symbol(T, Decl(arraySlice.d.ts, 2, 13)) + +type IsEqual = +>IsEqual : Symbol(IsEqual, Decl(arraySlice.d.ts, 2, 53)) +>A : Symbol(A, Decl(arraySlice.d.ts, 3, 13)) +>B : Symbol(B, Decl(arraySlice.d.ts, 3, 15)) + + [A] extends [B] +>A : Symbol(A, Decl(arraySlice.d.ts, 3, 13)) +>B : Symbol(B, Decl(arraySlice.d.ts, 3, 15)) + + ? [B] extends [A] +>B : Symbol(B, Decl(arraySlice.d.ts, 3, 15)) +>A : Symbol(A, Decl(arraySlice.d.ts, 3, 13)) + + ? _IsEqual +>_IsEqual : Symbol(_IsEqual, Decl(arraySlice.d.ts, 8, 10)) +>A : Symbol(A, Decl(arraySlice.d.ts, 3, 13)) +>B : Symbol(B, Decl(arraySlice.d.ts, 3, 15)) + + : false + : false; +type _IsEqual = never; +>_IsEqual : Symbol(_IsEqual, Decl(arraySlice.d.ts, 8, 10)) +>A : Symbol(A, Decl(arraySlice.d.ts, 9, 14)) +>B : Symbol(B, Decl(arraySlice.d.ts, 9, 16)) + +type Primitive = +>Primitive : Symbol(Primitive, Decl(arraySlice.d.ts, 9, 28)) + + | null + | undefined + | string + | number + | boolean + | symbol + | bigint; +type UnknownArray = any; +>UnknownArray : Symbol(UnknownArray, Decl(arraySlice.d.ts, 17, 10)) + +type IfNotAnyOrNever = +>IfNotAnyOrNever : Symbol(IfNotAnyOrNever, Decl(arraySlice.d.ts, 18, 24)) +>T : Symbol(T, Decl(arraySlice.d.ts, 19, 21)) +>Cases : Symbol(Cases, Decl(arraySlice.d.ts, 19, 23)) +>ifNot : Symbol(ifNot, Decl(arraySlice.d.ts, 19, 39)) +>ifAny : Symbol(ifAny, Decl(arraySlice.d.ts, 19, 54)) +>ifNever : Symbol(ifNever, Decl(arraySlice.d.ts, 19, 71)) + + IsNever extends true +>IsNever : Symbol(IsNever, Decl(arraySlice.d.ts, 1, 33)) +>T : Symbol(T, Decl(arraySlice.d.ts, 19, 21)) + + ? 'ifNever' extends keyof Cases +>Cases : Symbol(Cases, Decl(arraySlice.d.ts, 19, 23)) + + ? Cases['ifNever'] +>Cases : Symbol(Cases, Decl(arraySlice.d.ts, 19, 23)) + + : never + : Cases['ifNot']; +>Cases : Symbol(Cases, Decl(arraySlice.d.ts, 19, 23)) + +type And = B; +>And : Symbol(And, Decl(arraySlice.d.ts, 24, 20)) +>A : Symbol(A, Decl(arraySlice.d.ts, 25, 9)) +>B : Symbol(B, Decl(arraySlice.d.ts, 25, 27)) +>B : Symbol(B, Decl(arraySlice.d.ts, 25, 27)) + +type Not = any; +>Not : Symbol(Not, Decl(arraySlice.d.ts, 25, 51)) +>A : Symbol(A, Decl(arraySlice.d.ts, 26, 9)) + +type MaxLength = never; +>MaxLength : Symbol(MaxLength, Decl(arraySlice.d.ts, 26, 34)) +>Array_ : Symbol(Array_, Decl(arraySlice.d.ts, 27, 15)) +>UnknownArray : Symbol(UnknownArray, Decl(arraySlice.d.ts, 17, 10)) + +type HasNoStaticElements = unknown; +>HasNoStaticElements : Symbol(HasNoStaticElements, Decl(arraySlice.d.ts, 27, 52)) +>Array_ : Symbol(Array_, Decl(arraySlice.d.ts, 28, 25)) +>UnknownArray : Symbol(UnknownArray, Decl(arraySlice.d.ts, 17, 10)) + +type CollapseLiterals = Union extends Primitive +>CollapseLiterals : Symbol(CollapseLiterals, Decl(arraySlice.d.ts, 28, 64)) +>Union : Symbol(Union, Decl(arraySlice.d.ts, 29, 22)) +>Union : Symbol(Union, Decl(arraySlice.d.ts, 29, 22)) +>Primitive : Symbol(Primitive, Decl(arraySlice.d.ts, 9, 28)) + + ? Union extends infer Collapsed & {} +>Union : Symbol(Union, Decl(arraySlice.d.ts, 29, 22)) +>Collapsed : Symbol(Collapsed, Decl(arraySlice.d.ts, 30, 22)) + + ? Collapsed +>Collapsed : Symbol(Collapsed, Decl(arraySlice.d.ts, 30, 22)) + + : Union +>Union : Symbol(Union, Decl(arraySlice.d.ts, 29, 22)) + + : Union; +>Union : Symbol(Union, Decl(arraySlice.d.ts, 29, 22)) + +type PositiveNumericStringGt = A; +>PositiveNumericStringGt : Symbol(PositiveNumericStringGt, Decl(arraySlice.d.ts, 33, 9)) +>A : Symbol(A, Decl(arraySlice.d.ts, 34, 29)) +>B : Symbol(B, Decl(arraySlice.d.ts, 34, 46)) +>A : Symbol(A, Decl(arraySlice.d.ts, 34, 29)) + +type Absolute = _Absolute : N>; +>Absolute : Symbol(Absolute, Decl(arraySlice.d.ts, 34, 69)) +>N : Symbol(N, Decl(arraySlice.d.ts, 35, 14)) +>_Absolute : Symbol(_Absolute, Decl(arraySlice.d.ts, 35, 92)) +>N : Symbol(N, Decl(arraySlice.d.ts, 35, 14)) +>UnwrapBrand : Symbol(UnwrapBrand, Decl(arraySlice.d.ts, 95, 11)) +>N : Symbol(N, Decl(arraySlice.d.ts, 35, 14)) +>N : Symbol(N, Decl(arraySlice.d.ts, 35, 14)) + +type _Absolute = N extends bigint +>_Absolute : Symbol(_Absolute, Decl(arraySlice.d.ts, 35, 92)) +>N : Symbol(N, Decl(arraySlice.d.ts, 36, 15)) +>N : Symbol(N, Decl(arraySlice.d.ts, 36, 15)) + + ? `${N}` extends `-${infer Magnitude extends bigint}` +>N : Symbol(N, Decl(arraySlice.d.ts, 36, 15)) +>Magnitude : Symbol(Magnitude, Decl(arraySlice.d.ts, 37, 27)) + + ? Magnitude +>Magnitude : Symbol(Magnitude, Decl(arraySlice.d.ts, 37, 27)) + + : N +>N : Symbol(N, Decl(arraySlice.d.ts, 36, 15)) + + : `${N}` extends `-${infer Magnitude extends number}` +>N : Symbol(N, Decl(arraySlice.d.ts, 36, 15)) +>Magnitude : Symbol(Magnitude, Decl(arraySlice.d.ts, 40, 27)) + + ? Magnitude +>Magnitude : Symbol(Magnitude, Decl(arraySlice.d.ts, 40, 27)) + + : `${N}` extends '-Infinity' +>N : Symbol(N, Decl(arraySlice.d.ts, 36, 15)) + + ? PositiveInfinity +>PositiveInfinity : Symbol(PositiveInfinity, Decl(arraySlice.d.ts, 100, 32)) + + : `${number}` extends `${N}` ? number : N; +>N : Symbol(N, Decl(arraySlice.d.ts, 36, 15)) +>N : Symbol(N, Decl(arraySlice.d.ts, 36, 15)) + +type GreaterThan = +>GreaterThan : Symbol(GreaterThan, Decl(arraySlice.d.ts, 44, 45)) +>A : Symbol(A, Decl(arraySlice.d.ts, 45, 17)) +>_Numeric : Symbol(_Numeric, Decl(arraySlice.d.ts, 99, 5)) +>B : Symbol(B, Decl(arraySlice.d.ts, 45, 36)) +>_Numeric : Symbol(_Numeric, Decl(arraySlice.d.ts, 99, 5)) + + _GreaterThan : A, B extends object ? UnwrapBrand : B>; +>_GreaterThan : Symbol(_GreaterThan, Decl(arraySlice.d.ts, 46, 92)) +>A : Symbol(A, Decl(arraySlice.d.ts, 45, 17)) +>UnwrapBrand : Symbol(UnwrapBrand, Decl(arraySlice.d.ts, 95, 11)) +>A : Symbol(A, Decl(arraySlice.d.ts, 45, 17)) +>A : Symbol(A, Decl(arraySlice.d.ts, 45, 17)) +>B : Symbol(B, Decl(arraySlice.d.ts, 45, 36)) +>UnwrapBrand : Symbol(UnwrapBrand, Decl(arraySlice.d.ts, 95, 11)) +>B : Symbol(B, Decl(arraySlice.d.ts, 45, 36)) +>B : Symbol(B, Decl(arraySlice.d.ts, 45, 36)) + +type _GreaterThan = +>_GreaterThan : Symbol(_GreaterThan, Decl(arraySlice.d.ts, 46, 92)) +>A : Symbol(A, Decl(arraySlice.d.ts, 47, 18)) +>_Numeric : Symbol(_Numeric, Decl(arraySlice.d.ts, 99, 5)) +>B : Symbol(B, Decl(arraySlice.d.ts, 47, 37)) +>_Numeric : Symbol(_Numeric, Decl(arraySlice.d.ts, 99, 5)) + + A extends _Numeric +>A : Symbol(A, Decl(arraySlice.d.ts, 47, 18)) +>_Numeric : Symbol(_Numeric, Decl(arraySlice.d.ts, 99, 5)) + + ? B extends _Numeric +>B : Symbol(B, Decl(arraySlice.d.ts, 47, 37)) +>_Numeric : Symbol(_Numeric, Decl(arraySlice.d.ts, 99, 5)) + + ? `${number}` extends `${A | B}` +>A : Symbol(A, Decl(arraySlice.d.ts, 47, 18)) +>B : Symbol(B, Decl(arraySlice.d.ts, 47, 37)) + + ? boolean + : bigint extends A | B +>A : Symbol(A, Decl(arraySlice.d.ts, 47, 18)) +>B : Symbol(B, Decl(arraySlice.d.ts, 47, 37)) + + ? boolean + : A extends PositiveInfinity +>A : Symbol(A, Decl(arraySlice.d.ts, 47, 18)) +>PositiveInfinity : Symbol(PositiveInfinity, Decl(arraySlice.d.ts, 100, 32)) + + ? B extends PositiveInfinity ? false : true +>B : Symbol(B, Decl(arraySlice.d.ts, 47, 37)) +>PositiveInfinity : Symbol(PositiveInfinity, Decl(arraySlice.d.ts, 100, 32)) + + : B extends NegativeInfinity +>B : Symbol(B, Decl(arraySlice.d.ts, 47, 37)) +>NegativeInfinity : Symbol(NegativeInfinity, Decl(arraySlice.d.ts, 101, 32)) + + ? A extends NegativeInfinity ? false : true +>A : Symbol(A, Decl(arraySlice.d.ts, 47, 18)) +>NegativeInfinity : Symbol(NegativeInfinity, Decl(arraySlice.d.ts, 101, 32)) + + : A extends NegativeInfinity +>A : Symbol(A, Decl(arraySlice.d.ts, 47, 18)) +>NegativeInfinity : Symbol(NegativeInfinity, Decl(arraySlice.d.ts, 101, 32)) + + ? false + : B extends PositiveInfinity +>B : Symbol(B, Decl(arraySlice.d.ts, 47, 37)) +>PositiveInfinity : Symbol(PositiveInfinity, Decl(arraySlice.d.ts, 100, 32)) + + ? false + : [IsNegative, IsNegative] extends infer Signs extends [boolean, boolean] +>IsNegative : Symbol(IsNegative, Decl(arraySlice.d.ts, 102, 30)) +>A : Symbol(A, Decl(arraySlice.d.ts, 47, 18)) +>IsNegative : Symbol(IsNegative, Decl(arraySlice.d.ts, 102, 30)) +>B : Symbol(B, Decl(arraySlice.d.ts, 47, 37)) +>Signs : Symbol(Signs, Decl(arraySlice.d.ts, 62, 56)) + + ? [true, false] extends Signs +>Signs : Symbol(Signs, Decl(arraySlice.d.ts, 62, 56)) + + ? false + : [false, true] extends Signs +>Signs : Symbol(Signs, Decl(arraySlice.d.ts, 62, 56)) + + ? true + : [false, false] extends Signs +>Signs : Symbol(Signs, Decl(arraySlice.d.ts, 62, 56)) + + ? PositiveNumericStringGt<`${A}`, `${B}`> +>PositiveNumericStringGt : Symbol(PositiveNumericStringGt, Decl(arraySlice.d.ts, 33, 9)) +>A : Symbol(A, Decl(arraySlice.d.ts, 47, 18)) +>B : Symbol(B, Decl(arraySlice.d.ts, 47, 37)) + + : PositiveNumericStringGt<`${Absolute}`, `${Absolute}`> +>PositiveNumericStringGt : Symbol(PositiveNumericStringGt, Decl(arraySlice.d.ts, 33, 9)) +>Absolute : Symbol(Absolute, Decl(arraySlice.d.ts, 34, 69)) +>B : Symbol(B, Decl(arraySlice.d.ts, 47, 37)) +>Absolute : Symbol(Absolute, Decl(arraySlice.d.ts, 34, 69)) +>A : Symbol(A, Decl(arraySlice.d.ts, 47, 18)) + + : never + : never + : never; +type IsReadonlyArray = never; +>IsReadonlyArray : Symbol(IsReadonlyArray, Decl(arraySlice.d.ts, 72, 10)) +>Array_ : Symbol(Array_, Decl(arraySlice.d.ts, 73, 21)) +>UnknownArray : Symbol(UnknownArray, Decl(arraySlice.d.ts, 17, 10)) + +type UnionMember = +>UnionMember : Symbol(UnionMember, Decl(arraySlice.d.ts, 73, 58)) +>T : Symbol(T, Decl(arraySlice.d.ts, 74, 17)) + + IsNever extends true +>IsNever : Symbol(IsNever, Decl(arraySlice.d.ts, 1, 33)) +>T : Symbol(T, Decl(arraySlice.d.ts, 74, 17)) + + ? never + : (T extends any ? () => T : never) extends () => (infer R) +>T : Symbol(T, Decl(arraySlice.d.ts, 74, 17)) +>T : Symbol(T, Decl(arraySlice.d.ts, 74, 17)) +>R : Symbol(R, Decl(arraySlice.d.ts, 77, 58)) + + ? R +>R : Symbol(R, Decl(arraySlice.d.ts, 77, 58)) + + : never; +type TagContainer = { +>TagContainer : Symbol(TagContainer, Decl(arraySlice.d.ts, 79, 11)) +>Token : Symbol(Token, Decl(arraySlice.d.ts, 80, 18)) + + readonly [tag]: Token; +>[tag] : Symbol([tag], Decl(arraySlice.d.ts, 80, 28)) +>tag : Symbol(tag, Decl(arraySlice.d.ts, 1, 13)) +>Token : Symbol(Token, Decl(arraySlice.d.ts, 80, 18)) + +}; +type Tag = unknown; +>Tag : Symbol(Tag, Decl(arraySlice.d.ts, 82, 2)) +>TagName : Symbol(TagName, Decl(arraySlice.d.ts, 83, 9)) +>PropertyKey : Symbol(PropertyKey, Decl(lib.es5.d.ts, --, --)) +>TagMetadata : Symbol(TagMetadata, Decl(arraySlice.d.ts, 83, 37)) + +type RemoveAllTags = T extends TagContainer +>RemoveAllTags : Symbol(RemoveAllTags, Decl(arraySlice.d.ts, 83, 61)) +>T : Symbol(T, Decl(arraySlice.d.ts, 84, 19)) +>T : Symbol(T, Decl(arraySlice.d.ts, 84, 19)) +>TagContainer : Symbol(TagContainer, Decl(arraySlice.d.ts, 79, 11)) + + ? RemoveAllTags>> +>RemoveAllTags : Symbol(RemoveAllTags, Decl(arraySlice.d.ts, 83, 61)) +>UnionMember : Symbol(UnionMember, Decl(arraySlice.d.ts, 73, 58)) +>RemoveTag : Symbol(RemoveTag, Decl(arraySlice.d.ts, 86, 5)) +>T : Symbol(T, Decl(arraySlice.d.ts, 84, 19)) + + : T; +>T : Symbol(T, Decl(arraySlice.d.ts, 84, 19)) + +type RemoveTag> = +>RemoveTag : Symbol(RemoveTag, Decl(arraySlice.d.ts, 86, 5)) +>T : Symbol(T, Decl(arraySlice.d.ts, 87, 15)) +>TagContainer : Symbol(TagContainer, Decl(arraySlice.d.ts, 79, 11)) + + | { + [ThisTag in keyof T[typeof tag]]: T extends infer Underlying & Tag +>ThisTag : Symbol(ThisTag, Decl(arraySlice.d.ts, 89, 3)) +>T : Symbol(T, Decl(arraySlice.d.ts, 87, 15)) +>tag : Symbol(tag, Decl(arraySlice.d.ts, 1, 13)) +>T : Symbol(T, Decl(arraySlice.d.ts, 87, 15)) +>Underlying : Symbol(Underlying, Decl(arraySlice.d.ts, 89, 51)) +>Tag : Symbol(Tag, Decl(arraySlice.d.ts, 82, 2)) +>ThisTag : Symbol(ThisTag, Decl(arraySlice.d.ts, 89, 3)) +>T : Symbol(T, Decl(arraySlice.d.ts, 87, 15)) +>tag : Symbol(tag, Decl(arraySlice.d.ts, 1, 13)) +>ThisTag : Symbol(ThisTag, Decl(arraySlice.d.ts, 89, 3)) + + ? [Underlying] extends [T] ? never : Underlying +>Underlying : Symbol(Underlying, Decl(arraySlice.d.ts, 89, 51)) +>T : Symbol(T, Decl(arraySlice.d.ts, 87, 15)) +>Underlying : Symbol(Underlying, Decl(arraySlice.d.ts, 89, 51)) + + : never + }[keyof T[typeof tag]] +>T : Symbol(T, Decl(arraySlice.d.ts, 87, 15)) +>tag : Symbol(tag, Decl(arraySlice.d.ts, 1, 13)) + + | (T extends infer Underlying & TagContainer +>T : Symbol(T, Decl(arraySlice.d.ts, 87, 15)) +>Underlying : Symbol(Underlying, Decl(arraySlice.d.ts, 93, 19)) +>TagContainer : Symbol(TagContainer, Decl(arraySlice.d.ts, 79, 11)) +>T : Symbol(T, Decl(arraySlice.d.ts, 87, 15)) +>tag : Symbol(tag, Decl(arraySlice.d.ts, 1, 13)) + + ? [Underlying] extends [T] ? never : Underlying +>Underlying : Symbol(Underlying, Decl(arraySlice.d.ts, 93, 19)) +>T : Symbol(T, Decl(arraySlice.d.ts, 87, 15)) +>Underlying : Symbol(Underlying, Decl(arraySlice.d.ts, 93, 19)) + + : never); +type UnwrapBrand = IfNotAnyOrNever}>; +>UnwrapBrand : Symbol(UnwrapBrand, Decl(arraySlice.d.ts, 95, 11)) +>T : Symbol(T, Decl(arraySlice.d.ts, 96, 17)) +>IfNotAnyOrNever : Symbol(IfNotAnyOrNever, Decl(arraySlice.d.ts, 18, 24)) +>T : Symbol(T, Decl(arraySlice.d.ts, 96, 17)) +>ifNot : Symbol(ifNot, Decl(arraySlice.d.ts, 96, 42)) +>_UnwrapBrand : Symbol(_UnwrapBrand, Decl(arraySlice.d.ts, 96, 78)) +>T : Symbol(T, Decl(arraySlice.d.ts, 96, 17)) +>Primitive : Symbol(Primitive, Decl(arraySlice.d.ts, 9, 28)) + +type _UnwrapBrand = T extends Primitive +>_UnwrapBrand : Symbol(_UnwrapBrand, Decl(arraySlice.d.ts, 96, 78)) +>T : Symbol(T, Decl(arraySlice.d.ts, 97, 18)) +>Base : Symbol(Base, Decl(arraySlice.d.ts, 97, 20)) +>T : Symbol(T, Decl(arraySlice.d.ts, 97, 18)) +>Primitive : Symbol(Primitive, Decl(arraySlice.d.ts, 9, 28)) + + ? CollapseLiterals ? RemoveAllTags : T> +>CollapseLiterals : Symbol(CollapseLiterals, Decl(arraySlice.d.ts, 28, 64)) +>T : Symbol(T, Decl(arraySlice.d.ts, 97, 18)) +>TagContainer : Symbol(TagContainer, Decl(arraySlice.d.ts, 79, 11)) +>RemoveAllTags : Symbol(RemoveAllTags, Decl(arraySlice.d.ts, 83, 61)) +>T : Symbol(T, Decl(arraySlice.d.ts, 97, 18)) +>T : Symbol(T, Decl(arraySlice.d.ts, 97, 18)) + + : T; +>T : Symbol(T, Decl(arraySlice.d.ts, 97, 18)) + +type _Numeric = number | bigint; +>_Numeric : Symbol(_Numeric, Decl(arraySlice.d.ts, 99, 5)) + +type PositiveInfinity = unknown; +>PositiveInfinity : Symbol(PositiveInfinity, Decl(arraySlice.d.ts, 100, 32)) + +type NegativeInfinity = never; +>NegativeInfinity : Symbol(NegativeInfinity, Decl(arraySlice.d.ts, 101, 32)) + +type IsNegative = never; +>IsNegative : Symbol(IsNegative, Decl(arraySlice.d.ts, 102, 30)) +>T : Symbol(T, Decl(arraySlice.d.ts, 103, 16)) +>_Numeric : Symbol(_Numeric, Decl(arraySlice.d.ts, 99, 5)) + +type Sum = any; +>Sum : Symbol(Sum, Decl(arraySlice.d.ts, 103, 44)) +>A : Symbol(A, Decl(arraySlice.d.ts, 104, 9)) +>B : Symbol(B, Decl(arraySlice.d.ts, 104, 26)) + +type LessThanOrEqual = unknown; +>LessThanOrEqual : Symbol(LessThanOrEqual, Decl(arraySlice.d.ts, 104, 51)) +>A : Symbol(A, Decl(arraySlice.d.ts, 105, 21)) +>_Numeric : Symbol(_Numeric, Decl(arraySlice.d.ts, 99, 5)) +>B : Symbol(B, Decl(arraySlice.d.ts, 105, 40)) +>_Numeric : Symbol(_Numeric, Decl(arraySlice.d.ts, 99, 5)) + +type ArraySlice< +>ArraySlice : Symbol(ArraySlice, Decl(arraySlice.d.ts, 105, 71)) + + Array_ extends readonly unknown[], +>Array_ : Symbol(Array_, Decl(arraySlice.d.ts, 106, 16)) + + Start extends number = never, +>Start : Symbol(Start, Decl(arraySlice.d.ts, 107, 35)) + + End extends number = never, +>End : Symbol(End, Decl(arraySlice.d.ts, 108, 30)) + +> = ArraySliceImplementation : Start, End>; +>ArraySliceImplementation : Symbol(ArraySliceImplementation, Decl(arraySlice.d.ts, 110, 93)) +>Array_ : Symbol(Array_, Decl(arraySlice.d.ts, 106, 16)) +>Start : Symbol(Start, Decl(arraySlice.d.ts, 107, 35)) +>UnwrapBrand : Symbol(UnwrapBrand, Decl(arraySlice.d.ts, 95, 11)) +>Start : Symbol(Start, Decl(arraySlice.d.ts, 107, 35)) +>Start : Symbol(Start, Decl(arraySlice.d.ts, 107, 35)) +>End : Symbol(End, Decl(arraySlice.d.ts, 108, 30)) + +type ArraySliceImplementation< +>ArraySliceImplementation : Symbol(ArraySliceImplementation, Decl(arraySlice.d.ts, 110, 93)) + + Array_ extends readonly unknown[], +>Array_ : Symbol(Array_, Decl(arraySlice.d.ts, 111, 30)) + + Start extends number, +>Start : Symbol(Start, Decl(arraySlice.d.ts, 112, 35)) + + End extends number, +>End : Symbol(End, Decl(arraySlice.d.ts, 113, 22)) + +> = Array_ extends unknown ? _ArraySlice : never; +>Array_ : Symbol(Array_, Decl(arraySlice.d.ts, 111, 30)) +>_ArraySlice : Symbol(_ArraySlice, Decl(arraySlice.d.ts, 115, 69)) +>Array_ : Symbol(Array_, Decl(arraySlice.d.ts, 111, 30)) +>Start : Symbol(Start, Decl(arraySlice.d.ts, 112, 35)) +>End : Symbol(End, Decl(arraySlice.d.ts, 113, 22)) + +type _ArraySlice< +>_ArraySlice : Symbol(_ArraySlice, Decl(arraySlice.d.ts, 115, 69)) + + Array_ extends readonly unknown[], +>Array_ : Symbol(Array_, Decl(arraySlice.d.ts, 116, 17)) + + Start extends number = 0, +>Start : Symbol(Start, Decl(arraySlice.d.ts, 117, 35)) + + End extends number = Array_['length'], +>End : Symbol(End, Decl(arraySlice.d.ts, 118, 26)) +>Array_ : Symbol(Array_, Decl(arraySlice.d.ts, 116, 17)) + +> = And, IsEqual> extends true +>And : Symbol(And, Decl(arraySlice.d.ts, 24, 20)) +>IsEqual : Symbol(IsEqual, Decl(arraySlice.d.ts, 2, 53)) +>Start : Symbol(Start, Decl(arraySlice.d.ts, 117, 35)) +>IsEqual : Symbol(IsEqual, Decl(arraySlice.d.ts, 2, 53)) +>End : Symbol(End, Decl(arraySlice.d.ts, 118, 26)) + + ? Array_ +>Array_ : Symbol(Array_, Decl(arraySlice.d.ts, 116, 17)) + + : number extends Array_['length'] +>Array_ : Symbol(Array_, Decl(arraySlice.d.ts, 116, 17)) + + ? VariableLengthArraySliceHelper extends true ? 0 : Start, End extends PositiveInfinity ? never : End> +>VariableLengthArraySliceHelper : Symbol(VariableLengthArraySliceHelper, Decl(arraySlice.d.ts, 128, 66)) +>Array_ : Symbol(Array_, Decl(arraySlice.d.ts, 116, 17)) +>IsNever : Symbol(IsNever, Decl(arraySlice.d.ts, 1, 33)) +>Start : Symbol(Start, Decl(arraySlice.d.ts, 117, 35)) +>Start : Symbol(Start, Decl(arraySlice.d.ts, 117, 35)) +>End : Symbol(End, Decl(arraySlice.d.ts, 118, 26)) +>PositiveInfinity : Symbol(PositiveInfinity, Decl(arraySlice.d.ts, 100, 32)) +>End : Symbol(End, Decl(arraySlice.d.ts, 118, 26)) + + : `${number}` extends `${Start | End}` +>Start : Symbol(Start, Decl(arraySlice.d.ts, 117, 35)) +>End : Symbol(End, Decl(arraySlice.d.ts, 118, 26)) + + ? UnknownLengthArraySlice +>UnknownLengthArraySlice : Symbol(UnknownLengthArraySlice, Decl(arraySlice.d.ts, 145, 37)) +>Array_ : Symbol(Array_, Decl(arraySlice.d.ts, 116, 17)) + + : ArraySliceResult extends true ? 0 : Start, IsEqual extends true ? MaxLength : End>>; +>ArraySliceResult : Symbol(ArraySliceResult, Decl(arraySlice.d.ts, 126, 164)) +>Array_ : Symbol(Array_, Decl(arraySlice.d.ts, 116, 17)) +>ArraySliceHelper : Symbol(ArraySliceHelper, Decl(arraySlice.d.ts, 146, 70)) +>Array_ : Symbol(Array_, Decl(arraySlice.d.ts, 116, 17)) +>IsEqual : Symbol(IsEqual, Decl(arraySlice.d.ts, 2, 53)) +>Start : Symbol(Start, Decl(arraySlice.d.ts, 117, 35)) +>Start : Symbol(Start, Decl(arraySlice.d.ts, 117, 35)) +>IsEqual : Symbol(IsEqual, Decl(arraySlice.d.ts, 2, 53)) +>End : Symbol(End, Decl(arraySlice.d.ts, 118, 26)) +>MaxLength : Symbol(MaxLength, Decl(arraySlice.d.ts, 26, 34)) +>Array_ : Symbol(Array_, Decl(arraySlice.d.ts, 116, 17)) +>End : Symbol(End, Decl(arraySlice.d.ts, 118, 26)) + +type ArraySliceResult = +>ArraySliceResult : Symbol(ArraySliceResult, Decl(arraySlice.d.ts, 126, 164)) +>Array_ : Symbol(Array_, Decl(arraySlice.d.ts, 127, 22)) +>Sliced : Symbol(Sliced, Decl(arraySlice.d.ts, 127, 56)) + + IsReadonlyArray extends true ? Readonly : Sliced; +>IsReadonlyArray : Symbol(IsReadonlyArray, Decl(arraySlice.d.ts, 72, 10)) +>Array_ : Symbol(Array_, Decl(arraySlice.d.ts, 127, 22)) +>Readonly : Symbol(Readonly, Decl(lib.es5.d.ts, --, --)) +>Sliced : Symbol(Sliced, Decl(arraySlice.d.ts, 127, 56)) +>Sliced : Symbol(Sliced, Decl(arraySlice.d.ts, 127, 56)) + +type VariableLengthArraySliceHelper< +>VariableLengthArraySliceHelper : Symbol(VariableLengthArraySliceHelper, Decl(arraySlice.d.ts, 128, 66)) + + Array_ extends readonly unknown[], +>Array_ : Symbol(Array_, Decl(arraySlice.d.ts, 129, 36)) + + Start extends number, +>Start : Symbol(Start, Decl(arraySlice.d.ts, 130, 35)) + + End extends number, +>End : Symbol(End, Decl(arraySlice.d.ts, 131, 22)) + +> = And< +>And : Symbol(And, Decl(arraySlice.d.ts, 24, 20)) + + And>, Not>>, +>And : Symbol(And, Decl(arraySlice.d.ts, 24, 20)) +>Not : Symbol(Not, Decl(arraySlice.d.ts, 25, 51)) +>IsNegative : Symbol(IsNegative, Decl(arraySlice.d.ts, 102, 30)) +>Start : Symbol(Start, Decl(arraySlice.d.ts, 130, 35)) +>Not : Symbol(Not, Decl(arraySlice.d.ts, 25, 51)) +>IsNegative : Symbol(IsNegative, Decl(arraySlice.d.ts, 102, 30)) +>End : Symbol(End, Decl(arraySlice.d.ts, 131, 22)) + + IsEqual, true> +>IsEqual : Symbol(IsEqual, Decl(arraySlice.d.ts, 2, 53)) +>LessThanOrEqual : Symbol(LessThanOrEqual, Decl(arraySlice.d.ts, 104, 51)) +>End : Symbol(End, Decl(arraySlice.d.ts, 131, 22)) +>Start : Symbol(Start, Decl(arraySlice.d.ts, 130, 35)) + +> extends true + ? [] + : And< +>And : Symbol(And, Decl(arraySlice.d.ts, 24, 20)) + + And>, Not>>, +>And : Symbol(And, Decl(arraySlice.d.ts, 24, 20)) +>Not : Symbol(Not, Decl(arraySlice.d.ts, 25, 51)) +>IsNegative : Symbol(IsNegative, Decl(arraySlice.d.ts, 102, 30)) +>Start : Symbol(Start, Decl(arraySlice.d.ts, 130, 35)) +>Not : Symbol(Not, Decl(arraySlice.d.ts, 25, 51)) +>IsNegative : Symbol(IsNegative, Decl(arraySlice.d.ts, 102, 30)) +>End : Symbol(End, Decl(arraySlice.d.ts, 131, 22)) + + IsEqual, true> +>IsEqual : Symbol(IsEqual, Decl(arraySlice.d.ts, 2, 53)) +>GreaterThan : Symbol(GreaterThan, Decl(arraySlice.d.ts, 44, 45)) +>End : Symbol(End, Decl(arraySlice.d.ts, 131, 22)) +>Start : Symbol(Start, Decl(arraySlice.d.ts, 130, 35)) + + > extends true + ? HasNoStaticElements extends true +>HasNoStaticElements : Symbol(HasNoStaticElements, Decl(arraySlice.d.ts, 27, 52)) +>Array_ : Symbol(Array_, Decl(arraySlice.d.ts, 129, 36)) + + ? UnknownLengthArraySlice +>UnknownLengthArraySlice : Symbol(UnknownLengthArraySlice, Decl(arraySlice.d.ts, 145, 37)) +>Array_ : Symbol(Array_, Decl(arraySlice.d.ts, 129, 36)) + + : ArraySliceResult> +>ArraySliceResult : Symbol(ArraySliceResult, Decl(arraySlice.d.ts, 126, 164)) +>Array_ : Symbol(Array_, Decl(arraySlice.d.ts, 129, 36)) +>ArraySliceByPositiveIndex : Symbol(ArraySliceByPositiveIndex, Decl(arraySlice.d.ts, 152, 10)) +>Array_ : Symbol(Array_, Decl(arraySlice.d.ts, 129, 36)) +>Start : Symbol(Start, Decl(arraySlice.d.ts, 130, 35)) +>End : Symbol(End, Decl(arraySlice.d.ts, 131, 22)) + + : UnknownLengthArraySlice; +>UnknownLengthArraySlice : Symbol(UnknownLengthArraySlice, Decl(arraySlice.d.ts, 145, 37)) +>Array_ : Symbol(Array_, Decl(arraySlice.d.ts, 129, 36)) + +type UnknownLengthArraySlice = any; +>UnknownLengthArraySlice : Symbol(UnknownLengthArraySlice, Decl(arraySlice.d.ts, 145, 37)) +>Array_ : Symbol(Array_, Decl(arraySlice.d.ts, 146, 29)) + +type ArraySliceHelper< +>ArraySliceHelper : Symbol(ArraySliceHelper, Decl(arraySlice.d.ts, 146, 70)) + + Array_ extends readonly unknown[], +>Array_ : Symbol(Array_, Decl(arraySlice.d.ts, 147, 22)) + + Start extends number = 0, +>Start : Symbol(Start, Decl(arraySlice.d.ts, 148, 35)) + + End extends number = MaxLength, +>End : Symbol(End, Decl(arraySlice.d.ts, 149, 26)) +>MaxLength : Symbol(MaxLength, Decl(arraySlice.d.ts, 26, 34)) +>Array_ : Symbol(Array_, Decl(arraySlice.d.ts, 147, 22)) + + ArrayLength extends number = MaxLength, +>ArrayLength : Symbol(ArrayLength, Decl(arraySlice.d.ts, 150, 40)) +>MaxLength : Symbol(MaxLength, Decl(arraySlice.d.ts, 26, 34)) +>Array_ : Symbol(Array_, Decl(arraySlice.d.ts, 147, 22)) + +> = never; +type ArraySliceByPositiveIndex< +>ArraySliceByPositiveIndex : Symbol(ArraySliceByPositiveIndex, Decl(arraySlice.d.ts, 152, 10)) + + Array_ extends readonly unknown[], +>Array_ : Symbol(Array_, Decl(arraySlice.d.ts, 153, 31)) + + Start extends number, +>Start : Symbol(Start, Decl(arraySlice.d.ts, 154, 35)) + + End extends number, +>End : Symbol(End, Decl(arraySlice.d.ts, 155, 22)) + + Result extends Array = [], +>Result : Symbol(Result, Decl(arraySlice.d.ts, 156, 20)) +>Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --) ... and 4 more) +>Array_ : Symbol(Array_, Decl(arraySlice.d.ts, 153, 31)) + +> = Start extends End +>Start : Symbol(Start, Decl(arraySlice.d.ts, 154, 35)) +>End : Symbol(End, Decl(arraySlice.d.ts, 155, 22)) + + ? Result +>Result : Symbol(Result, Decl(arraySlice.d.ts, 156, 20)) + + : ArraySliceByPositiveIndex, End, [...Result, Array_[Start]]>; +>ArraySliceByPositiveIndex : Symbol(ArraySliceByPositiveIndex, Decl(arraySlice.d.ts, 152, 10)) +>Array_ : Symbol(Array_, Decl(arraySlice.d.ts, 153, 31)) +>Sum : Symbol(Sum, Decl(arraySlice.d.ts, 103, 44)) +>Start : Symbol(Start, Decl(arraySlice.d.ts, 154, 35)) +>End : Symbol(End, Decl(arraySlice.d.ts, 155, 22)) +>Result : Symbol(Result, Decl(arraySlice.d.ts, 156, 20)) +>Array_ : Symbol(Array_, Decl(arraySlice.d.ts, 153, 31)) +>Start : Symbol(Start, Decl(arraySlice.d.ts, 154, 35)) + +=== main.ts === +// Reduced from type-fest's ArraySlice. Inferring Value from the argument +// measures the variances of ArraySlice, which takes the restrictive +// instantiations of conditional types whose type parameters are already +// restrictive, many times over through the brand-unwrapping types. Such an +// instantiation must be the conditional type itself: making and evaluating +// a separate copy roughly triples the work, enough to exceed the +// instantiation count limit (TS2589) here. Smaller cases do not get near +// the limit either way, so the case is as large as the limit requires. +import type {ArraySlice} from './arraySlice.d.ts'; +>ArraySlice : Symbol(ArraySlice, Decl(main.ts, 8, 13)) + +declare function f(values: ArraySlice): void; +>f : Symbol(f, Decl(main.ts, 8, 50)) +>Value : Symbol(Value, Decl(main.ts, 9, 19)) +>values : Symbol(values, Decl(main.ts, 9, 26)) +>ArraySlice : Symbol(ArraySlice, Decl(main.ts, 8, 13)) +>Value : Symbol(Value, Decl(main.ts, 9, 19)) +>Value : Symbol(Value, Decl(main.ts, 9, 19)) +>Value : Symbol(Value, Decl(main.ts, 9, 19)) + +declare const x: ArraySlice; +>x : Symbol(x, Decl(main.ts, 10, 13)) +>ArraySlice : Symbol(ArraySlice, Decl(main.ts, 8, 13)) +>id : Symbol(id, Decl(main.ts, 10, 42)) +>id : Symbol(id, Decl(main.ts, 10, 70)) +>id : Symbol(id, Decl(main.ts, 10, 83)) + +f(x); +>f : Symbol(f, Decl(main.ts, 8, 50)) +>x : Symbol(x, Decl(main.ts, 10, 13)) + diff --git a/tsc/testdata/baselines/reference/compiler/restrictiveInstantiationOfRestrictiveConditional.types b/tsc/testdata/baselines/reference/compiler/restrictiveInstantiationOfRestrictiveConditional.types new file mode 100644 index 0000000000000..0a15d1aba9524 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/restrictiveInstantiationOfRestrictiveConditional.types @@ -0,0 +1,338 @@ +//// [tests/cases/compiler/restrictiveInstantiationOfRestrictiveConditional.ts] //// + +=== arraySlice.d.ts === +export type {ArraySlice}; +>ArraySlice : ArraySlice + +declare const tag: unique symbol; +>tag : unique symbol + +type IsNever = [T] extends [never] ? true : false; +>IsNever : IsNever +>true : true +>false : false + +type IsEqual = +>IsEqual : IsEqual + + [A] extends [B] + ? [B] extends [A] + ? _IsEqual + : false +>false : false + + : false; +>false : false + +type _IsEqual = never; +>_IsEqual : never + +type Primitive = +>Primitive : Primitive + + | null + | undefined + | string + | number + | boolean + | symbol + | bigint; +type UnknownArray = any; +>UnknownArray : any + +type IfNotAnyOrNever = +>IfNotAnyOrNever : IfNotAnyOrNever +>ifNot : unknown +>ifAny : unknown +>ifNever : unknown + + IsNever extends true +>true : true + + ? 'ifNever' extends keyof Cases + ? Cases['ifNever'] + : never + : Cases['ifNot']; +type And = B; +>And : B + +type Not = any; +>Not : any + +type MaxLength = never; +>MaxLength : never + +type HasNoStaticElements = unknown; +>HasNoStaticElements : unknown + +type CollapseLiterals = Union extends Primitive +>CollapseLiterals : CollapseLiterals + + ? Union extends infer Collapsed & {} + ? Collapsed + : Union + : Union; +type PositiveNumericStringGt = A; +>PositiveNumericStringGt : A + +type Absolute = _Absolute : N>; +>Absolute : Absolute + +type _Absolute = N extends bigint +>_Absolute : _Absolute + + ? `${N}` extends `-${infer Magnitude extends bigint}` + ? Magnitude + : N + : `${N}` extends `-${infer Magnitude extends number}` + ? Magnitude + : `${N}` extends '-Infinity' + ? PositiveInfinity + : `${number}` extends `${N}` ? number : N; +type GreaterThan = +>GreaterThan : GreaterThan + + _GreaterThan : A, B extends object ? UnwrapBrand : B>; +type _GreaterThan = +>_GreaterThan : _GreaterThan + + A extends _Numeric + ? B extends _Numeric + ? `${number}` extends `${A | B}` + ? boolean + : bigint extends A | B + ? boolean + : A extends PositiveInfinity + ? B extends PositiveInfinity ? false : true +>false : false +>true : true + + : B extends NegativeInfinity + ? A extends NegativeInfinity ? false : true +>false : false +>true : true + + : A extends NegativeInfinity + ? false +>false : false + + : B extends PositiveInfinity + ? false +>false : false + + : [IsNegative, IsNegative] extends infer Signs extends [boolean, boolean] + ? [true, false] extends Signs +>true : true +>false : false + + ? false +>false : false + + : [false, true] extends Signs +>false : false +>true : true + + ? true +>true : true + + : [false, false] extends Signs +>false : false +>false : false + + ? PositiveNumericStringGt<`${A}`, `${B}`> + : PositiveNumericStringGt<`${Absolute}`, `${Absolute}`> + : never + : never + : never; +type IsReadonlyArray = never; +>IsReadonlyArray : never + +type UnionMember = +>UnionMember : UnionMember + + IsNever extends true +>true : true + + ? never + : (T extends any ? () => T : never) extends () => (infer R) + ? R + : never; +type TagContainer = { +>TagContainer : TagContainer + + readonly [tag]: Token; +>[tag] : Token +>tag : unique symbol + +}; +type Tag = unknown; +>Tag : unknown + +type RemoveAllTags = T extends TagContainer +>RemoveAllTags : RemoveAllTags + + ? RemoveAllTags>> + : T; +type RemoveTag> = +>RemoveTag : RemoveTag + + | { + [ThisTag in keyof T[typeof tag]]: T extends infer Underlying & Tag +>tag : unique symbol +>tag : unique symbol + + ? [Underlying] extends [T] ? never : Underlying + : never + }[keyof T[typeof tag]] +>tag : unique symbol + + | (T extends infer Underlying & TagContainer +>tag : unique symbol + + ? [Underlying] extends [T] ? never : Underlying + : never); +type UnwrapBrand = IfNotAnyOrNever}>; +>UnwrapBrand : UnwrapBrand +>ifNot : _UnwrapBrand + +type _UnwrapBrand = T extends Primitive +>_UnwrapBrand : _UnwrapBrand + + ? CollapseLiterals ? RemoveAllTags : T> + : T; +type _Numeric = number | bigint; +>_Numeric : _Numeric + +type PositiveInfinity = unknown; +>PositiveInfinity : unknown + +type NegativeInfinity = never; +>NegativeInfinity : never + +type IsNegative = never; +>IsNegative : never + +type Sum = any; +>Sum : any + +type LessThanOrEqual = unknown; +>LessThanOrEqual : unknown + +type ArraySlice< +>ArraySlice : ArraySlice + + Array_ extends readonly unknown[], + Start extends number = never, + End extends number = never, +> = ArraySliceImplementation : Start, End>; +type ArraySliceImplementation< +>ArraySliceImplementation : ArraySliceImplementation + + Array_ extends readonly unknown[], + Start extends number, + End extends number, +> = Array_ extends unknown ? _ArraySlice : never; +type _ArraySlice< +>_ArraySlice : _ArraySlice + + Array_ extends readonly unknown[], + Start extends number = 0, + End extends number = Array_['length'], +> = And, IsEqual> extends true +>true : true + + ? Array_ + : number extends Array_['length'] + ? VariableLengthArraySliceHelper extends true ? 0 : Start, End extends PositiveInfinity ? never : End> +>true : true + + : `${number}` extends `${Start | End}` + ? UnknownLengthArraySlice + : ArraySliceResult extends true ? 0 : Start, IsEqual extends true ? MaxLength : End>>; +>true : true +>true : true + +type ArraySliceResult = +>ArraySliceResult : Readonly + + IsReadonlyArray extends true ? Readonly : Sliced; +>true : true + +type VariableLengthArraySliceHelper< +>VariableLengthArraySliceHelper : IsEqual<_GreaterThan; }> : End, Start extends object ? IfNotAnyOrNever; }> : Start>, true> extends true ? Readonly> : any + + Array_ extends readonly unknown[], + Start extends number, + End extends number, +> = And< + And>, Not>>, + IsEqual, true> +>true : true + +> extends true +>true : true + + ? [] + : And< + And>, Not>>, + IsEqual, true> +>true : true + + > extends true +>true : true + + ? HasNoStaticElements extends true +>true : true + + ? UnknownLengthArraySlice + : ArraySliceResult> + : UnknownLengthArraySlice; +type UnknownLengthArraySlice = any; +>UnknownLengthArraySlice : any + +type ArraySliceHelper< +>ArraySliceHelper : never + + Array_ extends readonly unknown[], + Start extends number = 0, + End extends number = MaxLength, + ArrayLength extends number = MaxLength, +> = never; +type ArraySliceByPositiveIndex< +>ArraySliceByPositiveIndex : ArraySliceByPositiveIndex + + Array_ extends readonly unknown[], + Start extends number, + End extends number, + Result extends Array = [], +> = Start extends End + ? Result + : ArraySliceByPositiveIndex, End, [...Result, Array_[Start]]>; + +=== main.ts === +// Reduced from type-fest's ArraySlice. Inferring Value from the argument +// measures the variances of ArraySlice, which takes the restrictive +// instantiations of conditional types whose type parameters are already +// restrictive, many times over through the brand-unwrapping types. Such an +// instantiation must be the conditional type itself: making and evaluating +// a separate copy roughly triples the work, enough to exceed the +// instantiation count limit (TS2589) here. Smaller cases do not get near +// the limit either way, so the case is as large as the limit requires. +import type {ArraySlice} from './arraySlice.d.ts'; +>ArraySlice : ArraySlice + +declare function f(values: ArraySlice): void; +>f : (values: ArraySlice) => void +>values : ArraySlice + +declare const x: ArraySlice; +>x : ArraySlice +>id : "row" +>id : "row" +>id : "row" + +f(x); +>f(x) : void +>f : (values: ArraySlice) => void +>x : ArraySlice + diff --git a/tsc/testdata/baselines/reference/compiler/returnTypeInferenceNotTooBroad(checkorder=default).js b/tsc/testdata/baselines/reference/compiler/returnTypeInferenceNotTooBroad(checkorder=default).js new file mode 100644 index 0000000000000..90085dfe2092f --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/returnTypeInferenceNotTooBroad(checkorder=default).js @@ -0,0 +1,24 @@ +//// [tests/cases/compiler/returnTypeInferenceNotTooBroad.ts] //// + +//// [returnTypeInferenceNotTooBroad.ts] +type Signs = { kind: 'a'; a: 3; } | { kind: 'b'; b: 2; } | { kind: 'c'; c: 1; }; +interface Opts { + low?: number; + sign?: T +} +interface Wrapper { +} +declare function sepsis(opts: Opts): Wrapper; +declare function unwrap(w: Wrapper): T; +export const y = sepsis({ low: 1, sign: { kind: 'a', a: 3 }}); +// $ExpectType { kind: "a"; a: 3; } +export const yun = unwrap(y); +// $ExpectType { kind: "a"; a: 3; } +export const yone = unwrap(sepsis({ low: 1, sign: { kind: 'a', a: 3 }})); + +//// [returnTypeInferenceNotTooBroad.js] +export const y = sepsis({ low: 1, sign: { kind: 'a', a: 3 } }); +// $ExpectType { kind: "a"; a: 3; } +export const yun = unwrap(y); +// $ExpectType { kind: "a"; a: 3; } +export const yone = unwrap(sepsis({ low: 1, sign: { kind: 'a', a: 3 } })); diff --git a/tsc/testdata/baselines/reference/compiler/returnTypeInferenceNotTooBroad(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/returnTypeInferenceNotTooBroad(checkorder=default).symbols new file mode 100644 index 0000000000000..ad8e148932bab --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/returnTypeInferenceNotTooBroad(checkorder=default).symbols @@ -0,0 +1,69 @@ +//// [tests/cases/compiler/returnTypeInferenceNotTooBroad.ts] //// + +=== returnTypeInferenceNotTooBroad.ts === +type Signs = { kind: 'a'; a: 3; } | { kind: 'b'; b: 2; } | { kind: 'c'; c: 1; }; +>Signs : Symbol(Signs, Decl(returnTypeInferenceNotTooBroad.ts, 0, 0)) +>kind : Symbol(kind, Decl(returnTypeInferenceNotTooBroad.ts, 0, 14)) +>a : Symbol(a, Decl(returnTypeInferenceNotTooBroad.ts, 0, 25)) +>kind : Symbol(kind, Decl(returnTypeInferenceNotTooBroad.ts, 0, 37)) +>b : Symbol(b, Decl(returnTypeInferenceNotTooBroad.ts, 0, 48)) +>kind : Symbol(kind, Decl(returnTypeInferenceNotTooBroad.ts, 0, 60)) +>c : Symbol(c, Decl(returnTypeInferenceNotTooBroad.ts, 0, 71)) + +interface Opts { +>Opts : Symbol(Opts, Decl(returnTypeInferenceNotTooBroad.ts, 0, 80)) +>T : Symbol(T, Decl(returnTypeInferenceNotTooBroad.ts, 1, 15)) + + low?: number; +>low : Symbol(Opts.low, Decl(returnTypeInferenceNotTooBroad.ts, 1, 19)) + + sign?: T +>sign : Symbol(Opts.sign, Decl(returnTypeInferenceNotTooBroad.ts, 2, 17)) +>T : Symbol(T, Decl(returnTypeInferenceNotTooBroad.ts, 1, 15)) +} +interface Wrapper { +>Wrapper : Symbol(Wrapper, Decl(returnTypeInferenceNotTooBroad.ts, 4, 1)) +>T : Symbol(T, Decl(returnTypeInferenceNotTooBroad.ts, 5, 18)) +} +declare function sepsis(opts: Opts): Wrapper; +>sepsis : Symbol(sepsis, Decl(returnTypeInferenceNotTooBroad.ts, 6, 1)) +>T : Symbol(T, Decl(returnTypeInferenceNotTooBroad.ts, 7, 24)) +>Signs : Symbol(Signs, Decl(returnTypeInferenceNotTooBroad.ts, 0, 0)) +>opts : Symbol(opts, Decl(returnTypeInferenceNotTooBroad.ts, 7, 41)) +>Opts : Symbol(Opts, Decl(returnTypeInferenceNotTooBroad.ts, 0, 80)) +>T : Symbol(T, Decl(returnTypeInferenceNotTooBroad.ts, 7, 24)) +>Wrapper : Symbol(Wrapper, Decl(returnTypeInferenceNotTooBroad.ts, 4, 1)) +>T : Symbol(T, Decl(returnTypeInferenceNotTooBroad.ts, 7, 24)) + +declare function unwrap(w: Wrapper): T; +>unwrap : Symbol(unwrap, Decl(returnTypeInferenceNotTooBroad.ts, 7, 68)) +>T : Symbol(T, Decl(returnTypeInferenceNotTooBroad.ts, 8, 24)) +>w : Symbol(w, Decl(returnTypeInferenceNotTooBroad.ts, 8, 27)) +>Wrapper : Symbol(Wrapper, Decl(returnTypeInferenceNotTooBroad.ts, 4, 1)) +>T : Symbol(T, Decl(returnTypeInferenceNotTooBroad.ts, 8, 24)) +>T : Symbol(T, Decl(returnTypeInferenceNotTooBroad.ts, 8, 24)) + +export const y = sepsis({ low: 1, sign: { kind: 'a', a: 3 }}); +>y : Symbol(y, Decl(returnTypeInferenceNotTooBroad.ts, 9, 12)) +>sepsis : Symbol(sepsis, Decl(returnTypeInferenceNotTooBroad.ts, 6, 1)) +>low : Symbol(low, Decl(returnTypeInferenceNotTooBroad.ts, 9, 25)) +>sign : Symbol(sign, Decl(returnTypeInferenceNotTooBroad.ts, 9, 33)) +>kind : Symbol(kind, Decl(returnTypeInferenceNotTooBroad.ts, 9, 41)) +>a : Symbol(a, Decl(returnTypeInferenceNotTooBroad.ts, 9, 52)) + +// $ExpectType { kind: "a"; a: 3; } +export const yun = unwrap(y); +>yun : Symbol(yun, Decl(returnTypeInferenceNotTooBroad.ts, 11, 12)) +>unwrap : Symbol(unwrap, Decl(returnTypeInferenceNotTooBroad.ts, 7, 68)) +>y : Symbol(y, Decl(returnTypeInferenceNotTooBroad.ts, 9, 12)) + +// $ExpectType { kind: "a"; a: 3; } +export const yone = unwrap(sepsis({ low: 1, sign: { kind: 'a', a: 3 }})); +>yone : Symbol(yone, Decl(returnTypeInferenceNotTooBroad.ts, 13, 12)) +>unwrap : Symbol(unwrap, Decl(returnTypeInferenceNotTooBroad.ts, 7, 68)) +>sepsis : Symbol(sepsis, Decl(returnTypeInferenceNotTooBroad.ts, 6, 1)) +>low : Symbol(low, Decl(returnTypeInferenceNotTooBroad.ts, 13, 35)) +>sign : Symbol(sign, Decl(returnTypeInferenceNotTooBroad.ts, 13, 43)) +>kind : Symbol(kind, Decl(returnTypeInferenceNotTooBroad.ts, 13, 51)) +>a : Symbol(a, Decl(returnTypeInferenceNotTooBroad.ts, 13, 62)) + diff --git a/tsc/testdata/baselines/reference/compiler/returnTypeInferenceNotTooBroad(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/returnTypeInferenceNotTooBroad(checkorder=default).types new file mode 100644 index 0000000000000..94962df020556 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/returnTypeInferenceNotTooBroad(checkorder=default).types @@ -0,0 +1,67 @@ +//// [tests/cases/compiler/returnTypeInferenceNotTooBroad.ts] //// + +=== returnTypeInferenceNotTooBroad.ts === +type Signs = { kind: 'a'; a: 3; } | { kind: 'b'; b: 2; } | { kind: 'c'; c: 1; }; +>Signs : Signs +>kind : "a" +>a : 3 +>kind : "b" +>b : 2 +>kind : "c" +>c : 1 + +interface Opts { + low?: number; +>low : number | undefined + + sign?: T +>sign : T | undefined +} +interface Wrapper { +} +declare function sepsis(opts: Opts): Wrapper; +>sepsis : (opts: Opts) => Wrapper +>opts : Opts + +declare function unwrap(w: Wrapper): T; +>unwrap : (w: Wrapper) => T +>w : Wrapper + +export const y = sepsis({ low: 1, sign: { kind: 'a', a: 3 }}); +>y : Wrapper<{ kind: "a"; a: 3; }> +>sepsis({ low: 1, sign: { kind: 'a', a: 3 }}) : Wrapper<{ kind: "a"; a: 3; }> +>sepsis : (opts: Opts) => Wrapper +>{ low: 1, sign: { kind: 'a', a: 3 }} : { low: number; sign: { kind: "a"; a: 3; }; } +>low : number +>1 : 1 +>sign : { kind: "a"; a: 3; } +>{ kind: 'a', a: 3 } : { kind: "a"; a: 3; } +>kind : "a" +>'a' : "a" +>a : 3 +>3 : 3 + +// $ExpectType { kind: "a"; a: 3; } +export const yun = unwrap(y); +>yun : { kind: "a"; a: 3; } +>unwrap(y) : { kind: "a"; a: 3; } +>unwrap : (w: Wrapper) => T +>y : Wrapper<{ kind: "a"; a: 3; }> + +// $ExpectType { kind: "a"; a: 3; } +export const yone = unwrap(sepsis({ low: 1, sign: { kind: 'a', a: 3 }})); +>yone : { kind: "a"; a: 3; } +>unwrap(sepsis({ low: 1, sign: { kind: 'a', a: 3 }})) : { kind: "a"; a: 3; } +>unwrap : (w: Wrapper) => T +>sepsis({ low: 1, sign: { kind: 'a', a: 3 }}) : Wrapper<{ kind: "a"; a: 3; }> +>sepsis : (opts: Opts) => Wrapper +>{ low: 1, sign: { kind: 'a', a: 3 }} : { low: number; sign: { kind: "a"; a: 3; }; } +>low : number +>1 : 1 +>sign : { kind: "a"; a: 3; } +>{ kind: 'a', a: 3 } : { kind: "a"; a: 3; } +>kind : "a" +>'a' : "a" +>a : 3 +>3 : 3 + diff --git a/tsc/testdata/baselines/reference/compiler/returnTypeInferenceNotTooBroad(checkorder=typesfirst).js b/tsc/testdata/baselines/reference/compiler/returnTypeInferenceNotTooBroad(checkorder=typesfirst).js new file mode 100644 index 0000000000000..90085dfe2092f --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/returnTypeInferenceNotTooBroad(checkorder=typesfirst).js @@ -0,0 +1,24 @@ +//// [tests/cases/compiler/returnTypeInferenceNotTooBroad.ts] //// + +//// [returnTypeInferenceNotTooBroad.ts] +type Signs = { kind: 'a'; a: 3; } | { kind: 'b'; b: 2; } | { kind: 'c'; c: 1; }; +interface Opts { + low?: number; + sign?: T +} +interface Wrapper { +} +declare function sepsis(opts: Opts): Wrapper; +declare function unwrap(w: Wrapper): T; +export const y = sepsis({ low: 1, sign: { kind: 'a', a: 3 }}); +// $ExpectType { kind: "a"; a: 3; } +export const yun = unwrap(y); +// $ExpectType { kind: "a"; a: 3; } +export const yone = unwrap(sepsis({ low: 1, sign: { kind: 'a', a: 3 }})); + +//// [returnTypeInferenceNotTooBroad.js] +export const y = sepsis({ low: 1, sign: { kind: 'a', a: 3 } }); +// $ExpectType { kind: "a"; a: 3; } +export const yun = unwrap(y); +// $ExpectType { kind: "a"; a: 3; } +export const yone = unwrap(sepsis({ low: 1, sign: { kind: 'a', a: 3 } })); diff --git a/tsc/testdata/baselines/reference/compiler/returnTypeInferenceNotTooBroad(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/returnTypeInferenceNotTooBroad(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..ad8e148932bab --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/returnTypeInferenceNotTooBroad(checkorder=typesfirst).symbols @@ -0,0 +1,69 @@ +//// [tests/cases/compiler/returnTypeInferenceNotTooBroad.ts] //// + +=== returnTypeInferenceNotTooBroad.ts === +type Signs = { kind: 'a'; a: 3; } | { kind: 'b'; b: 2; } | { kind: 'c'; c: 1; }; +>Signs : Symbol(Signs, Decl(returnTypeInferenceNotTooBroad.ts, 0, 0)) +>kind : Symbol(kind, Decl(returnTypeInferenceNotTooBroad.ts, 0, 14)) +>a : Symbol(a, Decl(returnTypeInferenceNotTooBroad.ts, 0, 25)) +>kind : Symbol(kind, Decl(returnTypeInferenceNotTooBroad.ts, 0, 37)) +>b : Symbol(b, Decl(returnTypeInferenceNotTooBroad.ts, 0, 48)) +>kind : Symbol(kind, Decl(returnTypeInferenceNotTooBroad.ts, 0, 60)) +>c : Symbol(c, Decl(returnTypeInferenceNotTooBroad.ts, 0, 71)) + +interface Opts { +>Opts : Symbol(Opts, Decl(returnTypeInferenceNotTooBroad.ts, 0, 80)) +>T : Symbol(T, Decl(returnTypeInferenceNotTooBroad.ts, 1, 15)) + + low?: number; +>low : Symbol(Opts.low, Decl(returnTypeInferenceNotTooBroad.ts, 1, 19)) + + sign?: T +>sign : Symbol(Opts.sign, Decl(returnTypeInferenceNotTooBroad.ts, 2, 17)) +>T : Symbol(T, Decl(returnTypeInferenceNotTooBroad.ts, 1, 15)) +} +interface Wrapper { +>Wrapper : Symbol(Wrapper, Decl(returnTypeInferenceNotTooBroad.ts, 4, 1)) +>T : Symbol(T, Decl(returnTypeInferenceNotTooBroad.ts, 5, 18)) +} +declare function sepsis(opts: Opts): Wrapper; +>sepsis : Symbol(sepsis, Decl(returnTypeInferenceNotTooBroad.ts, 6, 1)) +>T : Symbol(T, Decl(returnTypeInferenceNotTooBroad.ts, 7, 24)) +>Signs : Symbol(Signs, Decl(returnTypeInferenceNotTooBroad.ts, 0, 0)) +>opts : Symbol(opts, Decl(returnTypeInferenceNotTooBroad.ts, 7, 41)) +>Opts : Symbol(Opts, Decl(returnTypeInferenceNotTooBroad.ts, 0, 80)) +>T : Symbol(T, Decl(returnTypeInferenceNotTooBroad.ts, 7, 24)) +>Wrapper : Symbol(Wrapper, Decl(returnTypeInferenceNotTooBroad.ts, 4, 1)) +>T : Symbol(T, Decl(returnTypeInferenceNotTooBroad.ts, 7, 24)) + +declare function unwrap(w: Wrapper): T; +>unwrap : Symbol(unwrap, Decl(returnTypeInferenceNotTooBroad.ts, 7, 68)) +>T : Symbol(T, Decl(returnTypeInferenceNotTooBroad.ts, 8, 24)) +>w : Symbol(w, Decl(returnTypeInferenceNotTooBroad.ts, 8, 27)) +>Wrapper : Symbol(Wrapper, Decl(returnTypeInferenceNotTooBroad.ts, 4, 1)) +>T : Symbol(T, Decl(returnTypeInferenceNotTooBroad.ts, 8, 24)) +>T : Symbol(T, Decl(returnTypeInferenceNotTooBroad.ts, 8, 24)) + +export const y = sepsis({ low: 1, sign: { kind: 'a', a: 3 }}); +>y : Symbol(y, Decl(returnTypeInferenceNotTooBroad.ts, 9, 12)) +>sepsis : Symbol(sepsis, Decl(returnTypeInferenceNotTooBroad.ts, 6, 1)) +>low : Symbol(low, Decl(returnTypeInferenceNotTooBroad.ts, 9, 25)) +>sign : Symbol(sign, Decl(returnTypeInferenceNotTooBroad.ts, 9, 33)) +>kind : Symbol(kind, Decl(returnTypeInferenceNotTooBroad.ts, 9, 41)) +>a : Symbol(a, Decl(returnTypeInferenceNotTooBroad.ts, 9, 52)) + +// $ExpectType { kind: "a"; a: 3; } +export const yun = unwrap(y); +>yun : Symbol(yun, Decl(returnTypeInferenceNotTooBroad.ts, 11, 12)) +>unwrap : Symbol(unwrap, Decl(returnTypeInferenceNotTooBroad.ts, 7, 68)) +>y : Symbol(y, Decl(returnTypeInferenceNotTooBroad.ts, 9, 12)) + +// $ExpectType { kind: "a"; a: 3; } +export const yone = unwrap(sepsis({ low: 1, sign: { kind: 'a', a: 3 }})); +>yone : Symbol(yone, Decl(returnTypeInferenceNotTooBroad.ts, 13, 12)) +>unwrap : Symbol(unwrap, Decl(returnTypeInferenceNotTooBroad.ts, 7, 68)) +>sepsis : Symbol(sepsis, Decl(returnTypeInferenceNotTooBroad.ts, 6, 1)) +>low : Symbol(low, Decl(returnTypeInferenceNotTooBroad.ts, 13, 35)) +>sign : Symbol(sign, Decl(returnTypeInferenceNotTooBroad.ts, 13, 43)) +>kind : Symbol(kind, Decl(returnTypeInferenceNotTooBroad.ts, 13, 51)) +>a : Symbol(a, Decl(returnTypeInferenceNotTooBroad.ts, 13, 62)) + diff --git a/tsc/testdata/baselines/reference/compiler/returnTypeInferenceNotTooBroad(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/returnTypeInferenceNotTooBroad(checkorder=typesfirst).types new file mode 100644 index 0000000000000..1f07d04ed8463 --- /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: string; a: number; } +>unwrap(sepsis({ low: 1, sign: { kind: 'a', a: 3 }})) : { kind: string; a: number; } +>unwrap : (w: Wrapper) => T +>sepsis({ low: 1, sign: { kind: 'a', a: 3 }}) : Wrapper<{ kind: string; a: number; }> +>sepsis : (opts: Opts) => Wrapper +>{ low: 1, sign: { kind: 'a', a: 3 }} : { low: number; sign: { kind: string; a: number; }; } +>low : number +>1 : 1 +>sign : { kind: string; a: number; } +>{ kind: 'a', a: 3 } : { kind: string; a: number; } +>kind : string +>'a' : "a" +>a : number +>3 : 3 + diff --git a/tsc/testdata/baselines/reference/compiler/sharedMemberLayoutThisIntersectionBase(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/sharedMemberLayoutThisIntersectionBase(checkorder=default).errors.txt new file mode 100644 index 0000000000000..b56bf6531dd0a --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/sharedMemberLayoutThisIntersectionBase(checkorder=default).errors.txt @@ -0,0 +1,24 @@ +sharedMemberLayoutThisIntersectionBase.ts(7,3): error TS2339: Property 'm' does not exist on type 'D<"b">'. +sharedMemberLayoutThisIntersectionBase.ts(12,3): error TS2339: Property 'm' does not exist on type 'C<"b">'. + + +==== sharedMemberLayoutThisIntersectionBase.ts (2 errors) ==== + interface A { kind: string; m: this["kind"] } + interface B { m: "a" } + type AB = A & B; + + interface D extends AB { kind: T } + declare let d: D<"b">; + d.m; + ~ +!!! error TS2339: Property 'm' does not exist on type 'D<"b">'. + + declare const ABCtor: new () => AB; + class C extends ABCtor { declare kind: T } + declare let c: C<"b">; + c.m; + ~ +!!! error TS2339: Property 'm' does not exist on type 'C<"b">'. + + export {}; + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/sharedMemberLayoutThisIntersectionBase(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/sharedMemberLayoutThisIntersectionBase(checkorder=default).symbols new file mode 100644 index 0000000000000..793b38f82728b --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/sharedMemberLayoutThisIntersectionBase(checkorder=default).symbols @@ -0,0 +1,51 @@ +//// [tests/cases/compiler/sharedMemberLayoutThisIntersectionBase.ts] //// + +=== sharedMemberLayoutThisIntersectionBase.ts === +interface A { kind: string; m: this["kind"] } +>A : Symbol(A, Decl(sharedMemberLayoutThisIntersectionBase.ts, 0, 0)) +>kind : Symbol(A.kind, Decl(sharedMemberLayoutThisIntersectionBase.ts, 0, 13)) +>m : Symbol(A.m, Decl(sharedMemberLayoutThisIntersectionBase.ts, 0, 27)) + +interface B { m: "a" } +>B : Symbol(B, Decl(sharedMemberLayoutThisIntersectionBase.ts, 0, 45)) +>m : Symbol(B.m, Decl(sharedMemberLayoutThisIntersectionBase.ts, 1, 13)) + +type AB = A & B; +>AB : Symbol(AB, Decl(sharedMemberLayoutThisIntersectionBase.ts, 1, 22)) +>A : Symbol(A, Decl(sharedMemberLayoutThisIntersectionBase.ts, 0, 0)) +>B : Symbol(B, Decl(sharedMemberLayoutThisIntersectionBase.ts, 0, 45)) + +interface D extends AB { kind: T } +>D : Symbol(D, Decl(sharedMemberLayoutThisIntersectionBase.ts, 2, 16)) +>T : Symbol(T, Decl(sharedMemberLayoutThisIntersectionBase.ts, 4, 12)) +>AB : Symbol(AB, Decl(sharedMemberLayoutThisIntersectionBase.ts, 1, 22)) +>kind : Symbol(D.kind, Decl(sharedMemberLayoutThisIntersectionBase.ts, 4, 42)) +>T : Symbol(T, Decl(sharedMemberLayoutThisIntersectionBase.ts, 4, 12)) + +declare let d: D<"b">; +>d : Symbol(d, Decl(sharedMemberLayoutThisIntersectionBase.ts, 5, 11)) +>D : Symbol(D, Decl(sharedMemberLayoutThisIntersectionBase.ts, 2, 16)) + +d.m; +>d : Symbol(d, Decl(sharedMemberLayoutThisIntersectionBase.ts, 5, 11)) + +declare const ABCtor: new () => AB; +>ABCtor : Symbol(ABCtor, Decl(sharedMemberLayoutThisIntersectionBase.ts, 8, 13)) +>AB : Symbol(AB, Decl(sharedMemberLayoutThisIntersectionBase.ts, 1, 22)) + +class C extends ABCtor { declare kind: T } +>C : Symbol(C, Decl(sharedMemberLayoutThisIntersectionBase.ts, 8, 35)) +>T : Symbol(T, Decl(sharedMemberLayoutThisIntersectionBase.ts, 9, 8)) +>ABCtor : Symbol(ABCtor, Decl(sharedMemberLayoutThisIntersectionBase.ts, 8, 13)) +>kind : Symbol(C.kind, Decl(sharedMemberLayoutThisIntersectionBase.ts, 9, 42)) +>T : Symbol(T, Decl(sharedMemberLayoutThisIntersectionBase.ts, 9, 8)) + +declare let c: C<"b">; +>c : Symbol(c, Decl(sharedMemberLayoutThisIntersectionBase.ts, 10, 11)) +>C : Symbol(C, Decl(sharedMemberLayoutThisIntersectionBase.ts, 8, 35)) + +c.m; +>c : Symbol(c, Decl(sharedMemberLayoutThisIntersectionBase.ts, 10, 11)) + +export {}; + diff --git a/tsc/testdata/baselines/reference/compiler/sharedMemberLayoutThisIntersectionBase(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/sharedMemberLayoutThisIntersectionBase(checkorder=default).types new file mode 100644 index 0000000000000..41de65a71ea2f --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/sharedMemberLayoutThisIntersectionBase(checkorder=default).types @@ -0,0 +1,42 @@ +//// [tests/cases/compiler/sharedMemberLayoutThisIntersectionBase.ts] //// + +=== sharedMemberLayoutThisIntersectionBase.ts === +interface A { kind: string; m: this["kind"] } +>kind : string +>m : this["kind"] + +interface B { m: "a" } +>m : "a" + +type AB = A & B; +>AB : AB + +interface D extends AB { kind: T } +>kind : T + +declare let d: D<"b">; +>d : D<"b"> + +d.m; +>d.m : any +>d : D<"b"> +>m : any + +declare const ABCtor: new () => AB; +>ABCtor : new () => AB + +class C extends ABCtor { declare kind: T } +>C : C +>ABCtor : A & B +>kind : T + +declare let c: C<"b">; +>c : C<"b"> + +c.m; +>c.m : any +>c : C<"b"> +>m : any + +export {}; + diff --git a/tsc/testdata/baselines/reference/compiler/sharedMemberLayoutThisIntersectionBase(checkorder=typesfirst).errors.txt b/tsc/testdata/baselines/reference/compiler/sharedMemberLayoutThisIntersectionBase(checkorder=typesfirst).errors.txt new file mode 100644 index 0000000000000..b56bf6531dd0a --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/sharedMemberLayoutThisIntersectionBase(checkorder=typesfirst).errors.txt @@ -0,0 +1,24 @@ +sharedMemberLayoutThisIntersectionBase.ts(7,3): error TS2339: Property 'm' does not exist on type 'D<"b">'. +sharedMemberLayoutThisIntersectionBase.ts(12,3): error TS2339: Property 'm' does not exist on type 'C<"b">'. + + +==== sharedMemberLayoutThisIntersectionBase.ts (2 errors) ==== + interface A { kind: string; m: this["kind"] } + interface B { m: "a" } + type AB = A & B; + + interface D extends AB { kind: T } + declare let d: D<"b">; + d.m; + ~ +!!! error TS2339: Property 'm' does not exist on type 'D<"b">'. + + declare const ABCtor: new () => AB; + class C extends ABCtor { declare kind: T } + declare let c: C<"b">; + c.m; + ~ +!!! error TS2339: Property 'm' does not exist on type 'C<"b">'. + + export {}; + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/sharedMemberLayoutThisIntersectionBase(checkorder=typesfirst).symbols b/tsc/testdata/baselines/reference/compiler/sharedMemberLayoutThisIntersectionBase(checkorder=typesfirst).symbols new file mode 100644 index 0000000000000..793b38f82728b --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/sharedMemberLayoutThisIntersectionBase(checkorder=typesfirst).symbols @@ -0,0 +1,51 @@ +//// [tests/cases/compiler/sharedMemberLayoutThisIntersectionBase.ts] //// + +=== sharedMemberLayoutThisIntersectionBase.ts === +interface A { kind: string; m: this["kind"] } +>A : Symbol(A, Decl(sharedMemberLayoutThisIntersectionBase.ts, 0, 0)) +>kind : Symbol(A.kind, Decl(sharedMemberLayoutThisIntersectionBase.ts, 0, 13)) +>m : Symbol(A.m, Decl(sharedMemberLayoutThisIntersectionBase.ts, 0, 27)) + +interface B { m: "a" } +>B : Symbol(B, Decl(sharedMemberLayoutThisIntersectionBase.ts, 0, 45)) +>m : Symbol(B.m, Decl(sharedMemberLayoutThisIntersectionBase.ts, 1, 13)) + +type AB = A & B; +>AB : Symbol(AB, Decl(sharedMemberLayoutThisIntersectionBase.ts, 1, 22)) +>A : Symbol(A, Decl(sharedMemberLayoutThisIntersectionBase.ts, 0, 0)) +>B : Symbol(B, Decl(sharedMemberLayoutThisIntersectionBase.ts, 0, 45)) + +interface D extends AB { kind: T } +>D : Symbol(D, Decl(sharedMemberLayoutThisIntersectionBase.ts, 2, 16)) +>T : Symbol(T, Decl(sharedMemberLayoutThisIntersectionBase.ts, 4, 12)) +>AB : Symbol(AB, Decl(sharedMemberLayoutThisIntersectionBase.ts, 1, 22)) +>kind : Symbol(D.kind, Decl(sharedMemberLayoutThisIntersectionBase.ts, 4, 42)) +>T : Symbol(T, Decl(sharedMemberLayoutThisIntersectionBase.ts, 4, 12)) + +declare let d: D<"b">; +>d : Symbol(d, Decl(sharedMemberLayoutThisIntersectionBase.ts, 5, 11)) +>D : Symbol(D, Decl(sharedMemberLayoutThisIntersectionBase.ts, 2, 16)) + +d.m; +>d : Symbol(d, Decl(sharedMemberLayoutThisIntersectionBase.ts, 5, 11)) + +declare const ABCtor: new () => AB; +>ABCtor : Symbol(ABCtor, Decl(sharedMemberLayoutThisIntersectionBase.ts, 8, 13)) +>AB : Symbol(AB, Decl(sharedMemberLayoutThisIntersectionBase.ts, 1, 22)) + +class C extends ABCtor { declare kind: T } +>C : Symbol(C, Decl(sharedMemberLayoutThisIntersectionBase.ts, 8, 35)) +>T : Symbol(T, Decl(sharedMemberLayoutThisIntersectionBase.ts, 9, 8)) +>ABCtor : Symbol(ABCtor, Decl(sharedMemberLayoutThisIntersectionBase.ts, 8, 13)) +>kind : Symbol(C.kind, Decl(sharedMemberLayoutThisIntersectionBase.ts, 9, 42)) +>T : Symbol(T, Decl(sharedMemberLayoutThisIntersectionBase.ts, 9, 8)) + +declare let c: C<"b">; +>c : Symbol(c, Decl(sharedMemberLayoutThisIntersectionBase.ts, 10, 11)) +>C : Symbol(C, Decl(sharedMemberLayoutThisIntersectionBase.ts, 8, 35)) + +c.m; +>c : Symbol(c, Decl(sharedMemberLayoutThisIntersectionBase.ts, 10, 11)) + +export {}; + diff --git a/tsc/testdata/baselines/reference/compiler/sharedMemberLayoutThisIntersectionBase(checkorder=typesfirst).types b/tsc/testdata/baselines/reference/compiler/sharedMemberLayoutThisIntersectionBase(checkorder=typesfirst).types new file mode 100644 index 0000000000000..41de65a71ea2f --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/sharedMemberLayoutThisIntersectionBase(checkorder=typesfirst).types @@ -0,0 +1,42 @@ +//// [tests/cases/compiler/sharedMemberLayoutThisIntersectionBase.ts] //// + +=== sharedMemberLayoutThisIntersectionBase.ts === +interface A { kind: string; m: this["kind"] } +>kind : string +>m : this["kind"] + +interface B { m: "a" } +>m : "a" + +type AB = A & B; +>AB : AB + +interface D extends AB { kind: T } +>kind : T + +declare let d: D<"b">; +>d : D<"b"> + +d.m; +>d.m : any +>d : D<"b"> +>m : any + +declare const ABCtor: new () => AB; +>ABCtor : new () => AB + +class C extends ABCtor { declare kind: T } +>C : C +>ABCtor : A & B +>kind : T + +declare let c: C<"b">; +>c : C<"b"> + +c.m; +>c.m : any +>c : C<"b"> +>m : any + +export {}; + diff --git a/tsc/testdata/baselines/reference/compiler/signatureHelpInferenceQueryOrder(checkorder=default).errors.txt b/tsc/testdata/baselines/reference/compiler/signatureHelpInferenceQueryOrder(checkorder=default).errors.txt new file mode 100644 index 0000000000000..1509944c6c1ec --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/signatureHelpInferenceQueryOrder(checkorder=default).errors.txt @@ -0,0 +1,16 @@ +signatureHelpInferenceQueryOrder.ts(7,30): error TS2741: Property 'b' is missing in type 'A' but required in type 'B'. + + +==== signatureHelpInferenceQueryOrder.ts (1 errors) ==== + function f(y: T, y1: U, p: (z: U) => T, p1: (x: T) => U): [T, U] { return [y, p1(y)]; } + interface A { a: A; } + interface B extends A { b; } + + declare var a: A, b: B; + + var d = f(a, b, x => x, x => x); + ~ +!!! error TS2741: Property 'b' is missing in type 'A' but required in type 'B'. +!!! related TS2728 signatureHelpInferenceQueryOrder.ts:3:25: 'b' is declared here. +!!! related TS6502 signatureHelpInferenceQueryOrder.ts:1:51: The expected type comes from the return type of this signature. + \ No newline at end of file diff --git a/tsc/testdata/baselines/reference/compiler/signatureHelpInferenceQueryOrder(checkorder=default).js b/tsc/testdata/baselines/reference/compiler/signatureHelpInferenceQueryOrder(checkorder=default).js new file mode 100644 index 0000000000000..e588ae57cb9ae --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/signatureHelpInferenceQueryOrder(checkorder=default).js @@ -0,0 +1,16 @@ +//// [tests/cases/compiler/signatureHelpInferenceQueryOrder.ts] //// + +//// [signatureHelpInferenceQueryOrder.ts] +function f(y: T, y1: U, p: (z: U) => T, p1: (x: T) => U): [T, U] { return [y, p1(y)]; } +interface A { a: A; } +interface B extends A { b; } + +declare var a: A, b: B; + +var d = f(a, b, x => x, x => x); + + +//// [signatureHelpInferenceQueryOrder.js] +"use strict"; +function f(y, y1, p, p1) { return [y, p1(y)]; } +var d = f(a, b, x => x, x => x); diff --git a/tsc/testdata/baselines/reference/compiler/signatureHelpInferenceQueryOrder(checkorder=default).symbols b/tsc/testdata/baselines/reference/compiler/signatureHelpInferenceQueryOrder(checkorder=default).symbols new file mode 100644 index 0000000000000..b19ea30bb2348 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/signatureHelpInferenceQueryOrder(checkorder=default).symbols @@ -0,0 +1,51 @@ +//// [tests/cases/compiler/signatureHelpInferenceQueryOrder.ts] //// + +=== signatureHelpInferenceQueryOrder.ts === +function f(y: T, y1: U, p: (z: U) => T, p1: (x: T) => U): [T, U] { return [y, p1(y)]; } +>f : Symbol(f, Decl(signatureHelpInferenceQueryOrder.ts, 0, 0)) +>T : Symbol(T, Decl(signatureHelpInferenceQueryOrder.ts, 0, 11)) +>U : Symbol(U, Decl(signatureHelpInferenceQueryOrder.ts, 0, 13)) +>y : Symbol(y, Decl(signatureHelpInferenceQueryOrder.ts, 0, 17)) +>T : Symbol(T, Decl(signatureHelpInferenceQueryOrder.ts, 0, 11)) +>y1 : Symbol(y1, Decl(signatureHelpInferenceQueryOrder.ts, 0, 22)) +>U : Symbol(U, Decl(signatureHelpInferenceQueryOrder.ts, 0, 13)) +>p : Symbol(p, Decl(signatureHelpInferenceQueryOrder.ts, 0, 29)) +>z : Symbol(z, Decl(signatureHelpInferenceQueryOrder.ts, 0, 34)) +>U : Symbol(U, Decl(signatureHelpInferenceQueryOrder.ts, 0, 13)) +>T : Symbol(T, Decl(signatureHelpInferenceQueryOrder.ts, 0, 11)) +>p1 : Symbol(p1, Decl(signatureHelpInferenceQueryOrder.ts, 0, 45)) +>x : Symbol(x, Decl(signatureHelpInferenceQueryOrder.ts, 0, 51)) +>T : Symbol(T, Decl(signatureHelpInferenceQueryOrder.ts, 0, 11)) +>U : Symbol(U, Decl(signatureHelpInferenceQueryOrder.ts, 0, 13)) +>T : Symbol(T, Decl(signatureHelpInferenceQueryOrder.ts, 0, 11)) +>U : Symbol(U, Decl(signatureHelpInferenceQueryOrder.ts, 0, 13)) +>y : Symbol(y, Decl(signatureHelpInferenceQueryOrder.ts, 0, 17)) +>p1 : Symbol(p1, Decl(signatureHelpInferenceQueryOrder.ts, 0, 45)) +>y : Symbol(y, Decl(signatureHelpInferenceQueryOrder.ts, 0, 17)) + +interface A { a: A; } +>A : Symbol(A, Decl(signatureHelpInferenceQueryOrder.ts, 0, 93)) +>a : Symbol(A.a, Decl(signatureHelpInferenceQueryOrder.ts, 1, 13)) +>A : Symbol(A, Decl(signatureHelpInferenceQueryOrder.ts, 0, 93)) + +interface B extends A { b; } +>B : Symbol(B, Decl(signatureHelpInferenceQueryOrder.ts, 1, 21)) +>A : Symbol(A, Decl(signatureHelpInferenceQueryOrder.ts, 0, 93)) +>b : Symbol(B.b, Decl(signatureHelpInferenceQueryOrder.ts, 2, 23)) + +declare var a: A, b: B; +>a : Symbol(a, Decl(signatureHelpInferenceQueryOrder.ts, 4, 11)) +>A : Symbol(A, Decl(signatureHelpInferenceQueryOrder.ts, 0, 93)) +>b : Symbol(b, Decl(signatureHelpInferenceQueryOrder.ts, 4, 17)) +>B : Symbol(B, Decl(signatureHelpInferenceQueryOrder.ts, 1, 21)) + +var d = f(a, b, x => x, x => x); +>d : Symbol(d, Decl(signatureHelpInferenceQueryOrder.ts, 6, 3)) +>f : Symbol(f, Decl(signatureHelpInferenceQueryOrder.ts, 0, 0)) +>a : Symbol(a, Decl(signatureHelpInferenceQueryOrder.ts, 4, 11)) +>b : Symbol(b, Decl(signatureHelpInferenceQueryOrder.ts, 4, 17)) +>x : Symbol(x, Decl(signatureHelpInferenceQueryOrder.ts, 6, 15)) +>x : Symbol(x, Decl(signatureHelpInferenceQueryOrder.ts, 6, 15)) +>x : Symbol(x, Decl(signatureHelpInferenceQueryOrder.ts, 6, 23)) +>x : Symbol(x, Decl(signatureHelpInferenceQueryOrder.ts, 6, 23)) + diff --git a/tsc/testdata/baselines/reference/compiler/signatureHelpInferenceQueryOrder(checkorder=default).types b/tsc/testdata/baselines/reference/compiler/signatureHelpInferenceQueryOrder(checkorder=default).types new file mode 100644 index 0000000000000..ece3363ee1b85 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/signatureHelpInferenceQueryOrder(checkorder=default).types @@ -0,0 +1,40 @@ +//// [tests/cases/compiler/signatureHelpInferenceQueryOrder.ts] //// + +=== signatureHelpInferenceQueryOrder.ts === +function f(y: T, y1: U, p: (z: U) => T, p1: (x: T) => U): [T, U] { return [y, p1(y)]; } +>f : (y: T, y1: U, p: (z: U) => T, p1: (x: T) => U) => [T, U] +>y : T +>y1 : U +>p : (z: U) => T +>z : U +>p1 : (x: T) => U +>x : T +>[y, p1(y)] : [T, U] +>y : T +>p1(y) : U +>p1 : (x: T) => U +>y : T + +interface A { a: A; } +>a : A + +interface B extends A { b; } +>b : any + +declare var a: A, b: B; +>a : A +>b : B + +var d = f(a, b, x => x, x => x); +>d : [A, B] +>f(a, b, x => x, x => x) : [A, B] +>f : (y: T, y1: U, p: (z: U) => T, p1: (x: T) => U) => [T, U] +>a : A +>b : B +>x => x : (x: B) => B +>x : B +>x : B +>x => x : (x: A) => A +>x : A +>x : A + diff --git a/tsc/testdata/baselines/reference/compiler/signatureHelpInferenceQueryOrder(checkorder=editorfirst).js b/tsc/testdata/baselines/reference/compiler/signatureHelpInferenceQueryOrder(checkorder=editorfirst).js new file mode 100644 index 0000000000000..e588ae57cb9ae --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/signatureHelpInferenceQueryOrder(checkorder=editorfirst).js @@ -0,0 +1,16 @@ +//// [tests/cases/compiler/signatureHelpInferenceQueryOrder.ts] //// + +//// [signatureHelpInferenceQueryOrder.ts] +function f(y: T, y1: U, p: (z: U) => T, p1: (x: T) => U): [T, U] { return [y, p1(y)]; } +interface A { a: A; } +interface B extends A { b; } + +declare var a: A, b: B; + +var d = f(a, b, x => x, x => x); + + +//// [signatureHelpInferenceQueryOrder.js] +"use strict"; +function f(y, y1, p, p1) { return [y, p1(y)]; } +var d = f(a, b, x => x, x => x); diff --git a/tsc/testdata/baselines/reference/compiler/signatureHelpInferenceQueryOrder(checkorder=editorfirst).symbols b/tsc/testdata/baselines/reference/compiler/signatureHelpInferenceQueryOrder(checkorder=editorfirst).symbols new file mode 100644 index 0000000000000..b19ea30bb2348 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/signatureHelpInferenceQueryOrder(checkorder=editorfirst).symbols @@ -0,0 +1,51 @@ +//// [tests/cases/compiler/signatureHelpInferenceQueryOrder.ts] //// + +=== signatureHelpInferenceQueryOrder.ts === +function f(y: T, y1: U, p: (z: U) => T, p1: (x: T) => U): [T, U] { return [y, p1(y)]; } +>f : Symbol(f, Decl(signatureHelpInferenceQueryOrder.ts, 0, 0)) +>T : Symbol(T, Decl(signatureHelpInferenceQueryOrder.ts, 0, 11)) +>U : Symbol(U, Decl(signatureHelpInferenceQueryOrder.ts, 0, 13)) +>y : Symbol(y, Decl(signatureHelpInferenceQueryOrder.ts, 0, 17)) +>T : Symbol(T, Decl(signatureHelpInferenceQueryOrder.ts, 0, 11)) +>y1 : Symbol(y1, Decl(signatureHelpInferenceQueryOrder.ts, 0, 22)) +>U : Symbol(U, Decl(signatureHelpInferenceQueryOrder.ts, 0, 13)) +>p : Symbol(p, Decl(signatureHelpInferenceQueryOrder.ts, 0, 29)) +>z : Symbol(z, Decl(signatureHelpInferenceQueryOrder.ts, 0, 34)) +>U : Symbol(U, Decl(signatureHelpInferenceQueryOrder.ts, 0, 13)) +>T : Symbol(T, Decl(signatureHelpInferenceQueryOrder.ts, 0, 11)) +>p1 : Symbol(p1, Decl(signatureHelpInferenceQueryOrder.ts, 0, 45)) +>x : Symbol(x, Decl(signatureHelpInferenceQueryOrder.ts, 0, 51)) +>T : Symbol(T, Decl(signatureHelpInferenceQueryOrder.ts, 0, 11)) +>U : Symbol(U, Decl(signatureHelpInferenceQueryOrder.ts, 0, 13)) +>T : Symbol(T, Decl(signatureHelpInferenceQueryOrder.ts, 0, 11)) +>U : Symbol(U, Decl(signatureHelpInferenceQueryOrder.ts, 0, 13)) +>y : Symbol(y, Decl(signatureHelpInferenceQueryOrder.ts, 0, 17)) +>p1 : Symbol(p1, Decl(signatureHelpInferenceQueryOrder.ts, 0, 45)) +>y : Symbol(y, Decl(signatureHelpInferenceQueryOrder.ts, 0, 17)) + +interface A { a: A; } +>A : Symbol(A, Decl(signatureHelpInferenceQueryOrder.ts, 0, 93)) +>a : Symbol(A.a, Decl(signatureHelpInferenceQueryOrder.ts, 1, 13)) +>A : Symbol(A, Decl(signatureHelpInferenceQueryOrder.ts, 0, 93)) + +interface B extends A { b; } +>B : Symbol(B, Decl(signatureHelpInferenceQueryOrder.ts, 1, 21)) +>A : Symbol(A, Decl(signatureHelpInferenceQueryOrder.ts, 0, 93)) +>b : Symbol(B.b, Decl(signatureHelpInferenceQueryOrder.ts, 2, 23)) + +declare var a: A, b: B; +>a : Symbol(a, Decl(signatureHelpInferenceQueryOrder.ts, 4, 11)) +>A : Symbol(A, Decl(signatureHelpInferenceQueryOrder.ts, 0, 93)) +>b : Symbol(b, Decl(signatureHelpInferenceQueryOrder.ts, 4, 17)) +>B : Symbol(B, Decl(signatureHelpInferenceQueryOrder.ts, 1, 21)) + +var d = f(a, b, x => x, x => x); +>d : Symbol(d, Decl(signatureHelpInferenceQueryOrder.ts, 6, 3)) +>f : Symbol(f, Decl(signatureHelpInferenceQueryOrder.ts, 0, 0)) +>a : Symbol(a, Decl(signatureHelpInferenceQueryOrder.ts, 4, 11)) +>b : Symbol(b, Decl(signatureHelpInferenceQueryOrder.ts, 4, 17)) +>x : Symbol(x, Decl(signatureHelpInferenceQueryOrder.ts, 6, 15)) +>x : Symbol(x, Decl(signatureHelpInferenceQueryOrder.ts, 6, 15)) +>x : Symbol(x, Decl(signatureHelpInferenceQueryOrder.ts, 6, 23)) +>x : Symbol(x, Decl(signatureHelpInferenceQueryOrder.ts, 6, 23)) + diff --git a/tsc/testdata/baselines/reference/compiler/signatureHelpInferenceQueryOrder(checkorder=editorfirst).types b/tsc/testdata/baselines/reference/compiler/signatureHelpInferenceQueryOrder(checkorder=editorfirst).types new file mode 100644 index 0000000000000..a4d785ae4e6cd --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/signatureHelpInferenceQueryOrder(checkorder=editorfirst).types @@ -0,0 +1,40 @@ +//// [tests/cases/compiler/signatureHelpInferenceQueryOrder.ts] //// + +=== signatureHelpInferenceQueryOrder.ts === +function f(y: T, y1: U, p: (z: U) => T, p1: (x: T) => U): [T, U] { return [y, p1(y)]; } +>f : (y: T, y1: U, p: (z: U) => T, p1: (x: T) => U) => [T, U] +>y : T +>y1 : U +>p : (z: U) => T +>z : U +>p1 : (x: T) => U +>x : T +>[y, p1(y)] : [T, U] +>y : T +>p1(y) : U +>p1 : (x: T) => U +>y : T + +interface A { a: A; } +>a : A + +interface B extends A { b; } +>b : any + +declare var a: A, b: B; +>a : A +>b : B + +var d = f(a, b, x => x, x => x); +>d : [A, A] +>f(a, b, x => x, x => x) : [A, A] +>f : (y: T, y1: U, p: (z: U) => T, p1: (x: T) => U) => [T, U] +>a : A +>b : B +>x => x : (x: B) => B +>x : B +>x : B +>x => x : (x: A) => A +>x : A +>x : A + diff --git a/tsc/testdata/baselines/reference/compiler/substitutionInDeferredConditionalOfConditional.symbols b/tsc/testdata/baselines/reference/compiler/substitutionInDeferredConditionalOfConditional.symbols new file mode 100644 index 0000000000000..3b8125dec8b95 --- /dev/null +++ b/tsc/testdata/baselines/reference/compiler/substitutionInDeferredConditionalOfConditional.symbols @@ -0,0 +1,94 @@ +//// [tests/cases/compiler/substitutionInDeferredConditionalOfConditional.ts] //// + +=== substitutionInDeferredConditionalOfConditional.ts === +// Children always produces a Record, so it satisfies NeedsRecord. Its +// true branch narrows S["states"] to Record even when S is +// a conditional type that is itself deferred. + +interface Schema { +>Schema : Symbol(Schema, Decl(substitutionInDeferredConditionalOfConditional.ts, 0, 0)) + + states?: Record; +>states : Symbol(Schema.states, Decl(substitutionInDeferredConditionalOfConditional.ts, 4, 18)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) +>Schema : Symbol(Schema, Decl(substitutionInDeferredConditionalOfConditional.ts, 0, 0)) +} +type Resolve, Segments extends readonly string[]> = +>Resolve : Symbol(Resolve, Decl(substitutionInDeferredConditionalOfConditional.ts, 6, 1)) +>S : Symbol(S, Decl(substitutionInDeferredConditionalOfConditional.ts, 7, 13)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) +>Schema : Symbol(Schema, Decl(substitutionInDeferredConditionalOfConditional.ts, 0, 0)) +>Segments : Symbol(Segments, Decl(substitutionInDeferredConditionalOfConditional.ts, 7, 46)) + + Segments extends [infer Head extends string, ...infer Rest extends string[]] +>Segments : Symbol(Segments, Decl(substitutionInDeferredConditionalOfConditional.ts, 7, 46)) +>Head : Symbol(Head, Decl(substitutionInDeferredConditionalOfConditional.ts, 8, 27)) +>Rest : Symbol(Rest, Decl(substitutionInDeferredConditionalOfConditional.ts, 8, 57)) + + ? Head extends keyof S +>Head : Symbol(Head, Decl(substitutionInDeferredConditionalOfConditional.ts, 8, 27)) +>S : Symbol(S, Decl(substitutionInDeferredConditionalOfConditional.ts, 7, 13)) + + ? Rest extends [] +>Rest : Symbol(Rest, Decl(substitutionInDeferredConditionalOfConditional.ts, 8, 57)) + + ? S[Head] +>S : Symbol(S, Decl(substitutionInDeferredConditionalOfConditional.ts, 7, 13)) +>Head : Symbol(Head, Decl(substitutionInDeferredConditionalOfConditional.ts, 8, 27)) + + : S[Head]["states"] extends Record +>S : Symbol(S, Decl(substitutionInDeferredConditionalOfConditional.ts, 7, 13)) +>Head : Symbol(Head, Decl(substitutionInDeferredConditionalOfConditional.ts, 8, 27)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) +>Schema : Symbol(Schema, Decl(substitutionInDeferredConditionalOfConditional.ts, 0, 0)) + + ? Resolve +>Resolve : Symbol(Resolve, Decl(substitutionInDeferredConditionalOfConditional.ts, 6, 1)) +>S : Symbol(S, Decl(substitutionInDeferredConditionalOfConditional.ts, 7, 13)) +>Head : Symbol(Head, Decl(substitutionInDeferredConditionalOfConditional.ts, 8, 27)) +>Rest : Symbol(Rest, Decl(substitutionInDeferredConditionalOfConditional.ts, 8, 57)) + + : never + : never + : never; +type Split