From 102fe660be007101cd0745254c0d9e45b6e1e60d Mon Sep 17 00:00:00 2001 From: HeyeOpenSource Date: Mon, 14 Oct 2024 10:41:35 +0200 Subject: [PATCH 01/48] - Add new DotNet- / Nuget-Cataloger-Configuration. Signed-off-by: HeyeOpenSource --- cmd/syft/internal/options/dotnet.go | 22 ++++ syft/cataloging/pkgcataloging/config.go | 8 ++ syft/pkg/cataloger/dotnet/config.go | 144 +++++++++++++++++++++++ syft/pkg/cataloger/dotnet/config_test.go | 107 +++++++++++++++++ 4 files changed, 281 insertions(+) create mode 100644 cmd/syft/internal/options/dotnet.go create mode 100644 syft/pkg/cataloger/dotnet/config.go create mode 100644 syft/pkg/cataloger/dotnet/config_test.go diff --git a/cmd/syft/internal/options/dotnet.go b/cmd/syft/internal/options/dotnet.go new file mode 100644 index 00000000000..ccda0e86826 --- /dev/null +++ b/cmd/syft/internal/options/dotnet.go @@ -0,0 +1,22 @@ +package options + +import ( + "strings" + + "github.com/anchore/syft/syft/pkg/cataloger/dotnet" +) + +type dotnetConfig struct { + SearchLocalLicenses bool `yaml:"search-local-licenses" json:"search-local-licenses" mapstructure:"search-local-licenses"` + SearchRemoteLicenses bool `yaml:"search-remote-licenses" json:"search-remote-licenses" mapstructure:"search-remote-licenses"` + Providers string `yaml:"package-providers,omitempty" json:"package-providers,omitempty" mapstructure:"package-providers"` +} + +func defaultDotnetConfig() dotnetConfig { + def := dotnet.DefaultCatalogerConfig() + return dotnetConfig{ + SearchLocalLicenses: def.SearchLocalLicenses, + SearchRemoteLicenses: def.SearchRemoteLicenses, + Providers: strings.Join(def.Providers, ","), + } +} diff --git a/syft/cataloging/pkgcataloging/config.go b/syft/cataloging/pkgcataloging/config.go index ac55de7efe5..eae84f3a645 100644 --- a/syft/cataloging/pkgcataloging/config.go +++ b/syft/cataloging/pkgcataloging/config.go @@ -2,6 +2,7 @@ package pkgcataloging import ( "github.com/anchore/syft/syft/pkg/cataloger/binary" + "github.com/anchore/syft/syft/pkg/cataloger/dotnet" "github.com/anchore/syft/syft/pkg/cataloger/golang" "github.com/anchore/syft/syft/pkg/cataloger/java" "github.com/anchore/syft/syft/pkg/cataloger/javascript" @@ -12,6 +13,7 @@ import ( type Config struct { Binary binary.ClassifierCatalogerConfig `yaml:"binary" json:"binary" mapstructure:"binary"` Golang golang.CatalogerConfig `yaml:"golang" json:"golang" mapstructure:"golang"` + DotNet dotnet.CatalogerConfig `yaml:"dotnet" json:"dotnet" mapstructure:"dotnet"` JavaArchive java.ArchiveCatalogerConfig `yaml:"java-archive" json:"java-archive" mapstructure:"java-archive"` JavaScript javascript.CatalogerConfig `yaml:"javascript" json:"javascript" mapstructure:"javascript"` LinuxKernel kernel.LinuxKernelCatalogerConfig `yaml:"linux-kernel" json:"linux-kernel" mapstructure:"linux-kernel"` @@ -22,6 +24,7 @@ func DefaultConfig() Config { return Config{ Binary: binary.DefaultClassifierCatalogerConfig(), Golang: golang.DefaultCatalogerConfig(), + DotNet: dotnet.DefaultCatalogerConfig(), LinuxKernel: kernel.DefaultLinuxKernelCatalogerConfig(), Python: python.DefaultCatalogerConfig(), JavaArchive: java.DefaultArchiveCatalogerConfig(), @@ -38,6 +41,11 @@ func (c Config) WithGolangConfig(cfg golang.CatalogerConfig) Config { return c } +func (c Config) WithDotNetConfig(cfg dotnet.CatalogerConfig) Config { + c.DotNet = cfg + return c +} + func (c Config) WithJavascriptConfig(cfg javascript.CatalogerConfig) Config { c.JavaScript = cfg return c diff --git a/syft/pkg/cataloger/dotnet/config.go b/syft/pkg/cataloger/dotnet/config.go new file mode 100644 index 00000000000..1cd1ff3d530 --- /dev/null +++ b/syft/pkg/cataloger/dotnet/config.go @@ -0,0 +1,144 @@ +package dotnet + +import ( + "context" + "encoding/json" + "io" + "net/http" + "os" + "os/exec" + "strconv" + "strings" + "time" +) + +const ( + defaultProvider = "https://www.nuget.org/api/v2/package" +) + +type CatalogerConfig struct { + SearchLocalLicenses bool `yaml:"search-local-licenses" json:"search-local-licenses" mapstructure:"search-local-licenses"` + SearchRemoteLicenses bool `yaml:"search-remote-licenses" json:"search-remote-licenses" mapstructure:"search-remote-licenses"` + Providers []string `yaml:"package-providers,omitempty" json:"package-providers,omitempty" mapstructure:"package-providers"` +} + +// DefaultCatalogerConfig create a CatalogerConfig with default options, which includes: +// - setting the default remote proxy if none is provided +// - setting the default no proxy if none is provided +// - setting the default local module cache dir if none is provided +func DefaultCatalogerConfig() CatalogerConfig { + g := CatalogerConfig{} + + nuget := os.Getenv("NUGET_SEARCH_LOCAL_LICENSES") + if value, err := strconv.ParseBool(nuget); err == nil { + g = g.WithSearchLocalLicenses(value) + } + + remote := os.Getenv("NUGET_SEARCH_REMOTE_LICENSES") + if value, err := strconv.ParseBool(remote); err == nil { + g = g.WithSearchRemoteLicenses(value) + } + + // process the proxy settings (for remote search) + if len(g.Providers) == 0 { + nugetProviders := os.Getenv("NUGET_PACKAGE_PROVIDERS") + if nugetProviders == "" { + nugetProviders = getDefaultProviders() + } + g = g.WithProviders(nugetProviders) + } + + return g +} + +func (g CatalogerConfig) WithSearchLocalLicenses(input bool) CatalogerConfig { + g.SearchLocalLicenses = input + return g +} + +func (g CatalogerConfig) WithSearchRemoteLicenses(input bool) CatalogerConfig { + g.SearchRemoteLicenses = input + return g +} + +func (g CatalogerConfig) WithProviders(input string) CatalogerConfig { + if input == "" { + return g + } + g.Providers = strings.Split(input, ",") + return g +} + +type sourceApiResource struct { + ID string `json:"@id"` + Type string `json:"@type"` + Comment string `json:"comment,omitempty"` +} + +type sourceApiContext struct { + Vocab string `json:"@vocab"` + Comment string `json:"comment,omitempty"` +} + +type sourceApi struct { + Version string `json:"version"` + Resources []sourceApiResource `json:"resources"` + Context *sourceApiContext `json:"@context,omitempty"` +} + +func getDefaultProviders() string { + // Try to find enabled remote nuget package sources + packageSources := []string{} + ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second) + cmd := exec.CommandContext(ctx, "dotnet", "nuget", "list", "source", "--format", "Short") + if stdout, err := cmd.StdoutPipe(); err == nil { + if err := cmd.Start(); err == nil { + if data, err := io.ReadAll(stdout); err == nil { + lines := strings.Split(string(data), "\n") + for _, line := range lines { + line = strings.TrimSpace(line) + // Expect something like + // E https://api.nuget.org/v3/index.json + // or + // D https://api.nuget.org/v3/index.json + + // Only enabled sources + if strings.HasPrefix(line, "E ") { + packageSource := strings.TrimSpace(line[2:]) + if strings.HasPrefix(packageSource, "https://") { + found := false + if !found { + packageSources = append(packageSources, packageSource) + } + } + } + } + } + } + } + cancel() + if len(packageSources) > 0 { + providers := []string{} + for _, packageSource := range packageSources { + if response, err := http.Get(packageSource); err == nil && response.StatusCode == http.StatusOK { + apiData, err := io.ReadAll(response.Body) + response.Body.Close() + if err == nil { + api := sourceApi{} + if err = json.Unmarshal(apiData, &api); err == nil { + for _, apiResource := range api.Resources { + if strings.HasSuffix(apiResource.ID, "/package") { + providers = append(providers, apiResource.ID) + } + } + } + } + } + } + if len(providers) > 0 { + return strings.Join(providers, ",") + } + } + + return defaultProvider +} diff --git a/syft/pkg/cataloger/dotnet/config_test.go b/syft/pkg/cataloger/dotnet/config_test.go new file mode 100644 index 00000000000..2dea2c2c304 --- /dev/null +++ b/syft/pkg/cataloger/dotnet/config_test.go @@ -0,0 +1,107 @@ +package dotnet + +import ( + "testing" + + "github.com/mitchellh/go-homedir" + "github.com/stretchr/testify/assert" +) + +func Test_Config(t *testing.T) { + type opts struct { + local *bool + remote *bool + providers *string + } + + trueVal := true + falseVal := false + optProvider := "https://www.nuget.org/api/v2/package" + + homedirCacheDisabled := homedir.DisableCache + homedir.DisableCache = true + t.Cleanup(func() { + homedir.DisableCache = homedirCacheDisabled + }) + + allEnv := map[string]string{ + "HOME": "/usr/home", + "NUGET_SEARCH_LOCAL_LICENSES": "", + "NUGET_SEARCH_REMOTE_LICENSES": "", + "NUGET_PACKAGE_PROVIDERS": "", + } + + tests := []struct { + name string + env map[string]string + opts opts + expected CatalogerConfig + }{ + { + name: "absolute defaults", + env: map[string]string{}, + opts: opts{}, + expected: CatalogerConfig{ + SearchLocalLicenses: false, + SearchRemoteLicenses: false, + Providers: []string{"https://www.nuget.org/api/v2/package"}, + }, + }, + { + name: "set via env defaults", + env: map[string]string{ + "NUGET_SEARCH_LOCAL_LICENSES": "true", + "NUGET_SEARCH_REMOTE_LICENSES": "false", + "NUGET_PACKAGE_PROVIDERS": "https://my.proxy", + }, + opts: opts{}, + expected: CatalogerConfig{ + SearchLocalLicenses: true, + SearchRemoteLicenses: false, + Providers: []string{"https://my.proxy"}, + }, + }, + { + name: "set via configuration", + env: map[string]string{ + "NUGET_SEARCH_LOCAL_LICENSES": "true", + "NUGET_SEARCH_REMOTE_LICENSES": "false", + "NUGET_PACKAGE_PROVIDERS": "https://my.proxy", + }, + opts: opts{ + local: &falseVal, + remote: &trueVal, + providers: &optProvider, + }, + expected: CatalogerConfig{ + SearchLocalLicenses: false, + SearchRemoteLicenses: true, + Providers: []string{"https://www.nuget.org/api/v2/package"}, + }, + }, + } + + for _, test := range tests { + t.Run(test.name, func(t *testing.T) { + for k, v := range allEnv { + t.Setenv(k, v) + } + for k, v := range test.env { + t.Setenv(k, v) + } + got := DefaultCatalogerConfig() + + if test.opts.local != nil { + got = got.WithSearchLocalLicenses(*test.opts.local) + } + if test.opts.remote != nil { + got = got.WithSearchRemoteLicenses(*test.opts.remote) + } + if test.opts.providers != nil { + got = got.WithProviders(*test.opts.providers) + } + + assert.Equal(t, test.expected, got) + }) + } +} From df811986f4800458cb53702db9428be0eec581cd Mon Sep 17 00:00:00 2001 From: HeyeOpenSource Date: Mon, 14 Oct 2024 11:02:17 +0200 Subject: [PATCH 02/48] - Added NuGet license resolver. Signed-off-by: HeyeOpenSource --- syft/pkg/cataloger/dotnet/licenses.go | 378 ++++++++++++++++++++++++++ 1 file changed, 378 insertions(+) create mode 100644 syft/pkg/cataloger/dotnet/licenses.go diff --git a/syft/pkg/cataloger/dotnet/licenses.go b/syft/pkg/cataloger/dotnet/licenses.go new file mode 100644 index 00000000000..61a7ef0151f --- /dev/null +++ b/syft/pkg/cataloger/dotnet/licenses.go @@ -0,0 +1,378 @@ +package dotnet + +import ( + "archive/zip" + "bytes" + "context" + "encoding/json" + "encoding/xml" + "errors" + "fmt" + "io" + "net/http" + "os" + "os/exec" + "path/filepath" + "strings" + "time" + + "github.com/anchore/syft/internal/licenses" + "github.com/anchore/syft/syft/file" + "github.com/anchore/syft/syft/internal/fileresolver" + "github.com/anchore/syft/syft/pkg" + "github.com/scylladb/go-set/strset" +) + +type nugetLicenses struct { + opts CatalogerConfig + localNuGetCacheResolvers []file.Resolver + lowerLicenseFileNames *strset.Set +} + +func newNugetLicenses(opts CatalogerConfig) nugetLicenses { + return nugetLicenses{ + opts: opts, + localNuGetCacheResolvers: nil, + lowerLicenseFileNames: strset.New(lowercaseLicenseFiles()...), + } +} + +func lowercaseLicenseFiles() []string { + fileNames := licenses.FileNames() + for i := range fileNames { + fileNames[i] = strings.ToLower(fileNames[i]) + } + return fileNames +} + +func (c *nugetLicenses) getLicenses(moduleName, moduleVersion string, resolver file.Resolver) ([]pkg.License, error) { + licenses := []pkg.License{} + + if c.opts.SearchLocalLicenses { + if c.localNuGetCacheResolvers == nil { + // Try to determine nuget package folder resolverss + c.localNuGetCacheResolvers = getLocalNugetFolderResolvers(resolver) + } + + // if we're running against a directory on the filesystem, it may not include the + // user's homedir, so we defer to using the localModCacheResolver + for _, resolver := range c.localNuGetCacheResolvers { + if lics, err := c.findLocalLicenses(resolver, moduleSearchGlob(moduleName, moduleVersion)); err == nil && len(lics) > 0 { + for _, lic := range lics { + found := false + for _, known := range licenses { + if known.Value == lic.Value && + known.SPDXExpression == lic.SPDXExpression && + known.Type == lic.Type { + found = true + break + } + } + if !found { + licenses = append(licenses, lic) + } + } + } + } + } + + if c.opts.SearchRemoteLicenses { + if lics, err := c.findRemoteLicenses(moduleName, moduleVersion); err == nil { + for _, lic := range lics { + found := false + for _, known := range licenses { + if known.Value == lic.Value && + known.SPDXExpression == lic.SPDXExpression && + known.Type == lic.Type { + found = true + break + } + } + if !found { + licenses = append(licenses, lic) + } + } + } + } + + var err error + if len(licenses) == 0 { + err = errors.New("no licenses found") + } + return licenses, err +} + +func (c *nugetLicenses) findLocalLicenses(resolver file.Resolver, globMatch string) (out []pkg.License, err error) { + out = make([]pkg.License, 0) + if resolver == nil { + return + } + + locations, err := resolver.FilesByGlob(globMatch) + if err != nil { + return nil, err + } + + for _, l := range locations { + fileName := filepath.Base(l.RealPath) + if c.lowerLicenseFileNames.Has(strings.ToLower(fileName)) { + contents, err := resolver.FileContentsByLocation(l) + if err != nil { + return nil, err + } + parsed, err := licenses.Parse(contents, l) + if err != nil { + return nil, err + } + + out = append(out, parsed...) + } + } + + return +} + +// File is used in the NuSpec struct +type File struct { + Source string `xml:"src,attr"` + Target string `xml:"target,attr"` +} + +// Dependency is used in the NuSpec struct +type Dependency struct { + ID string `xml:"id,attr"` + Version string `xml:"version,attr"` +} + +// NuSpec represents a .nuspec XML file found in the root of the .nupack or .nupkg files +type NuSpec struct { + XMLName xml.Name `xml:"package"` + Xmlns string `xml:"xmlns,attr,omitempty"` + Meta struct { // MetaData + ID string `xml:"id"` + Version string `xml:"version"` + Title string `xml:"title,omitempty"` + Authors string `xml:"authors"` + Owners string `xml:"owners,omitempty"` + LicenseURL string `xml:"licenseUrl,omitempty"` + License struct { + Text string `xml:",chardata"` + Type string `xml:"type,attr"` + } `xml:"license,omitempty"` + ProjectURL string `xml:"projectUrl,omitempty"` + IconURL string `xml:"iconUrl,omitempty"` + ReqLicenseAccept bool `xml:"requireLicenseAcceptance"` + Description string `xml:"description"` + ReleaseNotes string `xml:"releaseNotes,omitempty"` + Copyright string `xml:"copyright,omitempty"` + Summary string `xml:"summary,omitempty"` + Language string `xml:"language,omitempty"` + Tags string `xml:"tags,omitempty"` + Dependencies struct { + Dependency []Dependency `xml:"dependency"` + } `xml:"dependencies,omitempty"` + } `xml:"metadata"` + Files struct { + File []File `xml:"file"` + } `xml:"files,omitempty"` +} + +// removeBOM removes any ByteOrderMark at the beginning of a given file content +func removeBOM(input []byte) []byte { + if len(input) >= 2 { + if input[0] == 254 && + input[1] == 255 { + // UTF-16 (BE) + return input[2:] + } + if input[0] == 255 && + input[1] == 254 { + // UTF-16 (LE) + return input[2:] + } + if len(input) >= 3 { + if input[0] == 239 && + input[1] == 187 && + input[2] == 191 { + // UTF-8 + return input[3:] + } + if len(input) >= 4 { + if input[0] == 0 && + input[1] == 0 && + input[2] == 254 && + input[3] == 255 { + // UTF-32 (BE) + return input[4:] + } + if input[0] == 255 && + input[1] == 254 && + input[2] == 0 && + input[3] == 0 { + // UTF-32 (LE) + return input[4:] + } + } + } + } + return input +} + +func (c *nugetLicenses) findRemoteLicenses(moduleName, moduleVersion string) (out []pkg.License, err error) { + if len(c.opts.Providers) == 0 { + return nil, errors.ErrUnsupported + } + + foundPackage := false + for _, provider := range c.opts.Providers { + if response, err := http.Get(fmt.Sprintf("%s/%s/%s", provider, moduleName, moduleVersion)); err == nil && response.StatusCode == http.StatusOK { + foundPackage = true + moduleData, err := io.ReadAll(response.Body) + response.Body.Close() + if err == nil { + if zr, err := zip.NewReader(bytes.NewReader(moduleData), int64(len(moduleData))); err == nil { + if specFile, err := zr.Open(moduleName + ".nuspec"); err == nil { + defer specFile.Close() + if specFileData, err := io.ReadAll(specFile); err == nil { + specFileData = removeBOM(specFileData) + var nuspec NuSpec + if err = xml.Unmarshal(specFileData, &nuspec); err == nil { + switch nuspec.Meta.License.Type { + case "expression": + out = append(out, pkg.NewLicenseFromFields(nuspec.Meta.License.Text, nuspec.Meta.LicenseURL, nil)) + case "file": + if licenseFile, err := zr.Open(nuspec.Meta.License.Text); err == nil { + defer licenseFile.Close() + if licenseFileData, err := io.ReadAll(licenseFile); err == nil { + licenseFileData = removeBOM(licenseFileData) + if foundLicenses, err := licenses.Parse(bytes.NewBuffer(licenseFileData), file.NewLocation(nuspec.Meta.License.Text)); err == nil { + out = append(out, foundLicenses...) + } + } + } + default: + if nuspec.Meta.LicenseURL != "" { // Legacy + if response, err := http.Get(nuspec.Meta.LicenseURL); err == nil && response.StatusCode == http.StatusOK { + licenseFileData, err := io.ReadAll(response.Body) + response.Body.Close() + if err == nil { + licenseFileData = removeBOM(licenseFileData) + if foundLicenses, err := licenses.Parse(bytes.NewBuffer(licenseFileData), file.Location{}); err == nil { + for _, foundLicense := range foundLicenses { + foundLicense.URLs = append(foundLicense.URLs, nuspec.Meta.LicenseURL) + out = append(out, foundLicense) + } + } + } + } + } else { // Fallback + for _, fileRef := range nuspec.Files.File { + fileName := filepath.Base(fileRef.Source) + if c.lowerLicenseFileNames.Has(strings.ToLower(fileName)) { + if licenseFile, err := zr.Open(fileRef.Source); err == nil { + defer licenseFile.Close() + if licenseFileData, err := io.ReadAll(licenseFile); err == nil { + licenseFileData = removeBOM(licenseFileData) + if foundLicenses, err := licenses.Parse(bytes.NewBuffer(licenseFileData), file.NewLocation(nuspec.Meta.License.Text)); err == nil { + out = append(out, foundLicenses...) + } + } + } + } + } + } + } + } + } + } + } + } + } + } + + if foundPackage { + return nil, errors.New("no license could be found") + } + return nil, errors.New("package could not be found") +} + +func moduleDir(moduleName, moduleVersion string) string { + return strings.ToLower(fmt.Sprintf("%s/%s", moduleName, moduleVersion)) +} + +func moduleSearchGlob(moduleName, moduleVersion string) string { + return fmt.Sprintf("**/%s/*", moduleDir(moduleName, moduleVersion)) +} + +type nugetPackageFolders struct { + PackageFolders map[string]any `json:"packageFolders"` +} + +func getLocalNugetFolderResolvers(resolver file.Resolver) []file.Resolver { + nugetPackagePaths := []string{} + if injectedCachePath := os.Getenv("TEST_PARSE_DOTNET_DEPS_INJECT_CACHE_LOCATION"); injectedCachePath != "" { + nugetPackagePaths = append(nugetPackagePaths, injectedCachePath) + } else { + // Try to determine nuget package folders from temporary object files + if assetFiles, err := resolver.FilesByGlob("**/obj/project.assets.json"); err == nil && len(assetFiles) > 0 { + for _, assetFile := range assetFiles { + if contentReader, err := resolver.FileContentsByLocation(assetFile); err == nil { + if assetFileData, err := io.ReadAll(contentReader); err == nil { + folders := nugetPackageFolders{} + if err = json.Unmarshal(assetFileData, &folders); err == nil { + for folder := range folders.PackageFolders { + found := false + for _, known := range nugetPackagePaths { + if known == folder { + found = true + break + } + } + if !found { + nugetPackagePaths = append(nugetPackagePaths, folder) + } + } + } + } + } + } + } + + // Query nuget itself for its cache locations + ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second) + // cf. https://learn.microsoft.com/en-us/dotnet/core/tools/dotnet-nuget-locals + cmd := exec.CommandContext(ctx, "dotnet", "nuget", "locals", "all", "-l", "--force-english-output") + if stdout, err := cmd.StdoutPipe(); err == nil { + if err := cmd.Start(); err == nil { + if data, err := io.ReadAll(stdout); err == nil { + lines := strings.Split(string(data), "\n") + for _, line := range lines { + line = strings.TrimSpace(line) + if lineParts := strings.Split(line, ": "); len(lineParts) == 2 { + folder := lineParts[1] + found := false + for _, known := range nugetPackagePaths { + if known == folder { + found = true + break + } + } + if !found { + nugetPackagePaths = append(nugetPackagePaths, folder) + } + } + } + } + } + } + cancel() + } + + resolvers := []file.Resolver{} + if len(nugetPackagePaths) > 0 { + for _, nugetPackagePath := range nugetPackagePaths { + resolvers = append(resolvers, fileresolver.NewFromUnindexedDirectory(nugetPackagePath)) + } + } + return resolvers +} From 49ad147f48ff8b27fdfb31b4e822fdadecdf4b39 Mon Sep 17 00:00:00 2001 From: HeyeOpenSource Date: Mon, 14 Oct 2024 11:22:08 +0200 Subject: [PATCH 03/48] - Inject NuGet license parser into DotNet catalogers. Signed-off-by: HeyeOpenSource --- internal/task/package_tasks.go | 13 +- syft/pkg/cataloger/dotnet/cataloger.go | 23 +- syft/pkg/cataloger/dotnet/cataloger_test.go | 4 +- .../pkg/cataloger/dotnet/parse_dotnet_deps.go | 19 +- .../dotnet/parse_dotnet_deps_test.go | 62 +- .../parse_dotnet_portable_executable.go | 12 +- .../parse_dotnet_portable_executable_test.go | 27 +- .../newtonsoft.json/13.0.1/.nupkg.metadata | 5 + .../newtonsoft.json/13.0.1/.signature.p7s | Bin 0 -> 18122 bytes .../newtonsoft.json/13.0.1/LICENSE.md | 20 + .../13.0.1/lib/net20/Newtonsoft.Json.dll | Bin 0 -> 571944 bytes .../13.0.1/lib/net20/Newtonsoft.Json.xml | 10335 ++++++++++++++ .../13.0.1/lib/net35/Newtonsoft.Json.dll | Bin 0 -> 506920 bytes .../13.0.1/lib/net35/Newtonsoft.Json.xml | 9483 +++++++++++++ .../13.0.1/lib/net40/Newtonsoft.Json.dll | Bin 0 -> 576040 bytes .../13.0.1/lib/net40/Newtonsoft.Json.xml | 9683 +++++++++++++ .../13.0.1/lib/net45/Newtonsoft.Json.dll | Bin 0 -> 701992 bytes .../13.0.1/lib/net45/Newtonsoft.Json.xml | 11305 ++++++++++++++++ .../lib/netstandard1.0/Newtonsoft.Json.dll | Bin 0 -> 670760 bytes .../lib/netstandard1.0/Newtonsoft.Json.xml | 10993 +++++++++++++++ .../lib/netstandard1.3/Newtonsoft.Json.dll | Bin 0 -> 689704 bytes .../lib/netstandard1.3/Newtonsoft.Json.xml | 11115 +++++++++++++++ .../lib/netstandard2.0/Newtonsoft.Json.dll | Bin 0 -> 695336 bytes .../lib/netstandard2.0/Newtonsoft.Json.xml | 11280 +++++++++++++++ .../13.0.1/newtonsoft.json.13.0.1.nupkg | Bin 0 -> 2065787 bytes .../newtonsoft.json.13.0.1.nupkg.sha512 | 1 + .../13.0.1/newtonsoft.json.nuspec | 39 + .../newtonsoft.json/13.0.1/packageIcon.png | Bin 0 -> 8956 bytes .../6.0.0/.nupkg.metadata | 5 + .../6.0.0/.signature.p7s | Bin 0 -> 18703 bytes .../6.0.0/Icon.png | Bin 0 -> 7006 bytes .../6.0.0/LICENSE.TXT | 23 + .../6.0.0/THIRD-PARTY-NOTICES.TXT | 939 ++ ...em.Runtime.CompilerServices.Unsafe.targets | 6 + .../6.0.0/buildTransitive/netcoreapp3.1/_._ | 0 ...System.Runtime.CompilerServices.Unsafe.dll | Bin 0 -> 18024 bytes ...System.Runtime.CompilerServices.Unsafe.xml | 291 + ...System.Runtime.CompilerServices.Unsafe.dll | Bin 0 -> 18024 bytes ...System.Runtime.CompilerServices.Unsafe.xml | 291 + ...System.Runtime.CompilerServices.Unsafe.dll | Bin 0 -> 18024 bytes ...System.Runtime.CompilerServices.Unsafe.xml | 291 + ...System.Runtime.CompilerServices.Unsafe.dll | Bin 0 -> 18024 bytes ...System.Runtime.CompilerServices.Unsafe.xml | 291 + ...untime.compilerservices.unsafe.6.0.0.nupkg | Bin 0 -> 84343 bytes ...compilerservices.unsafe.6.0.0.nupkg.sha512 | 1 + ...tem.runtime.compilerservices.unsafe.nuspec | 29 + .../6.0.0/useSharedDesignerContext.txt | 0 47 files changed, 76557 insertions(+), 29 deletions(-) create mode 100644 syft/pkg/cataloger/dotnet/test-fixtures/NuGetCache/newtonsoft.json/13.0.1/.nupkg.metadata create mode 100644 syft/pkg/cataloger/dotnet/test-fixtures/NuGetCache/newtonsoft.json/13.0.1/.signature.p7s create mode 100644 syft/pkg/cataloger/dotnet/test-fixtures/NuGetCache/newtonsoft.json/13.0.1/LICENSE.md create mode 100644 syft/pkg/cataloger/dotnet/test-fixtures/NuGetCache/newtonsoft.json/13.0.1/lib/net20/Newtonsoft.Json.dll create mode 100644 syft/pkg/cataloger/dotnet/test-fixtures/NuGetCache/newtonsoft.json/13.0.1/lib/net20/Newtonsoft.Json.xml create mode 100644 syft/pkg/cataloger/dotnet/test-fixtures/NuGetCache/newtonsoft.json/13.0.1/lib/net35/Newtonsoft.Json.dll create mode 100644 syft/pkg/cataloger/dotnet/test-fixtures/NuGetCache/newtonsoft.json/13.0.1/lib/net35/Newtonsoft.Json.xml create mode 100644 syft/pkg/cataloger/dotnet/test-fixtures/NuGetCache/newtonsoft.json/13.0.1/lib/net40/Newtonsoft.Json.dll create mode 100644 syft/pkg/cataloger/dotnet/test-fixtures/NuGetCache/newtonsoft.json/13.0.1/lib/net40/Newtonsoft.Json.xml create mode 100644 syft/pkg/cataloger/dotnet/test-fixtures/NuGetCache/newtonsoft.json/13.0.1/lib/net45/Newtonsoft.Json.dll create mode 100644 syft/pkg/cataloger/dotnet/test-fixtures/NuGetCache/newtonsoft.json/13.0.1/lib/net45/Newtonsoft.Json.xml create mode 100644 syft/pkg/cataloger/dotnet/test-fixtures/NuGetCache/newtonsoft.json/13.0.1/lib/netstandard1.0/Newtonsoft.Json.dll create mode 100644 syft/pkg/cataloger/dotnet/test-fixtures/NuGetCache/newtonsoft.json/13.0.1/lib/netstandard1.0/Newtonsoft.Json.xml create mode 100644 syft/pkg/cataloger/dotnet/test-fixtures/NuGetCache/newtonsoft.json/13.0.1/lib/netstandard1.3/Newtonsoft.Json.dll create mode 100644 syft/pkg/cataloger/dotnet/test-fixtures/NuGetCache/newtonsoft.json/13.0.1/lib/netstandard1.3/Newtonsoft.Json.xml create mode 100644 syft/pkg/cataloger/dotnet/test-fixtures/NuGetCache/newtonsoft.json/13.0.1/lib/netstandard2.0/Newtonsoft.Json.dll create mode 100644 syft/pkg/cataloger/dotnet/test-fixtures/NuGetCache/newtonsoft.json/13.0.1/lib/netstandard2.0/Newtonsoft.Json.xml create mode 100644 syft/pkg/cataloger/dotnet/test-fixtures/NuGetCache/newtonsoft.json/13.0.1/newtonsoft.json.13.0.1.nupkg create mode 100644 syft/pkg/cataloger/dotnet/test-fixtures/NuGetCache/newtonsoft.json/13.0.1/newtonsoft.json.13.0.1.nupkg.sha512 create mode 100644 syft/pkg/cataloger/dotnet/test-fixtures/NuGetCache/newtonsoft.json/13.0.1/newtonsoft.json.nuspec create mode 100644 syft/pkg/cataloger/dotnet/test-fixtures/NuGetCache/newtonsoft.json/13.0.1/packageIcon.png create mode 100644 syft/pkg/cataloger/dotnet/test-fixtures/NuGetCache/system.runtime.compilerservices.unsafe/6.0.0/.nupkg.metadata create mode 100644 syft/pkg/cataloger/dotnet/test-fixtures/NuGetCache/system.runtime.compilerservices.unsafe/6.0.0/.signature.p7s create mode 100644 syft/pkg/cataloger/dotnet/test-fixtures/NuGetCache/system.runtime.compilerservices.unsafe/6.0.0/Icon.png create mode 100644 syft/pkg/cataloger/dotnet/test-fixtures/NuGetCache/system.runtime.compilerservices.unsafe/6.0.0/LICENSE.TXT create mode 100644 syft/pkg/cataloger/dotnet/test-fixtures/NuGetCache/system.runtime.compilerservices.unsafe/6.0.0/THIRD-PARTY-NOTICES.TXT create mode 100644 syft/pkg/cataloger/dotnet/test-fixtures/NuGetCache/system.runtime.compilerservices.unsafe/6.0.0/buildTransitive/netcoreapp2.0/System.Runtime.CompilerServices.Unsafe.targets create mode 100644 syft/pkg/cataloger/dotnet/test-fixtures/NuGetCache/system.runtime.compilerservices.unsafe/6.0.0/buildTransitive/netcoreapp3.1/_._ create mode 100644 syft/pkg/cataloger/dotnet/test-fixtures/NuGetCache/system.runtime.compilerservices.unsafe/6.0.0/lib/net461/System.Runtime.CompilerServices.Unsafe.dll create mode 100644 syft/pkg/cataloger/dotnet/test-fixtures/NuGetCache/system.runtime.compilerservices.unsafe/6.0.0/lib/net461/System.Runtime.CompilerServices.Unsafe.xml create mode 100644 syft/pkg/cataloger/dotnet/test-fixtures/NuGetCache/system.runtime.compilerservices.unsafe/6.0.0/lib/net6.0/System.Runtime.CompilerServices.Unsafe.dll create mode 100644 syft/pkg/cataloger/dotnet/test-fixtures/NuGetCache/system.runtime.compilerservices.unsafe/6.0.0/lib/net6.0/System.Runtime.CompilerServices.Unsafe.xml create mode 100644 syft/pkg/cataloger/dotnet/test-fixtures/NuGetCache/system.runtime.compilerservices.unsafe/6.0.0/lib/netcoreapp3.1/System.Runtime.CompilerServices.Unsafe.dll create mode 100644 syft/pkg/cataloger/dotnet/test-fixtures/NuGetCache/system.runtime.compilerservices.unsafe/6.0.0/lib/netcoreapp3.1/System.Runtime.CompilerServices.Unsafe.xml create mode 100644 syft/pkg/cataloger/dotnet/test-fixtures/NuGetCache/system.runtime.compilerservices.unsafe/6.0.0/lib/netstandard2.0/System.Runtime.CompilerServices.Unsafe.dll create mode 100644 syft/pkg/cataloger/dotnet/test-fixtures/NuGetCache/system.runtime.compilerservices.unsafe/6.0.0/lib/netstandard2.0/System.Runtime.CompilerServices.Unsafe.xml create mode 100644 syft/pkg/cataloger/dotnet/test-fixtures/NuGetCache/system.runtime.compilerservices.unsafe/6.0.0/system.runtime.compilerservices.unsafe.6.0.0.nupkg create mode 100644 syft/pkg/cataloger/dotnet/test-fixtures/NuGetCache/system.runtime.compilerservices.unsafe/6.0.0/system.runtime.compilerservices.unsafe.6.0.0.nupkg.sha512 create mode 100644 syft/pkg/cataloger/dotnet/test-fixtures/NuGetCache/system.runtime.compilerservices.unsafe/6.0.0/system.runtime.compilerservices.unsafe.nuspec create mode 100644 syft/pkg/cataloger/dotnet/test-fixtures/NuGetCache/system.runtime.compilerservices.unsafe/6.0.0/useSharedDesignerContext.txt diff --git a/internal/task/package_tasks.go b/internal/task/package_tasks.go index ff7f622fb32..4268b5848c5 100644 --- a/internal/task/package_tasks.go +++ b/internal/task/package_tasks.go @@ -73,7 +73,11 @@ func DefaultPackageTaskFactories() PackageTaskFactories { // language-specific package declared catalogers /////////////////////////////////////////////////////////////////////////// newSimplePackageTaskFactory(cpp.NewConanCataloger, pkgcataloging.DeclaredTag, pkgcataloging.DirectoryTag, pkgcataloging.LanguageTag, "cpp", "conan"), newSimplePackageTaskFactory(dart.NewPubspecLockCataloger, pkgcataloging.DeclaredTag, pkgcataloging.DirectoryTag, pkgcataloging.LanguageTag, "dart"), - newSimplePackageTaskFactory(dotnet.NewDotnetDepsCataloger, pkgcataloging.DeclaredTag, pkgcataloging.DirectoryTag, pkgcataloging.LanguageTag, "dotnet", "c#"), + newPackageTaskFactory( + func(cfg CatalogingFactoryConfig) pkg.Cataloger { + return dotnet.NewDotnetDepsCataloger(cfg.PackagesConfig.DotNet) + }, + pkgcataloging.DeclaredTag, pkgcataloging.DirectoryTag, pkgcataloging.LanguageTag, "dotnet", "c#"), newSimplePackageTaskFactory(elixir.NewMixLockCataloger, pkgcataloging.DeclaredTag, pkgcataloging.DirectoryTag, pkgcataloging.LanguageTag, "elixir"), newSimplePackageTaskFactory(erlang.NewRebarLockCataloger, pkgcataloging.DeclaredTag, pkgcataloging.DirectoryTag, pkgcataloging.LanguageTag, "erlang"), newSimplePackageTaskFactory(erlang.NewOTPCataloger, pkgcataloging.DeclaredTag, pkgcataloging.DirectoryTag, pkgcataloging.LanguageTag, "erlang", "otp"), @@ -114,7 +118,12 @@ func DefaultPackageTaskFactories() PackageTaskFactories { newSimplePackageTaskFactory(ocaml.NewOpamPackageManagerCataloger, pkgcataloging.DeclaredTag, pkgcataloging.DirectoryTag, pkgcataloging.LanguageTag, "ocaml", "opam"), // language-specific package for both image and directory scans (but not necessarily declared) //////////////////////////////////////// - newSimplePackageTaskFactory(dotnet.NewDotnetPortableExecutableCataloger, pkgcataloging.DirectoryTag, pkgcataloging.InstalledTag, pkgcataloging.ImageTag, pkgcataloging.LanguageTag, "dotnet", "c#", "binary"), + newPackageTaskFactory( + func(cfg CatalogingFactoryConfig) pkg.Cataloger { + return dotnet.NewDotnetPortableExecutableCataloger(cfg.PackagesConfig.DotNet) + }, + pkgcataloging.DirectoryTag, pkgcataloging.InstalledTag, pkgcataloging.ImageTag, pkgcataloging.LanguageTag, "dotnet", "c#", "binary", + ), newSimplePackageTaskFactory(python.NewInstalledPackageCataloger, pkgcataloging.DirectoryTag, pkgcataloging.InstalledTag, pkgcataloging.ImageTag, pkgcataloging.LanguageTag, "python"), newPackageTaskFactory( func(cfg CatalogingFactoryConfig) pkg.Cataloger { diff --git a/syft/pkg/cataloger/dotnet/cataloger.go b/syft/pkg/cataloger/dotnet/cataloger.go index 74ad55cfb99..b5671bef01e 100644 --- a/syft/pkg/cataloger/dotnet/cataloger.go +++ b/syft/pkg/cataloger/dotnet/cataloger.go @@ -8,14 +8,25 @@ import ( "github.com/anchore/syft/syft/pkg/cataloger/generic" ) +const ( + dotnetDepsCatalogerName = "dotnet-deps-cataloger" + dotnetPortableExecutableCatalogerName = "dotnet-portable-executable-cataloger" +) + // NewDotnetDepsCataloger returns a new Dotnet cataloger object base on deps json files. -func NewDotnetDepsCataloger() pkg.Cataloger { - return generic.NewCataloger("dotnet-deps-cataloger"). - WithParserByGlobs(parseDotnetDeps, "**/*.deps.json") +func NewDotnetDepsCataloger(opts CatalogerConfig) pkg.Cataloger { + c := dotnetDepsCataloger{ + licenses: newNugetLicenses(opts), + } + return generic.NewCataloger(dotnetDepsCatalogerName). + WithParserByGlobs(c.parseDotnetDeps, "**/*.deps.json") } // NewDotnetPortableExecutableCataloger returns a new Dotnet cataloger object base on portable executable files. -func NewDotnetPortableExecutableCataloger() pkg.Cataloger { - return generic.NewCataloger("dotnet-portable-executable-cataloger"). - WithParserByGlobs(parseDotnetPortableExecutable, "**/*.dll", "**/*.exe") +func NewDotnetPortableExecutableCataloger(opts CatalogerConfig) pkg.Cataloger { + c := dotnetPortableExecutableCataloger{ + licenses: newNugetLicenses(opts), + } + return generic.NewCataloger(dotnetPortableExecutableCatalogerName). + WithParserByGlobs(c.parseDotnetPortableExecutable, "**/*.dll", "**/*.exe") } diff --git a/syft/pkg/cataloger/dotnet/cataloger_test.go b/syft/pkg/cataloger/dotnet/cataloger_test.go index 7817d23152a..2a167c787b9 100644 --- a/syft/pkg/cataloger/dotnet/cataloger_test.go +++ b/syft/pkg/cataloger/dotnet/cataloger_test.go @@ -17,7 +17,7 @@ func TestCataloger_Globs(t *testing.T) { { name: "obtain deps.json files", fixture: "test-fixtures/glob-paths", - cataloger: NewDotnetDepsCataloger(), + cataloger: NewDotnetDepsCataloger(DefaultCatalogerConfig()), expected: []string{ "src/something.deps.json", }, @@ -25,7 +25,7 @@ func TestCataloger_Globs(t *testing.T) { { name: "obtain portable executable files", fixture: "test-fixtures/glob-paths", - cataloger: NewDotnetPortableExecutableCataloger(), + cataloger: NewDotnetPortableExecutableCataloger(DefaultCatalogerConfig()), expected: []string{ "src/something.dll", "src/something.exe", diff --git a/syft/pkg/cataloger/dotnet/parse_dotnet_deps.go b/syft/pkg/cataloger/dotnet/parse_dotnet_deps.go index 2d980ca4ef3..34e8fff30f3 100644 --- a/syft/pkg/cataloger/dotnet/parse_dotnet_deps.go +++ b/syft/pkg/cataloger/dotnet/parse_dotnet_deps.go @@ -15,7 +15,9 @@ import ( "github.com/anchore/syft/syft/pkg/cataloger/generic" ) -var _ generic.Parser = parseDotnetDeps +type dotnetDepsCataloger struct { + licenses nugetLicenses +} type dotnetDeps struct { RuntimeTarget dotnetRuntimeTarget `json:"runtimeTarget"` @@ -40,7 +42,7 @@ type dotnetDepsLibrary struct { } //nolint:funlen -func parseDotnetDeps(_ context.Context, _ file.Resolver, _ *generic.Environment, reader file.LocationReadCloser) ([]pkg.Package, []artifact.Relationship, error) { +func (c *dotnetDepsCataloger) parseDotnetDeps(_ context.Context, resolver file.Resolver, _ *generic.Environment, reader file.LocationReadCloser) ([]pkg.Package, []artifact.Relationship, error) { var pkgs []pkg.Package var pkgMap = make(map[string]pkg.Package) var relationships []artifact.Relationship @@ -65,6 +67,8 @@ func parseDotnetDeps(_ context.Context, _ file.Resolver, _ *generic.Environment, lib, reader.Location.WithAnnotation(pkg.EvidenceAnnotationKey, pkg.PrimaryEvidenceAnnotation), ) + rootPkg.FoundBy = dotnetDepsCatalogerName + break } } if rootPkg == nil { @@ -94,10 +98,15 @@ func parseDotnetDeps(_ context.Context, _ file.Resolver, _ *generic.Environment, reader.Location.WithAnnotation(pkg.EvidenceAnnotationKey, pkg.PrimaryEvidenceAnnotation), ) - if dotnetPkg != nil { - pkgs = append(pkgs, *dotnetPkg) - pkgMap[nameVersion] = *dotnetPkg + dotnetPkg.FoundBy = dotnetDepsCatalogerName + + // Try to resolve *.nupkg License + if licenses, err := c.licenses.getLicenses(name, version, resolver); err == nil && len(licenses) > 0 { + dotnetPkg.Licenses = pkg.NewLicenseSet(licenses...) } + + pkgs = append(pkgs, *dotnetPkg) + pkgMap[nameVersion] = *dotnetPkg } for pkgNameVersion, target := range depsDoc.Targets[depsDoc.RuntimeTarget.Name] { diff --git a/syft/pkg/cataloger/dotnet/parse_dotnet_deps_test.go b/syft/pkg/cataloger/dotnet/parse_dotnet_deps_test.go index 84878c86c1c..41f37aa9fd8 100644 --- a/syft/pkg/cataloger/dotnet/parse_dotnet_deps_test.go +++ b/syft/pkg/cataloger/dotnet/parse_dotnet_deps_test.go @@ -1,27 +1,38 @@ package dotnet import ( + "os" "testing" "github.com/anchore/syft/syft/artifact" "github.com/anchore/syft/syft/file" + "github.com/anchore/syft/syft/license" "github.com/anchore/syft/syft/pkg" "github.com/anchore/syft/syft/pkg/cataloger/internal/pkgtest" + "github.com/anchore/syft/syft/source" + "github.com/anchore/syft/syft/source/directorysource" ) func Test_corruptDotnetDeps(t *testing.T) { + cataloger := dotnetDepsCataloger{ + licenses: newNugetLicenses(DefaultCatalogerConfig()), + } pkgtest.NewCatalogTester(). FromFile(t, "test-fixtures/glob-paths/src/something.deps.json"). WithError(). - TestParser(t, parseDotnetDeps) + TestParser(t, cataloger.parseDotnetDeps) } func TestParseDotnetDeps(t *testing.T) { fixture := "test-fixtures/TestLibrary.deps.json" - fixtureLocationSet := file.NewLocationSet(file.NewLocation(fixture)) + s, _ := directorysource.NewFromPath("test-fixtures") + resolver, _ := s.FileResolver(source.AllLayersScope) + fixtureLocations, _ := resolver.FilesByGlob("**/TestLibrary.deps.json") + fixtureLocationSet := file.NewLocationSet(fixtureLocations...) rootPkg := pkg.Package{ Name: "TestLibrary", Version: "1.0.0", + FoundBy: dotnetDepsCatalogerName, PURL: "pkg:nuget/TestLibrary@1.0.0", Locations: fixtureLocationSet, Language: pkg.Dotnet, @@ -34,6 +45,7 @@ func TestParseDotnetDeps(t *testing.T) { testCommon := pkg.Package{ Name: "TestCommon", Version: "1.0.0", + FoundBy: dotnetDepsCatalogerName, PURL: "pkg:nuget/TestCommon@1.0.0", Locations: fixtureLocationSet, Language: pkg.Dotnet, @@ -46,6 +58,7 @@ func TestParseDotnetDeps(t *testing.T) { awssdkcore := pkg.Package{ Name: "AWSSDK.Core", Version: "3.7.10.6", + FoundBy: dotnetDepsCatalogerName, PURL: "pkg:nuget/AWSSDK.Core@3.7.10.6", Locations: fixtureLocationSet, Language: pkg.Dotnet, @@ -61,6 +74,7 @@ func TestParseDotnetDeps(t *testing.T) { msftDependencyInjectionAbstractions := pkg.Package{ Name: "Microsoft.Extensions.DependencyInjection.Abstractions", Version: "6.0.0", + FoundBy: dotnetDepsCatalogerName, PURL: "pkg:nuget/Microsoft.Extensions.DependencyInjection.Abstractions@6.0.0", Locations: fixtureLocationSet, Language: pkg.Dotnet, @@ -76,6 +90,7 @@ func TestParseDotnetDeps(t *testing.T) { msftDependencyInjection := pkg.Package{ Name: "Microsoft.Extensions.DependencyInjection", Version: "6.0.0", + FoundBy: dotnetDepsCatalogerName, PURL: "pkg:nuget/Microsoft.Extensions.DependencyInjection@6.0.0", Locations: fixtureLocationSet, Language: pkg.Dotnet, @@ -91,6 +106,7 @@ func TestParseDotnetDeps(t *testing.T) { msftLoggingAbstractions := pkg.Package{ Name: "Microsoft.Extensions.Logging.Abstractions", Version: "6.0.0", + FoundBy: dotnetDepsCatalogerName, PURL: "pkg:nuget/Microsoft.Extensions.Logging.Abstractions@6.0.0", Locations: fixtureLocationSet, Language: pkg.Dotnet, @@ -106,6 +122,7 @@ func TestParseDotnetDeps(t *testing.T) { msftExtensionsLogging := pkg.Package{ Name: "Microsoft.Extensions.Logging", Version: "6.0.0", + FoundBy: dotnetDepsCatalogerName, PURL: "pkg:nuget/Microsoft.Extensions.Logging@6.0.0", Locations: fixtureLocationSet, Language: pkg.Dotnet, @@ -121,6 +138,7 @@ func TestParseDotnetDeps(t *testing.T) { msftExtensionsOptions := pkg.Package{ Name: "Microsoft.Extensions.Options", Version: "6.0.0", + FoundBy: dotnetDepsCatalogerName, PURL: "pkg:nuget/Microsoft.Extensions.Options@6.0.0", Locations: fixtureLocationSet, Language: pkg.Dotnet, @@ -136,6 +154,7 @@ func TestParseDotnetDeps(t *testing.T) { msftExtensionsPrimitives := pkg.Package{ Name: "Microsoft.Extensions.Primitives", Version: "6.0.0", + FoundBy: dotnetDepsCatalogerName, PURL: "pkg:nuget/Microsoft.Extensions.Primitives@6.0.0", Locations: fixtureLocationSet, Language: pkg.Dotnet, @@ -151,10 +170,17 @@ func TestParseDotnetDeps(t *testing.T) { newtonsoftJson := pkg.Package{ Name: "Newtonsoft.Json", Version: "13.0.1", + FoundBy: dotnetDepsCatalogerName, PURL: "pkg:nuget/Newtonsoft.Json@13.0.1", Locations: fixtureLocationSet, - Language: pkg.Dotnet, - Type: pkg.DotnetPkg, + Licenses: pkg.NewLicenseSet(pkg.License{ + Value: "MIT", + SPDXExpression: "MIT", + Type: license.Concluded, + Locations: file.NewLocationSet(file.NewLocation("newtonsoft.json/13.0.1/LICENSE.md")), + }), + Language: pkg.Dotnet, + Type: pkg.DotnetPkg, Metadata: pkg.DotnetDepsEntry{ Name: "Newtonsoft.Json", Version: "13.0.1", @@ -166,6 +192,7 @@ func TestParseDotnetDeps(t *testing.T) { serilogSinksConsole := pkg.Package{ Name: "Serilog.Sinks.Console", Version: "4.0.1", + FoundBy: dotnetDepsCatalogerName, PURL: "pkg:nuget/Serilog.Sinks.Console@4.0.1", Locations: fixtureLocationSet, Language: pkg.Dotnet, @@ -181,6 +208,7 @@ func TestParseDotnetDeps(t *testing.T) { serilog := pkg.Package{ Name: "Serilog", Version: "2.10.0", + FoundBy: dotnetDepsCatalogerName, PURL: "pkg:nuget/Serilog@2.10.0", Locations: fixtureLocationSet, Language: pkg.Dotnet, @@ -196,6 +224,7 @@ func TestParseDotnetDeps(t *testing.T) { systemDiagnosticsDiagnosticsource := pkg.Package{ Name: "System.Diagnostics.DiagnosticSource", Version: "6.0.0", + FoundBy: dotnetDepsCatalogerName, PURL: "pkg:nuget/System.Diagnostics.DiagnosticSource@6.0.0", Locations: fixtureLocationSet, Language: pkg.Dotnet, @@ -211,17 +240,25 @@ func TestParseDotnetDeps(t *testing.T) { systemRuntimeCompilerServicesUnsafe := pkg.Package{ Name: "System.Runtime.CompilerServices.Unsafe", Version: "6.0.0", + FoundBy: dotnetDepsCatalogerName, PURL: "pkg:nuget/System.Runtime.CompilerServices.Unsafe@6.0.0", Locations: fixtureLocationSet, - Language: pkg.Dotnet, - Type: pkg.DotnetPkg, + Licenses: pkg.NewLicenseSet(pkg.License{ + Value: "MIT", + SPDXExpression: "MIT", + Type: license.Concluded, + Locations: file.NewLocationSet(file.NewLocation("system.runtime.compilerservices.unsafe/6.0.0/LICENSE.TXT")), + }), + Language: pkg.Dotnet, + Type: pkg.DotnetPkg, Metadata: pkg.DotnetDepsEntry{ Name: "System.Runtime.CompilerServices.Unsafe", Version: "6.0.0", Sha512: "sha512-/iUeP3tq1S0XdNNoMz5C9twLSrM/TH+qElHkXWaPvuNOt+99G75NrV0OS2EqHx5wMN7popYjpc8oTjC1y16DLg==", Path: "system.runtime.compilerservices.unsafe/6.0.0", HashPath: "system.runtime.compilerservices.unsafe.6.0.0.nupkg.sha512", - }} + }, + } expectedPkgs := []pkg.Package{ awssdkcore, @@ -362,5 +399,14 @@ func TestParseDotnetDeps(t *testing.T) { }, } - pkgtest.TestFileParser(t, fixture, parseDotnetDeps, expectedPkgs, expectedRelationships) + t.Run(fixture, func(t *testing.T) { + os.Setenv("TEST_PARSE_DOTNET_DEPS_INJECT_CACHE_LOCATION", "test-fixtures/NuGetCache") + defer os.Setenv("TEST_PARSE_DOTNET_DEPS_INJECT_CACHE_LOCATION", "") + pkgtest.NewCatalogTester(). + FromDirectory(t, "test-fixtures"). + Expects(expectedPkgs, expectedRelationships). + TestCataloger(t, NewDotnetDepsCataloger(CatalogerConfig{ + SearchLocalLicenses: true, + })) + }) } diff --git a/syft/pkg/cataloger/dotnet/parse_dotnet_portable_executable.go b/syft/pkg/cataloger/dotnet/parse_dotnet_portable_executable.go index 4ea4d1c18d7..c4be93b5553 100644 --- a/syft/pkg/cataloger/dotnet/parse_dotnet_portable_executable.go +++ b/syft/pkg/cataloger/dotnet/parse_dotnet_portable_executable.go @@ -18,9 +18,11 @@ import ( "github.com/anchore/syft/syft/pkg/cataloger/generic" ) -var _ generic.Parser = parseDotnetPortableExecutable +type dotnetPortableExecutableCataloger struct { + licenses nugetLicenses +} -func parseDotnetPortableExecutable(_ context.Context, _ file.Resolver, _ *generic.Environment, f file.LocationReadCloser) ([]pkg.Package, []artifact.Relationship, error) { +func (c *dotnetPortableExecutableCataloger) parseDotnetPortableExecutable(_ context.Context, resolver file.Resolver, _ *generic.Environment, f file.LocationReadCloser) ([]pkg.Package, []artifact.Relationship, error) { by, err := io.ReadAll(f) if err != nil { return nil, nil, fmt.Errorf("unable to read file: %w", err) @@ -50,6 +52,11 @@ func parseDotnetPortableExecutable(_ context.Context, _ file.Resolver, _ *generi return nil, nil, err } + // Try to resolve *.nupkg License + if licenses, err := c.licenses.getLicenses(dotNetPkg.Name, dotNetPkg.Version, resolver); err == nil && len(licenses) > 0 { + dotNetPkg.Licenses = pkg.NewLicenseSet(licenses...) + } + return []pkg.Package{dotNetPkg}, nil, nil } @@ -77,6 +84,7 @@ func buildDotNetPackage(versionResources map[string]string, f file.LocationReadC dnpkg = pkg.Package{ Name: name, Version: version, + FoundBy: dotnetPortableExecutableCatalogerName, Locations: file.NewLocationSet(f.Location.WithAnnotation(pkg.EvidenceAnnotationKey, pkg.PrimaryEvidenceAnnotation)), Type: pkg.DotnetPkg, Language: pkg.Dotnet, diff --git a/syft/pkg/cataloger/dotnet/parse_dotnet_portable_executable_test.go b/syft/pkg/cataloger/dotnet/parse_dotnet_portable_executable_test.go index 2be417d6a8e..0eb9d8393d3 100644 --- a/syft/pkg/cataloger/dotnet/parse_dotnet_portable_executable_test.go +++ b/syft/pkg/cataloger/dotnet/parse_dotnet_portable_executable_test.go @@ -34,6 +34,7 @@ func TestParseDotnetPortableExecutable(t *testing.T) { expectedPackage: pkg.Package{ Name: "Active Directory Authentication Library", Version: "3.14.40721.0918", + FoundBy: dotnetPortableExecutableCatalogerName, Metadata: pkg.DotnetPortableExecutableEntry{ AssemblyVersion: "3.14.2.11", LegalCopyright: "Copyright (c) Microsoft Corporation. All rights reserved.", @@ -48,17 +49,18 @@ func TestParseDotnetPortableExecutable(t *testing.T) { name: "dotnet package with malformed field and extended version", versionResources: map[string]string{ "CompanyName": "Microsoft Corporation", - "FileDescription": "äbFile\xa0\xa1Versi on", + "FileDescription": "äb\x01File\xa0\xa1Versi on", "FileVersion": "4.6.25512.01 built by: dlab-DDVSOWINAGE016. Commit Hash: d0d5c7b49271cadb6d97de26d8e623e98abdc8db", - "InternalName": "äbFileVersion", + "InternalName": "äb\x01FileVersion", "LegalCopyright": "© Microsoft Corporation. All rights reserved.", - "OriginalFilename": "TProductName", + "OriginalFilename": "T\x1a\x01ProductName", "ProductName": "Microsoft® .NET Framework", "ProductVersion": "4.6.25512.01 built by: dlab-DDVSOWINAGE016. Commit Hash: d0d5c7b49271cadb6d97de26d8e623e98abdc8db", }, expectedPackage: pkg.Package{ Name: "äbFileVersi on", Version: "4.6.25512.01", + FoundBy: dotnetPortableExecutableCatalogerName, PURL: "pkg:nuget/%C3%A4bFileVersi%20on@4.6.25512.01", Metadata: pkg.DotnetPortableExecutableEntry{ LegalCopyright: "© Microsoft Corporation. All rights reserved.", @@ -84,6 +86,7 @@ func TestParseDotnetPortableExecutable(t *testing.T) { expectedPackage: pkg.Package{ Name: "System.Data.Linq.dll", Version: "4.7.3190.0", + FoundBy: dotnetPortableExecutableCatalogerName, }, }, { @@ -101,6 +104,7 @@ func TestParseDotnetPortableExecutable(t *testing.T) { expectedPackage: pkg.Package{ Name: "The curl executable", Version: "8.4.0", + FoundBy: dotnetPortableExecutableCatalogerName, }, }, { @@ -118,6 +122,7 @@ func TestParseDotnetPortableExecutable(t *testing.T) { expectedPackage: pkg.Package{ Name: "Prometheus.AspNetCore.dll", Version: "8.0.1", + FoundBy: dotnetPortableExecutableCatalogerName, }, }, { @@ -134,6 +139,7 @@ func TestParseDotnetPortableExecutable(t *testing.T) { expectedPackage: pkg.Package{ Name: "Hidden Input", Version: "1, 0, 0, 0", + FoundBy: dotnetPortableExecutableCatalogerName, }, }, { @@ -150,6 +156,7 @@ func TestParseDotnetPortableExecutable(t *testing.T) { expectedPackage: pkg.Package{ Name: "SQLite", Version: "3.23.2", + FoundBy: dotnetPortableExecutableCatalogerName, }, }, { @@ -167,6 +174,7 @@ func TestParseDotnetPortableExecutable(t *testing.T) { expectedPackage: pkg.Package{ Name: "Brave Browser", Version: "80.1.7.92", + FoundBy: dotnetPortableExecutableCatalogerName, }, }, { @@ -179,6 +187,7 @@ func TestParseDotnetPortableExecutable(t *testing.T) { expectedPackage: pkg.Package{ Name: "Better version", Version: "80.1.7.92", + FoundBy: dotnetPortableExecutableCatalogerName, }, }, { @@ -191,6 +200,7 @@ func TestParseDotnetPortableExecutable(t *testing.T) { expectedPackage: pkg.Package{ Name: "Better version", Version: "80.1.7.92", + FoundBy: dotnetPortableExecutableCatalogerName, }, }, { @@ -203,6 +213,7 @@ func TestParseDotnetPortableExecutable(t *testing.T) { expectedPackage: pkg.Package{ Name: "Higher semantic version Product Version", Version: "3.0.1+b86b61bf676163639795b163d8d753b20aad6207", + FoundBy: dotnetPortableExecutableCatalogerName, }, }, { @@ -215,6 +226,7 @@ func TestParseDotnetPortableExecutable(t *testing.T) { expectedPackage: pkg.Package{ Name: "Higher semantic version File Version", Version: "3.0.1+b86b61bf676163639795b163d8d753b20aad6207", + FoundBy: dotnetPortableExecutableCatalogerName, }, }, { @@ -227,6 +239,7 @@ func TestParseDotnetPortableExecutable(t *testing.T) { expectedPackage: pkg.Package{ Name: "Invalid semantic version File Version", Version: "3.0.1+b86b61bf676163639795b163d8d753b20aad6207", + FoundBy: dotnetPortableExecutableCatalogerName, }, }, { @@ -239,6 +252,7 @@ func TestParseDotnetPortableExecutable(t *testing.T) { expectedPackage: pkg.Package{ Name: "Invalid semantic version File Version", Version: "3.0.1+b86b61bf676163639795b163d8d753b20aad6207", + FoundBy: dotnetPortableExecutableCatalogerName, }, }, { @@ -251,6 +265,7 @@ func TestParseDotnetPortableExecutable(t *testing.T) { expectedPackage: pkg.Package{ Name: "Invalid semantic version Product Version", Version: "3.0.1+b86b61bf676163639795b163d8d753b20aad6207", + FoundBy: dotnetPortableExecutableCatalogerName, }, }, { @@ -263,6 +278,7 @@ func TestParseDotnetPortableExecutable(t *testing.T) { expectedPackage: pkg.Package{ Name: "Semantically equal falls through, chooses File Version with more components", Version: "3.0.0.0", + FoundBy: dotnetPortableExecutableCatalogerName, }, }, } @@ -298,10 +314,13 @@ func TestParseDotnetPortableExecutable(t *testing.T) { } func Test_corruptDotnetPE(t *testing.T) { + cataloger := dotnetPortableExecutableCataloger{ + licenses: newNugetLicenses(DefaultCatalogerConfig()), + } pkgtest.NewCatalogTester(). FromFile(t, "test-fixtures/glob-paths/src/something.exe"). WithError(). - TestParser(t, parseDotnetPortableExecutable) + TestParser(t, cataloger.parseDotnetPortableExecutable) } func Test_extractVersion(t *testing.T) { diff --git a/syft/pkg/cataloger/dotnet/test-fixtures/NuGetCache/newtonsoft.json/13.0.1/.nupkg.metadata b/syft/pkg/cataloger/dotnet/test-fixtures/NuGetCache/newtonsoft.json/13.0.1/.nupkg.metadata new file mode 100644 index 00000000000..66fb2442c84 --- /dev/null +++ b/syft/pkg/cataloger/dotnet/test-fixtures/NuGetCache/newtonsoft.json/13.0.1/.nupkg.metadata @@ -0,0 +1,5 @@ +{ + "version": 2, + "contentHash": "ppPFpBcvxdsfUonNcvITKqLl3bqxWbDCZIzDWHzjpdAHRFfZe0Dw9HmA0+za13IdyrgJwpkDTDA9fHaxOrt20A==", + "source": "https://api.nuget.org/v3/index.json" +} \ No newline at end of file diff --git a/syft/pkg/cataloger/dotnet/test-fixtures/NuGetCache/newtonsoft.json/13.0.1/.signature.p7s b/syft/pkg/cataloger/dotnet/test-fixtures/NuGetCache/newtonsoft.json/13.0.1/.signature.p7s new file mode 100644 index 0000000000000000000000000000000000000000..988b1e193fae0469b73ff09d36ab594315c74f8d GIT binary patch literal 18122 zcmeHuXIN8PyDbSJ^d`NB-eD#5qV&E2>4G4HD!q3F6Dd*@P!JTAE(i$HMG#b)2#TnH z3W!ueRFqy6&kBNq+wa@%d!Dnu=iYn#gKMohXJ%IBJLY)DJ0^hDY=;vI#c0Q@kV6Qe z*;vgw0IOLAh2SH}0a7@zU5qxw2_FW90FFPJL9#7iX68HiWeU( zA>;%O*^#ZDczKO34TV;$sSt>Yj~~h+Av?(smXur?|0dML8W|RlL|_bbPY!uX8e7CG~rG#qRN$WU2NLvsgq<&!i{GeVt>-3<(de znb^lDtK3^OSnBt343{s+`{hin=fCJF!?aijX| zRr9LbmFe$`3qRJi6)C0BKmM9?ewN6VG1w4_55a@vIRI#Y0{l_gC?SxqFc`RyVgO3q zH4W~X0Kfb3j(4Y8qgT3nz z{23s4xfG2fWA8tX`}v1CrZ%tmIX_2Ds0P}X#m>(6y?A9_mDT--R-m3d-OhU7ABQHM z?mwxcaVTBNmAOdkt$BNB$-d_!MR-Gh0b4G|Trsr0KYl@IoD*l&5VRq*mu}7K9+PWIylS?%K$EpS)w**By_}VnkDC zRqNIh*@x{vH63)R^SHh6iNl>tnvgzH=Ge8vo?)N%Y1*9};DVyf29*IpItSnq7 z(Gbu5I1h$y8yLFRw?h|NYR%_Hs+^fb8aiL5$s4?T<>Eruo*dFICbd zmxT3(t?O0giq^Wyq{kWg*HkR!pAMz=D-H(8=IeIr^I}(Y3rzOOept})^i7Fys4cl_ z+mau(YG`lNwA%J=Q10@o24Jb+>3{jYu+7RJaVB(6JbmgI7bX<6bf8TJ(uc*|3_3L}WZfgjTqyN1e&@PVbs_T)NQz`jNF47qJKLm1 z-Ob@;kF{YwNQ&6ktXOXEBFPHZOz!(vLb!x|)W*%UkZ7j4 zLv7LG2EcMQlAinin=vPPiLPd5mhAnj4~`@t6YPlMM9JXR#&xZ0BpJPQwpsg{j!8Sn z-d4|#oZu5CX-#(}pGh3MLuGOEe$c)Yvw3aT=Z!+p!<6dJ5XiyBTRwa?$#z#7^%#i7 ztGn3Mj&>6A-+f}e@|Lsy=)OyemzuA9K4G2d@bH~hF)zPMw#)(^_PFW5wbdChn!Mm? z4qX5XO96v9bUTmXFuV5d!#U}=0+M{|;UcOaAgCjuEM3rM15kSIx{lpMGfqjp~c zR(oLuL~tBPkkC+y8EBXyG`$189MJ(Fbpdy8@o(@U@Y55-K|gOdCx-xkgqpXb6T-yR z#mm*p1xEw^Ds1nPl#k|05}mHLnG({Mc7BlPp+m$%dvO`SaJ?M_vd6#Qi$Ah8VIKniBCkl^T+Y#A}@1t zf5=cG{Tg?9J8ZEKCGbrt?Al_xtk0F5%G^}*Ha}<#^$hu3I$B}%*OB@29*(1SY`ics zfCNq?3|6to7{;Rk0Y38L;@%Ga zK6{uTpobfY1EvnB0?OG3vK3?Gx0^cnc}VPOD!#Md;I^CZyN!l9jxDOGh=J{a{kXvp zFlj&%K*3?)fAIhzKwxJcPzXIMZg78aB0n=yakYacKSkIUyQtD^&0ly+a?8(z;Hgm_ zX@E2TvU2uyvk#3tMKg>;$&(wiOAOc&I<$md3ybqTrNZdCXFBXPrPDI3wZpWF-3sD- zjWE)Hh|jGy$?Pxn--y^dumd5Y#`VFiYIXEeZ`5>1s0}+{Jj2m!A)knquL6d^*FJE zaQ5PUheK-plh^6sd>)!ShQ_yRCp&83$UbJOz*=m-sl1XQDZIGp9rlX=SXsu|y+eOJn+Wj7`O@m1RCiX9?c}r9QbO zk0NJ|b)C(bR6w%!yqzbRuxQY&nF*K@-t_2-2#}K|PoA5oG04C6){UejYN6D{pr&;t zu@}M1Jxk92w%oRCd$^G7_Ubo5uel66($ z+83q~-gCX*$ORVi5JaiYUjoQ)Ay4Q|G=nJP3Aq0z%Bb!10-!N6I{<^mrKA48#+dDF zR7d?gx�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 YI%F^9@W*K@&Ysvg_fyCI26#mL4~=*YV*mgE literal 0 HcmV?d00001 diff --git a/syft/pkg/cataloger/dotnet/test-fixtures/NuGetCache/newtonsoft.json/13.0.1/lib/net20/Newtonsoft.Json.xml b/syft/pkg/cataloger/dotnet/test-fixtures/NuGetCache/newtonsoft.json/13.0.1/lib/net20/Newtonsoft.Json.xml new file mode 100644 index 00000000000..181504fb3ef --- /dev/null +++ b/syft/pkg/cataloger/dotnet/test-fixtures/NuGetCache/newtonsoft.json/13.0.1/lib/net20/Newtonsoft.Json.xml @@ -0,0 +1,10335 @@ + + + + Newtonsoft.Json + + + + + Represents a BSON Oid (object id). + + + + + Gets or sets the value of the Oid. + + The value of the Oid. + + + + Initializes a new instance of the class. + + The Oid value. + + + + Represents a reader that provides fast, non-cached, forward-only access to serialized BSON data. + + + + + Gets or sets a value indicating whether binary data reading should be compatible with incorrect Json.NET 3.5 written binary. + + + true if binary data reading will be compatible with incorrect Json.NET 3.5 written binary; otherwise, false. + + + + + Gets or sets a value indicating whether the root object will be read as a JSON array. + + + true if the root object will be read as a JSON array; otherwise, false. + + + + + Gets or sets the used when reading values from BSON. + + The used when reading values from BSON. + + + + Initializes a new instance of the class. + + The containing the BSON data to read. + + + + Initializes a new instance of the class. + + The containing the BSON data to read. + + + + Initializes a new instance of the class. + + The containing the BSON data to read. + if set to true the root object will be read as a JSON array. + The used when reading values from BSON. + + + + Initializes a new instance of the class. + + The containing the BSON data to read. + if set to true the root object will be read as a JSON array. + The used when reading values from BSON. + + + + Reads the next JSON token from the underlying . + + + true if the next token was read successfully; false if there are no more tokens to read. + + + + + Changes the reader's state to . + If is set to true, the underlying is also closed. + + + + + Represents a writer that provides a fast, non-cached, forward-only way of generating BSON data. + + + + + Gets or sets the used when writing values to BSON. + When set to no conversion will occur. + + The used when writing values to BSON. + + + + Initializes a new instance of the class. + + The to write to. + + + + Initializes a new instance of the class. + + The to write to. + + + + Flushes whatever is in the buffer to the underlying and also flushes the underlying stream. + + + + + Writes the end. + + The token. + + + + Writes a comment /*...*/ containing the specified text. + + Text to place inside the comment. + + + + Writes the start of a constructor with the given name. + + The name of the constructor. + + + + Writes raw JSON. + + The raw JSON to write. + + + + Writes raw JSON where a value is expected and updates the writer's state. + + The raw JSON to write. + + + + Writes the beginning of a JSON array. + + + + + Writes the beginning of a JSON object. + + + + + Writes the property name of a name/value pair on a JSON object. + + The name of the property. + + + + Closes this writer. + If is set to true, the underlying is also closed. + If is set to true, the JSON is auto-completed. + + + + + Writes a value. + An error will raised if the value cannot be written as a single JSON token. + + The value to write. + + + + Writes a null value. + + + + + Writes an undefined value. + + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a [] value. + + The [] value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a [] value that represents a BSON object id. + + The Object ID value to write. + + + + Writes a BSON regex. + + The regex pattern. + The regex options. + + + + Specifies how constructors are used when initializing objects during deserialization by the . + + + + + First attempt to use the public default constructor, then fall back to a single parameterized constructor, then to the non-public default constructor. + + + + + Json.NET will use a non-public default constructor before falling back to a parameterized constructor. + + + + + Converts a binary value to and from a base 64 string value. + + + + + Writes the JSON representation of the object. + + The to write to. + The value. + The calling serializer. + + + + Reads the JSON representation of the object. + + The to read from. + Type of the object. + The existing value of object being read. + The calling serializer. + The object value. + + + + Determines whether this instance can convert the specified object type. + + Type of the object. + + true if this instance can convert the specified object type; otherwise, false. + + + + + Converts a to and from JSON and BSON. + + + + + Writes the JSON representation of the object. + + The to write to. + The value. + The calling serializer. + + + + Reads the JSON representation of the object. + + The to read from. + Type of the object. + The existing value of object being read. + The calling serializer. + The object value. + + + + Determines whether this instance can convert the specified object type. + + Type of the object. + + true if this instance can convert the specified object type; otherwise, false. + + + + + Creates a custom object. + + The object type to convert. + + + + Writes the JSON representation of the object. + + The to write to. + The value. + The calling serializer. + + + + Reads the JSON representation of the object. + + The to read from. + Type of the object. + The existing value of object being read. + The calling serializer. + The object value. + + + + Creates an object which will then be populated by the serializer. + + Type of the object. + The created object. + + + + Determines whether this instance can convert the specified object type. + + Type of the object. + + true if this instance can convert the specified object type; otherwise, false. + + + + + Gets a value indicating whether this can write JSON. + + + true if this can write JSON; otherwise, false. + + + + + Converts a to and from JSON. + + + + + Writes the JSON representation of the object. + + The to write to. + The value. + The calling serializer. + + + + Reads the JSON representation of the object. + + The to read from. + Type of the object. + The existing value of object being read. + The calling serializer. + The object value. + + + + Determines whether this instance can convert the specified value type. + + Type of the value. + + true if this instance can convert the specified value type; otherwise, false. + + + + + Converts a to and from JSON. + + + + + Writes the JSON representation of the object. + + The to write to. + The value. + The calling serializer. + + + + Reads the JSON representation of the object. + + The to read from. + Type of the object. + The existing value of object being read. + The calling serializer. + The object value. + + + + Determines whether this instance can convert the specified value type. + + Type of the value. + + true if this instance can convert the specified value type; otherwise, false. + + + + + Provides a base class for converting a to and from JSON. + + + + + Determines whether this instance can convert the specified object type. + + Type of the object. + + true if this instance can convert the specified object type; otherwise, false. + + + + + Converts a to and from the ISO 8601 date format (e.g. "2008-04-12T12:53Z"). + + + + + Gets or sets the date time styles used when converting a date to and from JSON. + + The date time styles used when converting a date to and from JSON. + + + + Gets or sets the date time format used when converting a date to and from JSON. + + The date time format used when converting a date to and from JSON. + + + + Gets or sets the culture used when converting a date to and from JSON. + + The culture used when converting a date to and from JSON. + + + + Writes the JSON representation of the object. + + The to write to. + The value. + The calling serializer. + + + + Reads the JSON representation of the object. + + The to read from. + Type of the object. + The existing value of object being read. + The calling serializer. + The object value. + + + + Converts a to and from a JavaScript Date constructor (e.g. new Date(52231943)). + + + + + Writes the JSON representation of the object. + + The to write to. + The value. + The calling serializer. + + + + Reads the JSON representation of the object. + + The to read from. + Type of the object. + The existing property value of the JSON that is being converted. + The calling serializer. + The object value. + + + + Converts a to and from JSON. + + + + + Writes the JSON representation of the object. + + The to write to. + The value. + The calling serializer. + + + + Reads the JSON representation of the object. + + The to read from. + Type of the object. + The existing value of object being read. + The calling serializer. + The object value. + + + + Determines whether this instance can convert the specified object type. + + Type of the object. + + true if this instance can convert the specified object type; otherwise, false. + + + + + Converts a to and from JSON and BSON. + + + + + Writes the JSON representation of the object. + + The to write to. + The value. + The calling serializer. + + + + Reads the JSON representation of the object. + + The to read from. + Type of the object. + The existing value of object being read. + The calling serializer. + The object value. + + + + Determines whether this instance can convert the specified object type. + + Type of the object. + + true if this instance can convert the specified object type; otherwise, false. + + + + + Converts an to and from its name string value. + + + + + Gets or sets a value indicating whether the written enum text should be camel case. + The default value is false. + + true if the written enum text will be camel case; otherwise, false. + + + + Gets or sets the naming strategy used to resolve how enum text is written. + + The naming strategy used to resolve how enum text is written. + + + + Gets or sets a value indicating whether integer values are allowed when serializing and deserializing. + The default value is true. + + true if integers are allowed when serializing and deserializing; otherwise, false. + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class. + + true if the written enum text will be camel case; otherwise, false. + + + + Initializes a new instance of the class. + + The naming strategy used to resolve how enum text is written. + true if integers are allowed when serializing and deserializing; otherwise, false. + + + + Initializes a new instance of the class. + + The of the used to write enum text. + + + + Initializes a new instance of the class. + + The of the used to write enum text. + + The parameter list to use when constructing the described by . + If null, the default constructor is used. + When non-null, there must be a constructor defined in the that exactly matches the number, + order, and type of these parameters. + + + + + Initializes a new instance of the class. + + The of the used to write enum text. + + The parameter list to use when constructing the described by . + If null, the default constructor is used. + When non-null, there must be a constructor defined in the that exactly matches the number, + order, and type of these parameters. + + true if integers are allowed when serializing and deserializing; otherwise, false. + + + + Writes the JSON representation of the object. + + The to write to. + The value. + The calling serializer. + + + + Reads the JSON representation of the object. + + The to read from. + Type of the object. + The existing value of object being read. + The calling serializer. + The object value. + + + + Determines whether this instance can convert the specified object type. + + Type of the object. + + true if this instance can convert the specified object type; otherwise, false. + + + + + Converts a to and from Unix epoch time + + + + + Writes the JSON representation of the object. + + The to write to. + The value. + The calling serializer. + + + + Reads the JSON representation of the object. + + The to read from. + Type of the object. + The existing property value of the JSON that is being converted. + The calling serializer. + The object value. + + + + Converts a to and from a string (e.g. "1.2.3.4"). + + + + + Writes the JSON representation of the object. + + The to write to. + The value. + The calling serializer. + + + + Reads the JSON representation of the object. + + The to read from. + Type of the object. + The existing property value of the JSON that is being converted. + The calling serializer. + The object value. + + + + Determines whether this instance can convert the specified object type. + + Type of the object. + + true if this instance can convert the specified object type; otherwise, false. + + + + + Converts XML to and from JSON. + + + + + Gets or sets the name of the root element to insert when deserializing to XML if the JSON structure has produced multiple root elements. + + The name of the deserialized root element. + + + + Gets or sets a value to indicate whether to write the Json.NET array attribute. + This attribute helps preserve arrays when converting the written XML back to JSON. + + true if the array attribute is written to the XML; otherwise, false. + + + + Gets or sets a value indicating whether to write the root JSON object. + + true if the JSON root object is omitted; otherwise, false. + + + + Gets or sets a value indicating whether to encode special characters when converting JSON to XML. + If true, special characters like ':', '@', '?', '#' and '$' in JSON property names aren't used to specify + XML namespaces, attributes or processing directives. Instead special characters are encoded and written + as part of the XML element name. + + true if special characters are encoded; otherwise, false. + + + + Writes the JSON representation of the object. + + The to write to. + The calling serializer. + The value. + + + + Reads the JSON representation of the object. + + The to read from. + Type of the object. + The existing value of object being read. + The calling serializer. + The object value. + + + + Checks if the is a namespace attribute. + + Attribute name to test. + The attribute name prefix if it has one, otherwise an empty string. + true if attribute name is for a namespace attribute, otherwise false. + + + + Determines whether this instance can convert the specified value type. + + Type of the value. + + true if this instance can convert the specified value type; otherwise, false. + + + + + Specifies how dates are formatted when writing JSON text. + + + + + Dates are written in the ISO 8601 format, e.g. "2012-03-21T05:40Z". + + + + + Dates are written in the Microsoft JSON format, e.g. "\/Date(1198908717056)\/". + + + + + Specifies how date formatted strings, e.g. "\/Date(1198908717056)\/" and "2012-03-21T05:40Z", are parsed when reading JSON text. + + + + + Date formatted strings are not parsed to a date type and are read as strings. + + + + + Date formatted strings, e.g. "\/Date(1198908717056)\/" and "2012-03-21T05:40Z", are parsed to . + + + + + Specifies how to treat the time value when converting between string and . + + + + + Treat as local time. If the object represents a Coordinated Universal Time (UTC), it is converted to the local time. + + + + + Treat as a UTC. If the object represents a local time, it is converted to a UTC. + + + + + Treat as a local time if a is being converted to a string. + If a string is being converted to , convert to a local time if a time zone is specified. + + + + + Time zone information should be preserved when converting. + + + + + The default JSON name table implementation. + + + + + Initializes a new instance of the class. + + + + + Gets a string containing the same characters as the specified range of characters in the given array. + + The character array containing the name to find. + The zero-based index into the array specifying the first character of the name. + The number of characters in the name. + A string containing the same characters as the specified range of characters in the given array. + + + + Adds the specified string into name table. + + The string to add. + This method is not thread-safe. + The resolved string. + + + + Specifies default value handling options for the . + + + + + + + + + Include members where the member value is the same as the member's default value when serializing objects. + Included members are written to JSON. Has no effect when deserializing. + + + + + Ignore members where the member value is the same as the member's default value when serializing objects + so that it is not written to JSON. + This option will ignore all default values (e.g. null for objects and nullable types; 0 for integers, + decimals and floating point numbers; and false for booleans). The default value ignored can be changed by + placing the on the property. + + + + + Members with a default value but no JSON will be set to their default value when deserializing. + + + + + Ignore members where the member value is the same as the member's default value when serializing objects + and set members to their default value when deserializing. + + + + + Specifies float format handling options when writing special floating point numbers, e.g. , + and with . + + + + + Write special floating point values as strings in JSON, e.g. "NaN", "Infinity", "-Infinity". + + + + + Write special floating point values as symbols in JSON, e.g. NaN, Infinity, -Infinity. + Note that this will produce non-valid JSON. + + + + + Write special floating point values as the property's default value in JSON, e.g. 0.0 for a property, null for a of property. + + + + + Specifies how floating point numbers, e.g. 1.0 and 9.9, are parsed when reading JSON text. + + + + + Floating point numbers are parsed to . + + + + + Floating point numbers are parsed to . + + + + + Specifies formatting options for the . + + + + + No special formatting is applied. This is the default. + + + + + Causes child objects to be indented according to the and settings. + + + + + Provides an interface for using pooled arrays. + + The array type content. + + + + Rent an array from the pool. This array must be returned when it is no longer needed. + + The minimum required length of the array. The returned array may be longer. + The rented array from the pool. This array must be returned when it is no longer needed. + + + + Return an array to the pool. + + The array that is being returned. + + + + Provides an interface to enable a class to return line and position information. + + + + + Gets a value indicating whether the class can return line information. + + + true if and can be provided; otherwise, false. + + + + + Gets the current line number. + + The current line number or 0 if no line information is available (for example, when returns false). + + + + Gets the current line position. + + The current line position or 0 if no line information is available (for example, when returns false). + + + + Instructs the how to serialize the collection. + + + + + Gets or sets a value indicating whether null items are allowed in the collection. + + true if null items are allowed in the collection; otherwise, false. + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class with a flag indicating whether the array can contain null items. + + A flag indicating whether the array can contain null items. + + + + Initializes a new instance of the class with the specified container Id. + + The container Id. + + + + Instructs the to use the specified constructor when deserializing that object. + + + + + Instructs the how to serialize the object. + + + + + Gets or sets the id. + + The id. + + + + Gets or sets the title. + + The title. + + + + Gets or sets the description. + + The description. + + + + Gets or sets the collection's items converter. + + The collection's items converter. + + + + The parameter list to use when constructing the described by . + If null, the default constructor is used. + When non-null, there must be a constructor defined in the that exactly matches the number, + order, and type of these parameters. + + + + [JsonContainer(ItemConverterType = typeof(MyContainerConverter), ItemConverterParameters = new object[] { 123, "Four" })] + + + + + + Gets or sets the of the . + + The of the . + + + + The parameter list to use when constructing the described by . + If null, the default constructor is used. + When non-null, there must be a constructor defined in the that exactly matches the number, + order, and type of these parameters. + + + + [JsonContainer(NamingStrategyType = typeof(MyNamingStrategy), NamingStrategyParameters = new object[] { 123, "Four" })] + + + + + + Gets or sets a value that indicates whether to preserve object references. + + + true to keep object reference; otherwise, false. The default is false. + + + + + Gets or sets a value that indicates whether to preserve collection's items references. + + + true to keep collection's items object references; otherwise, false. The default is false. + + + + + Gets or sets the reference loop handling used when serializing the collection's items. + + The reference loop handling. + + + + Gets or sets the type name handling used when serializing the collection's items. + + The type name handling. + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class with the specified container Id. + + The container Id. + + + + Provides methods for converting between .NET types and JSON types. + + + + + + + + Gets or sets a function that creates default . + Default settings are automatically used by serialization methods on , + and and on . + To serialize without using any default settings create a with + . + + + + + Represents JavaScript's boolean value true as a string. This field is read-only. + + + + + Represents JavaScript's boolean value false as a string. This field is read-only. + + + + + Represents JavaScript's null as a string. This field is read-only. + + + + + Represents JavaScript's undefined as a string. This field is read-only. + + + + + Represents JavaScript's positive infinity as a string. This field is read-only. + + + + + Represents JavaScript's negative infinity as a string. This field is read-only. + + + + + Represents JavaScript's NaN as a string. This field is read-only. + + + + + Converts the to its JSON string representation. + + The value to convert. + A JSON string representation of the . + + + + Converts the to its JSON string representation using the specified. + + The value to convert. + The format the date will be converted to. + The time zone handling when the date is converted to a string. + A JSON string representation of the . + + + + Converts the to its JSON string representation. + + The value to convert. + A JSON string representation of the . + + + + Converts the to its JSON string representation. + + The value to convert. + A JSON string representation of the . + + + + Converts the to its JSON string representation. + + The value to convert. + A JSON string representation of the . + + + + Converts the to its JSON string representation. + + The value to convert. + A JSON string representation of the . + + + + Converts the to its JSON string representation. + + The value to convert. + A JSON string representation of the . + + + + Converts the to its JSON string representation. + + The value to convert. + A JSON string representation of the . + + + + Converts the to its JSON string representation. + + The value to convert. + A JSON string representation of the . + + + + Converts the to its JSON string representation. + + The value to convert. + A JSON string representation of the . + + + + Converts the to its JSON string representation. + + The value to convert. + A JSON string representation of the . + + + + Converts the to its JSON string representation. + + The value to convert. + A JSON string representation of the . + + + + Converts the to its JSON string representation. + + The value to convert. + A JSON string representation of the . + + + + Converts the to its JSON string representation. + + The value to convert. + A JSON string representation of the . + + + + Converts the to its JSON string representation. + + The value to convert. + A JSON string representation of the . + + + + Converts the to its JSON string representation. + + The value to convert. + A JSON string representation of the . + + + + Converts the to its JSON string representation. + + The value to convert. + A JSON string representation of the . + + + + Converts the to its JSON string representation. + + The value to convert. + A JSON string representation of the . + + + + Converts the to its JSON string representation. + + The value to convert. + A JSON string representation of the . + + + + Converts the to its JSON string representation. + + The value to convert. + A JSON string representation of the . + + + + Converts the to its JSON string representation. + + The value to convert. + The string delimiter character. + A JSON string representation of the . + + + + Converts the to its JSON string representation. + + The value to convert. + The string delimiter character. + The string escape handling. + A JSON string representation of the . + + + + Converts the to its JSON string representation. + + The value to convert. + A JSON string representation of the . + + + + Serializes the specified object to a JSON string. + + The object to serialize. + A JSON string representation of the object. + + + + Serializes the specified object to a JSON string using formatting. + + The object to serialize. + Indicates how the output should be formatted. + + A JSON string representation of the object. + + + + + Serializes the specified object to a JSON string using a collection of . + + The object to serialize. + A collection of converters used while serializing. + A JSON string representation of the object. + + + + Serializes the specified object to a JSON string using formatting and a collection of . + + The object to serialize. + Indicates how the output should be formatted. + A collection of converters used while serializing. + A JSON string representation of the object. + + + + Serializes the specified object to a JSON string using . + + The object to serialize. + The used to serialize the object. + If this is null, default serialization settings will be used. + + A JSON string representation of the object. + + + + + Serializes the specified object to a JSON string using a type, formatting and . + + The object to serialize. + The used to serialize the object. + If this is null, default serialization settings will be used. + + The type of the value being serialized. + This parameter is used when is to write out the type name if the type of the value does not match. + Specifying the type is optional. + + + A JSON string representation of the object. + + + + + Serializes the specified object to a JSON string using formatting and . + + The object to serialize. + Indicates how the output should be formatted. + The used to serialize the object. + If this is null, default serialization settings will be used. + + A JSON string representation of the object. + + + + + Serializes the specified object to a JSON string using a type, formatting and . + + The object to serialize. + Indicates how the output should be formatted. + The used to serialize the object. + If this is null, default serialization settings will be used. + + The type of the value being serialized. + This parameter is used when is to write out the type name if the type of the value does not match. + Specifying the type is optional. + + + A JSON string representation of the object. + + + + + Deserializes the JSON to a .NET object. + + The JSON to deserialize. + The deserialized object from the JSON string. + + + + Deserializes the JSON to a .NET object using . + + The JSON to deserialize. + + The used to deserialize the object. + If this is null, default serialization settings will be used. + + The deserialized object from the JSON string. + + + + Deserializes the JSON to the specified .NET type. + + The JSON to deserialize. + The of object being deserialized. + The deserialized object from the JSON string. + + + + Deserializes the JSON to the specified .NET type. + + The type of the object to deserialize to. + The JSON to deserialize. + The deserialized object from the JSON string. + + + + Deserializes the JSON to the given anonymous type. + + + The anonymous type to deserialize to. This can't be specified + traditionally and must be inferred from the anonymous type passed + as a parameter. + + The JSON to deserialize. + The anonymous type object. + The deserialized anonymous type from the JSON string. + + + + Deserializes the JSON to the given anonymous type using . + + + The anonymous type to deserialize to. This can't be specified + traditionally and must be inferred from the anonymous type passed + as a parameter. + + The JSON to deserialize. + The anonymous type object. + + The used to deserialize the object. + If this is null, default serialization settings will be used. + + The deserialized anonymous type from the JSON string. + + + + Deserializes the JSON to the specified .NET type using a collection of . + + The type of the object to deserialize to. + The JSON to deserialize. + Converters to use while deserializing. + The deserialized object from the JSON string. + + + + Deserializes the JSON to the specified .NET type using . + + The type of the object to deserialize to. + The object to deserialize. + + The used to deserialize the object. + If this is null, default serialization settings will be used. + + The deserialized object from the JSON string. + + + + Deserializes the JSON to the specified .NET type using a collection of . + + The JSON to deserialize. + The type of the object to deserialize. + Converters to use while deserializing. + The deserialized object from the JSON string. + + + + Deserializes the JSON to the specified .NET type using . + + The JSON to deserialize. + The type of the object to deserialize to. + + The used to deserialize the object. + If this is null, default serialization settings will be used. + + The deserialized object from the JSON string. + + + + Populates the object with values from the JSON string. + + The JSON to populate values from. + The target object to populate values onto. + + + + Populates the object with values from the JSON string using . + + The JSON to populate values from. + The target object to populate values onto. + + The used to deserialize the object. + If this is null, default serialization settings will be used. + + + + + Serializes the to a JSON string. + + The node to serialize. + A JSON string of the . + + + + Serializes the to a JSON string using formatting. + + The node to serialize. + Indicates how the output should be formatted. + A JSON string of the . + + + + Serializes the to a JSON string using formatting and omits the root object if is true. + + The node to serialize. + Indicates how the output should be formatted. + Omits writing the root object. + A JSON string of the . + + + + Deserializes the from a JSON string. + + The JSON string. + The deserialized . + + + + Deserializes the from a JSON string nested in a root element specified by . + + The JSON string. + The name of the root element to append when deserializing. + The deserialized . + + + + Deserializes the from a JSON string nested in a root element specified by + and writes a Json.NET array attribute for collections. + + The JSON string. + The name of the root element to append when deserializing. + + A value to indicate whether to write the Json.NET array attribute. + This attribute helps preserve arrays when converting the written XML back to JSON. + + The deserialized . + + + + Deserializes the from a JSON string nested in a root element specified by , + writes a Json.NET array attribute for collections, and encodes special characters. + + The JSON string. + The name of the root element to append when deserializing. + + A value to indicate whether to write the Json.NET array attribute. + This attribute helps preserve arrays when converting the written XML back to JSON. + + + A value to indicate whether to encode special characters when converting JSON to XML. + If true, special characters like ':', '@', '?', '#' and '$' in JSON property names aren't used to specify + XML namespaces, attributes or processing directives. Instead special characters are encoded and written + as part of the XML element name. + + The deserialized . + + + + Converts an object to and from JSON. + + + + + Writes the JSON representation of the object. + + The to write to. + The value. + The calling serializer. + + + + Reads the JSON representation of the object. + + The to read from. + Type of the object. + The existing value of object being read. + The calling serializer. + The object value. + + + + Determines whether this instance can convert the specified object type. + + Type of the object. + + true if this instance can convert the specified object type; otherwise, false. + + + + + Gets a value indicating whether this can read JSON. + + true if this can read JSON; otherwise, false. + + + + Gets a value indicating whether this can write JSON. + + true if this can write JSON; otherwise, false. + + + + Converts an object to and from JSON. + + The object type to convert. + + + + Writes the JSON representation of the object. + + The to write to. + The value. + The calling serializer. + + + + Writes the JSON representation of the object. + + The to write to. + The value. + The calling serializer. + + + + Reads the JSON representation of the object. + + The to read from. + Type of the object. + The existing value of object being read. + The calling serializer. + The object value. + + + + Reads the JSON representation of the object. + + The to read from. + Type of the object. + The existing value of object being read. If there is no existing value then null will be used. + The existing value has a value. + The calling serializer. + The object value. + + + + Determines whether this instance can convert the specified object type. + + Type of the object. + + true if this instance can convert the specified object type; otherwise, false. + + + + + Instructs the to use the specified when serializing the member or class. + + + + + Gets the of the . + + The of the . + + + + The parameter list to use when constructing the described by . + If null, the default constructor is used. + + + + + Initializes a new instance of the class. + + Type of the . + + + + Initializes a new instance of the class. + + Type of the . + Parameter list to use when constructing the . Can be null. + + + + Represents a collection of . + + + + + Instructs the how to serialize the collection. + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class with the specified container Id. + + The container Id. + + + + The exception thrown when an error occurs during JSON serialization or deserialization. + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class + with a specified error message. + + The error message that explains the reason for the exception. + + + + Initializes a new instance of the class + with a specified error message and a reference to the inner exception that is the cause of this exception. + + The error message that explains the reason for the exception. + The exception that is the cause of the current exception, or null if no inner exception is specified. + + + + Initializes a new instance of the class. + + The that holds the serialized object data about the exception being thrown. + The that contains contextual information about the source or destination. + The parameter is null. + The class name is null or is zero (0). + + + + Instructs the to deserialize properties with no matching class member into the specified collection + and write values during serialization. + + + + + Gets or sets a value that indicates whether to write extension data when serializing the object. + + + true to write extension data when serializing the object; otherwise, false. The default is true. + + + + + Gets or sets a value that indicates whether to read extension data when deserializing the object. + + + true to read extension data when deserializing the object; otherwise, false. The default is true. + + + + + Initializes a new instance of the class. + + + + + Instructs the not to serialize the public field or public read/write property value. + + + + + Base class for a table of atomized string objects. + + + + + Gets a string containing the same characters as the specified range of characters in the given array. + + The character array containing the name to find. + The zero-based index into the array specifying the first character of the name. + The number of characters in the name. + A string containing the same characters as the specified range of characters in the given array. + + + + Instructs the how to serialize the object. + + + + + Gets or sets the member serialization. + + The member serialization. + + + + Gets or sets the missing member handling used when deserializing this object. + + The missing member handling. + + + + Gets or sets how the object's properties with null values are handled during serialization and deserialization. + + How the object's properties with null values are handled during serialization and deserialization. + + + + Gets or sets a value that indicates whether the object's properties are required. + + + A value indicating whether the object's properties are required. + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class with the specified member serialization. + + The member serialization. + + + + Initializes a new instance of the class with the specified container Id. + + The container Id. + + + + Instructs the to always serialize the member with the specified name. + + + + + Gets or sets the type used when serializing the property's collection items. + + The collection's items type. + + + + The parameter list to use when constructing the described by . + If null, the default constructor is used. + When non-null, there must be a constructor defined in the that exactly matches the number, + order, and type of these parameters. + + + + [JsonProperty(ItemConverterType = typeof(MyContainerConverter), ItemConverterParameters = new object[] { 123, "Four" })] + + + + + + Gets or sets the of the . + + The of the . + + + + The parameter list to use when constructing the described by . + If null, the default constructor is used. + When non-null, there must be a constructor defined in the that exactly matches the number, + order, and type of these parameters. + + + + [JsonProperty(NamingStrategyType = typeof(MyNamingStrategy), NamingStrategyParameters = new object[] { 123, "Four" })] + + + + + + Gets or sets the null value handling used when serializing this property. + + The null value handling. + + + + Gets or sets the default value handling used when serializing this property. + + The default value handling. + + + + Gets or sets the reference loop handling used when serializing this property. + + The reference loop handling. + + + + Gets or sets the object creation handling used when deserializing this property. + + The object creation handling. + + + + Gets or sets the type name handling used when serializing this property. + + The type name handling. + + + + Gets or sets whether this property's value is serialized as a reference. + + Whether this property's value is serialized as a reference. + + + + Gets or sets the order of serialization of a member. + + The numeric order of serialization. + + + + Gets or sets a value indicating whether this property is required. + + + A value indicating whether this property is required. + + + + + Gets or sets the name of the property. + + The name of the property. + + + + Gets or sets the reference loop handling used when serializing the property's collection items. + + The collection's items reference loop handling. + + + + Gets or sets the type name handling used when serializing the property's collection items. + + The collection's items type name handling. + + + + Gets or sets whether this property's collection items are serialized as a reference. + + Whether this property's collection items are serialized as a reference. + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class with the specified name. + + Name of the property. + + + + Represents a reader that provides fast, non-cached, forward-only access to serialized JSON data. + + + + + Specifies the state of the reader. + + + + + A read method has not been called. + + + + + The end of the file has been reached successfully. + + + + + Reader is at a property. + + + + + Reader is at the start of an object. + + + + + Reader is in an object. + + + + + Reader is at the start of an array. + + + + + Reader is in an array. + + + + + The method has been called. + + + + + Reader has just read a value. + + + + + Reader is at the start of a constructor. + + + + + Reader is in a constructor. + + + + + An error occurred that prevents the read operation from continuing. + + + + + The end of the file has been reached successfully. + + + + + Gets the current reader state. + + The current reader state. + + + + Gets or sets a value indicating whether the source should be closed when this reader is closed. + + + true to close the source when this reader is closed; otherwise false. The default is true. + + + + + Gets or sets a value indicating whether multiple pieces of JSON content can + be read from a continuous stream without erroring. + + + true to support reading multiple pieces of JSON content; otherwise false. + The default is false. + + + + + Gets the quotation mark character used to enclose the value of a string. + + + + + Gets or sets how time zones are handled when reading JSON. + + + + + Gets or sets how date formatted strings, e.g. "\/Date(1198908717056)\/" and "2012-03-21T05:40Z", are parsed when reading JSON. + + + + + Gets or sets how floating point numbers, e.g. 1.0 and 9.9, are parsed when reading JSON text. + + + + + Gets or sets how custom date formatted strings are parsed when reading JSON. + + + + + Gets or sets the maximum depth allowed when reading JSON. Reading past this depth will throw a . + A null value means there is no maximum. + The default value is 128. + + + + + Gets the type of the current JSON token. + + + + + Gets the text value of the current JSON token. + + + + + Gets the .NET type for the current JSON token. + + + + + Gets the depth of the current token in the JSON document. + + The depth of the current token in the JSON document. + + + + Gets the path of the current JSON token. + + + + + Gets or sets the culture used when reading JSON. Defaults to . + + + + + Initializes a new instance of the class. + + + + + Reads the next JSON token from the source. + + true if the next token was read successfully; false if there are no more tokens to read. + + + + Reads the next JSON token from the source as a of . + + A of . This method will return null at the end of an array. + + + + Reads the next JSON token from the source as a . + + A . This method will return null at the end of an array. + + + + Reads the next JSON token from the source as a []. + + A [] or null if the next JSON token is null. This method will return null at the end of an array. + + + + Reads the next JSON token from the source as a of . + + A of . This method will return null at the end of an array. + + + + Reads the next JSON token from the source as a of . + + A of . This method will return null at the end of an array. + + + + Reads the next JSON token from the source as a of . + + A of . This method will return null at the end of an array. + + + + Reads the next JSON token from the source as a of . + + A of . This method will return null at the end of an array. + + + + Skips the children of the current token. + + + + + Sets the current token. + + The new token. + + + + Sets the current token and value. + + The new token. + The value. + + + + Sets the current token and value. + + The new token. + The value. + A flag indicating whether the position index inside an array should be updated. + + + + Sets the state based on current token type. + + + + + Releases unmanaged and - optionally - managed resources. + + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + + Changes the reader's state to . + If is set to true, the source is also closed. + + + + + The exception thrown when an error occurs while reading JSON text. + + + + + Gets the line number indicating where the error occurred. + + The line number indicating where the error occurred. + + + + Gets the line position indicating where the error occurred. + + The line position indicating where the error occurred. + + + + Gets the path to the JSON where the error occurred. + + The path to the JSON where the error occurred. + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class + with a specified error message. + + The error message that explains the reason for the exception. + + + + Initializes a new instance of the class + with a specified error message and a reference to the inner exception that is the cause of this exception. + + The error message that explains the reason for the exception. + The exception that is the cause of the current exception, or null if no inner exception is specified. + + + + Initializes a new instance of the class. + + The that holds the serialized object data about the exception being thrown. + The that contains contextual information about the source or destination. + The parameter is null. + The class name is null or is zero (0). + + + + Initializes a new instance of the class + with a specified error message, JSON path, line number, line position, and a reference to the inner exception that is the cause of this exception. + + The error message that explains the reason for the exception. + The path to the JSON where the error occurred. + The line number indicating where the error occurred. + The line position indicating where the error occurred. + The exception that is the cause of the current exception, or null if no inner exception is specified. + + + + Instructs the to always serialize the member, and to require that the member has a value. + + + + + The exception thrown when an error occurs during JSON serialization or deserialization. + + + + + Gets the line number indicating where the error occurred. + + The line number indicating where the error occurred. + + + + Gets the line position indicating where the error occurred. + + The line position indicating where the error occurred. + + + + Gets the path to the JSON where the error occurred. + + The path to the JSON where the error occurred. + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class + with a specified error message. + + The error message that explains the reason for the exception. + + + + Initializes a new instance of the class + with a specified error message and a reference to the inner exception that is the cause of this exception. + + The error message that explains the reason for the exception. + The exception that is the cause of the current exception, or null if no inner exception is specified. + + + + Initializes a new instance of the class. + + The that holds the serialized object data about the exception being thrown. + The that contains contextual information about the source or destination. + The parameter is null. + The class name is null or is zero (0). + + + + Initializes a new instance of the class + with a specified error message, JSON path, line number, line position, and a reference to the inner exception that is the cause of this exception. + + The error message that explains the reason for the exception. + The path to the JSON where the error occurred. + The line number indicating where the error occurred. + The line position indicating where the error occurred. + The exception that is the cause of the current exception, or null if no inner exception is specified. + + + + Serializes and deserializes objects into and from the JSON format. + The enables you to control how objects are encoded into JSON. + + + + + Occurs when the errors during serialization and deserialization. + + + + + Gets or sets the used by the serializer when resolving references. + + + + + Gets or sets the used by the serializer when resolving type names. + + + + + Gets or sets the used by the serializer when resolving type names. + + + + + Gets or sets the used by the serializer when writing trace messages. + + The trace writer. + + + + Gets or sets the equality comparer used by the serializer when comparing references. + + The equality comparer. + + + + Gets or sets how type name writing and reading is handled by the serializer. + The default value is . + + + should be used with caution when your application deserializes JSON from an external source. + Incoming types should be validated with a custom + when deserializing with a value other than . + + + + + Gets or sets how a type name assembly is written and resolved by the serializer. + The default value is . + + The type name assembly format. + + + + Gets or sets how a type name assembly is written and resolved by the serializer. + The default value is . + + The type name assembly format. + + + + Gets or sets how object references are preserved by the serializer. + The default value is . + + + + + Gets or sets how reference loops (e.g. a class referencing itself) is handled. + The default value is . + + + + + Gets or sets how missing members (e.g. JSON contains a property that isn't a member on the object) are handled during deserialization. + The default value is . + + + + + Gets or sets how null values are handled during serialization and deserialization. + The default value is . + + + + + Gets or sets how default values are handled during serialization and deserialization. + The default value is . + + + + + Gets or sets how objects are created during deserialization. + The default value is . + + The object creation handling. + + + + Gets or sets how constructors are used during deserialization. + The default value is . + + The constructor handling. + + + + Gets or sets how metadata properties are used during deserialization. + The default value is . + + The metadata properties handling. + + + + Gets a collection that will be used during serialization. + + Collection that will be used during serialization. + + + + Gets or sets the contract resolver used by the serializer when + serializing .NET objects to JSON and vice versa. + + + + + Gets or sets the used by the serializer when invoking serialization callback methods. + + The context. + + + + Indicates how JSON text output is formatted. + The default value is . + + + + + Gets or sets how dates are written to JSON text. + The default value is . + + + + + Gets or sets how time zones are handled during serialization and deserialization. + The default value is . + + + + + Gets or sets how date formatted strings, e.g. "\/Date(1198908717056)\/" and "2012-03-21T05:40Z", are parsed when reading JSON. + The default value is . + + + + + Gets or sets how floating point numbers, e.g. 1.0 and 9.9, are parsed when reading JSON text. + The default value is . + + + + + Gets or sets how special floating point numbers, e.g. , + and , + are written as JSON text. + The default value is . + + + + + Gets or sets how strings are escaped when writing JSON text. + The default value is . + + + + + Gets or sets how and values are formatted when writing JSON text, + and the expected date format when reading JSON text. + The default value is "yyyy'-'MM'-'dd'T'HH':'mm':'ss.FFFFFFFK". + + + + + Gets or sets the culture used when reading JSON. + The default value is . + + + + + Gets or sets the maximum depth allowed when reading JSON. Reading past this depth will throw a . + A null value means there is no maximum. + The default value is 128. + + + + + Gets a value indicating whether there will be a check for additional JSON content after deserializing an object. + The default value is false. + + + true if there will be a check for additional JSON content after deserializing an object; otherwise, false. + + + + + Initializes a new instance of the class. + + + + + Creates a new instance. + The will not use default settings + from . + + + A new instance. + The will not use default settings + from . + + + + + Creates a new instance using the specified . + The will not use default settings + from . + + The settings to be applied to the . + + A new instance using the specified . + The will not use default settings + from . + + + + + Creates a new instance. + The will use default settings + from . + + + A new instance. + The will use default settings + from . + + + + + Creates a new instance using the specified . + The will use default settings + from as well as the specified . + + The settings to be applied to the . + + A new instance using the specified . + The will use default settings + from as well as the specified . + + + + + Populates the JSON values onto the target object. + + The that contains the JSON structure to read values from. + The target object to populate values onto. + + + + Populates the JSON values onto the target object. + + The that contains the JSON structure to read values from. + The target object to populate values onto. + + + + Deserializes the JSON structure contained by the specified . + + The that contains the JSON structure to deserialize. + The being deserialized. + + + + Deserializes the JSON structure contained by the specified + into an instance of the specified type. + + The containing the object. + The of object being deserialized. + The instance of being deserialized. + + + + Deserializes the JSON structure contained by the specified + into an instance of the specified type. + + The containing the object. + The type of the object to deserialize. + The instance of being deserialized. + + + + Deserializes the JSON structure contained by the specified + into an instance of the specified type. + + The containing the object. + The of object being deserialized. + The instance of being deserialized. + + + + Serializes the specified and writes the JSON structure + using the specified . + + The used to write the JSON structure. + The to serialize. + + + + Serializes the specified and writes the JSON structure + using the specified . + + The used to write the JSON structure. + The to serialize. + + The type of the value being serialized. + This parameter is used when is to write out the type name if the type of the value does not match. + Specifying the type is optional. + + + + + Serializes the specified and writes the JSON structure + using the specified . + + The used to write the JSON structure. + The to serialize. + + The type of the value being serialized. + This parameter is used when is Auto to write out the type name if the type of the value does not match. + Specifying the type is optional. + + + + + Serializes the specified and writes the JSON structure + using the specified . + + The used to write the JSON structure. + The to serialize. + + + + Specifies the settings on a object. + + + + + Gets or sets how reference loops (e.g. a class referencing itself) are handled. + The default value is . + + Reference loop handling. + + + + Gets or sets how missing members (e.g. JSON contains a property that isn't a member on the object) are handled during deserialization. + The default value is . + + Missing member handling. + + + + Gets or sets how objects are created during deserialization. + The default value is . + + The object creation handling. + + + + Gets or sets how null values are handled during serialization and deserialization. + The default value is . + + Null value handling. + + + + Gets or sets how default values are handled during serialization and deserialization. + The default value is . + + The default value handling. + + + + Gets or sets a collection that will be used during serialization. + + The converters. + + + + Gets or sets how object references are preserved by the serializer. + The default value is . + + The preserve references handling. + + + + Gets or sets how type name writing and reading is handled by the serializer. + The default value is . + + + should be used with caution when your application deserializes JSON from an external source. + Incoming types should be validated with a custom + when deserializing with a value other than . + + The type name handling. + + + + Gets or sets how metadata properties are used during deserialization. + The default value is . + + The metadata properties handling. + + + + Gets or sets how a type name assembly is written and resolved by the serializer. + The default value is . + + The type name assembly format. + + + + Gets or sets how a type name assembly is written and resolved by the serializer. + The default value is . + + The type name assembly format. + + + + Gets or sets how constructors are used during deserialization. + The default value is . + + The constructor handling. + + + + Gets or sets the contract resolver used by the serializer when + serializing .NET objects to JSON and vice versa. + + The contract resolver. + + + + Gets or sets the equality comparer used by the serializer when comparing references. + + The equality comparer. + + + + Gets or sets the used by the serializer when resolving references. + + The reference resolver. + + + + Gets or sets a function that creates the used by the serializer when resolving references. + + A function that creates the used by the serializer when resolving references. + + + + Gets or sets the used by the serializer when writing trace messages. + + The trace writer. + + + + Gets or sets the used by the serializer when resolving type names. + + The binder. + + + + Gets or sets the used by the serializer when resolving type names. + + The binder. + + + + Gets or sets the error handler called during serialization and deserialization. + + The error handler called during serialization and deserialization. + + + + Gets or sets the used by the serializer when invoking serialization callback methods. + + The context. + + + + Gets or sets how and values are formatted when writing JSON text, + and the expected date format when reading JSON text. + The default value is "yyyy'-'MM'-'dd'T'HH':'mm':'ss.FFFFFFFK". + + + + + Gets or sets the maximum depth allowed when reading JSON. Reading past this depth will throw a . + A null value means there is no maximum. + The default value is 128. + + + + + Indicates how JSON text output is formatted. + The default value is . + + + + + Gets or sets how dates are written to JSON text. + The default value is . + + + + + Gets or sets how time zones are handled during serialization and deserialization. + The default value is . + + + + + Gets or sets how date formatted strings, e.g. "\/Date(1198908717056)\/" and "2012-03-21T05:40Z", are parsed when reading JSON. + The default value is . + + + + + Gets or sets how special floating point numbers, e.g. , + and , + are written as JSON. + The default value is . + + + + + Gets or sets how floating point numbers, e.g. 1.0 and 9.9, are parsed when reading JSON text. + The default value is . + + + + + Gets or sets how strings are escaped when writing JSON text. + The default value is . + + + + + Gets or sets the culture used when reading JSON. + The default value is . + + + + + Gets a value indicating whether there will be a check for additional content after deserializing an object. + The default value is false. + + + true if there will be a check for additional content after deserializing an object; otherwise, false. + + + + + Initializes a new instance of the class. + + + + + Represents a reader that provides fast, non-cached, forward-only access to JSON text data. + + + + + Initializes a new instance of the class with the specified . + + The containing the JSON data to read. + + + + Gets or sets the reader's property name table. + + + + + Gets or sets the reader's character buffer pool. + + + + + Reads the next JSON token from the underlying . + + + true if the next token was read successfully; false if there are no more tokens to read. + + + + + Reads the next JSON token from the underlying as a of . + + A of . This method will return null at the end of an array. + + + + Reads the next JSON token from the underlying as a of . + + A of . This method will return null at the end of an array. + + + + Reads the next JSON token from the underlying as a . + + A . This method will return null at the end of an array. + + + + Reads the next JSON token from the underlying as a []. + + A [] or null if the next JSON token is null. This method will return null at the end of an array. + + + + Reads the next JSON token from the underlying as a of . + + A of . This method will return null at the end of an array. + + + + Reads the next JSON token from the underlying as a of . + + A of . This method will return null at the end of an array. + + + + Reads the next JSON token from the underlying as a of . + + A of . This method will return null at the end of an array. + + + + Changes the reader's state to . + If is set to true, the underlying is also closed. + + + + + Gets a value indicating whether the class can return line information. + + + true if and can be provided; otherwise, false. + + + + + Gets the current line number. + + + The current line number or 0 if no line information is available (for example, returns false). + + + + + Gets the current line position. + + + The current line position or 0 if no line information is available (for example, returns false). + + + + + Represents a writer that provides a fast, non-cached, forward-only way of generating JSON data. + + + + + Gets or sets the writer's character array pool. + + + + + Gets or sets how many s to write for each level in the hierarchy when is set to . + + + + + Gets or sets which character to use to quote attribute values. + + + + + Gets or sets which character to use for indenting when is set to . + + + + + Gets or sets a value indicating whether object names will be surrounded with quotes. + + + + + Initializes a new instance of the class using the specified . + + The to write to. + + + + Flushes whatever is in the buffer to the underlying and also flushes the underlying . + + + + + Closes this writer. + If is set to true, the underlying is also closed. + If is set to true, the JSON is auto-completed. + + + + + Writes the beginning of a JSON object. + + + + + Writes the beginning of a JSON array. + + + + + Writes the start of a constructor with the given name. + + The name of the constructor. + + + + Writes the specified end token. + + The end token to write. + + + + Writes the property name of a name/value pair on a JSON object. + + The name of the property. + + + + Writes the property name of a name/value pair on a JSON object. + + The name of the property. + A flag to indicate whether the text should be escaped when it is written as a JSON property name. + + + + Writes indent characters. + + + + + Writes the JSON value delimiter. + + + + + Writes an indent space. + + + + + Writes a value. + An error will raised if the value cannot be written as a single JSON token. + + The value to write. + + + + Writes a null value. + + + + + Writes an undefined value. + + + + + Writes raw JSON. + + The raw JSON to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a of value. + + The of value to write. + + + + Writes a value. + + The value to write. + + + + Writes a of value. + + The of value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a [] value. + + The [] value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a comment /*...*/ containing the specified text. + + Text to place inside the comment. + + + + Writes the given white space. + + The string of white space characters. + + + + Specifies the type of JSON token. + + + + + This is returned by the if a read method has not been called. + + + + + An object start token. + + + + + An array start token. + + + + + A constructor start token. + + + + + An object property name. + + + + + A comment. + + + + + Raw JSON. + + + + + An integer. + + + + + A float. + + + + + A string. + + + + + A boolean. + + + + + A null token. + + + + + An undefined token. + + + + + An object end token. + + + + + An array end token. + + + + + A constructor end token. + + + + + A Date. + + + + + Byte data. + + + + + + Represents a reader that provides validation. + + + JSON Schema validation has been moved to its own package. See https://www.newtonsoft.com/jsonschema for more details. + + + + + + Sets an event handler for receiving schema validation errors. + + + + + Gets the text value of the current JSON token. + + + + + + Gets the depth of the current token in the JSON document. + + The depth of the current token in the JSON document. + + + + Gets the path of the current JSON token. + + + + + Gets the quotation mark character used to enclose the value of a string. + + + + + + Gets the type of the current JSON token. + + + + + + Gets the .NET type for the current JSON token. + + + + + + Initializes a new instance of the class that + validates the content returned from the given . + + The to read from while validating. + + + + Gets or sets the schema. + + The schema. + + + + Gets the used to construct this . + + The specified in the constructor. + + + + Changes the reader's state to . + If is set to true, the underlying is also closed. + + + + + Reads the next JSON token from the underlying as a of . + + A of . + + + + Reads the next JSON token from the underlying as a []. + + + A [] or null if the next JSON token is null. + + + + + Reads the next JSON token from the underlying as a of . + + A of . + + + + Reads the next JSON token from the underlying as a of . + + A of . + + + + Reads the next JSON token from the underlying as a of . + + A of . + + + + Reads the next JSON token from the underlying as a . + + A . This method will return null at the end of an array. + + + + Reads the next JSON token from the underlying as a of . + + A of . This method will return null at the end of an array. + + + + Reads the next JSON token from the underlying . + + + true if the next token was read successfully; false if there are no more tokens to read. + + + + + Represents a writer that provides a fast, non-cached, forward-only way of generating JSON data. + + + + + Gets or sets a value indicating whether the destination should be closed when this writer is closed. + + + true to close the destination when this writer is closed; otherwise false. The default is true. + + + + + Gets or sets a value indicating whether the JSON should be auto-completed when this writer is closed. + + + true to auto-complete the JSON when this writer is closed; otherwise false. The default is true. + + + + + Gets the top. + + The top. + + + + Gets the state of the writer. + + + + + Gets the path of the writer. + + + + + Gets or sets a value indicating how JSON text output should be formatted. + + + + + Gets or sets how dates are written to JSON text. + + + + + Gets or sets how time zones are handled when writing JSON text. + + + + + Gets or sets how strings are escaped when writing JSON text. + + + + + Gets or sets how special floating point numbers, e.g. , + and , + are written to JSON text. + + + + + Gets or sets how and values are formatted when writing JSON text. + + + + + Gets or sets the culture used when writing JSON. Defaults to . + + + + + Initializes a new instance of the class. + + + + + Flushes whatever is in the buffer to the destination and also flushes the destination. + + + + + Closes this writer. + If is set to true, the destination is also closed. + If is set to true, the JSON is auto-completed. + + + + + Writes the beginning of a JSON object. + + + + + Writes the end of a JSON object. + + + + + Writes the beginning of a JSON array. + + + + + Writes the end of an array. + + + + + Writes the start of a constructor with the given name. + + The name of the constructor. + + + + Writes the end constructor. + + + + + Writes the property name of a name/value pair of a JSON object. + + The name of the property. + + + + Writes the property name of a name/value pair of a JSON object. + + The name of the property. + A flag to indicate whether the text should be escaped when it is written as a JSON property name. + + + + Writes the end of the current JSON object or array. + + + + + Writes the current token and its children. + + The to read the token from. + + + + Writes the current token. + + The to read the token from. + A flag indicating whether the current token's children should be written. + + + + Writes the token and its value. + + The to write. + + The value to write. + A value is only required for tokens that have an associated value, e.g. the property name for . + null can be passed to the method for tokens that don't have a value, e.g. . + + + + + Writes the token. + + The to write. + + + + Writes the specified end token. + + The end token to write. + + + + Writes indent characters. + + + + + Writes the JSON value delimiter. + + + + + Writes an indent space. + + + + + Writes a null value. + + + + + Writes an undefined value. + + + + + Writes raw JSON without changing the writer's state. + + The raw JSON to write. + + + + Writes raw JSON where a value is expected and updates the writer's state. + + The raw JSON to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a of value. + + The of value to write. + + + + Writes a of value. + + The of value to write. + + + + Writes a of value. + + The of value to write. + + + + Writes a of value. + + The of value to write. + + + + Writes a of value. + + The of value to write. + + + + Writes a of value. + + The of value to write. + + + + Writes a of value. + + The of value to write. + + + + Writes a of value. + + The of value to write. + + + + Writes a of value. + + The of value to write. + + + + Writes a of value. + + The of value to write. + + + + Writes a of value. + + The of value to write. + + + + Writes a of value. + + The of value to write. + + + + Writes a of value. + + The of value to write. + + + + Writes a of value. + + The of value to write. + + + + Writes a of value. + + The of value to write. + + + + Writes a of value. + + The of value to write. + + + + Writes a [] value. + + The [] value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + An error will raised if the value cannot be written as a single JSON token. + + The value to write. + + + + Writes a comment /*...*/ containing the specified text. + + Text to place inside the comment. + + + + Writes the given white space. + + The string of white space characters. + + + + Releases unmanaged and - optionally - managed resources. + + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + + Sets the state of the . + + The being written. + The value being written. + + + + The exception thrown when an error occurs while writing JSON text. + + + + + Gets the path to the JSON where the error occurred. + + The path to the JSON where the error occurred. + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class + with a specified error message. + + The error message that explains the reason for the exception. + + + + Initializes a new instance of the class + with a specified error message and a reference to the inner exception that is the cause of this exception. + + The error message that explains the reason for the exception. + The exception that is the cause of the current exception, or null if no inner exception is specified. + + + + Initializes a new instance of the class. + + The that holds the serialized object data about the exception being thrown. + The that contains contextual information about the source or destination. + The parameter is null. + The class name is null or is zero (0). + + + + Initializes a new instance of the class + with a specified error message, JSON path and a reference to the inner exception that is the cause of this exception. + + The error message that explains the reason for the exception. + The path to the JSON where the error occurred. + The exception that is the cause of the current exception, or null if no inner exception is specified. + + + + Specifies how JSON comments are handled when loading JSON. + + + + + Ignore comments. + + + + + Load comments as a with type . + + + + + Specifies how duplicate property names are handled when loading JSON. + + + + + Replace the existing value when there is a duplicate property. The value of the last property in the JSON object will be used. + + + + + Ignore the new value when there is a duplicate property. The value of the first property in the JSON object will be used. + + + + + Throw a when a duplicate property is encountered. + + + + + Contains the LINQ to JSON extension methods. + + + + + Returns a collection of tokens that contains the ancestors of every token in the source collection. + + The type of the objects in source, constrained to . + An of that contains the source collection. + An of that contains the ancestors of every token in the source collection. + + + + Returns a collection of tokens that contains every token in the source collection, and the ancestors of every token in the source collection. + + The type of the objects in source, constrained to . + An of that contains the source collection. + An of that contains every token in the source collection, the ancestors of every token in the source collection. + + + + Returns a collection of tokens that contains the descendants of every token in the source collection. + + The type of the objects in source, constrained to . + An of that contains the source collection. + An of that contains the descendants of every token in the source collection. + + + + Returns a collection of tokens that contains every token in the source collection, and the descendants of every token in the source collection. + + The type of the objects in source, constrained to . + An of that contains the source collection. + An of that contains every token in the source collection, and the descendants of every token in the source collection. + + + + Returns a collection of child properties of every object in the source collection. + + An of that contains the source collection. + An of that contains the properties of every object in the source collection. + + + + Returns a collection of child values of every object in the source collection with the given key. + + An of that contains the source collection. + The token key. + An of that contains the values of every token in the source collection with the given key. + + + + Returns a collection of child values of every object in the source collection. + + An of that contains the source collection. + An of that contains the values of every token in the source collection. + + + + Returns a collection of converted child values of every object in the source collection with the given key. + + The type to convert the values to. + An of that contains the source collection. + The token key. + An that contains the converted values of every token in the source collection with the given key. + + + + Returns a collection of converted child values of every object in the source collection. + + The type to convert the values to. + An of that contains the source collection. + An that contains the converted values of every token in the source collection. + + + + Converts the value. + + The type to convert the value to. + A cast as a of . + A converted value. + + + + Converts the value. + + The source collection type. + The type to convert the value to. + A cast as a of . + A converted value. + + + + Returns a collection of child tokens of every array in the source collection. + + The source collection type. + An of that contains the source collection. + An of that contains the values of every token in the source collection. + + + + Returns a collection of converted child tokens of every array in the source collection. + + An of that contains the source collection. + The type to convert the values to. + The source collection type. + An that contains the converted values of every token in the source collection. + + + + Returns the input typed as . + + An of that contains the source collection. + The input typed as . + + + + Returns the input typed as . + + The source collection type. + An of that contains the source collection. + The input typed as . + + + + Represents a collection of objects. + + The type of token. + + + + Gets the of with the specified key. + + + + + + Represents a JSON array. + + + + + + + + Gets the container's children tokens. + + The container's children tokens. + + + + Gets the node type for this . + + The type. + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class from another object. + + A object to copy from. + + + + Initializes a new instance of the class with the specified content. + + The contents of the array. + + + + Initializes a new instance of the class with the specified content. + + The contents of the array. + + + + Loads an from a . + + A that will be read for the content of the . + A that contains the JSON that was read from the specified . + + + + Loads an from a . + + A that will be read for the content of the . + The used to load the JSON. + If this is null, default load settings will be used. + A that contains the JSON that was read from the specified . + + + + Load a from a string that contains JSON. + + A that contains JSON. + A populated from the string that contains JSON. + + + + + + + Load a from a string that contains JSON. + + A that contains JSON. + The used to load the JSON. + If this is null, default load settings will be used. + A populated from the string that contains JSON. + + + + + + + Creates a from an object. + + The object that will be used to create . + A with the values of the specified object. + + + + Creates a from an object. + + The object that will be used to create . + The that will be used to read the object. + A with the values of the specified object. + + + + Writes this token to a . + + A into which this method will write. + A collection of which will be used when writing the token. + + + + Gets the with the specified key. + + The with the specified key. + + + + Gets or sets the at the specified index. + + + + + + Determines the index of a specific item in the . + + The object to locate in the . + + The index of if found in the list; otherwise, -1. + + + + + Inserts an item to the at the specified index. + + The zero-based index at which should be inserted. + The object to insert into the . + + is not a valid index in the . + + + + + Removes the item at the specified index. + + The zero-based index of the item to remove. + + is not a valid index in the . + + + + + Returns an enumerator that iterates through the collection. + + + A of that can be used to iterate through the collection. + + + + + Adds an item to the . + + The object to add to the . + + + + Removes all items from the . + + + + + Determines whether the contains a specific value. + + The object to locate in the . + + true if is found in the ; otherwise, false. + + + + + Copies the elements of the to an array, starting at a particular array index. + + The array. + Index of the array. + + + + Gets a value indicating whether the is read-only. + + true if the is read-only; otherwise, false. + + + + Removes the first occurrence of a specific object from the . + + The object to remove from the . + + true if was successfully removed from the ; otherwise, false. This method also returns false if is not found in the original . + + + + + Represents a JSON constructor. + + + + + Gets the container's children tokens. + + The container's children tokens. + + + + Gets or sets the name of this constructor. + + The constructor name. + + + + Gets the node type for this . + + The type. + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class from another object. + + A object to copy from. + + + + Initializes a new instance of the class with the specified name and content. + + The constructor name. + The contents of the constructor. + + + + Initializes a new instance of the class with the specified name and content. + + The constructor name. + The contents of the constructor. + + + + Initializes a new instance of the class with the specified name. + + The constructor name. + + + + Writes this token to a . + + A into which this method will write. + A collection of which will be used when writing the token. + + + + Gets the with the specified key. + + The with the specified key. + + + + Loads a from a . + + A that will be read for the content of the . + A that contains the JSON that was read from the specified . + + + + Loads a from a . + + A that will be read for the content of the . + The used to load the JSON. + If this is null, default load settings will be used. + A that contains the JSON that was read from the specified . + + + + Represents a token that can contain other tokens. + + + + + Occurs when the list changes or an item in the list changes. + + + + + Occurs before an item is added to the collection. + + + + + Gets the container's children tokens. + + The container's children tokens. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Gets a value indicating whether this token has child tokens. + + + true if this token has child values; otherwise, false. + + + + + Get the first child token of this token. + + + A containing the first child token of the . + + + + + Get the last child token of this token. + + + A containing the last child token of the . + + + + + Returns a collection of the child tokens of this token, in document order. + + + An of containing the child tokens of this , in document order. + + + + + Returns a collection of the child values of this token, in document order. + + The type to convert the values to. + + A containing the child values of this , in document order. + + + + + Returns a collection of the descendant tokens for this token in document order. + + An of containing the descendant tokens of the . + + + + Returns a collection of the tokens that contain this token, and all descendant tokens of this token, in document order. + + An of containing this token, and all the descendant tokens of the . + + + + Adds the specified content as children of this . + + The content to be added. + + + + Adds the specified content as the first children of this . + + The content to be added. + + + + Creates a that can be used to add tokens to the . + + A that is ready to have content written to it. + + + + Replaces the child nodes of this token with the specified content. + + The content. + + + + Removes the child nodes from this token. + + + + + Merge the specified content into this . + + The content to be merged. + + + + Merge the specified content into this using . + + The content to be merged. + The used to merge the content. + + + + Gets the count of child JSON tokens. + + The count of child JSON tokens. + + + + Represents a collection of objects. + + The type of token. + + + + An empty collection of objects. + + + + + Initializes a new instance of the struct. + + The enumerable. + + + + Returns an enumerator that can be used to iterate through the collection. + + + A that can be used to iterate through the collection. + + + + + Gets the of with the specified key. + + + + + + Determines whether the specified is equal to this instance. + + The to compare with this instance. + + true if the specified is equal to this instance; otherwise, false. + + + + + Determines whether the specified is equal to this instance. + + The to compare with this instance. + + true if the specified is equal to this instance; otherwise, false. + + + + + Returns a hash code for this instance. + + + A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table. + + + + + Represents a JSON object. + + + + + + + + Gets the container's children tokens. + + The container's children tokens. + + + + Occurs when a property value changes. + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class from another object. + + A object to copy from. + + + + Initializes a new instance of the class with the specified content. + + The contents of the object. + + + + Initializes a new instance of the class with the specified content. + + The contents of the object. + + + + Gets the node type for this . + + The type. + + + + Gets an of of this object's properties. + + An of of this object's properties. + + + + Gets a with the specified name. + + The property name. + A with the specified name or null. + + + + Gets the with the specified name. + The exact name will be searched for first and if no matching property is found then + the will be used to match a property. + + The property name. + One of the enumeration values that specifies how the strings will be compared. + A matched with the specified name or null. + + + + Gets a of of this object's property values. + + A of of this object's property values. + + + + Gets the with the specified key. + + The with the specified key. + + + + Gets or sets the with the specified property name. + + + + + + Loads a from a . + + A that will be read for the content of the . + A that contains the JSON that was read from the specified . + + is not valid JSON. + + + + + Loads a from a . + + A that will be read for the content of the . + The used to load the JSON. + If this is null, default load settings will be used. + A that contains the JSON that was read from the specified . + + is not valid JSON. + + + + + Load a from a string that contains JSON. + + A that contains JSON. + A populated from the string that contains JSON. + + is not valid JSON. + + + + + + + + Load a from a string that contains JSON. + + A that contains JSON. + The used to load the JSON. + If this is null, default load settings will be used. + A populated from the string that contains JSON. + + is not valid JSON. + + + + + + + + Creates a from an object. + + The object that will be used to create . + A with the values of the specified object. + + + + Creates a from an object. + + The object that will be used to create . + The that will be used to read the object. + A with the values of the specified object. + + + + Writes this token to a . + + A into which this method will write. + A collection of which will be used when writing the token. + + + + Gets the with the specified property name. + + Name of the property. + The with the specified property name. + + + + Gets the with the specified property name. + The exact property name will be searched for first and if no matching property is found then + the will be used to match a property. + + Name of the property. + One of the enumeration values that specifies how the strings will be compared. + The with the specified property name. + + + + Tries to get the with the specified property name. + The exact property name will be searched for first and if no matching property is found then + the will be used to match a property. + + Name of the property. + The value. + One of the enumeration values that specifies how the strings will be compared. + true if a value was successfully retrieved; otherwise, false. + + + + Adds the specified property name. + + Name of the property. + The value. + + + + Determines whether the JSON object has the specified property name. + + Name of the property. + true if the JSON object has the specified property name; otherwise, false. + + + + Removes the property with the specified name. + + Name of the property. + true if item was successfully removed; otherwise, false. + + + + Tries to get the with the specified property name. + + Name of the property. + The value. + true if a value was successfully retrieved; otherwise, false. + + + + Returns an enumerator that can be used to iterate through the collection. + + + A that can be used to iterate through the collection. + + + + + Raises the event with the provided arguments. + + Name of the property. + + + + Represents a JSON property. + + + + + Gets the container's children tokens. + + The container's children tokens. + + + + Gets the property name. + + The property name. + + + + Gets or sets the property value. + + The property value. + + + + Initializes a new instance of the class from another object. + + A object to copy from. + + + + Gets the node type for this . + + The type. + + + + Initializes a new instance of the class. + + The property name. + The property content. + + + + Initializes a new instance of the class. + + The property name. + The property content. + + + + Writes this token to a . + + A into which this method will write. + A collection of which will be used when writing the token. + + + + Loads a from a . + + A that will be read for the content of the . + A that contains the JSON that was read from the specified . + + + + Loads a from a . + + A that will be read for the content of the . + The used to load the JSON. + If this is null, default load settings will be used. + A that contains the JSON that was read from the specified . + + + + Represents a view of a . + + + + + Initializes a new instance of the class. + + The name. + + + + When overridden in a derived class, returns whether resetting an object changes its value. + + + true if resetting the component changes its value; otherwise, false. + + The component to test for reset capability. + + + + When overridden in a derived class, gets the current value of the property on a component. + + + The value of a property for a given component. + + The component with the property for which to retrieve the value. + + + + When overridden in a derived class, resets the value for this property of the component to the default value. + + The component with the property value that is to be reset to the default value. + + + + When overridden in a derived class, sets the value of the component to a different value. + + The component with the property value that is to be set. + The new value. + + + + When overridden in a derived class, determines a value indicating whether the value of this property needs to be persisted. + + + true if the property should be persisted; otherwise, false. + + The component with the property to be examined for persistence. + + + + When overridden in a derived class, gets the type of the component this property is bound to. + + + A that represents the type of component this property is bound to. + When the or + + methods are invoked, the object specified might be an instance of this type. + + + + + When overridden in a derived class, gets a value indicating whether this property is read-only. + + + true if the property is read-only; otherwise, false. + + + + + When overridden in a derived class, gets the type of the property. + + + A that represents the type of the property. + + + + + Gets the hash code for the name of the member. + + + + The hash code for the name of the member. + + + + + Represents a raw JSON string. + + + + + Initializes a new instance of the class from another object. + + A object to copy from. + + + + Initializes a new instance of the class. + + The raw json. + + + + Creates an instance of with the content of the reader's current token. + + The reader. + An instance of with the content of the reader's current token. + + + + Specifies the settings used when loading JSON. + + + + + Initializes a new instance of the class. + + + + + Gets or sets how JSON comments are handled when loading JSON. + The default value is . + + The JSON comment handling. + + + + Gets or sets how JSON line info is handled when loading JSON. + The default value is . + + The JSON line info handling. + + + + Gets or sets how duplicate property names in JSON objects are handled when loading JSON. + The default value is . + + The JSON duplicate property name handling. + + + + Specifies the settings used when merging JSON. + + + + + Initializes a new instance of the class. + + + + + Gets or sets the method used when merging JSON arrays. + + The method used when merging JSON arrays. + + + + Gets or sets how null value properties are merged. + + How null value properties are merged. + + + + Gets or sets the comparison used to match property names while merging. + The exact property name will be searched for first and if no matching property is found then + the will be used to match a property. + + The comparison used to match property names while merging. + + + + Specifies the settings used when selecting JSON. + + + + + Gets or sets a flag that indicates whether an error should be thrown if + no tokens are found when evaluating part of the expression. + + + A flag that indicates whether an error should be thrown if + no tokens are found when evaluating part of the expression. + + + + + Represents an abstract JSON token. + + + + + Gets a comparer that can compare two tokens for value equality. + + A that can compare two nodes for value equality. + + + + Gets or sets the parent. + + The parent. + + + + Gets the root of this . + + The root of this . + + + + Gets the node type for this . + + The type. + + + + Gets a value indicating whether this token has child tokens. + + + true if this token has child values; otherwise, false. + + + + + Compares the values of two tokens, including the values of all descendant tokens. + + The first to compare. + The second to compare. + true if the tokens are equal; otherwise false. + + + + Gets the next sibling token of this node. + + The that contains the next sibling token. + + + + Gets the previous sibling token of this node. + + The that contains the previous sibling token. + + + + Gets the path of the JSON token. + + + + + Adds the specified content immediately after this token. + + A content object that contains simple content or a collection of content objects to be added after this token. + + + + Adds the specified content immediately before this token. + + A content object that contains simple content or a collection of content objects to be added before this token. + + + + Returns a collection of the ancestor tokens of this token. + + A collection of the ancestor tokens of this token. + + + + Returns a collection of tokens that contain this token, and the ancestors of this token. + + A collection of tokens that contain this token, and the ancestors of this token. + + + + Returns a collection of the sibling tokens after this token, in document order. + + A collection of the sibling tokens after this tokens, in document order. + + + + Returns a collection of the sibling tokens before this token, in document order. + + A collection of the sibling tokens before this token, in document order. + + + + Gets the with the specified key. + + The with the specified key. + + + + Gets the with the specified key converted to the specified type. + + The type to convert the token to. + The token key. + The converted token value. + + + + Get the first child token of this token. + + A containing the first child token of the . + + + + Get the last child token of this token. + + A containing the last child token of the . + + + + Returns a collection of the child tokens of this token, in document order. + + An of containing the child tokens of this , in document order. + + + + Returns a collection of the child tokens of this token, in document order, filtered by the specified type. + + The type to filter the child tokens on. + A containing the child tokens of this , in document order. + + + + Returns a collection of the child values of this token, in document order. + + The type to convert the values to. + A containing the child values of this , in document order. + + + + Removes this token from its parent. + + + + + Replaces this token with the specified token. + + The value. + + + + Writes this token to a . + + A into which this method will write. + A collection of which will be used when writing the token. + + + + Returns the indented JSON for this token. + + + ToString() returns a non-JSON string value for tokens with a type of . + If you want the JSON for all token types then you should use . + + + The indented JSON for this token. + + + + + Returns the JSON for this token using the given formatting and converters. + + Indicates how the output should be formatted. + A collection of s which will be used when writing the token. + The JSON for this token using the given formatting and converters. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to of . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to of . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to of . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to of . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to of . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to of . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to of . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to of . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to of . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to of . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to of . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to of . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to of . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to of . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to of . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to of . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to []. + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to of . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to of . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an implicit conversion from to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from of to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from of to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from of to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from of to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from of to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from of to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from of to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from of to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from of to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from of to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from of to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from of to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from of to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from of to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from [] to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from of to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from of to . + + The value to create a from. + The initialized with the specified value. + + + + Creates a for this token. + + A that can be used to read this token and its descendants. + + + + Creates a from an object. + + The object that will be used to create . + A with the value of the specified object. + + + + Creates a from an object using the specified . + + The object that will be used to create . + The that will be used when reading the object. + A with the value of the specified object. + + + + Creates an instance of the specified .NET type from the . + + The object type that the token will be deserialized to. + The new object created from the JSON value. + + + + Creates an instance of the specified .NET type from the . + + The object type that the token will be deserialized to. + The new object created from the JSON value. + + + + Creates an instance of the specified .NET type from the using the specified . + + The object type that the token will be deserialized to. + The that will be used when creating the object. + The new object created from the JSON value. + + + + Creates an instance of the specified .NET type from the using the specified . + + The object type that the token will be deserialized to. + The that will be used when creating the object. + The new object created from the JSON value. + + + + Creates a from a . + + A positioned at the token to read into this . + + A that contains the token and its descendant tokens + that were read from the reader. The runtime type of the token is determined + by the token type of the first token encountered in the reader. + + + + + Creates a from a . + + An positioned at the token to read into this . + The used to load the JSON. + If this is null, default load settings will be used. + + A that contains the token and its descendant tokens + that were read from the reader. The runtime type of the token is determined + by the token type of the first token encountered in the reader. + + + + + Load a from a string that contains JSON. + + A that contains JSON. + A populated from the string that contains JSON. + + + + Load a from a string that contains JSON. + + A that contains JSON. + The used to load the JSON. + If this is null, default load settings will be used. + A populated from the string that contains JSON. + + + + Creates a from a . + + A positioned at the token to read into this . + The used to load the JSON. + If this is null, default load settings will be used. + + A that contains the token and its descendant tokens + that were read from the reader. The runtime type of the token is determined + by the token type of the first token encountered in the reader. + + + + + Creates a from a . + + A positioned at the token to read into this . + + A that contains the token and its descendant tokens + that were read from the reader. The runtime type of the token is determined + by the token type of the first token encountered in the reader. + + + + + Selects a using a JSONPath expression. Selects the token that matches the object path. + + + A that contains a JSONPath expression. + + A , or null. + + + + Selects a using a JSONPath expression. Selects the token that matches the object path. + + + A that contains a JSONPath expression. + + A flag to indicate whether an error should be thrown if no tokens are found when evaluating part of the expression. + A . + + + + Selects a using a JSONPath expression. Selects the token that matches the object path. + + + A that contains a JSONPath expression. + + The used to select tokens. + A . + + + + Selects a collection of elements using a JSONPath expression. + + + A that contains a JSONPath expression. + + An of that contains the selected elements. + + + + Selects a collection of elements using a JSONPath expression. + + + A that contains a JSONPath expression. + + A flag to indicate whether an error should be thrown if no tokens are found when evaluating part of the expression. + An of that contains the selected elements. + + + + Selects a collection of elements using a JSONPath expression. + + + A that contains a JSONPath expression. + + The used to select tokens. + An of that contains the selected elements. + + + + Creates a new instance of the . All child tokens are recursively cloned. + + A new instance of the . + + + + Adds an object to the annotation list of this . + + The annotation to add. + + + + Get the first annotation object of the specified type from this . + + The type of the annotation to retrieve. + The first annotation object that matches the specified type, or null if no annotation is of the specified type. + + + + Gets the first annotation object of the specified type from this . + + The of the annotation to retrieve. + The first annotation object that matches the specified type, or null if no annotation is of the specified type. + + + + Gets a collection of annotations of the specified type for this . + + The type of the annotations to retrieve. + An that contains the annotations for this . + + + + Gets a collection of annotations of the specified type for this . + + The of the annotations to retrieve. + An of that contains the annotations that match the specified type for this . + + + + Removes the annotations of the specified type from this . + + The type of annotations to remove. + + + + Removes the annotations of the specified type from this . + + The of annotations to remove. + + + + Compares tokens to determine whether they are equal. + + + + + Determines whether the specified objects are equal. + + The first object of type to compare. + The second object of type to compare. + + true if the specified objects are equal; otherwise, false. + + + + + Returns a hash code for the specified object. + + The for which a hash code is to be returned. + A hash code for the specified object. + The type of is a reference type and is null. + + + + Represents a reader that provides fast, non-cached, forward-only access to serialized JSON data. + + + + + Gets the at the reader's current position. + + + + + Initializes a new instance of the class. + + The token to read from. + + + + Initializes a new instance of the class. + + The token to read from. + The initial path of the token. It is prepended to the returned . + + + + Reads the next JSON token from the underlying . + + + true if the next token was read successfully; false if there are no more tokens to read. + + + + + Gets the path of the current JSON token. + + + + + Specifies the type of token. + + + + + No token type has been set. + + + + + A JSON object. + + + + + A JSON array. + + + + + A JSON constructor. + + + + + A JSON object property. + + + + + A comment. + + + + + An integer value. + + + + + A float value. + + + + + A string value. + + + + + A boolean value. + + + + + A null value. + + + + + An undefined value. + + + + + A date value. + + + + + A raw JSON value. + + + + + A collection of bytes value. + + + + + A Guid value. + + + + + A Uri value. + + + + + A TimeSpan value. + + + + + Represents a writer that provides a fast, non-cached, forward-only way of generating JSON data. + + + + + Gets the at the writer's current position. + + + + + Gets the token being written. + + The token being written. + + + + Initializes a new instance of the class writing to the given . + + The container being written to. + + + + Initializes a new instance of the class. + + + + + Flushes whatever is in the buffer to the underlying . + + + + + Closes this writer. + If is set to true, the JSON is auto-completed. + + + Setting to true has no additional effect, since the underlying is a type that cannot be closed. + + + + + Writes the beginning of a JSON object. + + + + + Writes the beginning of a JSON array. + + + + + Writes the start of a constructor with the given name. + + The name of the constructor. + + + + Writes the end. + + The token. + + + + Writes the property name of a name/value pair on a JSON object. + + The name of the property. + + + + Writes a value. + An error will be raised if the value cannot be written as a single JSON token. + + The value to write. + + + + Writes a null value. + + + + + Writes an undefined value. + + + + + Writes raw JSON. + + The raw JSON to write. + + + + Writes a comment /*...*/ containing the specified text. + + Text to place inside the comment. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a [] value. + + The [] value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Represents a value in JSON (string, integer, date, etc). + + + + + Initializes a new instance of the class from another object. + + A object to copy from. + + + + Initializes a new instance of the class with the given value. + + The value. + + + + Initializes a new instance of the class with the given value. + + The value. + + + + Initializes a new instance of the class with the given value. + + The value. + + + + Initializes a new instance of the class with the given value. + + The value. + + + + Initializes a new instance of the class with the given value. + + The value. + + + + Initializes a new instance of the class with the given value. + + The value. + + + + Initializes a new instance of the class with the given value. + + The value. + + + + Initializes a new instance of the class with the given value. + + The value. + + + + Initializes a new instance of the class with the given value. + + The value. + + + + Initializes a new instance of the class with the given value. + + The value. + + + + Initializes a new instance of the class with the given value. + + The value. + + + + Initializes a new instance of the class with the given value. + + The value. + + + + Initializes a new instance of the class with the given value. + + The value. + + + + Gets a value indicating whether this token has child tokens. + + + true if this token has child values; otherwise, false. + + + + + Creates a comment with the given value. + + The value. + A comment with the given value. + + + + Creates a string with the given value. + + The value. + A string with the given value. + + + + Creates a null value. + + A null value. + + + + Creates a undefined value. + + A undefined value. + + + + Gets the node type for this . + + The type. + + + + Gets or sets the underlying token value. + + The underlying token value. + + + + Writes this token to a . + + A into which this method will write. + A collection of s which will be used when writing the token. + + + + Indicates whether the current object is equal to another object of the same type. + + + true if the current object is equal to the parameter; otherwise, false. + + An object to compare with this object. + + + + Determines whether the specified is equal to the current . + + The to compare with the current . + + true if the specified is equal to the current ; otherwise, false. + + + + + Serves as a hash function for a particular type. + + + A hash code for the current . + + + + + Returns a that represents this instance. + + + ToString() returns a non-JSON string value for tokens with a type of . + If you want the JSON for all token types then you should use . + + + A that represents this instance. + + + + + Returns a that represents this instance. + + The format. + + A that represents this instance. + + + + + Returns a that represents this instance. + + The format provider. + + A that represents this instance. + + + + + Returns a that represents this instance. + + The format. + The format provider. + + A that represents this instance. + + + + + Compares the current instance with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other object. + + An object to compare with this instance. + + A 32-bit signed integer that indicates the relative order of the objects being compared. The return value has these meanings: + Value + Meaning + Less than zero + This instance is less than . + Zero + This instance is equal to . + Greater than zero + This instance is greater than . + + + is not of the same type as this instance. + + + + + Specifies how line information is handled when loading JSON. + + + + + Ignore line information. + + + + + Load line information. + + + + + Specifies how JSON arrays are merged together. + + + + Concatenate arrays. + + + Union arrays, skipping items that already exist. + + + Replace all array items. + + + Merge array items together, matched by index. + + + + Specifies how null value properties are merged. + + + + + The content's null value properties will be ignored during merging. + + + + + The content's null value properties will be merged. + + + + + Specifies the member serialization options for the . + + + + + All public members are serialized by default. Members can be excluded using or . + This is the default member serialization mode. + + + + + Only members marked with or are serialized. + This member serialization mode can also be set by marking the class with . + + + + + All public and private fields are serialized. Members can be excluded using or . + This member serialization mode can also be set by marking the class with + and setting IgnoreSerializableAttribute on to false. + + + + + Specifies metadata property handling options for the . + + + + + Read metadata properties located at the start of a JSON object. + + + + + Read metadata properties located anywhere in a JSON object. Note that this setting will impact performance. + + + + + Do not try to read metadata properties. + + + + + Specifies missing member handling options for the . + + + + + Ignore a missing member and do not attempt to deserialize it. + + + + + Throw a when a missing member is encountered during deserialization. + + + + + Specifies null value handling options for the . + + + + + + + + + Include null values when serializing and deserializing objects. + + + + + Ignore null values when serializing and deserializing objects. + + + + + Specifies how object creation is handled by the . + + + + + Reuse existing objects, create new objects when needed. + + + + + Only reuse existing objects. + + + + + Always create new objects. + + + + + Specifies reference handling options for the . + Note that references cannot be preserved when a value is set via a non-default constructor such as types that implement . + + + + + + + + Do not preserve references when serializing types. + + + + + Preserve references when serializing into a JSON object structure. + + + + + Preserve references when serializing into a JSON array structure. + + + + + Preserve references when serializing. + + + + + Specifies reference loop handling options for the . + + + + + Throw a when a loop is encountered. + + + + + Ignore loop references and do not serialize. + + + + + Serialize loop references. + + + + + Indicating whether a property is required. + + + + + The property is not required. The default state. + + + + + The property must be defined in JSON but can be a null value. + + + + + The property must be defined in JSON and cannot be a null value. + + + + + The property is not required but it cannot be a null value. + + + + + + Contains the JSON schema extension methods. + + + JSON Schema validation has been moved to its own package. See https://www.newtonsoft.com/jsonschema for more details. + + + + + + + Determines whether the is valid. + + + JSON Schema validation has been moved to its own package. See https://www.newtonsoft.com/jsonschema for more details. + + + The source to test. + The schema to test with. + + true if the specified is valid; otherwise, false. + + + + + + Determines whether the is valid. + + + JSON Schema validation has been moved to its own package. See https://www.newtonsoft.com/jsonschema for more details. + + + The source to test. + The schema to test with. + When this method returns, contains any error messages generated while validating. + + true if the specified is valid; otherwise, false. + + + + + + Validates the specified . + + + JSON Schema validation has been moved to its own package. See https://www.newtonsoft.com/jsonschema for more details. + + + The source to test. + The schema to test with. + + + + + Validates the specified . + + + JSON Schema validation has been moved to its own package. See https://www.newtonsoft.com/jsonschema for more details. + + + The source to test. + The schema to test with. + The validation event handler. + + + + + An in-memory representation of a JSON Schema. + + + JSON Schema validation has been moved to its own package. See https://www.newtonsoft.com/jsonschema for more details. + + + + + + Gets or sets the id. + + + + + Gets or sets the title. + + + + + Gets or sets whether the object is required. + + + + + Gets or sets whether the object is read-only. + + + + + Gets or sets whether the object is visible to users. + + + + + Gets or sets whether the object is transient. + + + + + Gets or sets the description of the object. + + + + + Gets or sets the types of values allowed by the object. + + The type. + + + + Gets or sets the pattern. + + The pattern. + + + + Gets or sets the minimum length. + + The minimum length. + + + + Gets or sets the maximum length. + + The maximum length. + + + + Gets or sets a number that the value should be divisible by. + + A number that the value should be divisible by. + + + + Gets or sets the minimum. + + The minimum. + + + + Gets or sets the maximum. + + The maximum. + + + + Gets or sets a flag indicating whether the value can not equal the number defined by the minimum attribute (). + + A flag indicating whether the value can not equal the number defined by the minimum attribute (). + + + + Gets or sets a flag indicating whether the value can not equal the number defined by the maximum attribute (). + + A flag indicating whether the value can not equal the number defined by the maximum attribute (). + + + + Gets or sets the minimum number of items. + + The minimum number of items. + + + + Gets or sets the maximum number of items. + + The maximum number of items. + + + + Gets or sets the of items. + + The of items. + + + + Gets or sets a value indicating whether items in an array are validated using the instance at their array position from . + + + true if items are validated using their array position; otherwise, false. + + + + + Gets or sets the of additional items. + + The of additional items. + + + + Gets or sets a value indicating whether additional items are allowed. + + + true if additional items are allowed; otherwise, false. + + + + + Gets or sets whether the array items must be unique. + + + + + Gets or sets the of properties. + + The of properties. + + + + Gets or sets the of additional properties. + + The of additional properties. + + + + Gets or sets the pattern properties. + + The pattern properties. + + + + Gets or sets a value indicating whether additional properties are allowed. + + + true if additional properties are allowed; otherwise, false. + + + + + Gets or sets the required property if this property is present. + + The required property if this property is present. + + + + Gets or sets the a collection of valid enum values allowed. + + A collection of valid enum values allowed. + + + + Gets or sets disallowed types. + + The disallowed types. + + + + Gets or sets the default value. + + The default value. + + + + Gets or sets the collection of that this schema extends. + + The collection of that this schema extends. + + + + Gets or sets the format. + + The format. + + + + Initializes a new instance of the class. + + + + + Reads a from the specified . + + The containing the JSON Schema to read. + The object representing the JSON Schema. + + + + Reads a from the specified . + + The containing the JSON Schema to read. + The to use when resolving schema references. + The object representing the JSON Schema. + + + + Load a from a string that contains JSON Schema. + + A that contains JSON Schema. + A populated from the string that contains JSON Schema. + + + + Load a from a string that contains JSON Schema using the specified . + + A that contains JSON Schema. + The resolver. + A populated from the string that contains JSON Schema. + + + + Writes this schema to a . + + A into which this method will write. + + + + Writes this schema to a using the specified . + + A into which this method will write. + The resolver used. + + + + Returns a that represents the current . + + + A that represents the current . + + + + + + Returns detailed information about the schema exception. + + + JSON Schema validation has been moved to its own package. See https://www.newtonsoft.com/jsonschema for more details. + + + + + + Gets the line number indicating where the error occurred. + + The line number indicating where the error occurred. + + + + Gets the line position indicating where the error occurred. + + The line position indicating where the error occurred. + + + + Gets the path to the JSON where the error occurred. + + The path to the JSON where the error occurred. + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class + with a specified error message. + + The error message that explains the reason for the exception. + + + + Initializes a new instance of the class + with a specified error message and a reference to the inner exception that is the cause of this exception. + + The error message that explains the reason for the exception. + The exception that is the cause of the current exception, or null if no inner exception is specified. + + + + Initializes a new instance of the class. + + The that holds the serialized object data about the exception being thrown. + The that contains contextual information about the source or destination. + The parameter is null. + The class name is null or is zero (0). + + + + + Generates a from a specified . + + + JSON Schema validation has been moved to its own package. See https://www.newtonsoft.com/jsonschema for more details. + + + + + + Gets or sets how undefined schemas are handled by the serializer. + + + + + Gets or sets the contract resolver. + + The contract resolver. + + + + Generate a from the specified type. + + The type to generate a from. + A generated from the specified type. + + + + Generate a from the specified type. + + The type to generate a from. + The used to resolve schema references. + A generated from the specified type. + + + + Generate a from the specified type. + + The type to generate a from. + Specify whether the generated root will be nullable. + A generated from the specified type. + + + + Generate a from the specified type. + + The type to generate a from. + The used to resolve schema references. + Specify whether the generated root will be nullable. + A generated from the specified type. + + + + + Resolves from an id. + + + JSON Schema validation has been moved to its own package. See https://www.newtonsoft.com/jsonschema for more details. + + + + + + Gets or sets the loaded schemas. + + The loaded schemas. + + + + Initializes a new instance of the class. + + + + + Gets a for the specified reference. + + The id. + A for the specified reference. + + + + + The value types allowed by the . + + + JSON Schema validation has been moved to its own package. See https://www.newtonsoft.com/jsonschema for more details. + + + + + + No type specified. + + + + + String type. + + + + + Float type. + + + + + Integer type. + + + + + Boolean type. + + + + + Object type. + + + + + Array type. + + + + + Null type. + + + + + Any type. + + + + + + Specifies undefined schema Id handling options for the . + + + JSON Schema validation has been moved to its own package. See https://www.newtonsoft.com/jsonschema for more details. + + + + + + Do not infer a schema Id. + + + + + Use the .NET type name as the schema Id. + + + + + Use the assembly qualified .NET type name as the schema Id. + + + + + + Returns detailed information related to the . + + + JSON Schema validation has been moved to its own package. See https://www.newtonsoft.com/jsonschema for more details. + + + + + + Gets the associated with the validation error. + + The JsonSchemaException associated with the validation error. + + + + Gets the path of the JSON location where the validation error occurred. + + The path of the JSON location where the validation error occurred. + + + + Gets the text description corresponding to the validation error. + + The text description. + + + + + Represents the callback method that will handle JSON schema validation events and the . + + + JSON Schema validation has been moved to its own package. See https://www.newtonsoft.com/jsonschema for more details. + + + + + + A camel case naming strategy. + + + + + Initializes a new instance of the class. + + + A flag indicating whether dictionary keys should be processed. + + + A flag indicating whether explicitly specified property names should be processed, + e.g. a property name customized with a . + + + + + Initializes a new instance of the class. + + + A flag indicating whether dictionary keys should be processed. + + + A flag indicating whether explicitly specified property names should be processed, + e.g. a property name customized with a . + + + A flag indicating whether extension data names should be processed. + + + + + Initializes a new instance of the class. + + + + + Resolves the specified property name. + + The property name to resolve. + The resolved property name. + + + + Resolves member mappings for a type, camel casing property names. + + + + + Initializes a new instance of the class. + + + + + Resolves the contract for a given type. + + The type to resolve a contract for. + The contract for a given type. + + + + Used by to resolve a for a given . + + + + + Gets a value indicating whether members are being get and set using dynamic code generation. + This value is determined by the runtime permissions available. + + + true if using dynamic code generation; otherwise, false. + + + + + Gets or sets the default members search flags. + + The default members search flags. + + + + Gets or sets a value indicating whether compiler generated members should be serialized. + + + true if serialized compiler generated members; otherwise, false. + + + + + Gets or sets a value indicating whether to ignore the interface when serializing and deserializing types. + + + true if the interface will be ignored when serializing and deserializing types; otherwise, false. + + + + + Gets or sets a value indicating whether to ignore the attribute when serializing and deserializing types. + + + true if the attribute will be ignored when serializing and deserializing types; otherwise, false. + + + + + Gets or sets a value indicating whether to ignore IsSpecified members when serializing and deserializing types. + + + true if the IsSpecified members will be ignored when serializing and deserializing types; otherwise, false. + + + + + Gets or sets a value indicating whether to ignore ShouldSerialize members when serializing and deserializing types. + + + true if the ShouldSerialize members will be ignored when serializing and deserializing types; otherwise, false. + + + + + Gets or sets the naming strategy used to resolve how property names and dictionary keys are serialized. + + The naming strategy used to resolve how property names and dictionary keys are serialized. + + + + Initializes a new instance of the class. + + + + + Resolves the contract for a given type. + + The type to resolve a contract for. + The contract for a given type. + + + + Gets the serializable members for the type. + + The type to get serializable members for. + The serializable members for the type. + + + + Creates a for the given type. + + Type of the object. + A for the given type. + + + + Creates the constructor parameters. + + The constructor to create properties for. + The type's member properties. + Properties for the given . + + + + Creates a for the given . + + The matching member property. + The constructor parameter. + A created for the given . + + + + Resolves the default for the contract. + + Type of the object. + The contract's default . + + + + Creates a for the given type. + + Type of the object. + A for the given type. + + + + Creates a for the given type. + + Type of the object. + A for the given type. + + + + Creates a for the given type. + + Type of the object. + A for the given type. + + + + Creates a for the given type. + + Type of the object. + A for the given type. + + + + Creates a for the given type. + + Type of the object. + A for the given type. + + + + Creates a for the given type. + + Type of the object. + A for the given type. + + + + Determines which contract type is created for the given type. + + Type of the object. + A for the given type. + + + + Creates properties for the given . + + The type to create properties for. + /// The member serialization mode for the type. + Properties for the given . + + + + Creates the used by the serializer to get and set values from a member. + + The member. + The used by the serializer to get and set values from a member. + + + + Creates a for the given . + + The member's parent . + The member to create a for. + A created for the given . + + + + Resolves the name of the property. + + Name of the property. + Resolved name of the property. + + + + Resolves the name of the extension data. By default no changes are made to extension data names. + + Name of the extension data. + Resolved name of the extension data. + + + + Resolves the key of the dictionary. By default is used to resolve dictionary keys. + + Key of the dictionary. + Resolved key of the dictionary. + + + + Gets the resolved name of the property. + + Name of the property. + Name of the property. + + + + The default naming strategy. Property names and dictionary keys are unchanged. + + + + + Resolves the specified property name. + + The property name to resolve. + The resolved property name. + + + + The default serialization binder used when resolving and loading classes from type names. + + + + + Initializes a new instance of the class. + + + + + When overridden in a derived class, controls the binding of a serialized object to a type. + + Specifies the name of the serialized object. + Specifies the name of the serialized object. + + The type of the object the formatter creates a new instance of. + + + + + When overridden in a derived class, controls the binding of a serialized object to a type. + + The type of the object the formatter creates a new instance of. + Specifies the name of the serialized object. + Specifies the name of the serialized object. + + + + Represents a trace writer that writes to the application's instances. + + + + + Gets the that will be used to filter the trace messages passed to the writer. + For example a filter level of will exclude messages and include , + and messages. + + + The that will be used to filter the trace messages passed to the writer. + + + + + Writes the specified trace level, message and optional exception. + + The at which to write this trace. + The trace message. + The trace exception. This parameter is optional. + + + + Get and set values for a using dynamic methods. + + + + + Initializes a new instance of the class. + + The member info. + + + + Sets the value. + + The target to set the value on. + The value to set on the target. + + + + Gets the value. + + The target to get the value from. + The value. + + + + Provides information surrounding an error. + + + + + Gets the error. + + The error. + + + + Gets the original object that caused the error. + + The original object that caused the error. + + + + Gets the member that caused the error. + + The member that caused the error. + + + + Gets the path of the JSON location where the error occurred. + + The path of the JSON location where the error occurred. + + + + Gets or sets a value indicating whether this is handled. + + true if handled; otherwise, false. + + + + Provides data for the Error event. + + + + + Gets the current object the error event is being raised against. + + The current object the error event is being raised against. + + + + Gets the error context. + + The error context. + + + + Initializes a new instance of the class. + + The current object. + The error context. + + + + Provides methods to get attributes. + + + + + Returns a collection of all of the attributes, or an empty collection if there are no attributes. + + When true, look up the hierarchy chain for the inherited custom attribute. + A collection of s, or an empty collection. + + + + Returns a collection of attributes, identified by type, or an empty collection if there are no attributes. + + The type of the attributes. + When true, look up the hierarchy chain for the inherited custom attribute. + A collection of s, or an empty collection. + + + + Used by to resolve a for a given . + + + + + + + + + Resolves the contract for a given type. + + The type to resolve a contract for. + The contract for a given type. + + + + Used to resolve references when serializing and deserializing JSON by the . + + + + + Resolves a reference to its object. + + The serialization context. + The reference to resolve. + The object that was resolved from the reference. + + + + Gets the reference for the specified object. + + The serialization context. + The object to get a reference for. + The reference to the object. + + + + Determines whether the specified object is referenced. + + The serialization context. + The object to test for a reference. + + true if the specified object is referenced; otherwise, false. + + + + + Adds a reference to the specified object. + + The serialization context. + The reference. + The object to reference. + + + + Allows users to control class loading and mandate what class to load. + + + + + When implemented, controls the binding of a serialized object to a type. + + Specifies the name of the serialized object. + Specifies the name of the serialized object + The type of the object the formatter creates a new instance of. + + + + When implemented, controls the binding of a serialized object to a type. + + The type of the object the formatter creates a new instance of. + Specifies the name of the serialized object. + Specifies the name of the serialized object. + + + + Represents a trace writer. + + + + + Gets the that will be used to filter the trace messages passed to the writer. + For example a filter level of will exclude messages and include , + and messages. + + The that will be used to filter the trace messages passed to the writer. + + + + Writes the specified trace level, message and optional exception. + + The at which to write this trace. + The trace message. + The trace exception. This parameter is optional. + + + + Provides methods to get and set values. + + + + + Sets the value. + + The target to set the value on. + The value to set on the target. + + + + Gets the value. + + The target to get the value from. + The value. + + + + Contract details for a used by the . + + + + + Gets the of the collection items. + + The of the collection items. + + + + Gets a value indicating whether the collection type is a multidimensional array. + + true if the collection type is a multidimensional array; otherwise, false. + + + + Gets or sets the function used to create the object. When set this function will override . + + The function used to create the object. + + + + Gets a value indicating whether the creator has a parameter with the collection values. + + true if the creator has a parameter with the collection values; otherwise, false. + + + + Initializes a new instance of the class. + + The underlying type for the contract. + + + + Contract details for a used by the . + + + + + Gets or sets the default collection items . + + The converter. + + + + Gets or sets a value indicating whether the collection items preserve object references. + + true if collection items preserve object references; otherwise, false. + + + + Gets or sets the collection item reference loop handling. + + The reference loop handling. + + + + Gets or sets the collection item type name handling. + + The type name handling. + + + + Initializes a new instance of the class. + + The underlying type for the contract. + + + + Handles serialization callback events. + + The object that raised the callback event. + The streaming context. + + + + Handles serialization error callback events. + + The object that raised the callback event. + The streaming context. + The error context. + + + + Sets extension data for an object during deserialization. + + The object to set extension data on. + The extension data key. + The extension data value. + + + + Gets extension data for an object during serialization. + + The object to set extension data on. + + + + Contract details for a used by the . + + + + + Gets the underlying type for the contract. + + The underlying type for the contract. + + + + Gets or sets the type created during deserialization. + + The type created during deserialization. + + + + Gets or sets whether this type contract is serialized as a reference. + + Whether this type contract is serialized as a reference. + + + + Gets or sets the default for this contract. + + The converter. + + + + Gets the internally resolved for the contract's type. + This converter is used as a fallback converter when no other converter is resolved. + Setting will always override this converter. + + + + + Gets or sets all methods called immediately after deserialization of the object. + + The methods called immediately after deserialization of the object. + + + + Gets or sets all methods called during deserialization of the object. + + The methods called during deserialization of the object. + + + + Gets or sets all methods called after serialization of the object graph. + + The methods called after serialization of the object graph. + + + + Gets or sets all methods called before serialization of the object. + + The methods called before serialization of the object. + + + + Gets or sets all method called when an error is thrown during the serialization of the object. + + The methods called when an error is thrown during the serialization of the object. + + + + Gets or sets the default creator method used to create the object. + + The default creator method used to create the object. + + + + Gets or sets a value indicating whether the default creator is non-public. + + true if the default object creator is non-public; otherwise, false. + + + + Contract details for a used by the . + + + + + Gets or sets the dictionary key resolver. + + The dictionary key resolver. + + + + Gets the of the dictionary keys. + + The of the dictionary keys. + + + + Gets the of the dictionary values. + + The of the dictionary values. + + + + Gets or sets the function used to create the object. When set this function will override . + + The function used to create the object. + + + + Gets a value indicating whether the creator has a parameter with the dictionary values. + + true if the creator has a parameter with the dictionary values; otherwise, false. + + + + Initializes a new instance of the class. + + The underlying type for the contract. + + + + Contract details for a used by the . + + + + + Gets or sets the object constructor. + + The object constructor. + + + + Initializes a new instance of the class. + + The underlying type for the contract. + + + + Contract details for a used by the . + + + + + Initializes a new instance of the class. + + The underlying type for the contract. + + + + Contract details for a used by the . + + + + + Gets or sets the object member serialization. + + The member object serialization. + + + + Gets or sets the missing member handling used when deserializing this object. + + The missing member handling. + + + + Gets or sets a value that indicates whether the object's properties are required. + + + A value indicating whether the object's properties are required. + + + + + Gets or sets how the object's properties with null values are handled during serialization and deserialization. + + How the object's properties with null values are handled during serialization and deserialization. + + + + Gets the object's properties. + + The object's properties. + + + + Gets a collection of instances that define the parameters used with . + + + + + Gets or sets the function used to create the object. When set this function will override . + This function is called with a collection of arguments which are defined by the collection. + + The function used to create the object. + + + + Gets or sets the extension data setter. + + + + + Gets or sets the extension data getter. + + + + + Gets or sets the extension data value type. + + + + + Gets or sets the extension data name resolver. + + The extension data name resolver. + + + + Initializes a new instance of the class. + + The underlying type for the contract. + + + + Contract details for a used by the . + + + + + Initializes a new instance of the class. + + The underlying type for the contract. + + + + Maps a JSON property to a .NET member or constructor parameter. + + + + + Gets or sets the name of the property. + + The name of the property. + + + + Gets or sets the type that declared this property. + + The type that declared this property. + + + + Gets or sets the order of serialization of a member. + + The numeric order of serialization. + + + + Gets or sets the name of the underlying member or parameter. + + The name of the underlying member or parameter. + + + + Gets the that will get and set the during serialization. + + The that will get and set the during serialization. + + + + Gets or sets the for this property. + + The for this property. + + + + Gets or sets the type of the property. + + The type of the property. + + + + Gets or sets the for the property. + If set this converter takes precedence over the contract converter for the property type. + + The converter. + + + + Gets or sets the member converter. + + The member converter. + + + + Gets or sets a value indicating whether this is ignored. + + true if ignored; otherwise, false. + + + + Gets or sets a value indicating whether this is readable. + + true if readable; otherwise, false. + + + + Gets or sets a value indicating whether this is writable. + + true if writable; otherwise, false. + + + + Gets or sets a value indicating whether this has a member attribute. + + true if has a member attribute; otherwise, false. + + + + Gets the default value. + + The default value. + + + + Gets or sets a value indicating whether this is required. + + A value indicating whether this is required. + + + + Gets a value indicating whether has a value specified. + + + + + Gets or sets a value indicating whether this property preserves object references. + + + true if this instance is reference; otherwise, false. + + + + + Gets or sets the property null value handling. + + The null value handling. + + + + Gets or sets the property default value handling. + + The default value handling. + + + + Gets or sets the property reference loop handling. + + The reference loop handling. + + + + Gets or sets the property object creation handling. + + The object creation handling. + + + + Gets or sets or sets the type name handling. + + The type name handling. + + + + Gets or sets a predicate used to determine whether the property should be serialized. + + A predicate used to determine whether the property should be serialized. + + + + Gets or sets a predicate used to determine whether the property should be deserialized. + + A predicate used to determine whether the property should be deserialized. + + + + Gets or sets a predicate used to determine whether the property should be serialized. + + A predicate used to determine whether the property should be serialized. + + + + Gets or sets an action used to set whether the property has been deserialized. + + An action used to set whether the property has been deserialized. + + + + Returns a that represents this instance. + + + A that represents this instance. + + + + + Gets or sets the converter used when serializing the property's collection items. + + The collection's items converter. + + + + Gets or sets whether this property's collection items are serialized as a reference. + + Whether this property's collection items are serialized as a reference. + + + + Gets or sets the type name handling used when serializing the property's collection items. + + The collection's items type name handling. + + + + Gets or sets the reference loop handling used when serializing the property's collection items. + + The collection's items reference loop handling. + + + + A collection of objects. + + + + + Initializes a new instance of the class. + + The type. + + + + When implemented in a derived class, extracts the key from the specified element. + + The element from which to extract the key. + The key for the specified element. + + + + Adds a object. + + The property to add to the collection. + + + + Gets the closest matching object. + First attempts to get an exact case match of and then + a case insensitive match. + + Name of the property. + A matching property if found. + + + + Gets a property by property name. + + The name of the property to get. + Type property name string comparison. + A matching property if found. + + + + Contract details for a used by the . + + + + + Initializes a new instance of the class. + + The underlying type for the contract. + + + + Lookup and create an instance of the type described by the argument. + + The type to create. + Optional arguments to pass to an initializing constructor of the JsonConverter. + If null, the default constructor is used. + + + + A kebab case naming strategy. + + + + + Initializes a new instance of the class. + + + A flag indicating whether dictionary keys should be processed. + + + A flag indicating whether explicitly specified property names should be processed, + e.g. a property name customized with a . + + + + + Initializes a new instance of the class. + + + A flag indicating whether dictionary keys should be processed. + + + A flag indicating whether explicitly specified property names should be processed, + e.g. a property name customized with a . + + + A flag indicating whether extension data names should be processed. + + + + + Initializes a new instance of the class. + + + + + Resolves the specified property name. + + The property name to resolve. + The resolved property name. + + + + Represents a trace writer that writes to memory. When the trace message limit is + reached then old trace messages will be removed as new messages are added. + + + + + Gets the that will be used to filter the trace messages passed to the writer. + For example a filter level of will exclude messages and include , + and messages. + + + The that will be used to filter the trace messages passed to the writer. + + + + + Initializes a new instance of the class. + + + + + Writes the specified trace level, message and optional exception. + + The at which to write this trace. + The trace message. + The trace exception. This parameter is optional. + + + + Returns an enumeration of the most recent trace messages. + + An enumeration of the most recent trace messages. + + + + Returns a of the most recent trace messages. + + + A of the most recent trace messages. + + + + + A base class for resolving how property names and dictionary keys are serialized. + + + + + A flag indicating whether dictionary keys should be processed. + Defaults to false. + + + + + A flag indicating whether extension data names should be processed. + Defaults to false. + + + + + A flag indicating whether explicitly specified property names, + e.g. a property name customized with a , should be processed. + Defaults to false. + + + + + Gets the serialized name for a given property name. + + The initial property name. + A flag indicating whether the property has had a name explicitly specified. + The serialized property name. + + + + Gets the serialized name for a given extension data name. + + The initial extension data name. + The serialized extension data name. + + + + Gets the serialized key for a given dictionary key. + + The initial dictionary key. + The serialized dictionary key. + + + + Resolves the specified property name. + + The property name to resolve. + The resolved property name. + + + + Hash code calculation + + + + + + Object equality implementation + + + + + + + Compare to another NamingStrategy + + + + + + + Represents a method that constructs an object. + + The object type to create. + + + + When applied to a method, specifies that the method is called when an error occurs serializing an object. + + + + + Provides methods to get attributes from a , , or . + + + + + Initializes a new instance of the class. + + The instance to get attributes for. This parameter should be a , , or . + + + + Returns a collection of all of the attributes, or an empty collection if there are no attributes. + + When true, look up the hierarchy chain for the inherited custom attribute. + A collection of s, or an empty collection. + + + + Returns a collection of attributes, identified by type, or an empty collection if there are no attributes. + + The type of the attributes. + When true, look up the hierarchy chain for the inherited custom attribute. + A collection of s, or an empty collection. + + + + Get and set values for a using reflection. + + + + + Initializes a new instance of the class. + + The member info. + + + + Sets the value. + + The target to set the value on. + The value to set on the target. + + + + Gets the value. + + The target to get the value from. + The value. + + + + A snake case naming strategy. + + + + + Initializes a new instance of the class. + + + A flag indicating whether dictionary keys should be processed. + + + A flag indicating whether explicitly specified property names should be processed, + e.g. a property name customized with a . + + + + + Initializes a new instance of the class. + + + A flag indicating whether dictionary keys should be processed. + + + A flag indicating whether explicitly specified property names should be processed, + e.g. a property name customized with a . + + + A flag indicating whether extension data names should be processed. + + + + + Initializes a new instance of the class. + + + + + Resolves the specified property name. + + The property name to resolve. + The resolved property name. + + + + Specifies how strings are escaped when writing JSON text. + + + + + Only control characters (e.g. newline) are escaped. + + + + + All non-ASCII and control characters (e.g. newline) are escaped. + + + + + HTML (<, >, &, ', ") and control characters (e.g. newline) are escaped. + + + + + Indicates the method that will be used during deserialization for locating and loading assemblies. + + + + + In simple mode, the assembly used during deserialization need not match exactly the assembly used during serialization. Specifically, the version numbers need not match as the LoadWithPartialName method of the class is used to load the assembly. + + + + + In full mode, the assembly used during deserialization must match exactly the assembly used during serialization. The Load method of the class is used to load the assembly. + + + + + Specifies type name handling options for the . + + + should be used with caution when your application deserializes JSON from an external source. + Incoming types should be validated with a custom + when deserializing with a value other than . + + + + + Do not include the .NET type name when serializing types. + + + + + Include the .NET type name when serializing into a JSON object structure. + + + + + Include the .NET type name when serializing into a JSON array structure. + + + + + Always include the .NET type name when serializing. + + + + + Include the .NET type name when the type of the object being serialized is not the same as its declared type. + Note that this doesn't include the root serialized object by default. To include the root object's type name in JSON + you must specify a root type object with + or . + + + + + Determines whether the collection is null or empty. + + The collection. + + true if the collection is null or empty; otherwise, false. + + + + + Adds the elements of the specified collection to the specified generic . + + The list to add to. + The collection of elements to add. + + + + Converts the value to the specified type. If the value is unable to be converted, the + value is checked whether it assignable to the specified type. + + The value to convert. + The culture to use when converting. + The type to convert or cast the value to. + + The converted type. If conversion was unsuccessful, the initial value + is returned if assignable to the target type. + + + + + Helper class for serializing immutable collections. + Note that this is used by all builds, even those that don't support immutable collections, in case the DLL is GACed + https://github.com/JamesNK/Newtonsoft.Json/issues/652 + + + + + Provides a set of static (Shared in Visual Basic) methods for + querying objects that implement . + + + + + Returns the input typed as . + + + + + Returns an empty that has the + specified type argument. + + + + + Converts the elements of an to the + specified type. + + + + + Filters the elements of an based on a specified type. + + + + + Generates a sequence of integral numbers within a specified range. + + The value of the first integer in the sequence. + The number of sequential integers to generate. + + + + Generates a sequence that contains one repeated value. + + + + + Filters a sequence of values based on a predicate. + + + + + Filters a sequence of values based on a predicate. + Each element's index is used in the logic of the predicate function. + + + + + Projects each element of a sequence into a new form. + + + + + Projects each element of a sequence into a new form by + incorporating the element's index. + + + + + Projects each element of a sequence to an + and flattens the resulting sequences into one sequence. + + + + + Projects each element of a sequence to an , + and flattens the resulting sequences into one sequence. The + index of each source element is used in the projected form of + that element. + + + + + Projects each element of a sequence to an , + flattens the resulting sequences into one sequence, and invokes + a result selector function on each element therein. + + + + + Projects each element of a sequence to an , + flattens the resulting sequences into one sequence, and invokes + a result selector function on each element therein. The index of + each source element is used in the intermediate projected form + of that element. + + + + + Returns elements from a sequence as long as a specified condition is true. + + + + + Returns elements from a sequence as long as a specified condition is true. + The element's index is used in the logic of the predicate function. + + + + + Base implementation of First operator. + + + + + Returns the first element of a sequence. + + + + + Returns the first element in a sequence that satisfies a specified condition. + + + + + Returns the first element of a sequence, or a default value if + the sequence contains no elements. + + + + + Returns the first element of the sequence that satisfies a + condition or a default value if no such element is found. + + + + + Base implementation of Last operator. + + + + + Returns the last element of a sequence. + + + + + Returns the last element of a sequence that satisfies a + specified condition. + + + + + Returns the last element of a sequence, or a default value if + the sequence contains no elements. + + + + + Returns the last element of a sequence that satisfies a + condition or a default value if no such element is found. + + + + + Base implementation of Single operator. + + + + + Returns the only element of a sequence, and throws an exception + if there is not exactly one element in the sequence. + + + + + Returns the only element of a sequence that satisfies a + specified condition, and throws an exception if more than one + such element exists. + + + + + Returns the only element of a sequence, or a default value if + the sequence is empty; this method throws an exception if there + is more than one element in the sequence. + + + + + Returns the only element of a sequence that satisfies a + specified condition or a default value if no such element + exists; this method throws an exception if more than one element + satisfies the condition. + + + + + Returns the element at a specified index in a sequence. + + + + + Returns the element at a specified index in a sequence or a + default value if the index is out of range. + + + + + Inverts the order of the elements in a sequence. + + + + + Returns a specified number of contiguous elements from the start + of a sequence. + + + + + Bypasses a specified number of elements in a sequence and then + returns the remaining elements. + + + + + Bypasses elements in a sequence as long as a specified condition + is true and then returns the remaining elements. + + + + + Bypasses elements in a sequence as long as a specified condition + is true and then returns the remaining elements. The element's + index is used in the logic of the predicate function. + + + + + Returns the number of elements in a sequence. + + + + + Returns a number that represents how many elements in the + specified sequence satisfy a condition. + + + + + Returns a that represents the total number + of elements in a sequence. + + + + + Returns a that represents how many elements + in a sequence satisfy a condition. + + + + + Concatenates two sequences. + + + + + Creates a from an . + + + + + Creates an array from an . + + + + + Returns distinct elements from a sequence by using the default + equality comparer to compare values. + + + + + Returns distinct elements from a sequence by using a specified + to compare values. + + + + + Creates a from an + according to a specified key + selector function. + + + + + Creates a from an + according to a specified key + selector function and a key comparer. + + + + + Creates a from an + according to specified key + and element selector functions. + + + + + Creates a from an + according to a specified key + selector function, a comparer and an element selector function. + + + + + Groups the elements of a sequence according to a specified key + selector function. + + + + + Groups the elements of a sequence according to a specified key + selector function and compares the keys by using a specified + comparer. + + + + + Groups the elements of a sequence according to a specified key + selector function and projects the elements for each group by + using a specified function. + + + + + Groups the elements of a sequence according to a specified key + selector function and creates a result value from each group and + its key. + + + + + Groups the elements of a sequence according to a key selector + function. The keys are compared by using a comparer and each + group's elements are projected by using a specified function. + + + + + Groups the elements of a sequence according to a specified key + selector function and creates a result value from each group and + its key. The elements of each group are projected by using a + specified function. + + + + + Groups the elements of a sequence according to a specified key + selector function and creates a result value from each group and + its key. The keys are compared by using a specified comparer. + + + + + Groups the elements of a sequence according to a specified key + selector function and creates a result value from each group and + its key. Key values are compared by using a specified comparer, + and the elements of each group are projected by using a + specified function. + + + + + Applies an accumulator function over a sequence. + + + + + Applies an accumulator function over a sequence. The specified + seed value is used as the initial accumulator value. + + + + + Applies an accumulator function over a sequence. The specified + seed value is used as the initial accumulator value, and the + specified function is used to select the result value. + + + + + Produces the set union of two sequences by using the default + equality comparer. + + + + + Produces the set union of two sequences by using a specified + . + + + + + Returns the elements of the specified sequence or the type + parameter's default value in a singleton collection if the + sequence is empty. + + + + + Returns the elements of the specified sequence or the specified + value in a singleton collection if the sequence is empty. + + + + + Determines whether all elements of a sequence satisfy a condition. + + + + + Determines whether a sequence contains any elements. + + + + + Determines whether any element of a sequence satisfies a + condition. + + + + + Determines whether a sequence contains a specified element by + using the default equality comparer. + + + + + Determines whether a sequence contains a specified element by + using a specified . + + + + + Determines whether two sequences are equal by comparing the + elements by using the default equality comparer for their type. + + + + + Determines whether two sequences are equal by comparing their + elements by using a specified . + + + + + Base implementation for Min/Max operator. + + + + + Base implementation for Min/Max operator for nullable types. + + + + + Returns the minimum value in a generic sequence. + + + + + Invokes a transform function on each element of a generic + sequence and returns the minimum resulting value. + + + + + Returns the maximum value in a generic sequence. + + + + + Invokes a transform function on each element of a generic + sequence and returns the maximum resulting value. + + + + + Makes an enumerator seen as enumerable once more. + + + The supplied enumerator must have been started. The first element + returned is the element the enumerator was on when passed in. + DO NOT use this method if the caller must be a generator. It is + mostly safe among aggregate operations. + + + + + Sorts the elements of a sequence in ascending order according to a key. + + + + + Sorts the elements of a sequence in ascending order by using a + specified comparer. + + + + + Sorts the elements of a sequence in descending order according to a key. + + + + + Sorts the elements of a sequence in descending order by using a + specified comparer. + + + + + Performs a subsequent ordering of the elements in a sequence in + ascending order according to a key. + + + + + Performs a subsequent ordering of the elements in a sequence in + ascending order by using a specified comparer. + + + + + Performs a subsequent ordering of the elements in a sequence in + descending order, according to a key. + + + + + Performs a subsequent ordering of the elements in a sequence in + descending order by using a specified comparer. + + + + + Base implementation for Intersect and Except operators. + + + + + Produces the set intersection of two sequences by using the + default equality comparer to compare values. + + + + + Produces the set intersection of two sequences by using the + specified to compare values. + + + + + Produces the set difference of two sequences by using the + default equality comparer to compare values. + + + + + Produces the set difference of two sequences by using the + specified to compare values. + + + + + Creates a from an + according to a specified key + selector function. + + + + + Creates a from an + according to a specified key + selector function and key comparer. + + + + + Creates a from an + according to specified key + selector and element selector functions. + + + + + Creates a from an + according to a specified key + selector function, a comparer, and an element selector function. + + + + + Correlates the elements of two sequences based on matching keys. + The default equality comparer is used to compare keys. + + + + + Correlates the elements of two sequences based on matching keys. + The default equality comparer is used to compare keys. A + specified is used to compare keys. + + + + + Correlates the elements of two sequences based on equality of + keys and groups the results. The default equality comparer is + used to compare keys. + + + + + Correlates the elements of two sequences based on equality of + keys and groups the results. The default equality comparer is + used to compare keys. A specified + is used to compare keys. + + + + + Computes the sum of a sequence of values. + + + + + Computes the sum of a sequence of + values that are obtained by invoking a transform function on + each element of the input sequence. + + + + + Computes the average of a sequence of values. + + + + + Computes the average of a sequence of values + that are obtained by invoking a transform function on each + element of the input sequence. + + + + + Computes the sum of a sequence of nullable values. + + + + + Computes the sum of a sequence of nullable + values that are obtained by invoking a transform function on + each element of the input sequence. + + + + + Computes the average of a sequence of nullable values. + + + + + Computes the average of a sequence of nullable values + that are obtained by invoking a transform function on each + element of the input sequence. + + + + + Returns the minimum value in a sequence of nullable + values. + + + + + Invokes a transform function on each element of a sequence and + returns the minimum nullable value. + + + + + Returns the maximum value in a sequence of nullable + values. + + + + + Invokes a transform function on each element of a sequence and + returns the maximum nullable value. + + + + + Computes the sum of a sequence of values. + + + + + Computes the sum of a sequence of + values that are obtained by invoking a transform function on + each element of the input sequence. + + + + + Computes the average of a sequence of values. + + + + + Computes the average of a sequence of values + that are obtained by invoking a transform function on each + element of the input sequence. + + + + + Computes the sum of a sequence of nullable values. + + + + + Computes the sum of a sequence of nullable + values that are obtained by invoking a transform function on + each element of the input sequence. + + + + + Computes the average of a sequence of nullable values. + + + + + Computes the average of a sequence of nullable values + that are obtained by invoking a transform function on each + element of the input sequence. + + + + + Returns the minimum value in a sequence of nullable + values. + + + + + Invokes a transform function on each element of a sequence and + returns the minimum nullable value. + + + + + Returns the maximum value in a sequence of nullable + values. + + + + + Invokes a transform function on each element of a sequence and + returns the maximum nullable value. + + + + + Computes the sum of a sequence of nullable values. + + + + + Computes the sum of a sequence of + values that are obtained by invoking a transform function on + each element of the input sequence. + + + + + Computes the average of a sequence of values. + + + + + Computes the average of a sequence of values + that are obtained by invoking a transform function on each + element of the input sequence. + + + + + Computes the sum of a sequence of nullable values. + + + + + Computes the sum of a sequence of nullable + values that are obtained by invoking a transform function on + each element of the input sequence. + + + + + Computes the average of a sequence of nullable values. + + + + + Computes the average of a sequence of nullable values + that are obtained by invoking a transform function on each + element of the input sequence. + + + + + Returns the minimum value in a sequence of nullable + values. + + + + + Invokes a transform function on each element of a sequence and + returns the minimum nullable value. + + + + + Returns the maximum value in a sequence of nullable + values. + + + + + Invokes a transform function on each element of a sequence and + returns the maximum nullable value. + + + + + Computes the sum of a sequence of values. + + + + + Computes the sum of a sequence of + values that are obtained by invoking a transform function on + each element of the input sequence. + + + + + Computes the average of a sequence of values. + + + + + Computes the average of a sequence of values + that are obtained by invoking a transform function on each + element of the input sequence. + + + + + Computes the sum of a sequence of nullable values. + + + + + Computes the sum of a sequence of nullable + values that are obtained by invoking a transform function on + each element of the input sequence. + + + + + Computes the average of a sequence of nullable values. + + + + + Computes the average of a sequence of nullable values + that are obtained by invoking a transform function on each + element of the input sequence. + + + + + Returns the minimum value in a sequence of nullable + values. + + + + + Invokes a transform function on each element of a sequence and + returns the minimum nullable value. + + + + + Returns the maximum value in a sequence of nullable + values. + + + + + Invokes a transform function on each element of a sequence and + returns the maximum nullable value. + + + + + Computes the sum of a sequence of values. + + + + + Computes the sum of a sequence of + values that are obtained by invoking a transform function on + each element of the input sequence. + + + + + Computes the average of a sequence of values. + + + + + Computes the average of a sequence of values + that are obtained by invoking a transform function on each + element of the input sequence. + + + + + Computes the sum of a sequence of nullable values. + + + + + Computes the sum of a sequence of nullable + values that are obtained by invoking a transform function on + each element of the input sequence. + + + + + Computes the average of a sequence of nullable values. + + + + + Computes the average of a sequence of nullable values + that are obtained by invoking a transform function on each + element of the input sequence. + + + + + Returns the minimum value in a sequence of nullable + values. + + + + + Invokes a transform function on each element of a sequence and + returns the minimum nullable value. + + + + + Returns the maximum value in a sequence of nullable + values. + + + + + Invokes a transform function on each element of a sequence and + returns the maximum nullable value. + + + + + Represents a collection of objects that have a common key. + + + + + Gets the key of the . + + + + + Defines an indexer, size property, and Boolean search method for + data structures that map keys to + sequences of values. + + + + + Represents a sorted sequence. + + + + + Performs a subsequent ordering on the elements of an + according to a key. + + + + + Represents a collection of keys each mapped to one or more values. + + + + + Gets the number of key/value collection pairs in the . + + + + + Gets the collection of values indexed by the specified key. + + + + + Determines whether a specified key is in the . + + + + + Applies a transform function to each key and its associated + values and returns the results. + + + + + Returns a generic enumerator that iterates through the . + + + + + See issue #11 + for why this method is needed and cannot be expressed as a + lambda at the call site. + + + + + See issue #11 + for why this method is needed and cannot be expressed as a + lambda at the call site. + + + + + Gets the type of the typed collection's items. + + The type. + The type of the typed collection's items. + + + + Gets the member's underlying type. + + The member. + The underlying type of the member. + + + + Determines whether the property is an indexed property. + + The property. + + true if the property is an indexed property; otherwise, false. + + + + + Gets the member's value on the object. + + The member. + The target object. + The member's value on the object. + + + + Sets the member's value on the target object. + + The member. + The target. + The value. + + + + Determines whether the specified MemberInfo can be read. + + The MemberInfo to determine whether can be read. + /// if set to true then allow the member to be gotten non-publicly. + + true if the specified MemberInfo can be read; otherwise, false. + + + + + Determines whether the specified MemberInfo can be set. + + The MemberInfo to determine whether can be set. + if set to true then allow the member to be set non-publicly. + if set to true then allow the member to be set if read-only. + + true if the specified MemberInfo can be set; otherwise, false. + + + + + Builds a string. Unlike this class lets you reuse its internal buffer. + + + + + Determines whether the string is all white space. Empty string will return false. + + The string to test whether it is all white space. + + true if the string is all white space; otherwise, false. + + + + + Specifies the state of the . + + + + + An exception has been thrown, which has left the in an invalid state. + You may call the method to put the in the Closed state. + Any other method calls result in an being thrown. + + + + + The method has been called. + + + + + An object is being written. + + + + + An array is being written. + + + + + A constructor is being written. + + + + + A property is being written. + + + + + A write method has not been called. + + + + + This attribute allows us to define extension methods without + requiring .NET Framework 3.5. For more information, see the section, + Extension Methods in .NET Framework 2.0 Apps, + of Basic Instincts: Extension Methods + column in MSDN Magazine, + issue Nov 2007. + + + + Specifies that an output will not be null even if the corresponding type allows it. + + + Specifies that when a method returns , the parameter will not be null even if the corresponding type allows it. + + + Initializes the attribute with the specified return value condition. + + The return value condition. If the method returns this value, the associated parameter will not be null. + + + + Gets the return value condition. + + + Specifies that an output may be null even if the corresponding type disallows it. + + + Specifies that null is allowed as an input even if the corresponding type disallows it. + + + + Specifies that the method will not return if the associated Boolean parameter is passed the specified value. + + + + + Initializes a new instance of the class. + + + The condition parameter value. Code after the method will be considered unreachable by diagnostics if the argument to + the associated parameter matches this value. + + + + Gets the condition parameter value. + + + diff --git a/syft/pkg/cataloger/dotnet/test-fixtures/NuGetCache/newtonsoft.json/13.0.1/lib/net35/Newtonsoft.Json.dll b/syft/pkg/cataloger/dotnet/test-fixtures/NuGetCache/newtonsoft.json/13.0.1/lib/net35/Newtonsoft.Json.dll new file mode 100644 index 0000000000000000000000000000000000000000..fce555f89b996bba4ded5668b613387ca8d29d4d GIT binary patch literal 506920 zcmb@v34k0$^*`R*-P1kOGkeS)Gn?H_W)sM!GgmgdCQK5J5D7v!Bp6^f9D!gE0;F-4 zcx1Cn@aqKz6asz)xdidR3;lW@hzg4ORo4?l38>(K_x=6))#d;BysDn*+06#<|J$Ue zs$RW%_3G8DS7%qBwD~QDWf+Ey=b2{=iGZ)Z!Eimz*|KIHPp4Ju5xwTB>@o0D|r@L zx6Hy@S4*TlcTleQBX6b=Gmh~sPoMna(VpFWg-PdzxNZ-ME*!7#jh=$@m(X7-xT z8b;INjCIRI6KX5JTEnfGLDp$4bsY;jO7OUL8#Ae+p#}v_+_L{hu(GFE8|^n&vnI*^z6UCc~V_5XI;iw2kXgGBB8qm7K||SdiEx(~o$LGk>dP?>leAvtuJk zq--v<2rNNZ0^x)^^gGANrOzJ)axN)OFMm~DTTpNjTsZ4!BJ!CSA?*&CP{@gmCH(XA+9hp5PkL zD!M9|PY9RIiPFQS<@#w90jvtI)G5?g+SbH83qFd#xp}NBWjH!7$GsEP(FJ%4+)dCE zS1E=a({BesS2E6b3|ht|poz*&D?*;a>)xClNxHf+Q<>&M#Yx=U5i2ZB#}w~dIvjYl zG-L6!bMpiP@T6mRrtOXx>ifG=ht9PZ4Sms!i$<8PXbkeTjWY6$F<+5%tZZiT8L!Z3 zIwDxhc1HFQ=47EM3TNnNSt{%j@S9&`S`*?yvp9?rg2vJf!HD-Ogon)r3H>mkcmP-$ z0>lFV-1grRrn-))2x8Q7MxoUyg8LXnP)!oGw(a+m*Ph82 zsMtN?4w#vF{^5*3{qzpTj2FU%iA_t_@XlbBlr-K-_h#PX9)D{3{S$ zg9dK}D7D{ni;f%2ga60zywQYy!$jw?A!=nY31$i;kFjL=uATI?R*t>;<9|J<==^DOS}GE2;{e#4Vk|aFqQf1 z%{gM~S?lbU>g*R8!S^tDa;+-fi=clp#V}yz7Wprs54O-U(1^@Ap~)er??krx2oMq?Ov^2G(f?FLWm27#Qn5(AJOiYwfm%Y{|VR0 z4UDcwuV6fk2UgnnJ)TeDsXUDz^YZ&3J=KEDyYHueEd^oT{dM|}QvR>fe~R*dk$zYb z;(UqzW0e03^rL`;b2#I_Sot5If4%ZQNdK|Q4_=%67b*W&=s!;RAEN&R)MjlSxAjN)MPk|t>Ah%p4sWBRO|!6jNsZu+m7PeA+F{4 z=c_C_EtO1kA7<1@A`jbtxzGgKONo{@J1twK5WK9$izz(E4$c6+8KT3!+XiZaW88E< zM`>dpraID^k9`C`o-?+{q^-Au(~&TE8v?d#TEQejQQPiFQ_3s*-e+WomF*Q7?Wh$% z`yegxEkct+o(1+yCf!BoV+3%HIkg16kN;ob!SXK!fx8*bH^NCo!J~4YOO`0KD%0%;?lqnM+2p5|$a| zyNqRK|7jV}FQX+=S2HMH4vKbhi5)x$Pcc{Ma)YOkxVM~gtEZB=BH+8+;Ew>7eioHE z=&QUtj2FB}<<0&S=0N)HjzP!hM&7N+du(r#s%K@d=|SsVoN?~-w-AjuXfAb}#ddJ< zfl*mmJDEo8-Ye+Ko0gsNVeD%8vHz~;=UBnZKnz-U5uI3YDI9ZZDO(q7Ho^_7_;N-- z2QvPvYx(R_#GfahyKCtu=u>>cJU%}@3v=j4Ag!&zduu*Dd? zsL3nmV3%6q91MeGLBi;o17ydvCj=Qp&=mDo+t3Pw6wh~kqH*Csn03`PWSHA=7n zh!DsJ5itSXvCXcD6Xui!_IWZ{O=(%t9nxnHE#tE0WGsU!ORT&-NIpdkdr5UUo^f+eP4!(|b z9kKQp2Z7Frm&SSo*9pwvzY#I?V~i=k0Z*~Rf$y7*xQ_Ii$<9<~vstW|!M7Og6uR0S ze~MlgD+cXmyXAiXqyhXkfTf@AZ)ta?Gt0n~n!1EJbVV|#Cv#N?3*ME@Ki63F8g?tR z5itW=DSx*A9nkIxzRMhncJMv8Q1e{bzZmwS)NEI8hg4-~4si9ZXyDxp+=v90PqU$s z%;E|&$bj!+$*z7bL@|RbKzpIHO=f^jMtS`+>**SE%5TlJUvodO7f&s~DuMrfWV45w zK?5*Kmu*ix0BjBc;sM~y5Fj1^&I$qIL4!FN03R8sW+rWkAhx9!GwKIn)Wh&h5X7ic z81N-Xd#HfvodL)ecA)^Rl6gu>o^J{__^%6#18>V_QQxU`{3@2^>(J<;qj3S6p zr!lIrwG%|yoK2Uq5f5oKLZ6K;rjNwyRZ?@DRnS}RR-Rm<+@gH2Whg|UDN{=u`5a7)jkk&1gNl5-4Q}Bwtmhy*s(;cz+johowV5Np^}SDOUuQS$>pa%)?S^omq*?j*9f8 zTnCDL0!1lwgvq7ur@IzoWF9S3UX@94hpHA0Rtnst71)LBSr|t&iw(V|W_juB(3&|1 zfb6p<6V}P{&iv8!aX_2(gLY#~;4!ru`U~Uj_H-9zlD5Ig&mrBUyAy`Bso3J)O*a*n z`pz4!=#~Ey6e_j9w@qYwsP&_ddXK|gob0td9oG7*>Iu&=p&nU)1pSu(K&?Gw*an<)1 zT#QmMg78w{F|K6@QSA)5oGmKhwbF#*H}cx&thZ2tPvKdD=kIvP`X!aWh%dS3-Qu>a zxn11!nw#KO9>$O9+Z0XkSENW`)-Hjkn7p~X(5!wd@QfpORoSF_Q@CN3z;^fMP5*CT9#X7vK1+(M@8u|ZA7nU&c0kkqMI&ph#*t{?gf zo7&Cku0z39T+2$;*l)oSG{JNC!Uk)hxU##GZ;;9ViABUH!3z;LLJ z&551Rl%`@|LYBTgGuH;L(9L>#(aN+SRV%%lfHCv|UZajaqeR+~cov%zGwuPei|3Rh z*@7HRALB%9;d97dljtjG?GM53G~?7pBRF*;JUWUqBxkGd--E1B5OhS|b4q7cFADjO zN?6(F+d*ugCSzXvoT2~@!&2D-pg;(rL+ag6Y{WfdV;+ z`)8`vCFz-FFcQ~{U^GWQw4R*_DJlBo+H+((vll=UkB6rnPodxJkwWCnKJDf_?NP+c zYAmU_(R|42nDB9`sYFq-b16*7Rl1*Bx#m$BUo#^ckHd_dY`!}`56bwpken)9WNNe8 z%m!^Jfa(7qIK*a`ECI}y`M$LU(hbrq-ez;Yb+xNl)`=Vv|ZF1pSMa@rr=oP%T2D{uBV)0csN|_#&a>A2|S~CUXSO^c(&rX z98YB*eoViMJeuqUoq-B*6i79tTxxjGtfo?7{c?ZQvHW5T8>FS=z!Vyc+8c_91;qYI zVui!a0M-efVKo66C?Eeltr^mQqkx|Lt-VNP_#rkO7ZYU@hl5WbR=( z!}2j$^e#s;?M<1x35~lx8f?LH+~LQ8i+m59?wNz7gV6qineMPkZL+vn-3)yngEqyF=z_L#5UK|&ZNc)RYY5r0v0 zo%qh3NU*r%4p?LFb+E8TB2+zb>-|nLbyyFZ z5C~#k!x&bvc(7dfS^zk9QrjjNvUw8(aV7C}jKX4%ii$CcAlj5Bu6-Fr(OVdJo6D_O z2*IJWd3kuskcX?_`l&DqeY-b7 z5ToA6C=3`>s#Zo3#Hgzog?>~;q096p2;xdOx+_@;uU>~nBd0bA!ICh-idNNzkLNJM?Tk(3V6I0?u-o?f@)FiWM7RewggYrM&D2E zg+m2}Lmh-eHG{(z0*49(hiwxMRmYrsJAS49%}EnBMVh}U#g(F(eqCdF#xAYdUsHxl zNtD~)0U-8HU5rz3VA^r==lC#O=)diO&O$8c0PB9B5>j66;9k;QHZvW|XB)qS{lyR? zZ3Wi>!H2g{D&r(@pBZcdW(6NWw1|nGU>T8v+d~*V!Ak^oH(?ky z1oQ+LP=?;kSm77;#j-i%ZNk6 z2!_PoSiA3G1kH<-gCVgg*6#N)f;L1V7!t!_jeitg3~{XS{~}CUxB^Nuw|2ju2^WV6 z84}xJ?fw8G2Equ2#NJrDKgftBVFW{BQmpY0!7JI*BMrzJ{|I5s{=#LB3?eplD98n2&(ua1!GZh>%m)RbwkHbi*vuV}ehF%lPdhJa-P0(&*ZG0RF&EPQn z7F(1X{0kPpXBo!TIH%`diI@(YVtW_^>@=FFIbhkrBND(ai6rbvJHdxBSm+FSy$Pg49twB(Q^BOd#b+7#MrZEYJUgLYTpJ9DfrlYN>Lq;Az;fz(*aIGH4_WZNxGPae`kXP_XRIjplB4XG$B7 zv4S4~ZjKYgy#^O)vAf(P(OXJ~#uUOByTL2hV329)DM>?^N4ToIP^>_vn9Bph$S?j56aCn`z}%8v_WcB0KV zkHW4Mlr7PDQU=S!7;7fwBNSyK3uf?yq70rHWsb8mE1qm|%gVu;t#pw%LZgm3Ksg`9 zC>i9{9xcKsGQwL*y)7^pOmrp2zubLh8ws9N)E%{7XO6Q=F5>9VPXJdvx4#r@6|*fk zhe;r-hmAYXOp(iCZm>luefiVOKb= z@mf^877tZJH{lh7{w@V}h1+2l?Nc~rGvt|E+uy?iaKR}SyoO#JlT$G~fR8bs% zWl_fEv@2uxqP2UL%!m2n#AgtcxuR|S8f^o00^9R{p}}c4rn}I+Ly=^#D5m=;EBH^a zV2%^i5pR#n7!p+-7t_9_w4mKkC|m~gp!brN15G(X%uQJgqd-$enPT-p^CqE5P)DLY zA%joQOh~UlnoSDD=U@~xC9O@GHzOg}y;W1HH&M`hyU--4!)y1#HtOj%x}Y7s7*V)- zN1BpWs{0nw#5(Vh!Y9X;s>=Y)JA@`d9m)2jj6%U@QsT*{rBM7?kX<Ttpab{7%m=w%$7;e!HoxaODxH|?rU zCKk97s`oN(@DL!Xm%)f%6seh;R1vjM0{}pqr1o{ihAj~$Fj6(DI)Ez+hoNwlKmk=# z01;2E<)P`bDCt-+Zlz-Z1(C;GiZgP~r5@p2i2((|n;$aGvi#SvIdLqz6m4jjeMj+7 zj8L<9SB;}mtRw`lfz2qIZuq*Ij7y*B%%7}Q8z>XB)F2ORj`2Uks)zX16a^~}-ULC6 zlEEZ~vnmS1S8swKM#*sUkud6qj3S6pGN8OajQRqj2x62BDSr?~J<}}K`g&yF_up47e zl>^L@H$f1iK1VXk!zc_jy$OQIC<>$)6%PPk3<2WVVEP=Rs`FVgQq8Nin*!?V1*osF z3|@}Jq+wzRrw>hMoQ}Mj;Y>SOM2!t2H~(Ga5yZa~5*H5u4}<{mfF|uJX|JFz`0qoy zl8J)|;@f$n>VjNn)}qbHrUlKDrI|t#UN_SDJs6S~5AyqR2oR6XZvotu%y0a&h~}J| zqkgD5X2~%4seVlt$|~r34$0U69U>_iK0=SAcz9zOn?HfFCh@ZMEAm-G3h5L zzxfJQ;dB>9rRvSKJ?|tKT8*aRnPZqadH(fOmTOJ_w=gt3CeO)%dQ};V6yF0rBo31x z&1FAbE?$TS3iTKPo0;rbyp&K&CgAJM-9JLKe=MvYHvSZHKQ}JMUPOb)$ozd)F=vi{ zA6|1DCdA&C^M+f1OF!N)rlUjt6dB!&5V=7d9k2qsW#_M-k;MNVkYOEuD-KRCGp*=e z%)pewIE;0fmF*`Rn`Q|_tq1rnxG_9eM8bseVSME_c+A}xZ`%G#P=-=mP8KB#n|=R(cV+*UQ+il{feIY$n+Y z2T_$Gf*bQ+N!&DXV|y1u!_;1M9(%d7_|)6fn#B#K)xFt{b#HF5yEpro=6h&kG2=fV zTl9mlLsW-rFXG$ytpCwVoJ$V5`6m8->Zr}j<4*rG&pdO~&}MTSosU)LspGRwPEyec=&wk77sAZ<$yI3IUlDe81{OEDo* z#J0gT#oQca$kX%?G zRZ(t!hbo%|Nf0!YU|v6D&GEGi;pcF;tEBE~{D@wKX-2W^mr0to^WXUT| z3yPER{|dKwS2k~EGX5jYL2@xHFzhjIJk*mm|pqcwVcY&2TGM;3uBzU-MFN7nRRK+VUBd3nh5wiuv(eam}xh zIG$U!1|oxd<{EV8Mg^T40%xy5mjidl8jL{Tj+cW9hO!XVuOW_A+tA+4j6NO=F5~n3 zZ?opqS)5@AtJx{836GRK1vx+0v#kkbKXGVMX?xf)W;t?!@y1-$$$FJ1r@=rYMz_ZJ z8*+n|{R)WSEF+py`6%)Ip8-~R@9d;fYklQ*ReinXgz_vH#!0UhA`{b;%6>R!wI?L*HIl@D4XxDqK4qGoYJ>8B;*3%A^Q1W=tX4#0&cEZLw zFM$izycOhJs532_o4b4s7AcI%MTpcI{V&!_M5D2>EgEh4PoR$SW;UyA6qfAR4TY+= zFL(TK9D}cBPJ`j%V2o}Bd8?<)ks$3+sKl;Tp`Pc42R_TLT)R<-$-Nsq;N~KSQYQ%4 z+1RJa;z&Cu_YRINT7IkMC@t=c=FrO0s^(zN(p07V&(<8mvgqdUxqp$OG>4DS+feYz z?Xy6xY7VbwL`dp6HwT$ly$v;Z1lof&PpKsoP>vCSOL!9W%p`Vz2P;;-C`&ycXKq?{)-K4vhPGg!T2z@WcOuhN)f1`U*Z)#P|>i)2= zv1W8gdGN;m<54hu7x$ZM%cgMUI6L$=!X6f9_{xS*Mz5H<0ot* zGe=nH_f*?(SA7b!Yh50PR-8*??^~Wr;nsS)4g}cO9E}uoqtAh09|zt=cy7USk9O&Q zwx@!%D&%_didOV{LtQn zbj$@$~XSM>1IwAiqg%za2CbN;4F~tX0nWU{@sl9GnYZ0{IjxU&+087 zVl5~iUN{4<8U7eOdt})|Ub~YwAkjI@iu@PM&EA#lA`TGwzl>ZlqyJcG&R27f3L{pU zy=q<}G*+4mR7eu3zT`~BCUjd5RgR3B{p`rT+)kXy_B|O7sP4JDw(3+LOk_vH;e?uI zs-**U6dm%2$?0llRhzbLY?!v8YmD|bGF?-ajqheXujyL;i;4xs>~K5O>if{!QdUop zG5>2AW@Pers=P}%L_CJ->E{xhtP#khU&Usy>H+>)mcPRmtfg&{VH&1y9IfF!U^+O? z_#-$OABUdxblzEv`SU*Rfnr$Pjh)akeBPQ#P$6i|C_IJl!MkY9>lAFsn%&BCR{4m+ zr&V#B?C9`^@Z-S>NqO!x9VO-Jrq=LK?~DP%t`H@oD!0^U9t0W0@d`5Q)Y;cz^Q=$W z&YiWQjNc_IviM!J<}Hu_gKMzqZB)*L6+viOc{hH~DqmXJpa2)Fz-xlJt>r=dUQj-! zf+c?9?GQj!-EQSmmVk3{;DscHZ8~E?N34RibR(C52b&>A4i`gI7SWS}XC6Jx@U+o$ z7Cam<@XEu=G)RPn_5X^RyBpQ- ztl^8J0M!ge(y@-X)}62oH0D+6)AYkkkMV%uL7eKIQM}QwkHt$I|ZV zi)eZU>=nvkd8+q@^;`WNeAr*R6YHaLOGI?BLQ{`v>Q1UM!7doJs?;PaGf+*va$ZB6 z48g;wV;QCN0L|K3yHcaNasPKB(++7J78g^_r3z<-BaP8;l*d|DKf;O)3B2`{1 zwj8_7Y!j++DcqP98}&D^iRd-(7sH>?{$t>;6T;m|%HZU`7PAjT%Z}NaRwNtCKOR&R zuk1F_spDQSEQ!`_mMU-02o{_-bEUS+@ejvjTi0-p&eW{_DHMM+anBg0pI%h{)pc!X zhW(Jxt|LveM=6$%F|l4(w>TbQcVD*~s;wp6Qg2w-vPS1%1wl9RAK{pR>-c{Lm12`@ zaTXqe{B7fJ6h8i}+{n5;;uc2N_rX)bgY67)XZjgF*u!*lJ#(c417*M9Tekh z(bIt*EBC5lu5{X>jh0O0O7pB-vD|6pCd#c=?rijwxuxZp1?!Kqsb=+q6zGl6^_df) zT^A@#(NWh=TIEP{PN1=Jkl2??BC9(7QV!z2pR3U3v*6P1u6f+A` z2FkNo_&NtXdf5MY`qk8&%V3UFSh1s#!^%y9g^o|&X!s>uzNExaIEYsV(z*hjnH>{! z*fJi6pbk_|QbohHDtaZ*F2QrPe$Is}Ys09bGF}l}Rz8k`FBC3ska{xg`0tom&cd~! zWE)EZDb<#UwG_@{r6?(!KC6BzF9c`~!T6H!@6!4?W>^iCLO-YXZd5f>Cl~R)f+fQo zdT{ull>yfYs|`9=Hs}gR<4yPfp$%xmI=qVUv4G}qaP*;2$WimOZ>GRapQp0;S|43C z()8!vSqpAMRi@&lfmvfx+`>E?7LMg2?Jc*u4CdT+tpNvTuA%T|k6MtzmBpxPY{UHp z9B1>VTmF$Sxg}hAx~1$`xkKe=Bm+O$4mR&OD9 zVzD89@~-=2C(@6J{rv}J_wGFMVSeYpJhZ zSDvQnanwo;BYCD;qnAe;Ra4Dq zkWEG=zXRgqqA7i0mbl5S-Viu;JRTi-Mpk#eYu#+!FXD}GuUz5gP`H145<}9 zgBb3>6h5L#T)2n5M_d=Mt&y9;HL{<{^_%s~zj`@aDc9y!aVspecC;s${nhJwA8w96 zqJg2Pwb@M~%G!vn=N4|n=2zIiCB(+z?ZAep!p(_X^KhGjC80M`lCu*y3ep+^r5+2% zCsaS34Z)3c@`;>}ic;C*J&)>CXnqp2It*3uBQL6LZmx`}b=i4WjMIW ztYZ;dZ~JSZ(|m85GZ;C*l9da;Qg&`|czYDQ{45=s(TB3Rm&-@Z9k~s!Su64fNVz_| zVXWDbBR3af_wH_#nr<6L)f`yk%$xWbehY1S5*|e|vaW>F4aIe7yZS~*uvfjTpTZox z%|99?94O#Dg9XaFf0Xw|T}wgVh@mzvHs%I6=CLN^w<~S;zZ-c<6z)&_4KQ$#R~>y; zzLL6ACC(+1Y1^y3600fkVk<;Ay7voMPW39k1<6EFOEAi`n|31{m%OyQz+VT3!7nb^ z5U(Qf*gYVD*?9G*HOBRIB{&gH#t$rG4dvM(97#SMv%Zc*8Yh0dw5RA6PD>}chf%^x zmlnuDOBl)jpm_6>m6xLmiYDLtJGeaerL#iI;pBN^<1UWtglV+(#?u74l!%wW^os-?gh!pUg%@I zn6)oC1f{{>acf8AVj!>b34{(>atm?W21iBqylS+W<`z&z+UHBb`n+ zmML8;Q(Biv5!v6@(H?0{>9i_NyDAQ{!0vx|oNk7>P`QeYYVY*VpelEyJF>&A>CPI1 zoXn;>M4wO0JSTmYs~@w&=V|H($+JroMdj(GyR@=QK38R#CA3IYWx}e;)T^pypk^g( zRKWtY|KlvH>S$%|fE5&d^bQrb7BVsZXbfbV`mm${@!r)`nhO1&Fqi$@)bO`j%O13} zf4iN(!506?7+&cUEIdes%@yu9#f*1@(sAr#8aiAvs}3pg3W$Hyxr+8&x%@ER{V!nH z5E(~c1;oyJRMBIzVZBA;pQRgB{d)sN?B9AT+Tz6=+%?~X2r56v4^9QGxl7!9c|!#! zn;Hk;OTxL*N97WWNC_+)mt^nhV_ys#q78*E;Nun&8BS(bS2-EhYtZTxP_!_)WotJQ zA*7id6{?Ly@=md}hM{v+XW_GB)xh@eoFz1{Bd372TR3p5Pi1iZP_5=+T7!3L zO}sAfCUkV!QMHDL_mN~MA!E{)LPqFs@y#MGg>YUO-ReL^7NcUvmvn6PRULdrL~-G$ zbw&Mo9d+IF(ARaO3M!0jei{=@9GOuUVd&#-JW&ngh_3i?qBJfnVD(4NA@utauVv=P;d}7=9tL50#qB zc@a)9^ucT(U&dErmP!5?r*UTJl|AiC47X&#mzo|IQ4;RG$QczGT%!(iUbeo+jRD{t zRDWs8SDW%335A%zHIuT`1(ZjlDA@I~Yba{37$_~>Ar)k|vWCL!GIL~y7Y5A9)gh{n zNwm7lVjCpIKf8E3-zexQ4_XU`k5X6WmJTx)=#K9X&xq-gt@=g~kN;}I&^Gab!xL*9 zn$_3W{KCYl8WT7|Ra;Abu6$fEn-2vNJ``>8K_B>dpq95;{b$WDe5|SQ(f<7T_@CMG z&>-PM(Iy}Cfse|(u*S^l1vNk9&UYg=N)2!xmPQh#f_UwB)~Vo5wSC7suXzqzPSWyC z6}&2c97Yt;T?zjL?iP4id|OSF7OmUQuw5n94K%&{AeK55IKF7)|OIF{8!m6*F;JmuP5&tCPujRLH z+W4)TWc4>uEXJCCiIoD}pAvT~-XEg}Hy2wI^xzKqUoip*PtoNo3gV$W*Vg3uE)e0n z3UBI(ysN-M;hQ`Yl22BWnYn&Nwp)1Ax#QeCaf9O_Tx>o2?*}#0$9j~L|G7E-3q-M& zSZEbeXSX{i7-RZx1|FtfLPFl!;`{d=-eIiPgN7@lcp_v09^7`MGM`XMbm;7c&{7?$z7Kh}Hce*+ zp`r3>gKX7x`U&X8uB&0w|HaavhFAeUmg&Nxt=0^2?IUd88r^397D-V!QU$2iPl!NS zJCeS!q|9SZq@2zXuZxNLY{jiweAiKFoc|pvGKL9!DT#Z2XFwE7ImYq#2@=(FGi>`Z zgs}as_@J6)a9v-@KM`Ud2~NUqp(h$!iaw&I2&CcV+h4@h3JSQO^uv77gePtV;42-L<84mv}jyIA~FgAua2G&rTf?2{l4 z0iTSuBavN%)Ya$_1l20FG!ntqr|3uiYo>o{J(;Q=G$PhbSYy(xcC#tTR~+z8@_d!Q z<)2Q5*44s0{Fe|AL6C4AA>(f%!qqq~A_c=eh4SL9-v@BUNA)-hRB?WaFD9G11CINgS;L(KHXu`Q@pV&zI)H!IsWESm6!gJ8AhegMhD+VBn*+_v!A~VBCr|JP! zyO!w^&n?~QVWBPg-jx=O!8T(Xd*H^X&zSd7n2@Es^^6rAr>)8K?}XIU)!BW>_IQM} zsZu5~<47aX_D5BGq?Na73Z~B&jr~m!OT@xO&@o4Ge=}^;QkR zTfoy@C-4v`>hUy@HQx~T_kigGq*Cj(ws8u|%0H{F4!N|d32hweM#|5Epp~(%y(nmA z2pg?*}eDYgkT*p`ca&bXHqHFr-Yi)ufHQ{@fFAq%^|R8C9DHU#WJ+RAJn>c*UB`yk%Yc!Ict+pUprD|3#>X{_EmCCe(9 z);2UARGaF9cus@5W@8$~mP5iS9oHkal}`)8kd5_##`vBER0OKpFI`6zpC z$=7{6yV%0hR=UOKO1C=LeQUg}$tpc6{91Bk zLzQ<3pN32f>drGa7%6OHSY~o3z><>lntG6<&^mzzZQZeOPo};~8?kmA ztaPeyGs{*h+GEP5s5=00R2&RpuP}Od;CnE-!eKi?ad)7DLE5al181gt25NfwTR`{C}!R;F;FB9VX z3NM8(5xj$#rztns1`xh{ybKpcTtF`jf$$<}9sgy3`Ph&1ip?(eCh%I0Cscqwgqkir zv_FOWCR_yPA^2lgmA)?#yqB4DCW5=@rd;Kbq;W~Pn&&$9d-0+Z*GcnILYxrW{$jy5Ld%8yhKT{TNu-@;)aF<%hyDMy68O+ zTXuALe~nNByiOEJ-^bEr;klch7D+*Gw4g`KC}`TvE9Iyj(Tnf%Y{ZXj{peh%D|sAUJtRtQxSS}s>eA7vXGAcvQLKdaP)&R_>EE6yR}4FRvX!V2(#dS`400)Pc@ z{MP_b#C~nMPuGaE_jDKpsRzryKoy*Q`ySBUB;^)sM!SS-`$pF%0f*_3>zAuk_JXM_G{HV7y1X43l0Y!K>gCKl=^1l^|j`XjL9f?>rb<Gn( zL7f(N9iA)jz>XU^z(B_M4W0^&FHay$;laeqXh+d|4BqzaN%hdiWba%Jc`c|>D*{Cas9r~oMU;Q4J1#-I36;akJAVx67T4ik$`J4<0Qi1j_^G`mX7w;+A~mKy8>dj! zX9Lf~zKzNc*B;KK7y^W%9i@2dOo~LENfFy99GzLYwf-AX?c(<@g%5i*5?C-3&N*64 zj?AL!RhhAb+n89lHLTq#&4MW2)X2Cjch{jay@w(E2uxk_Bz*#{LOL|%#Xr_qWt%TcnWxw@?C z(NVRzktJI>J9!DIC!RI+n`bdWNQ8-HAd~8^Gf|I@GO@45L_MBmAQRi4HT5-7CQfvu zt?*L_-X&HL#&OO3Z2v!?zF5sFqE-EGjjVqrlu=j+nOMk|@!h>G4^vIYmS=j2zhz}PCji?E8@f0;tEgh%k%0=uH$sAuzbR!e! zp#ihHaiJDt1WC^AiFJN=LjFU@vg4mnL!BvP+?&qorx6TwS}5^K;~J&4 zi$WbbD5a=AhU|qfAxb+~Bl`83MC;mD*8wXK?Ie2*lp5Gue8>#;4ooT3MrpI87y`(f z{~BngsAvhIyLTo5^Hfg(R!OPC3 z_G9r?H2ul_xOEvUi>7Dt@w~RH%Z>hxO4pCHXS+h}%00*ioq5npg&P3Q@~PoKE< zqM`eo;2MBX!5xFH@fFw;{w=uXTo}#8nVfeGmQt}en@ilbILn`I{>q9a; zkz@$<;_1UPA5Sz{Pc2zCEFe7d@H|`bdc%}iAa|n>^X4HDIqXGN^N|&vXjXmCH^KZ` z0#J?=2lVI2V~?oNHE7j)Y`vi8(dAhg@nD4y^{D{jL0wY^7sAC#4*Et1(T(3C_wNC{ zqP$Hnc7SV>7Xtqr!H)x9f9s2beohFmlOYe*Yz#i0er&j$C=^=Q=J-Lgo_ue<4`-#^ z#l~gkZjzeLP~T>qIU$c|1GGQ*-nk1z`D%4Bt{BFK0M@3tYe4pS>v$RJt3P7SwCMNs zx6*5A>uH#8PZ{r<(9_3HrPI?LzQ{1+Q|TlSekz^0>0BV$1VZ`~N3%Z9BXPh<9Rx?> zfYV&Znf3W1i33gxab9m_hHPurXMPxG2DhWuu)PD^);hgexDp4PHsVlC#Iw#E$3m~% zL@V8k#1Mk-zWbOD;U%RB$_Ne%hR+C+FC4Xf3o?asJ@dv33?gjo9mInx?;p{6 zJXF_X_yKncR)NfMrsJ0dumz>Q_)dV>tC(>C>Xm;AOQk3tt6cr1^$K>W>f{8-mn{H9D*m0=jC`Rd==dcKERC3 z;6rq5xd>Q3E@Il!RD%!C0hi*Ka$UBgQU5XvwLaDlzC9z--nj^qEWCMhH(e}T2R{-F z^+job9|9Pkeh|RnAA~M8sn6Tu4U1A6;zt1dj=#X5(6PxWSJVL_T7uMe~hWWH1U8GIVhX zUa(&!x_lVsE%+k?)g`c<>T8hIVR-$&VSum;+K599pCkfw!nG z5_5)An)IV6A_inKZZr9PWBHb%iuAB2(v{b{7~q#2Wk)bDr3d4)x$wE_Si)WWf~J#= z0^cHS<2<%2emuv2n0N_n;ikMZtrlE%cUbI{i@FM3W^e$tF{>Yj z40zfS1)1IRZ7ASg#g9P_>d0bd@Q?X_M5(il$MF>Keq}z_lFzlGKmGf`C{hL-$8Tj{ zYWZKHj5Eo?$uK(ah2Q@IesFCu?R$0@ne#}D>fEx!IQ%MoV;L`P($iB0!k38<4<4lB zKY(91D>v(Ykh*8de(Cwh3nz~1=F^h5LxxqMx^cC0s<6n7^PC86bt3pW)KKiKHSEN@ zN4!Ejo*hlaGs_-zN>H1^Kuv9G_7CF`{moVmSoAkrdjMo5czC#Fg>Sabldg*&yJZRL zuIkbty^SEwwa)|A2m4h1V|~Yr2SAeJph*t5tecfkZooSPiQyGy^_3tb#;xHj?d*XL z=c%DSiCE|HN>*|wSF+MGf0%c0LD*lRlx3)q9bT`Hq?R5MxJrW$dC=2SM#nCR%eW+( zp1yL*>cQRX65uysrRp3dh=K4JD2xXVd-A9sMh|k>6Gue-cQXUPze?8%{u>Sv6AE#W zKAVY7OdZ-hphum?M3nX*y*lT30PKU)t`ks)63I&4rjQvmh{3m5 z4o1HP)~+G?I$G(eF#7tL(fb%J{S{N+Ff;l_Mt>(veag(}jf|GQiK)4i(2zHm5>!XU z==Pb>*OGJTml*xlnbH5r)ISLGe%s9Gn;89Y7=821Xmt2q@JJYa%gpFo8U4dB8ZQtw za(+9b9}T1Lm>K;JMoS+~&hMNVeHWv}pfdWMGo$Zjv~;D6e%H+CcQabLNJhVBX7qa* z{Ww`WdG`6v`~`EJ0?fZ6f^7vKg6#d{(Kv8*25F&*@K_);SRM7l8SHHEcf{1c#LT9* zAo3+N6HfwmFpuXjJR^9p!DwKk+}MZbqj+HVji2KA zJ)R@cdGTq(GapYL&tZ5ftMFsmci)fkh|&?$E;g(1*gcSMA;AL_7?$_C!LL|MAj6h7 z=~0v*Gb~qs0vR7(f|>1&2S3-y*t2a?`lBc_JoY|C8DCVo5Xgz(*BbeYL>5I?$PACY zpU56Rl?2K5VhH#Pjr}EJi{2}2hQ~gju<>28ZN!cRztq@YAhuWsh0XBTk5Kubt-mvd zjkPB<_GgJLtwLclJoZ6F+nw%u8EL!0(;E8$VvA`}*bI+-NMXmPyUrtaJot&mevsH= zX%sfYWA`fT#B|qIVkZJrok;u3#1_M&uo)ivu)_AHyUr)J7yL|PbD$iKky()pk9|a8 zC#SnGp6N{|gC{liL&TP$wxZ4O*wacTsp+m2#7+fIY3v-a^)Q#T86LxN7fP^sy6Z4v zHwVAf*b9lRhsnfdcAyJfnoLhP2{cN%*UvBi!kP8c5hy~1vt?pjIg*5Ef9`w(L5 zu`_8iJoaCzlx@>p7ZJNHfZ~e;p^#0=PAJ+8%b{oRomQvH)9K(33j6ZK#Qu{G+{b{- zCQLgrNZ03z?VZOW9*c^tPHR)E>HjZMRhs_!%rkb~_}l(J0NsVQ&2jsS;6g8P9`yv+ z7|(Ko7s1Wq)(`O%%-oVq5!kVaEO=AoLRJftHZK3X5mE_WkDrbCSD4i|Ve?i%+LCd- zSB*U|q>=F&lu@lSV+_l)lqQ}eo=!X*3m=6C<=~m%13sq#j`d7=|0l#LT+A0io)IZo z>a8d2N~-sq^7c+LjDdSw^{*H)sn5)O5Deq;M>R9nCRPtdU}$A<5>B(jxpg?9mMM|C zi<(CHi_G;@HTJY7PQ+@2*(0MEjN(q$;~Gm1Yi$2LL|)whMbA*|vivO&6o;N$mehux zu=%};5(Zl6qy`Ny~59t48=Vvo&N^S;X<>et&9WAO2M z5N|Qqqxdd&9Ryl2;|-t#i^1=|n;+C`)MW={1*7^*oc=~l`NEOcf?t4JN9VOvhgx@J!x~8G$BcW*M?7b41J4z zW=z_|Qt%YpFz;-9hh_Q7SZsqcx=HbX*VN}-L*qLk93=~#3XV@R#x{(&BiG%cCnvwe zeT6IvX*#0QF_u$`CvST(y}Vdr*|`0*&AjdwX5{!P~5M z_1CC9`SGzG;N?H9SLUp-Pa!z*Y5YKWK12U!>5oldv(PhJ?1}r}%KXKWb%6_{+{DKW zH~2i<;_`OG-W$LwPG|V5z6IE4j+25i9(#SjWzSN->N(C#urU|huLv|*f-;R8l_CU~ zwGdF`8wdyocJKwD;4@{UW(8k_!|v%*VYMb8Yr1TQv)xhBwy`R$RY zgO{;fXah(1VH@C)2P=30s9pgd)_f2iuFZTIuHK1yI=T}D8L9pKc}CB$+K1X|3OU{8 zd<@kJK33NX`5&0olaP-@OksUZ*^?0as~7UU`f=g~Q}Ce2)D@Kq#D;iba$@x;v?HpW3; z1Av#x@>`%@c6ezzmI?kF-ryUIaIkAM9825DLXTT&PGh-Fc((wN7ZBsvEc%#>wMmQD zw0b_eg97X)j8+$X>JvaBN`91wXHQQCpWDGFIyXsy>jO|5XVhxL)HQ)`l}b(6Sbg~x zC>Nt!gFlN_h-?k&I>{Le*Qz>UUO1X$T#UT3*xqFQCJQ*6MygmevxQY`(s{1hZhR`b zvF_wm9Vd*OAJQ}VZ5xiexn`m1b!&Q7JeU$Do#y>LeCI_IeIiP3tFavUQRNSn~T@Rw^4mQ!yXJgUc)gtRosgw?8FVXiJm$` zf8x$)M;wRTZZoa8zXYVi9ZyYr=%)}4`%0{%@+=$9@?!;TvE|;7a?umwp6WREOj(G$ zc7+R1`VJrreP7StFyb{{&h+^7H?rXtYbGKTd*}~nx*1xDA4`#3Kg$4Fa`QctkFmU5 zk1K#qm2_lx#i~9P+7b(2YcqN=WQ?Pm*-v!r(L7G~f?2qT5sW*{ak^Mu71s)$kaXir zrmS)R`{E7oy?;T(Y9HO;Cw08wI2Qi4nUru0l)G#ZN*ED(`Rg?vR+dNzruk02e`Ze*VVW|FVS{b{x3kpwCy$Du;j{P-4 z7$AH{mmpdFJr%hL&|Ml8`;Wr2P?NqhSio$$YH~?dH!ckmY2*NNDlh-#8r6^05NySq zqG?Bn_A|xIx`>Jz6EECZFtY%^0jqV5NmgNA!k0)?9;&(2S*at;$qFV`?9Q#rC!ynZ z@LS5r%j92gj{gqc5^iawJN7Z4b@IM(5Ar93V;zdOw7B|8upt8qbBeW~&PZ@QH8P8U ze0DMtCvr-QB4}5#AMS_%7IBD=!yH)*xkN!0m%=LNKI$G07vWw>7c&R)g*Hbp?t~U7 z^(F!R!7L+f;xz3BG<2m;G1^a_;Ym-vfeA3w`U8qkj9HmeG3)eqlbKd4d#cF`+0_aY zz+|b2izxmCSkhHkOQxXZYAg|s6kJK9h6|t}>r;79&gNH6zLD7luLQF<=Z~G@3{<3~ z#wMJx{28>x9y+q0it$BytjrUx=J;QjtvUWzIH`EGzhGQe%kj?OZ-6c?Wd`Ea%IpZ- zBZ-fUIR0z#-R1;O_7o;?XPu32<}L&2vA>6T+VV|EaK||YB(@O}!*}Ft2#XU>y8U?A z0ToWecGoG$N>#Y5#MyF^NA(ERd&4+&17I~@gpSHYvbq-D*~z5+RbN9i@ya zIS<(>;UcU3t+CFH8E=1lK)I+^jvM%w$ry2LGc<7?u?{@Hie~kg)FA7;nYQjkuLXEh?Ufyo$%!zPM{`RoO*TX2->J43+p+P|NbhUXQ8#)0iNM z2;QVjP|UO~{~tP9ee&rLQ`TLQ_7oRXq~?cPWA51BKx!{Rq_h+LU@yArK6?tCUJWZg z_J5$YmmtBS2cL44<&$Q6iis4#WDFnDei9S~jk9?UI9I(N(uq=R!|-zKpAnMw6nX}o zT?&zzv41J%?J3v>9l=!oNhs=G!jMB_&WLc-a1{=|VHEAYu$mb}LTnW4BjB zpX@1Wm=d;W=FO6)N%KQK(r!*+Q85O@E?y5vsq8SeusIJhu%3kPjxVbzo}QPO`N^wb z9UOZMhX=gC!B5gHw&Oi`7hZ5F>?4orBVqfoWW(ALRg_OdmrKTFx)oy00&i1t{)Hir zv?0qJi-XceG@$r^B`rt{V%T<4sj%(f%@(AA?M&;|z$JFi=^I_&3V3J={vEe~@id0e z(x-n9w8oJ~EVIex*Pu;nU#>LGCAl_ib^?GeHMBM1bHQzp>PXVgd4nzZ8D2`n!O`yJ z{Z^`wG2;w0Co)4Z9CcfcWby1sD((*bygP4U?0F^*9uR|*t;`T^B2`E^FScQGIyTDl zd9e-43u;h`J8Tb#9S&LDp~s;TX=hU%a0fIewxJ(o*)wb+GPYscCVs!vG`<1YZYkgP z)1F%aJDyvS&OR`cc)34zBFeN~73#$2Td33Og}M!2_lunfizI)#U?*-njnhfgUEH_| zeZd6FHr=%djp12~hgBt1N^`u!&UC~w+dCXQZl)ui=}5F=Asovdz3o`yhEeIQVEMo> z-F+RYbP9Lhrt!PJ?Bf?#-B#{I{;oyk!0U=a{FcM42cayf+$w5R4#zn+BQQ8R($SKRrCXNS>6Q*q z#MXLz=$q;0RY~xij%~wdVbFIOM6IU=zk`GflV>ErjlE&%)(ql}X~b8@PY z_7z>BZ#WM6EATp)mnpc}g3Uu9{+nSOK(npAO+I5@a6$Z9z)EH0*Rd?kFA8l}CEh;L z;S^eNUv30|*Uqye9q~dpZoR!3R=R{r#QSykz>Di|M>-O!phvC5t4k19VuXz^Z6`+A z3X#De?6|`l*1apKJ%v&j%w{qfB8+}#%tI_MGRLL8g2{{66*}7Skugd+o{oVF;Ll%< zmPdE(*D11CcKI=}*vm;;2*$EedXlAz?dLbHYd`Zc8I@}@aw@(IZCOav;svvY)Iy|n zX|JQBy+a8h)!sSXh0Vg=bY~$2;M*Y%*`(@7=T>yIx2I*3JKc^G{b|_%-%=EVA-Uu{ zb%k$hSjtK#ir7$!h)kpml|Qkt{|*DZiKNCu7AEn@p|sA*ZwncKm=Ax8XduL#>l?`o zW@9*&GnobgJ_Slg*vRIEKz{?T+cdMa;uMb4@%!ba2C$1n2@rd%{`7eAw^!V))kECELoa2Nm?H+KO6 z=MiuQ05PP-cqg_Yj*iS3?b)2mZP_}qNmhsKq4$w-=7pPawt9u`mC4<=-Q(H(RP zfCf?k^E3d8t}uEufTmM0dNtsyAx57DTo_`^*MKjE7z;Gur6EQxp&?%iQF5M!Y^&iU zHRKC5oRo&J5eP52W)1ml4W~szFcQ)@ts3$`4W~^*&a2_1HRQn>PP>L|t>JWN$d_w4 zof>j}4W~;(zEZ=*25(PFN8OYdB#|U=>i) z39Ev(O3?}HVr2~{r}?2~Dx7`|xu}M-P(z>v8fTG)oKV9#L_=!B{M>+saFU=XFVT?N zbOP5JDh=FU!&xejJ)Ak`ISV0WDV+x zsJ{mFPSv$pgZic-I;COrr|K%LK?|lLDy(6-#8gCQL!dVmQNR$GoQh~%2uw{yR4fEG zPepVp1hz~?lqdwYPDN@v1h!2@R4D|e>jDeKnrpA`DCd?a#64V9=$v*=hTzBM!Cs8@ z;AanK6KcF>8ILOSV$7Fi+Qn0SeEatM=<)ZUm$Iw(z&`qKV(=CQKUxdk%HaLA;B5>} z)q=M(_|sbO4hH|H7JLVTZRLE&!$8BwYE239j2Pl>U2{__)@SD~oWi*m2DQcGkKq-xwyWhe@=ac3Zq+n?9 zbmit!gC_!y;;SWG0{{hxgxA#)4j>^zgZStRU6rvS;`gFfr%mpxWw3{iQ&s0OFMj#^ zJb3iHDrO8f83y(}v4*q3+17677I5_vZ9dUhFS`|J-`4`;N44=8$OyTRPZe?iR1p1g|w{IkxihI zD=Qu*vFnPndc45AV2-mktqq*JCEd)>GJFSj5Hsp=BILZy?uekWBLyu^`8I((D}I^n z%pbbnnZK-8UCE-7Oj6P3JEJ#jmUK1Vu&_poK@SyoPesOjzTbRg`;$0r8&+(?)<@`gULr0U%DB_ zs|bq7By||G-9j6V#0uFEqPbZ1QoJ~>t7=g4#E;JIcxo)p8S0F%C(8gb8U#zAxwMYD zpb-@(hc#+UP<3X|FqDU~!1zbb99aJ!Yi|N4S5@WlSKfQ|YUw4Z?oL&wJ4q*j4v(&? zPUsGpPFTV!ivnRYVP9qEK~>^H(``UO#Q-BHI&n}$(QzGD98noua2=gE<2Y`_9TjzS z+{Y#UzrSWe1qoW z9K*sEnXjiDu3p2YV%4g0ZgrK-#Hy9${OT1Lq+7M5Tv)w`w`W!j1Vo@+`N`|2u!)Uy zAoj`O!b)TIV%xQWq^?=^#)a|*RbD^k@l80kr7%q6WE^WB}`Wi9Y~0FO<`s3~0L5`M=%=9%7k0Nx@09{*JyvKyqM zHO^x8^0uGJqT0An6Peu`I-5d zXeou3qY-|qU5(e0YoZQd^z+O{(+lX=#5@zW7o}{U{DhT+ryRLts)I=`gH7c!hHsg^ z2)X{IJo-BGsJJ{l<+9x6GMf}#nan2zNksN+>JVL{8BF!}GUt-ZwlMHz$42)6cX7Jb5H`oJFb%SkmV@<)hXE5g?F}4wc92O%+!z+^sQa`%))t50?n%?x(ltodr+Z;l%LBtBa+-K9Ibviy8{aO zIZI8J-0n(oex^JlUlnbOzImOTM9Nzz)Gf_!VU7+YTSe81cvXaga z|eRw`s zM=oRxnuwe;B%(|wQF>b=545!h|0ZAkd1f%Bd^lSU-WN9;;MC$o2OcRLu|sgH$B?~* zHT6;hs4hb>9j#cK_RJ1=*(I^Jhg-F~0R1B?V5EQI^u!gdJ|QW{Rc$?2F=zBY`YV^Y;=>TdSqwItx1zcs}G#pazk@lu8ZW&q)~j=Zj1J8w`eAbfWX-e&3(7o zXQ@WJ&5m!i*?od{w%K+AbhO#*-ffoD>e7xD+tg~YljpS9hK?3nvuBHCWe&fHy~VwH z#a9Q zeC;5lJd3JS#zjlDN_ni@owSUI^!oN^~R>tTaqnlhDIs3ju zzwWEl9GOaKq+hzYeIDKJRx;+{i9L6?Y3#;oKicz~6nkVfR>YNhftMZS z#MZBW-_ExBGJNSM29MRo6bN)wMPM>OA)j@@EK&ipw*PUO6Tn z;hZar;j(wrGUuR*X^ykmfGm4E2WsbZ=Z83n><;thHTe6P!_UFU*)ll{a_u}IBKy#! zzoMU%aSkwLEGF5=0Opn|POPG+<* z_*g~#O%gTQD@z`l?=0mwVoMJpE$Hb=&3x#$ z-keBsLX@%xa<<5!H9O4OIVX@#SbR_cH|qzM!BrwKCH}o?v0Al2bFmsN?x@A_!s9(j z*+>FA%5G(!W*ncO$PXux_tgZ|4q68BiHiQ&xzSCL*5A&eI-F>sx|TBY(mar$BxomE zJ0T{~H-3hIu5$4+<=z9|&OA|#OXK?S$%;J88hAZphOxn3#WFrS$+$-3Vs&*GpF%|R z1vK(yw((TFrZS0pquioz^E6y<6ynKcflu!m3AdtoJ}-HZi#>Dk8?81to!E(P`9S8- zQ|(%3X3v^^S)DVf*%?Z(XM{5aOd^~mx7JY4Y=KcFgsWDc3*DDh^I61k%A@MmHExJ2 z!khp#D*9VVBlv>8{8yE}WuO#5uBXT@g|mGstcPY?q9B{&@Hz7Y*jojr$mX8-kE z9J|Bw_-&pq*fxbkONkR-fGe$QM-kH?kiy$P5us$iR4lIg~(Ws?wZ4Vp))-L9@`qPca|#Ika)>@>`iaqqIz zY%unwB)c}HN81(jx4e{k1+jJHWW>}`LabCgQ`NngoTaL(?_5<~L9iU)Fy?}nFivnq z_x&N3jIlejrU=K2SnNUKONdZuUTV?sSDKf}DV`CWU#EB0KB7vsQFq=Bs&<_C zfFD1bRMA`D8%E>HacYS#M{mc!6V}MZimxDGi@fgs*M(1!|6p8UIRQ6;~L1 zL1$s|T3vqW^Xj$L<+F_bVh~>mE?vRwReZAX)%*st*YF!(YtHNV4S8e81;qGr@%0vR z1HU_&ncO+*?6)Ck)BqMYEqIHZmPan$irbH$!*6}SkDse=H`l9-QjbBIpsg1iKabGv z4uwMl^nk*$46MLJZua>^V9mdgPk+z>pLXz@1kaZHb8BCTpf@b#cG%+*pQo~Vsydz_ zeCm@B9QUl^76M!m=cM_+|NYToglA}+n{W<{YS%+;VL!7d@geE2eMFYjF!SgI6kwdzgM^%%Zjatk}E zsUJbSc6&C?hs%N(w^67)ZtCi`z6YswP*5B5ja3|R34@yh{oDZAWgh)vhF*zdTn=?E6OxhAQd+u!Rf#p?IZR=-xi zYtNyr9@wh!zGv;|U8*5`Tjx9~FY~Bxd#}4yze;?!Lv^_EXbV->-*vm)ok)fIn)O0! zTnKXy8Ca_Yt}0q{kliP1&MOG5Ep0NL6-WJn_+GvQ>ei|) zn}=k)?Q@Na-t$zob^O+m;G;i3-a&!&p*i#S>}!De@jviO&z-%m@pM*>JXF66 z_*y&lu2w&6wbMXr(Q8#svm*-B$m%b$RG7)WyrF9n|kI^YQ?=aR1S*r%zoc z>s_i7bh6pRAr8MA(myc>`vJnX8AEh;>srwVSkAdt^w0WaXFjM8cefwrn~d)s7My#8 z$MhQv4LzX9Imw+@-th<>ty>OO*?HKB&940@IP;9u4!h+$vNnE@sQtMD>j_UIs6R)K zg2L-cxt*7#owO3aNpM7!)ma2}?l}j}O?b}XaNXc}Goho~6cQ~XPPCk#(ShCQziT^G z3j6b@$(E6ftRP_F_>u;%$+~Hzg!KyRZMvuBF5aM4>rKCv9P2?TUqwYgZj@~?jK}?< z2PFTIJ}-4T;$W1O!=3D7-B>EeZzF1f^QjL~14u*P4l=*t`wD2&o-K=erP0imq7-(_ zY&r)}&yW9!DbMazb$NC>*J#uonhD;X=G!UORLe2KYX*5s*?ap#Z0=sbJ?a(Q4q3_~ z9&T3?7@y90jZ2)mJzh!?_4SZWXg@6W!TRm+*u9j*S&vP(i;m%teoo@y6__w7T_4U*jTk zuk}eqE_y~7^+}AkHQ!G;Jr#saNdGqE>)BlX-rAv@EZ%zo|C3{KZC-#}ypH76US)_M zBE`xuzk{w?rh4Y(a&KY^?!$g9JAlAxc_~|8n7fmA(8~ALxqwSAul6V)U$8Sctei^&(A zOoN}Ce4oy@db;=EXXp=Cjd>4BlkhsepHoNv0QHmyR4nl0N#LW&_Y=vNVQk^*R78JF zpT>vj#L4wF?%sr%13?k~xy0F%y7z4ivJTUf?xrE8R(?gG#c(&|9C`dUc}Ax-=M+b+ z*}JSEyK_M~FoF0`^l^yPgLwHH43gRcFOTz|sl~m~2l*XasF9Jc4l|nVP%&Dsjvbb` zj8R?SH2F(;m(|4AOTog)uExYcsqzTiuO-rmx5LRgui%Z;$90jWI{8d@L6TiV{3Xg> z;0++_hVe7G{qM!c7I*n8ccGl|Br4njax%^AUcw zX|8I%jBdP5(-|*N&i)Hv$1phF76qM00XZgi%$xma+jF;P8*AV8&)%$d(?R0?Senb& z?Fo-eK5b@rZay7RKHkoKPEl{g_5?w7ES)~4FS&ivqH6O(ZraNDwv)k<@a(7XSsmOw z6lT5-?fzclHhLa)o%%H1<_UHUH~utnWphD$g&7PH1+y5+&|TUSwGw{@Xhdr8qLt*X z;aEF3D5U&sVx5G?i8>%(AWeUmwQIkaN6UZ+3q~-o(bf#(JHHQ#JKFX9qUw1H<-z04 zsploC=YP6-o+^Ag>-n0$y`D|#8K?EUcy2vUZr4*G?Rp-bEu?I)5BD3mtJTzX52&jz zN0Ped+^#US?WNLEBecEP<@0dx*Zeopw6Si2x%XcE{G6ZWQD7l+aD*6epCQLh68(+( z!P?23GzQ#f$R=Vo9@0cibG+(lBPx3Y6)WFY8{N3)m)IPF1(jDf$DEo-cyvWG1iJyfPL!M_B4!AFZ!>Gz^ zA`LA_tl{vV zTH!j%PxHvms=f^Teda-@ckij*nHheIvwh=bKATzcgVfzSZ%Ng?mvo)SfudzL=8vqv zDcr`adhGGN3=(tgx42J_xSU005q4{|>~_ga%c`uOdwGYooR<+Wu`3yKVFu|^<{wDQ z1G+RZy8(DyX&kJ(f&g@*Skk_1oZiC8ZW{k2*nzdrBq*#+^yW^j<@veu%5YV0Z>~2C z@kBd`z0oh@<{R?**z;97|@v* z@6YDLgRahpn_=T+FMRQ)uGG~px+ewXRzeur!5?WjWm)&@~D=%NZ$}&qrCVuAU%d+-ayfR;LU+!%WnyXe!99MEBIlm~0HI#gZ zlkZ~pZGMwHoTeBGXAWyq(=u41&*aO-nX^CdOtFea&eDA$XhiEBMeOP2k@@yKueq0u zuLv41BGkRg3}3w)`3UkccF#^63?Y#yJ;8ir`#dxFdh^Bb$Q9PIk)F+i2iq;8F|U$3 zkMs2EPYy%aJo;mSL$hDkd@3HqGd+XX(U#4PVzxqm<}#-Ea9Y2O{zH?UV(0){PolMF zF0}~yt@Xfco+f7LThL?-&*?2sn)m(6``ZL7@9*#pr}aB0ZvkB1-?a$(wYc$}Wr8gB{C%(s7? z1-ewu&+b@%)f#`KfL($y3j5)6j<2XNRK(<6@Zgtz=)B$X-rqQRuwbD*@@}|s!7n-V zAabv~+dlcm**h@V=j*8g*1?a)zqoBbc^8=X_Vb>1>?QN?mdtzUo8SA;w|emQnfHe; z4fgxg?RfjgMg|acaX~BeqzOiKi!t8h2ARKJ??_Kg(%-L+s!i$)l{jzy{1Qii7OVk6e2&KUa?T z;~F2R?w22F%Kg0Yh1E(}xv*F*g@gQd@x~jUARM~T?H^px6CX%qGQQbj2Dg&G^+F?M zts2^SmmS0-AbUaDD2Wh!9*u$J5F={FTXgm3Aa zSW5Jo86WY9K;&sLF7~4NtP0q6A|x*0^qu7+l5_-gDIgnrMAGw&3h`Z%9L}+o-hdx1 zlnWXJ8F0zG33{7Ipg7Rw*I2Yn64F&Yz$-^fiOFf=#VnwsoO0Em#msfAvAe@d(lxa! z*IYoXZhPc!Ez?AXcm8(t>y>#7yZYcUib#FD(s)HmLL{Z_v(AW}MYTU{_K*j>au{uu z1Ko?E@!nEl>G(0F!pMRR-=(ceXvRzkAFQoNe1R%bH7)`mpd3x&nEIZgSsbhDcbtybnwL^X2~?21z;pNIDRC@~5YSj37i$;zR+pncZ zQ`hzpl#`c=P<4{Td4BS-T3P2~agMxFGex|Zc*G6t3i4y)vw7g#q;z9*vzL*?pIsMn z_ZI)a5#iksfO&{hLdgWRTWy^ib^@7!#7DsbK6M^EMOmQCGy@&84U9RE-lo)?`(~9N z7m4M{RKr-AaThLzG0Htk@f7W!Nas1`6ljGuML zJw~s7el&44SNgRn-{#Bsk3u#{Ie3iOk5A`42rjUr1Wy;&TxSX@`$o{@IJ7O_p#uu zzd3k+uZ{PNDB8xm?}&Zj%?5N#S?)+M$6$})l;R!TNazA={d}{9&kHEi=-8&07ni_O zBVZPiWBmIVrW{jGOh{cjAT;{1{9c;k;kg-{jWWiK<32Jd?-<*8Vwy6wC5|z^eI~K> zcNSdUW^H%BvbApAwmhB|zPeTTBTrp;m!B)|*cjw0J2sB(WzpQYnt_dDjeTa|_M2CO z%i9f?-?wnFm8cjFt>%1n{J?N%yr;T8TsmHbi5c&$uJ*Qw+b|uFF>lL-a!Ypt_YdUm zhbFjTnC98SGS+Jvqbb@=4A!zRx5F4^J4|W3o(z(g z?il!HLk!ihiLaGWTy1n6nbI&Gpy)fxcFrw(Jg17yuda6$ zLwi-V$+)VaNwkn$yLKJc-B_ZMG>AO6ENLyzH_HUy*tl{ZVI6hOje(0hzdIze;JD0^ z7_a8%%Yg4e|EI=rL3K%jV-QyynJ*+CKfs=myp6~IG8UAj_3N2@Sxun5SPpKYjOX%D zUS893q1J-w5(ue=Yco|@zx#;+ia ztZIbuunNdxBQVKupG7X-qsRwZMe5GL(_p*c3`)%pyIIE*Sq2QiP!b41G%FD1M= z!cTFwId>7bT8qFkCEuoyXhIy+3jAGbKS6DB@qW0w^U);m$|NVY(Hg~A33Tlnh+swc zgW1Sa=>thS9;4kN!m(TbQt-f_Jfg%dT!t(sFng;r#|z`_!-eTtB%u6%3bj|CgF1XLkd^wT(YaVB)XWrfFEA$fWWUV(8!>9t%YP`_&#ISs< z^-zGEO~)+kxD!1h-#Fr)!kvN@$~znvR|Po%DrRco5bDK1Q6C+q-1n$lKZ0eej@G+Y z%4`D19K+#Q#7>=v!cXJsy^7aXBJ$ld5^e?WVYn$T$HmP)QgB9<Dea?_yoo5HP4x#7Imy^xZ_tZ(3Vkh{p-7Ey_6utC{A#=+IW2+?ZcSttwhY zw6PM_g0-Lmqs4>hAOmJeHIYKOnK)@sy-u?xh310jV1x3kN_2=^-j*9cx0{Smn&71{ zJ=h3_YjJIX*iI)ku=#=Q9rMF_@Jh7_Y6p2`)+Uq7Tm!rdcG7&9n=wgz;@w=?94WlJ z8hFUb^SS1f%7!v(SLl^_h`endJ=xwz*Tx6)FpW$^=Z)v9Wm)g3F5tCNo}oglkaMaC zHuERU;V1eKcTa$Hf&F>TUdsId`T91ejVzcv#ZP*vtqQYS=8pMmG?vzZ*XTBdM2Cs? zhpT`Tv^k14_Cu( zP%NvzyGQoV;2Df8yP$Rg=L*pV(YQLvqX$Yk%aq*7pwPObBNz>5m@aw#n5lis9%c0bZRcjlr(Dkw zPw2cWZTWSd!I#n!xj+WSwA9>6cEvE5fej82#iM8vcq41#6R93z_2;NCsf|Qz4%7K| z0rW=r*5b#s=TyJV!CZMkEy+;*ygm)q+^ zo|oUQ-!aW1%W)L8>z7I|r{!w4;XVm+Nj&vkNe?99G6(m;z5{^GvmQkV?5Hz3o&T>9Eo9?U*3F1qeXcHsO4J0R)&CJo@7Z1hs~WXPOTsFR*D?yAl4h0i?Pb|GvduZ0?x!# zm4i)#XInMV6jjO^G|?B_6>Mj_b21GrQ^>>BT#IqC$g|F+@`EO0-UzEq##VaM-{b4w zBT~zy@As4M6Z)PFT@`?ywczMk8~9=u-9`4M1#>wY-6QHCx~FCl_?{+GZOTS$^H@|C zPU;2f1gtltgACJ#-4pk1IU`8cYgqNhl1#KS8S7Ul9F(-g}?F$XnXs8}f!ae8XNVp0$T>_ly69_Gq30`Z}XLl`qre zMn1y7{pwXXtsp>mQR_rl!pwOZz~<@vM90#H;CGMXQ(2wMMNh{u<`LzLIZ+&3ec^@F z<59}?oE@9q)JP1kL%;w_67&mdt{!%Jt}0!J>0E?3vVRd+6% z2mS=k%(n^7HLz?;{nmbwK;9Eq!;UPQ?8!~BdSn)Lt%Y$+;jRW-v9AsXkg?Z6w0fw^ zRF9-XyDqRhKv$f)m3V%>>H&75MAlPFU&jo!KaMGvM1q)4T}k2Xy1>Y|ID=i)i6qpY z>`voD+Qqp=ycw0`q}R}ey-QQ+vJvJ`I$}RvUvNiRjI_<78sD?^J=;YoAJmmJp=5Ps z9__ULTt29eheOn}6WwAL>gIzPDsF2*J#3ysUN`!B-|=ngVr(>dfkfU9w7gixhyP6n z%F>Pyc+u8?sx84h3~x||6F;hAOspdyFZMa~S3SwqS|6JZcCclu)VUPSYp}Rk)4|j zlkdmL*Wdaf0%`^SL4Avu9%H!3&Z<2ar82E3--AD2UYsH2D^(=fh*@GAH1T^XL0QOlxRzpLhe%`1t~Q-JYTR9S2+ zdIdu>BodR#)j+;c3KBh{q0G6@$>cyOv($?*QK&8%Uz>cdOTKaPy*~M3ugKzQ!>Ra< z_ML#y z+!7!UvC(k*r&er9m~G5)@nqs#PV?A}lP=0IS*^X9@(;AoN zshjo3CT4FUXC(I`!1<`XAJ62~oW<9C0YBRms%NI|L$jFv^KyNH=#_lNctJLZcn>4Q zjM+T`Foh`E*it{bM3uV5i(ao_Q=1>H#7fLZiKF`!f%;0u)!_SS>aDk8^?s#8tuN!w zg#0K=E6n~1{s&=4S1#=H;%#76-@r8SFJ#j_`wPMl->b(a@#?we&G@Qeu6YaJQI67H z$akA^*_A7}u9pV^N1J0ZqgT4VH#GZ8qKuto!)}{0ZuYWM+h)+A*&yK@^X@S`D6YAzj_g?9P>VN4O{h}~hMLtfL zDH(V)j#qY=z4SzWe$E8ttpM?cYSXXH%Va*IyrRD+31=?RR%q7cj~p7U0WeDkc4B}R z;n*F%KzlaH{zkVcBszg!*zE+5xxw{MCo?~4k^!eOJZ?+|mJ8kW4Y-}qP)VW_`9YP_ z$tuIOchIxgu1iYU&l%S%iCiDxe&IqI-cCX)c5$zMg`Kg!m}s?Pfz#HNxT>df^Zz9B z>i}&4#7fc$sw0l<2aM3U6I{*>PWAyts1XiL=F?0;hK*lw-Q|*0c5^?E^Ij*(^c(-l zyk73hN1707g9UGQ_~71^>%j9^{Otk>L><7 zYU*3@bwmi`t^8t(RPZpq7Ek;b38Ir}o`G%$kCG^32RH5w?fs?LiBu!n&BQ0o%S}-`6YA}1i`%;be~sy8G!lb7G*SjFnHJ_ zISEeDTZtpFN{#a`yRMNnt&I42iXK0QUt}Y$8u2?)%-1rMsEMjGIJrD}AvjDSWhBM! z@K%7$mx4vS9@pB}StOK2-XM{iS(h=*xfSDW14wLxP*aoahj==`G+BgO(zgu!pYH~Sl#l(g(dr_x9Z zu@)Y$B{3uY&4f1>E2EcD*>LQ-#y#pUuVgqm)iZZ;8O^hY>$R4XgZ;5?{j)NE@!Vl@ zvzl)^d5vyUNVJgxXJ0Zm&Mobsq>$(|;=m^qGH8fo{*`{&d@(V!*Sdq?a9Y0+`(idv zJoB9R>lEId?>GVV?WB8UAvs^=9+bH%DA#mEi$+OT+ixe`(oI(Bt)EiBWuQ{l-3H=@ zsh>wKY236Dx7&aAt<}#rsXh{D^ATuud0=kc5DaA z=udU#PD|thL#Hov7ofZyY>Z8cRc`K34eKW9M8^iGI%CS?RmO zm#RJXrxWxSJSM1{aOGm;!eQ;w=IyE=lUO*z0uk&);Of~NzfZEocY#!N1~o$usOZY- zvc5ZWx60zG^UG9Lq_Vm_jIqq(Vra(O_-by-O210B@k*GhaM~9zL!I;R3zb2SbufiQ z@Rrs1@9?9Cqg9}`IE-J8w=3~>HNH)cZld}S-pCP2$3ucgBEQhl4eyP7H0=#ChtS~} z?DQ<^@Wc&9)7Sv>wdPatT3-;(Mu0ikoI3}b`ZIH;Mb(|ZvvyRT`};w4BGLas7#!aX z-h4ifs4IFW{nVzF0*l21kVo>xR6LHd(!{57N%>xel{fQmMl<&|xU33QCIjwETNK0b za^mbX9HqwP%v3Z#N4}=3alGkj7y`Am9z#c{6gn``p%#~}1+G;j{Eq)g2x`t{q5)@e zYBA>Tv9|Q=O-~KcEQOb36yi z^A3R)Ro^Bkx;*{KSAUZo^pbBYS9BJ`kf!bR!)ZbP$cnKxr`4Zj^`&uy%)IVpq$xH`4V;W0x1j2)++X8-$yWpZ+%-j z!{}L5I4AGZ$RlUoyu63t&6~F%@4%?Y<$Kcs{at(`wkr@&laSM+i6sx3_}|1|%egd2lX znbD5{`*;W5Qjsi3^^-JJzLhGQwJSp|Rd$b5-InU7X{th+YPrmhccjBJx452CuD;$9 z|96@g`xptPD|)%v)|qh!k5xVY!RpBrXO9q; z3Z*wNsoDn(^wzuyOh^3AbKf6E@!4@*EI0`j1URhQdbN^7Mp_ucjWSb~C~LRXLju z&K!@Gznb#DO!>{%QiY=5Rpshk{5sq@lW#Cgdva}iPLtmWgBer0nz>vT^c=U97o&_T%Y=p9$; zj}=SLt#`zLnMCuLt;g}C5(j<)-+FgjcddFvTMsY2vcB`kw46Bq@jT*D(G%0ERG02uQ5VbAqbKib(M39* zy-+0<74myk!Gag>S%t!0HAprd1*?JUzY9PQ)|Wo;l8!p4ev*b|^fnk_*X$9N%bZWx z*DdVo&M-HtALsTzSSU-|YA36RW6;Ht!7L{pXS|GF+HY%;LlBF|@l|`^_zf%TdRCs4 z&JM@lfyd(ti}t6v&_{ZdkDk4XKZFBON1!$0-)-$9q#_yg2Q#c1x_SZJ|=Tubd z+&EgHT&o=+rl;)C9%$FtC2(2Vyh9UacBxEe&xSB%e)8Inc8~XUcpSNG0wZmhxsiEC ze_r5hLg|b!TidVk$8-pK*~IGDC%`U<&g0h&MAnhoXyfLmCqor4Z>>wWB2rARBc|uH z_*XO*9G^tyOr{kxh|X>0>6wP=&hMoyFuuI;U@J{KiPtfjg7(rg`E0*7&NZgN$;eN} zWxIP%4)_%}-R!)+)sbczBPXONb!6X8)sEXyAHOz4DHU?utCaC-(e7+Xo-o#U<%uoS9-xmWO0Jp-VH9;9@_yRwn`(DIej`wH@){44rfDJt zFa9L3qHi0KuJ{e)&|N(ap8AcrdOTF(K25lZGgjMX!^F|0K$=C{8SpVP4hIUjc424C z381CM_<11Y@*ug?-^~*3?Jn-6Y z$`|QM1dW0P`qOW6OFCj?35=Qh=4Es~^er1xY<1b=_|5ODYE=#e-lR!L^bl|PR^ok| zc*#D;cPfpx&vBcw_%6+4kn2;Vk6$T|-?;&Tr@al*yU08RV0$0lELaixIlJ-Wc0oQ8 zqBoM*uKL)Hh?Tz5xkKV$ffDLHI)eDD%K9MDz34Rp^85g~eGaF?JDVBtGnwyzH<}`1 z=L6GkgqPQLF4_X5tLhDO1t#3>Mwm5DIUQ`rba{|LD;>lN#3 z;A~dgVR9EUfylA?o;K~whK2RufTR#xKEQ?n)yTa zAo;r;N_{=M7p|1Q$D!5N>)uJnuIf8fK!@MZ8*n&uWNUbIWFuU1wF^;kd5ead>^xMO zux%WkvJnRSR=^nI=$oIsXFZ>F)qtj->4=+)-)0@6Z^7<`tA!q>6Dm!3&0pA)ZF6nU&oiIue+cT?tsxA1J80R4zc(zO=1xga!bEu?U^JbEjMlzb({KRoAANgs z?zH)>4LLsMP#Bl@r+F5ZLU{IFQopA{Jt_cM>1=eCbn0c#yIU3!98Out3_HAOSm8 zow*kze6V@2G z2DyW!Qd;7X;pSaMds(=-y-VN0X4CwOnm5~bsQF_14ma<&@8afj?YpG;Hhs5AMln|O zTj#S{1H|KepZ4&#zJww;&tB?peHkujTgb&%Q4_tT_#se9wh8gSi%8aI`bbNCq`Uqf z)CS2z{7Y6AU^Si_>8|#sW;L}poA`L13u>#LkuV?0{bu7S@;PT2tx!KRH*#Uj*=w;pQT1~9 z=cL(_d!>PLf+eX|dQtn5_Mt?yKs6U4W7G@UD zW41Ew9L-3mx+Ba%*L{EuYF0KEiNnTI7F4TszIt>gTi=frj|mS8IVvq$N3D_npfg;I zzJc2|`>CPEQf}ftt&aa9iX)0biq316(`s5jeiWeTtC}*tB_2B)cterZWE-=-2`)Bb z==Q5*z0FgXfGZ00mG-MS9`;e@3aF~&BKn5>iM?TGuQdp7B`yC4Dk}<_%{BeG|tEcDVgGsYx8`SS9#Ge3I->)Es(Ky9I z*!U0f&0*W}F@kngfSZEM9s$uO39WG~`6<4M>8%HM4dm?&5EF94W+Vb0@NzuiVVTm& zDNnd0bHPovtwPVnjhkn?uiyBk`Wi>Zuvs%GT`**9%)kL;Si#XJ$^opGJ+VY+$0~|D z91`4xB0BekepGA}o|$y{B&K5p{|OpcALiIzUAWaZF-29+=+gK+jZ^rD%#W?iaPKm0 zh8NtM)~~xRPnoDV{^c^0VZ%h_#zVWzyB!Uvcv1NVGhO;%>$sqAcBY$;x=UVPbr*90 zP`Cn=OkbtbH%-u!CNKv9y-9@m`l4C$X~;!>0#mF(iM1e!RZ70)~7R=$3;=U_(vrz!wXyY|YW|q9Or2tl_dpA57Wn zLY&h94l^(v86>M(3x;h^Xbuc#SffFL4?(nRR|J5OkZ-=wVV__nr?#Z12B6xZ;p zmH=99+bEmAUBu)9Z|9d8ScZKx4$=;F&Z=Be=ZzLK#%4tB1gv*MT$Q6pxS(zCKq`*>pNU=ux?g1%q!^Q{S^wh zR7vM__4T4|+O}9Nlv4_zyrOZIH1}aiJDZehwd<8Hop$gHtSw5`il@wBA5!M9g4}I z>L;S>NNqH&E2`VrK#(d=2Q`W~oweEycd%kbXx5*TicM z0+yu!a{ySL0?YwmMG7znb=N)%fk5VGZazMo%KGVP=h0!zUOQxxagH!PAl~3D4dGUe4^^Rj*Xx^r6HZu0hZ+urP zV8V8ZzE0l1U>>1729^v|qqM}Jlg)<5DZ7F(& zR+4d-i2-g>uB!wn&m6>uhLrsCaPa!MjUUyvhHkgM@xM~ZVwJ@Rm>lzAxab z|Hz#xBK}BE6`9)Es7Z1^yvoTQ=jJUUD{p=Ouk%*hDsO%Nuk%)yQr`OhU*sLwJ+%KZ zdaDc7*v#k~|C`Z!J`~<*^v=f19l^gSg8$GFoCUK*@RZ(*S37!N+`Jp9$EY{M0Ss!2 z_ecaH#ksMIo3C&IueN|!Dqxuc=%zOIZp*6v7DA~(dC=6oXl}~vu*VYH^&*zIqY~& z$GSW{Wi7m$jw5HsUKkTJEq}sdkZsFX+0o?&Pg_IJF&m@aP8Ju(bESuUh+ir>w;ne^}VNMdCauahB`)k(p~#aGETUarwjFI{iZ9sYjVe2aG6FMB&Yv6qpV#4domZC4S2|&!pwE)oIQPl z@Hlhtp5f4tA%`}9(L!nuu#;b;I2eneY(2}|u^8$OJX@M95#Q`dmWZG+@8tGsaf%WJ zGpFj4o!Q7|>|-6Pu)pOI@Q?FI0o&#yoVbk(3q^Yd#^{{2x#*YBxij_F50V^(|izJ0HbA& z3sc8MspI0*aY^d9G<95-I-Z?6-~wGfEV0gUW$L&pbzGe~u1Ou&%E4@OnrJA-!yJ-A z+7z?IrWlh-immdNIzI_cPZO8}z!@pP901Nt0pWpxO-B!q^)0Z3ruIbSd%?$ zn)vnM#*rG6uOu5c&pA!>SHNK3m;k=4UJgAkO6h41$`sGeZaWi+p4ih+=UU{7^UXj( z^kRYBoH%>2C~NB+GWY)yU2{y<2@6MF0hP$;-KkRZD}?TxOqUUEKrM>DD$s}1Wu|L1 zS8fS+ywi=(At0(`6m>>4d~4O+}?B9dr*RZ44f z06^3ejNL}hmji}bA2a)}E~*{K%oU13%&Ya)EMN`**Q5Y*0Jt^<+F>Xj>m;(SCWrwIa05ns8IRI=) z0p>W)bBe+;05N@;f)1x|U5W#A%>RT#&}=fgxXZk0VOSr8WWqQ)TH6OjCaFS_oF=@R zE>SSusfc9WZy$kT8N~%j|5)|dN<5>lIRHE-1(*ZCb5nph06Z@Rm;=D`Q-C=D+?WE) z0bn`>m;=B~DZm^6W>SDT0L-QUa~$PGQr(bQ`PrAMR>XKg8p9j_wxs}b0Ju2?m;=Bq zDZm_V%r9fipQJHwB`|NO>!FH)THpIT8k<|Q@6|Vz(LdrvUxRqj*ZJwZ#^=wxkc2E5 z-ymSi@^aiUIPV3$W6UrY6B^K@vbiblH#DPq6U z!RI5e`X-Q-*sFOb`1sd3p=sfI(zhfC_9!E-?`7P;#p~?AX&+^~MM8=;7 z#<-ln!kbphZ^lf~l@%DWZHeb!QuJLtJG$v2wpy~-=Gm7A%SzYI4P6XHA30KqZXPu6g zf=GRWJGinSQ>7#2C1GfSBp2abDDQ5o^l1)%1HGy6sKx|I?aRb*tI)7lw0nc*4>d~& z;^6U*@%IMfU5#BE!OGcpwiFQ7rR-{KI;|BnU}@>US)Ea4I3QqsM0dJ3jJ~9{@upSz zse1`?&iGFhP&wjO0Ac(i-1Qlhh@QmZ?h)(3>_p!&*Z2|zVFUJ$e6U!yG}l0%>v|`$ zOU)XQb1|Z?qi)bxc6#Re-Z1_Fq;#O(a4YK>Mm6+;OD=jBWwMDBMim}viFZ>fdtsj^ zeX$%Pn#E_(USWJRsE6^-gdICv1^8j}mw4mbELjl82{rtc{^jn-O$1uC9oW$L@v+K@GD;rp>nHab^5~Agw)b$j6gX2fK za)&0@`u2i^*_&v*oy?Lu^2=O07urd7sAf4je1|6|b6d87ubG~XpOIjE7HfZ%H~Anf z5S`8YrR)HwroS?@UE0cIzlUPamKTv+VY`zmy>FjYYV@9w)YPHAeKpC9nR9hM1Vi^M zoPP8*vcWb@oBF;{p9a(WD(Dbq{y=-_KD#zPV#-0r|-pl8=jx!S^93@?psV-F*E1JNJI74-u>-9jM) z(KqGK)<&ueT~Wj1bd1v^q)j>o;-|3w-F(lk)imBfIN)zxNR|EgN5CQ1mq}0FK4!SH zY?mn$A^Lv;+&z@o70~N^uX;yjb)D8=9KV$QRqyt^=G8=>kJ@q#ZGQNs2#;!SeG)i@nfpM^_t%};LNm#JNO-(Ke&i?MrkXCBbf%J+b5itS#Yh} zC#Y_)2N@2yI_qZmaMkY}pyTQ?G$BzTrG*UUIPB|E#GxnwtZ zW@~*}n+=vuvc_ej$7$4r;@!M#dTfdGS^l*qK9~Q0<(~p&e=V~z`Cp%W@8PR|#Yz9u zIBPXO&>!vfM!k>}eODzVklaA@L+5pLu~`NikWV^no}d>Rsfs~+D>Io3BZf_JEXan@ zw}@!g%rG#Z8ES4?n{m2C-p;UK=PqdD`dT;}(A1#wm&&yr%C1})d+_IxX+ zb4;y!x2)K8G|eZ`7G-{}9pKeC!&LLTep~U{(xPz;)8>2|`(|)f`t9(DnLn#vSz}>9 zZS%1?QI!8Y|GoSVBz|8vSUhWQ^Hr27-pf}mKv zw$~o(&7sx$QPH&68^m&82ElY!c}=lj@Ip4$w^%(?7T4p04CcPYYLqN#HlpJf(YaA4 z3v$Kkd_SI4Oa`aEc1Nd}!QMg!KA;q^blMte>&7Hk&ulp`RS<6*?~ zVn2E%%@W_i&laKr^W!IJoA}54;D+Z7oZ?Cke>-M4P7JX0kU<1rx5ti_IoiVb+_`YJW7L8#SyX960)jx;e>$$|s60Tl7wBe)X*1&Vi^&Q1@xt@BH z1*y_5a%FO*-&RH~unE88m}!2aIqAs%UrvFYp0Z53xzqrJBni_=3vImhGll~4(872Dri>V=56 zC`qO#%J*7)z!P6*O5KA*Pi#pf?i)D&YvcHqYQ_x)7T7T<^cD(M_{OktF8CYVZla8{zti++ zmufX~p-ib5oSHqA$s*TVIMtS48rjvz6;c-OpuX_mYV*DN!q5hu-DJLK%@MFTFQZeH z4}TOm@{8?wM)u$Eo;_o^9%CEcsqaukS|xR`k;3?>Bf?16_^`jPPLeLKDz|g9z|CdV zEI;*P%hRT@NwU~S_i$Ov?H&0!o#U7}or4ou*Eu@4;&u=Gs02dRs9(Vi)#(95s*J8Aj8`q>GnRHq*^so-3x)HVGLBH|oJwjdA zaP5u39BX%zC=5+-UaMX()VVimth^|hCwS}AU8gl6fSVz>$+wDI;aRu8*xzrQpT-8( z4WhxR_UYJHpkKaGFDu#Ba$~BW`ijhohcb(`x6&Ep*%09*@$U7C-}q9RrF&7{;h){A zef?DdzGW{&4f@&`Iq(vK^->wff~3s zyY4)qv9xpG@^dw5!6t3q9b@HuDccMD6|K0Z^JW5l*Q$yY-psC-n0gCd#Ybj71aXXxZ$jE4=q@ zK5gW7-Rv2XjR;pEBph0baW`kfEt^?H1BaRevUM*QLkEme)SF!od%z|ihR$guvGdO0 z9w+e>*THZbkI4pNdKIwRF@e3F$3(Lb5L=I6AXko1lMlNeXa5dYb{kdNek>$#Zv|eI zL<=HJ)D^oQ=NwH1DCN$P6yM49E?btrgA$hBG5l@|fIh-=D518H*9DByP^zHn?{1M)*d^PS&{kT zFEcCLIPK2#L!g|-k3Zi__Prg(IetQIVgCYW^#GNkz=?3`g?ibK?^kHAAHRYxf<*S< z2o{ks`euhFXA&N+P%QRRP#&RZU@C_59CzKHRrcB3`a7W;Tl=k&eS!7Ql=DoQGyUw( z)W(k=5%|(%;yYo^#J4_~_~=>-$%Fo6EYj4K$>4HA^+f6}+H_2TE@Lj9nPGFg69C5~ z{eXPtap;p*zkvEC<>DYC_5QndJGxcvBi z{Ib?0iwJXH5dDM!I5>Vj@<(opk7F04MxI916MOS%?TxM*dyAFRSi@@v^%lI=S}xHZ zSiu`jPtxP+eYo5tCi`bjO_3ZQAXZ|>>!)AvEUMH30_Ffl!ccCY(eXa}K?dX+ub zbX<0#tjc8A+f_MD&w|;}I4fvU>l;<;pHk~e^xs6R9rM&N1}#Q?MW|yW<~B$yhQg2k zk%ZB&1xreS9E@-VmT14Rx_WO46;5@5;{#likVl7=bVZYF@@z1jPkhAl`98^-l@RHu zIUQ_G(!u7gtXC!7E6DDX{qAJ#iSm0|W!ECk#GcbiXVYV{+6xcK>-2ZQ1(`(}qf7nZ z0yG8ePTBRq3-rZoy$3;YLTVZBb!3Loc?vS~*n>61K4K(fUcjJj6V`Zm>ovG4b}qL+ zSgQ`sI*|Alw=@T~hSUxZV%^B76|}D#H2(MAlYC}h`L%bfdO*PrijWlq@sXm`|F?4f^#7)uqg0OOfZrm>>Y|_fCjOB1 z9hAUwCjKb)W;qUKeG8+X65W$b_ZK*Vm_t8~F5(mM)cdkt)(q;nx&I_!*?2)KMEZ#? zq+}ryP>$A1D@mkC1L>^P?-$`7w!28ZGxE5_FUM;m~fpH;$$s_}l zQuY;%MX4`VR*8H|wM}aJBu=m^8qd<7Tl?0|yuJ;ZNiJQ{^O(2)N-ka7m(yMQbJfco z32F%`j6?g2Y1g;}#vCP`Xcj7Ly$Twp_8oO?I;o~(?D})NR`z!Xjmc|U-CXNTQZwVC zx)UzSHBq5;{6(tvc}Af&TyV@$KL$3kW=qK(a`hLgLv$8{v|HI7c=Z>!Z;$k)%Iv!9 zto|M^g^udRjpu;VP()b>N*_-TTkf4#=t&Bn%E*^ z>eLC$x=;P-&ws|-tG?@S{|!xNJ^7b7;CYT*L)-E9E&hAxC_m+&{cuKW5g&uU5*Nxa z8IU%(#tkfWrdw;1O_a9xXpI*?9WPu0P;pt?rPwIw@^Y;%-<`f9)%_ZP}Dn-)<$CSM!Q zr|p%eb+mCx+ACjOsP+=XuuGZ>MwMH`i)pEq)$HS15Fa1pr@yG-^%Eh-@lCeWHO;;^ zu*Y%cG-S~=WX$3Hy8cy6q{iQV$A(-4>35V9@vnnwq=D z#?T{Lb+IGP2Qc8jd+6~yXbjiNQ##*k6Jv0^M-;hU6d7MpJ*xRjQG#pV*ru?`a9_OF z2wm!hTR*;oW+F6?E3~LrO}pK%+TCtG1}L7Q+f5yhkS6JFe&f2B0hV+(KT>z|VR#(B zb6w^|zsS5yeQcODWdi)4WH!>9I=0s@dg!rqGG1XiDALnj8x(qgF6EyJh4g-IKJyw{ ziN4I7uDxq(PS@VG)koc&?#Ij39HAr!y&C zYv!n(lQa+8-QjU;chgt16%l{WS)`*^hHe%SWUpBSb%L?lBK^|V7o`+K%x7{)GNyiM5*sYGai#cKH z_v#4QWZvoQ2%&WZ<{j5=&(A#f=b0C)A85`00`1moJZFtc7o7s@WaCkFBoh}Mc|+nd zagkk5*O7sfIUqemE5Q2C-_D%e*=(%>D$@xsI+zoi-RKp~vj}beit)h1=N{!dj4j1)hM5fSry&b&JeIyag3v;B8|d7Hx_u9KxZ#-9(uqb? zZFUX=d%Zow9hj-}*$26ZWbajDaEq%-uhosD-_TN{+Y}OA$ATEKd#gs<5Y(Xmvk%_) zv8{8u7tOziD1xqq2EZRds5_jJP$Y2n$fbGCiho6O2c=3%#(0+!`pg?B8td5lm?C8T z*nBCsJA93hLlRVsVlb+$2I%5!C+p_l6N+B5L1tb{Qp~peuX5w1iy;0zF0yA9F4pgw zYf0ZxBK`w0Y!AmvtAE7ZpI`ef#;VS9aeK=0Yt znen=-Q>88wx%G2&SUWIDWwMjheLEP#1xb6N?hncUQFqlJWW6kuy4zS28`e&2SW)?}GaBR)oqvBh;=WPt^#6EJcpD_K*?@@-9OAOMOToY#Y=PnYbQX zi%N*NiDtWX&2~wKXW#J;%P&%6r}E+K%*DCzyJA+wBM{ zbpZnZ5-Hd9wG;J257%!7yb{y=fD;fdDfOG|5e8%Rh$q=V!3t}Ch{(nDo$;&r&K1IL>>K$N{jjjOM}L8tXphlIQe*?G|-Mb z(25)n)7t$*)&A0uS!d}VE)AB36CQ5Jjo0rzuD)6tau!w=mlpGA$6}{umDF)~183r@ z<2LOqmz0*cdi{fdDLGxemX?-IvHi@Hmbl~oLTPDw%D<$v)SdD#FD>sMX-61nM;K^D zkbUc7|FY`R(z2MlSjGMorIEfB(WyB3a38B^+aE%0%K7T9{?anTf3)tyX(!kxO`G=F z?d)Xs?6X1q|B!YjaCQ|{{(pV%+q*kSFX`@dmQH|9F8y9NBrVV+EFl822m%VSD4UAn zcC}yPLfav@;6gwJWfTPk1r-%h$8FRZabHHoeN>F2GwO(=hzsuF|NWhF?|b)kcb575 z^U3R~d#dWxe(KbzQ>SKV*ZOnQfmu5}9hC?69B89*{3two8+GH$9SK9~z!~iL$7U>~;M&cBxF{f- zefty+@w5HhCvp1(ni&?8yfdej=x4hXSGI+ zhPI|B5UrAWEl;biuVFfT^VL%v?UDaNX&^PW5Q)s-PZkhtPvz$=ARbD9WZanG`zcNz z+tV6l_NbQ{GuyTQH_P84cL^ zUzjN`jWb}3DgP|AssvMB2>V-1IeQ+RU$cucIWfA8@$;!b{fG>YHL!j_<`7jD59M6% zuS7zYtGLl~nX@iNuOUk|Q87+RxA^VS8G@<6ttenMBiy9 z#qrJivvUZi-;_3}v(lNdB0a&5`Zz z(0mymT)W+Q?zf6_3z?0hI~210o$bN5DmZV!3W=s^pXLtVrBE)cWz*(6@b1d+M1N)Z zraoqJC6%52CxhE%r@nLJ+A@?^TF)DQMG#|Jw?P^7n$jW%8$Sdz8Oo1zH_^wy27~Ei zv{AO<7bXL+2f@HXW4YjCS&vXGG?t6WSUwP`W!m&9s<{K&MMC3+AFZe4I^m@%Vbnog zexx~!yiSA#HF%Ud!suc74{oM0RYwAf5#%1ZT_*L^tEe)m6H+8~ka?uYLkSQmN_TgC zB@kM&p4LTzp?r%L(bTOyv5J-Cj=-v<5`@vORLbtQ;_N!R56xBRQMRGcVf!voVPCoF z(vqFp#=1>(TIsDUJcrp>dt+?;DsxyHYld%T4%bgB#zn>(YOQ04L`w2@@&-a#o-RBU zc}#bz)YH||J?Kk(HL3z1|0+v-b@#yiO{Uu>hfBs%IqYX?X31N*5#5xx;?4aBe~!Ri zoLS$sW?c^K(Y8qZi&}}Z>3l3-A?_s0;sVcO}ZdK!?YN^QMsKA>DaX1+)*0 z#v}@U1Dwa??Vj4Ns82$e^~|@^WzO2g?QzM9qeF3LyAJ9sOy8RpJy|3)l1eU`atf~U zx~!?3TX9fsmCKsSxi!E!|3!EG0x5!23Z}1(DVdi7JS zDgZa2R_3RVx*{PIAlAk`GcgvGj{HI^$BiF%zt6@+1?fMu>mLZBoh5exG6dJo;**W# z3^BA}s!!w5{)We;@iq6E_=O(FFyD{gHeIzXUfApRT-f3=)n@meBkWqwl^)%g^NWVr z^N-|W4+LruajI`E8>8PvW;8zxQdFdklW=DWSe{YN39T3(-1DsBczE zBb^+2t*b%mR2k=uGWx6;X#?+aVpA;`;<`pL?qUv&UFX+|@^v&|B_^&hWVOz7Bi4BQ z!l4h0ogSE&eRd~<361)1kcn)%mU359CT`N$eXGBRJ@D_(okSa@t4SfoM!|o42937u9ds z-N#^-&COiy(A?prJ7t0!F<9N;(%ID^qjGN>T6M^%bS*x8h5*0$R(|9W)cyk-wOR`88l)!Yr(*uJkUDrf9?1L{K|Czy8g#k($YWg>6UYSNO`Nb6msq;UqLrZf9rEBE`c(J|E!wc;G zj!b8s*Y20lDQMmY+gK$!(2A{M5VSX~#bm!mepH8A4nvX$}u64_(dl=t9Q&b1KYM1#ol2a~XCD$t| zT-z%|L&O^ob{z*l@g*`r+|S0Q0+z^@`GdJZl`m9`RZ2RX`vSJpA-AHh_EHkb*~^ih zjh)$S*jb2Y!RX2`jKhQZ;6{{$5T&?}a-h7Uy(|h1lZ;gMREQ({fk#^AdB>E`rTP?4 z(noGda8CtIg@Xk{=5ZBB$MZd%H57N`=go`(q3%pmbM&Fg7%ww~CWGB0He80=I2%+J zlf07HOTdmQ_}th%Rns3)!%%1mkT)Ld?^Tx&eV1H#9NKkc?-l>+EY^APAO&k1m(C9z zm8(B3cd+J0ko#Qji`S;_M3-_<`y6|6^vqo%C%zy5TdC)fm*Ce)Nj|DkoFmU_e%AH* zNRMeO`YKrT7RN+-aiPXCnX)h{z0QLB2?MX^@vVe2kAQe#ICN3z4C?}2VzGcT1uB^O zH0#}B<@YU(dZ1dx&uF%HzjU#ER0)aNS_-7ucxq{_Z@@OfFytI9a+LNx%_`lN!Td&@ z!H@Y3q)`;Gxx*$%9g=^!9XmQRwD6kSS;ABARa$zNYxPJ7m(36xl(MHIhNKW1W%Z?e;iH7K#kQs; zb_MN)m)?9>2%<7M#yeP0l9t#z-hba8ynCWJbd2_bhd~jrWYd#x>Lul+YifE)RJ~|x zspG&ry-_NO(TpuWh|;2X@;>7aw4~^nr@S8#7N)MDRgtnCCK`_Dr+y(2 z{yvIgl=*T|=A}IaKb=HT4-#ETN%Y-RqFiTz)b?&qEoaS=@(>-7M$bjLGw;rgIjz1Z zH}ivBNzfp7X6}{;{D@0qP1`R01HoR`Xtk>^*}hUogYdi2fk5}8XbF3xzI}+i5U?U2 zy6$o;A)I^dJ>sBP_B%_+i^{LN#n$HHh6lY5ku40-!QE!Ns#L7pQo8Q)eEfa(M!P$X zWalMYOv|*0GWJ`&>9PTtn#uE~d6UMgHxmJYdNU1c_9imb=AyalDCZ{HIy2!Wpm99) zbZ)CZ6LU!dmaI*9!nM0X*@r3GF(=Tw+%ur}7~jrgo|!xIwp`tL%%Z(*yqY#iFB;jt zOe==%0o$mwZ^od~fo->V0(r$A=yWYVh!MzYFqF;=NfdaT=i<>+tT2z1^A;;z>`b_e z8gvucNtdhEjgMv5XIBMnH;d|vbq^EE`OM>)%WJ5cE2(XoUb_QI`Az2Ebi0yTXUX;e z8NNJa+MBzZeT-0Xk-qdaAly|`LaV~8J3sMahDy8wcrjkd->%w~<#-jIZeClCM({WR z$fute8fuQ4l_7Cf6DMWJk`zW4j({Qa?<9#0r!@;FVay4u$VE9`1ICTdv%#^Csh!Lp z?V*p;WaVE{Ekv{2=qT7uKi#xTGbY(M4`IEETk*E7dL*lv-w(14G&qEhbvbtc{nK^@ z7(*c+rU#ohfG@Ti!kHVuh4vf3M<7q?l49pt2zU?2iqvr#2=pE~Oi1g{5fO;42#4tv z;pDEcn4;?$6WCRvDMeG*x(CH!_g`74FHP?H8Bb@ju!+mH<*$#xp)4V%dcVg=K0V5b zAeoW;P}`fP05O=6{BZK%45R6>T<4|Wh#<|nr8z-Cl6z34+~;Yl18J*#^A3cqOELi= zW_hpcl8;Umb?zKG8Q7lYP;z%-&a69W4=Hq~!l^T-c(9+4&3ozQiffl3Z{^+GHZ8I|SoC^@4A`-kJG#_wD<_#p#50Q=i zB&yL*A}{@>-ou~#?YjCJ#&2RNu)C~?_Xf@~y4QFC(_|EZ`5Ou2W}^LlyW(BR=(6Kh zhI?D&{OxND+q@JnZKlZI{zamodpdAdZ#dnZOPJK??Tn4F{Ouf+bm$FCLi3r>wQ~+g85j!{XDCam}~lNS0$C*@3XpW zzMp93E8qVm-^DNfKje#TidWOZ2yc-O>mfA%LNr{&+^T)WoKI(hHe`d2XbYOk1|8WJ zv@shbS#%To$!+mamTCpDP0wWf*lf@VZ9ykygC5lu#K}_&;i+vwkIn`m1IXkB&(KPB zTw4%RvK7SHRwmU^*&v;>wi@(|Y|zndLC0i+j%^FtoDDjyE$H-Y&}3WCBeFs4WHQA# zJR9`5wxF}KLFcpuJw6+BZd=fK*`V{=f-cAgJ)tcKWvNyhUfdRhq^1>gVO!8e*`Q0? zf}WHOdU9LPQ?fyqwFNyj8}zicpv$vCPj3r)hQ7`ZX0YzZaf!RE^4IYxQ>%!bI3a6j z5?&3zgF$3P3_@c9XEnWAv0k5vrSx-Rc@~R3ix687KZF#JmCaE!gjA60lY($OpnPDS z|D!F^RznHl+n$gk42>D{Mepu0-kmWi@xfmS<#NuHMVsXVIlq#O2Y#DWN>9jol?Gkx) z=t@&=o#piyHlpl2r0$_doNlHWH??8q8-Lf4mEA@!8+t3FQcbhyZt75t|*H~ z=u21uc^{X?()U`vw+_Q?WB&I-ix^m(FcY!>{54AP=^%!wD2}fQVh#dW#;`i--avZ2 zMSEB}=6r$k1Vz+-$@%+(DPQ9@bhfI+VD?=oY!!<$at0!HEOt)2#9zKJs5rga?463X zyZAO~dhr@tb!@|S*bH8ukMtparjUCUbstmR`v;>V!G!8&?c8GNCT^5y{pLYS8%G~+ zj*$A{+usb5@nx04^r73ym-4W!MBl|73bOF>w4jp26u0U?#O)xn!QXHjc14tTkh>JO zX6-&hk1&3EOM}tj)&)D)v1^ctW!^BH3yGH?8tfYAt__tdH_Z#SZFZS_eyYuf&`1T? z^1Gh=&|K^Z{0aLc)0GTK4K!?h^_J(MTPXj_mIJKjkBg_(zG;O zsT8s61K>H5U^(+a`c3+GWf@($2 zhYoVwr$;Z=OfK59rDL*`UL5;y|L)=yKpW!}y)nU`9h%EPUnJ-uf^rO3-JzMFXF6{N z44Hkc92i)fu`N2Ryjp-lbb|mGYgaUkuSb_LQe-avElRGJ1k7`N^2+FNbd8cV)|12R z%|r35psk>NT22hCl8(mIFwG|Uxv%uCKI8@G7l@D}W`B2VGZfHBzY~ z@O77B_8r`iEtTRa*%!cAVh{9zft{s3NncK zpx4X+8BO6_!gL7T7I}Ojt+4u9_JrpLk>X2}Vk6bNBn1lZJfQM#0`Yqz>BGG1-;Y`*%r!ZE2lPkUGVXTZWS8sJ=kHr_3Q3jgt4ltx&4vw+r8^KT9 z(&CTarZz&;QEq=|>q7d;%+NB?N|$|Gn9ZqZt#lEmDC_+?_n#4vR7{EDoY#XDVmi2q zG)kv5>FdGix%=Y9>D}af?it{OoFq86UCaoD7#>*EF>y7X6;&RXzVfJKCbGnx^0yDCc~$%V<=L@$r6;-tUOf9Brk z%6sUE1?b9C)Tq=?>;2id`WHmM7AFwS-a!^YOC~V;PJPel@ATV55WY!?OnoC}KgIL7 z7SuR^J@4#0EUNwv#%}vCa0f_i6ti450no@| z3>9bsB&LdC@|pnXY%zwmTI(xIA6PF=QU1{4s_@urlRu2)jQt>u@V}V|@-Oa)-pU~6 zNEzR)_&k0PeMQNdc)ycLX8tge)581nOa%GCrlS+bD~`hB&&B)wOfvI_k(?IZ`!f;b z2k)DkcyCsDE&g1*=%CYP-VWvuBRMU+zsy9CAG|j;@xDoTEq;Rc&b0X+%p{XPjoT_^K1n={_$zqKo?+N#MYo(!IZiSk6 z&anGdGdPURk7+SLtup<0CW8Ew>5OKX5VKW1{@l9m$|N&Cmc`rfK9GqZKX~tG;(dqk zTKu_qzn)2E{xFi$D(`=0BFGQk`EDh&-)#KT6OzXCW8Ew;g)6@-l8&C{JC}e zZYG)ed4#SF?=LbDxp=>sNoM{qlGDQbUzrHhN2<8tXIb$g`d0#W!v`^S1WJB+6g_<|g-xl)sH-p32{9z=g ziTnf2@YuYO{>e>_;VpYyp3YGYXJ=EpKGH)Hg`A0{=c9?nP4uy~0RvPx#lLHBd=f4P06oF<#g*ae#RM&>0Re z4*-Uq1Iz<}(dGd20AO@Ez&rpLP!2E;00xi)%md(`Q-FB@d?*E&2f&9@fO!CXBn6lU zz(-Snc>sJY1(*lGzoY>30Qh(cFb{xFqyX~(_+$z&4}gD70p*RUO#$Ws@VOLV9sr+D0pz=5J668E^G)I_u@vU>*Knh^)ysC-SM(?Rx}=`6!E#)1ZU{O=8^K{ zw2XPwm!=3B|IA9z_!3((CXXTS%+3{d?5W&pFjrmU^F?n~T3OB#>g#!hU|muGUR_Qx zhxx`gtuWuV{8jH!aB)7@)7p8D+J*`pHQP(`+~Ju-_8m_u0&HwnvwTC%(l}1uZ^;|Z zepAi53(vRpJ);O=yoCtCjDq5?fhh$jNf`4W5D-*!s+=3lw32z^_;>;a&x=nG3I|13 zAOkl1>R2UkU0ckw)aC&X1_xOs&E0>U|KLbA9rnO?8Y#96ey=x(lFBp z@+Uq?pX>BFo_@M4^X3302H}lQBJGjgh`rp)D}N*?N% z!rq5SQ4f?1PIgw%W?zrDyLODjh9)ZRSvFbkDWNTYD%k2HJ>`K7!#(9nG(*cBvZT^e zHr>7?ZP3rT6UP70%S52xlSgR3vqEJm)@EI09tb{+YTEGd3fPUE#_QO`Ur}CyR>vt6 z3w4*Va4?%x=r)8P@TI@nH%%+ui6zG)a6q1?lUoMO@E*jJ&AP zDiSvs&fqh^Jrmb)oQ02gkHs1PI?~+E-2)FdrMWyMl^~b9FmfJz~xe{#Z_LNBj}qimCTD9!-v;{@P7^GXAjy&0E5@x%5Y{W~SC(__Swe zZKffzKMz^pc$dW}n^>>Qrc>e%W<(y!yMSdEiBHjU$*LS>)tOYeB-8;2cJS$)>aZvL3C z{AtticW?R_NgcH597X-Fg1-OsKhS6+XVcm0l(A)UM1k$4EVz)@D&1HXTV=Ifv*?vg$Ddv6L_0| zPd4Dnm#1}yiOx+y0V(IPO(5K8Zi>?#fRAkgVe4{J=nMdSY7@u`pPO1@z!x@w2yAjw zms}h#QZGG{i@N+zVZ;tt?uhJ3Tz!L{Q0lbqlx>E2}?j zZzq?HJSunabG%&t>RFCdCQ&R95elvEV{J{*12eMZRgT3Uj_oPF?P1&Fi${i+D&%gX z-e`>W*#0i5<6x`yZ`^zB(=IyAyJ+hN=;$u4e%uRR7N0AYZu#`GS0)YU;LNrniO37z zdX&-oR$IiRZ{MAL7+C@-Z=a)c=iS)qH@46@bX?ibt2t~0#SuPlI(D}cMV{GNTYH8_ zuw6znPJG8|=?3C4HHgO6yk5Gl+B3^G%usF9uw6B=j;*0_``_Pt z-n=E@&oM?%rsCMg&r7uwgB()iI)`b=>s*Tg#sGT?7dMn=wQLs?#&_&!{}b8YSgw|M;}r&vcNH&g%Z4{1l=n~T{%RL2LV-Ym2CP39TQz7MIUAwX369*I292T3%`CQuuMC-A|!bUw$9!TvR#2xN5n zS7b35Uugcn;2&9%e3Y)y{@()z@ed__6jh%yvN`z}C16$JKMeoK>g3}%eOzfDJ5(vj zGhl+u{d3~}#odT27DcK2MA~*s7;D!M65ox2y*Pyhg;}Kv7UgG!jSI}PDYm}~n-qu4 zb51bxHvr?s=(WMNM}2Y60lv{cKqLuj=W{Rvx82vI?*Ff|_%}!LB zP!Tn68j|b#=TF*Fd(3J>M(Fk7e(NZ&YOv{MAx0^%eF1j~dK!1zxDRJPz_>5Y=x?h%0tXC4 zFA~P&YtX*BN>1jE?mLR}BMmV~x6*jL6NrxX@?${5csnHIxE<2**=I+@0Dq8jJJh{^kYOkaX10fSqZcRUq1Zp> zPUH78e)qsZ{*K?fhB}xB{2VJ+Sx_9VbFS!gJ|SVg;vyim)Y zH@Is9(?8vrOv_5!jNC>Fqw8Z6P?JIkVHgY1JocyU;Qb4^-&5QZw0;;`<3eq-n|c4B zYI`7m_W-MCW)PY65z94q(Yk$k9#DZ(`IP#h09DCHt7y}U#%nw~dbc9Toa%Q89gMD| zJmY;OyKFZODqVg3;l;U^sw=ARFS}V}>y@T(1PsKep0&HLA~tg913gA}H#2*nFxsv$kWiWd=in25c17-^-**1za7Q|r1lzj9PCR!a?Sty5F=)Ct z+!c1SAxQW&E(RFCman06Y~;6ck&UWq*onff7`PIx;>j#{{~5zefy135KCP zU@#jjdD%0}J&LjoRO#L2p^x*vks!iN#;C=kOppnd#M8Ize0ml)`?Caal2Q zor&A`|LLNVX!uf>$#37Oo5ERT4W7CxgMRu>f5k` z0T8AD^8m=F0P_GSqyX~(K$PaWm91(*jwIR%&pKqUp32S7Cim-3NQ}<1Y(|x zc>r{$0P_G?lmg5H05i6p#5@3&qyX~(=t%+Q0e}S1lb8oUUkWe}fc_L<9so;IfO)P@ z&UiK^`Gm&VnDY_#pxd;`dv^qxq{&5n;VJ{(!;y_*)+h;y2+6nUro~q+B2q zD2x>$dWrCieLiS>m9N;;&YnTTx%vi3cA?M+ai(SiJJ5sY6g`U-J)r9J~TNHC*}i}BNy7+d-N^$fnaPgu@3 zzDTlKi8}ya#>4d&g_q)I5+3A})$SfbqL1l{#WTlMI#;S<9l1RrL-NJ?dV^(adiy8PKLjhViqgVzsuS7(W{i zmc!}dGw|Wqsqn|hGm+ZemtEPlqWN5}=AsShTrcE?fpZ1CC(I+mh(WYAL_wioMU0=r zHwh)XID>enDPH^;)#|x~F35 z)<}q-kGHe7k%oE!zOG{Y7NFyu#Ri8_)%dM^I0%M=>$IG+2hj|!jqMnYT}?cTGyX}= z**kU*z*Qu-ra~K7b28{gML(OtZI*#Rm|gJ&cNw@{34PO`X| zSsveFSqP*z$~7lr&J?Od-=T7Uk#gsE4-93>t%k4nazVhlz>~ZkSQxAIJw!eaxdWg2 zp(7G!bVTk^+td4CZ^%9B$Ep9XxuXv6urvSXWl2beXf(NuWptsqjp4-Qe9XRABrXSD z_Pt831V!c{0cU0oFpu;JPG@}TU#b_CP?_+y##PjPRyhQX7t57DJ2jkcd#s8*ExyAMhu&Lix(`eQ&<~b#4d)rw@ zU-trvcChu#J%%~k_%PX^LN@zh@(3bnUm-jBi1L0V7$e#l^JC*f&7hCY2|}u9V<)3c z#-OOF>+-X86~^`=7bNWw#vxhMPYq@i=3gc_s$)e^sa(U>yk^$cb$0DLiH)iq7Z)rp z$I(b7xes9#6D@)o6*3jcHE`~;5kPB0eY5IMVXc! z05;r#w1K4w5XOt=f^|gioZ8NVAeL=OzQrMO7*|L#KkRcB*12HVRyGb{+}#%D44-%^ zF?{urz=U{S{j zcnIT_3x-MY!8z0Uy|L1IV~x_y>&3@f*iwaUn490R7B;wG*b6P}zy-seYGGn&=i|J_ z!o-Nrub;FU(3B*sZJ_CrzDn(3{?Jme-~CugXGev0MM?cw>rOtmMw zm!D*JFCNJZ`i1ea;Ha-lviVS&jl<_*3*)1So*lt&BZWt6g=I$YaYR2-603}2;K2G9 zB-uUO%1#lDV;r39hluNQz}ZR-w%UoFBB{4U)@H4%wy13UVK;h?ikO^Wu~}=KU?oZK zoBj4BtN6!4{Y)6<4}u^x%2!C3$u$Wx8791> z_fX1Fsyqot`MoSh>Gr*}2033jm>WOd`AVIYe-t=+Wblh(t;f-*)aGcs1DUyzHt8rO zMX`X*9<($o)4P^pD^D5YpEEUnv2jcDPP z(toCf6F&SEx#8PVUfJt(7InJ!?cy^&$X2+p)4bP^1D5YXs}L6TpF;L#Qhclsy;939 z>QcTWe+19&;>WeF?Ih9Y4uwRoB2Ij*is=nqe_Vo#y)V$t1iAtHUQ{n%YGuFWk6=P>6pIDqSi6B5Qp({R&Bl;1XaxX4kX!Xn8l6+rDz+%c+xY z``X7ZNW)E^)?JHW`>RzQy@d4|JiCjW;Z+;g3${Zc(KX^D9u$uDWH%^^lD!Vk?&9nD znB-*LE zaX3|z83Bn%lA0b6^hZBem0{TQZbJ=Ezk6V!FgH-cCebuf)1>9MeT;F13Bu{?=#0kQ zjIS%A*DBWeBfA?nE5AUm;Z{enfPq7A$Xerq&H7eFQ?uTRXLs>7{wB?;5U=PBLVXOV zIiC~ix8vA(GaBSMu5$JSJ2~ZEKF-DmqbckfN@EV$rjPounUC8AsotxwvNKat4 zgSKI|XgO3vRcPEnfp#7YK=b8D&70~F*ZECMGpp|)s-rWa_jaUuyQ9sm=K{2`dG2eo?ofwb%nYAHbZOe$_wZ@Y> z4*E!TCBTeLWXwKUpT_S5yy1t5?cm>VnMM{IMJ&T@_b{ZnlkoUgCk+=ye?nyGr%N`2 zgYb66iH}nyez#ECKkqATKHlO@3_~H0^er583Z_Yxvh=C++%)kaYwg4qJ-5}{X%lI9 zfZYa0`zMXJAnarne%S7L9R+wo0!t^bOe-2^V%97O4P`@us>Mmu^c$AIR ze}HK#OK``mzQ3w_{e{mcj!pMJs?gaximDGWER4w$9VM^C35V{teVZ z{)Z?tE|>UtX0c`!C7IIOzYjm z;&rzH1KgL;`<`5Nd9JL!JO+b&6g_?q(FS%qt(II58=8!FJtO52sI}s;jwoiy{$kBd z(){IYoi@|>C3oW0)Kpep+?u_`+;E@2lN6Zj8@_3(IfU-H|x}CTH;Qi+q zf>!mx!r{tb*tm=0#OuK_X!9KU*;d|xLz1Gxpe033in1XIcw95U>yQ+14;2_ZZ$cG2 zw^<1lw^dHB!f3x$2uBs_w_1P}`q?V_P^RcMZhU+heXa92UaZx%S{&GbX>D6nWzhU^ zA2Z&B#+&?<`d*ajpZ`mJlbUvx^3kKntlohVjQ8R|(u)Coq8^&l7+pyd&TWkDv?t3} zaql?m$%?fB3hWim&XS%yj^-$NOW|18ds8*LceuTcL@zF;z8qdKUah3*OmwO?>{M-` z=1)l5t}JOQ#*fVQ$iULpU`l9Be{Su@)_z{|+WQCbgr-n1L6apt1y|ub7CM~PcT0D7 zX!emtH2FGQ(PS|IQloVSAg}Jag8?}GiRLI|EB`*m^aiZtcTWFKVCM^?hC0H+^5?DZ zoPPT2)1U#CCnJRIv^^~6i|597gKJN;ox-^+=F;4nm!$QS6@y&v58?%Fvjt5apw!MK zkMMrS7^PrOBRjJ{2&bQaW3sroGWhW1n&}yVv>H%aHL$M!Sq^EV9^rZ^RxwM z?5qW#bD|C=QK8<=WZu3PQszrEF7lE1*ZLNJTr#ZM6EdAO7QDkK3yfg7u)u=XQ!;z> zT(L-xRxw^4oem~F2_KHT41duc&{^7M_aDmje!tOB?yhol&USWF9Yzj4Rvx~v8UKfR=PafI)xy^IGq|1OwI=H<4aaXIOKkF@Q8pUU(a;&^bG3f!e09 z0DIZIiau~n%;*D~@BT4o(VR$3pYn#3hMyn6XJ1Bx7=(ndP7KUblxV(eIxl)iWw8L}OC!jT%gCtTPJ;wou=yf=7} zT(g_H#_f%XI33?juhrFZX5%XRZM*^raR}p<|r_S^C3P{hms&7$@ zh2>axWct1|=Dnh;F4ohKaz#WmTh$SzvFc#*f4IT*^Xe6eLz#>0J`AMh=(kwbE|gEa z#GTN9r%=xPxW+lwml+{E*_tO9(wjS;-y8WcX>wD~HF|;0WwpDuv|?+Cy%fyykdT=~ zKj*)GgcvL5&zqQy=@PH9EF;~0fvH_JIAyOw&mGlB7F7{K5_9IR-8??kE zHdgh(bmzNzFvr0&%S5Ri+EcFAd&<6OV$s3`Z6gSDlcYd4(7?Rg-Bb3SL&lJl={36! zTBtzNPk1A&(X;vEn+(nGN04{!klaC!H8CgtD{>R>O#S!f4*Emt@9Eh3vW|YLnmaw5 z{x&$$;|equs$<9v2#mTFvhmX zf^@C%ae{WJe3WWt3-d0WW5{%JPX%u<^GKjol#s*7#0zhxjk#h5d?rE0a@$LED?D+{wem5^0nZ7 zy710pfG76N0Ec#=w2I^;Z$6l7-7GEH-{>!NhxTGtJ`Y(O#5oF8Uo(Bb2C^1&517we zQ!dfAdvV#Ax9Tlf=%>h}bLv)tN@iB1OG;~JGrFLF!=iu#WD;pn=l%47G>|yw5GVQ| z@Y++8ulj`*yWQ%v0H&+H6gnu`dJ@6>69=b>-%R3qSH8Y3AN3PyaB@{8jrdLBUEGsT zzMY)-er@C9?7~6o3Tm=1>&<=ea|`TO5|U$*pLFj+L+Q*$uMrK5-Nw3ScX;n1&t#j~ z7YqZ{I-1%3aWLl*KMh=5{Ojbh(r}`wK@z=*fi9+f*qX~_B^S`J&s3Y+xsSz@!lCtC zsc1btmLHxt5}7NS2SUSD4O-T(7yC70*!Nenrq+Y9zsBJ4;!hH7!&mw-G8NrQNw)8j z6iDZFKf<%S_#2%t{wr}tcPJ!cGCO%P8Nn3gI#n{@tlairnYW1amruX(rj$LLFR+c? zp=wLEe&k+pY&l3M`ec3wCdT;YQ%P69a#`g0p z!F}{`o@FX+Ht654B3pFSoP0T36ge}T-wHAk{}(8p1ZInD3FIpzQb~sLjh>NTUfYr-R1KoJJve! zrzmV^jVgMvEC*%&l-svZt@w1so z7lGDTkfgdXiVD@WgW`qk>}}&f;{lgH|3rf4OP%dVr1_1{5IO!Ve-t22APxAO0zR(* zCP(~aGEo_{K0O+j!&=>sqb;w!R@7(!s}fqGx@yB^Tc5g%C6u4lUyWY?zfGr7iK-KV zyq2m{vGE1v;dNV@TbrCu3~&FUz~cP-83A8vedv4pm-U@E8^UcLWO~#Cy%+?mbpn-; zd!k$hrM_qWOI4@bqB9b4n9RrIkm2Zfajk9KtC_f5nHb1aP$Y-TODEn&Ub_&ZI7OkLy5*A|^?=--^cjO11VN!z1qBG$OYdy6m+q5i+)W4&P*TsE=GOxtH=}cGc9GVPD$9(;@g2iBEV3Q<{gH1*WhT7JMeU&&pPu1LZoZ#U+RZZ_K zmGfWiDihyQV^xR8uFv*ea=NDD+;nSU9SDKUN1}BpEjiA5j^@pD{2meqiTsi)E4Gn> zDQigQ!z%|K(Yv*2n|QHZ{Vr`24p>|vfny#_k7~SG<&vXOwQYJ>YLXONK7VedZCgL* z>4Ds@4xGPe4r|do>XyAOn%Q$w$$=JLKWVrA=qs9(s{$Ly5<6V#2LF6<3F3bz*qM@K zUT7c0-n_}@)>q{dwW!kCyou*JxvivRrP%loa8BH-rO?K@vY5Dc80zDn(7Ugy1XxCu z{!R2XeVi3Uf2P#I%t;#N`S|MsCVjCPSG*N7`A@__y8mn1A`#i6uLG>Q{ZSfR`S@Pa zjW5l!yGL)~_k{5J8RPaJ_z+M<-yqoYF!C9FQ`y|80|WN{$$^1~>w=S&CH|J;aBbDb z#Tv>&T=s+tG;*Glz#&DfAbwj3E=yu839M+1?*N=tnz0SOH8I|oGBFxegS?ei!}_~Q zt}&R>zXgjooD>h{SNWN8!uOPtGuNc7I%BYQ3nGp(k%!QbRd24ONoY~dI;%Q4R?)0Y zupSR+ZGuDmHV46y`CB`4^I;CIPOBd#FVyrHFfdH@HSW?Q>d9KK6hhP;9Oa?ysqRo! zf2hpwSg?N0=D$yI8t~xNE1vC06VAgw7%SG^r(_3E42NDt&m=RZ;vXj<6@P2M65iBn z(OUT}>e*1ghPJb@N>oF0I*a3llJ+*maR&H*l3Zs_rEzvW>4*C~P^aF-m?az);>*}? z{S;q!y2kc;X~zo#eWhJbV&N5sWV{A)EZ?XimM$1eHNFViD_YXOyMx$=CEx_;$LNM< zIk~WIR>xoKZ$}{xO>RLAj`bvO_XJprXne}=15Mank{y~c63#}y79$AfKhhojue{=| zkET7g(jK-CwikG-MKk)_iMZ;+&^$Ny+bEHsYgd13_t;Y1Eo=U|9&~SRX>yk};Li5i z_0AWuGXoo>?srpRRnH)%Q;mAgh9~f*t5fd4f$}8LpdpDHa=^McW6-+M=AFd z$HItX_#DsBTs#(*K58^PdwP=fqg!Z~%}ruqpgpY>XI}9vj5vnRvtB+IPny?bgopl^ zH4ju08Df>E70&=ZUTu7krrIID0aWKR(*))beR93XZ5qeMjIjBv1dK*8CJa|O;}7bM z&~Rc&Q11+(8lep&XoeWk8O$4c8O#IVtQ24#r-2e~Jg=F@c+tiGja?MC+TR&;)tk z?N)<9^PltF?|@%<3Q58OigF#+is2 zri>@$Zjq41w29T|`^aL?*$pPYY+Z{g=tvmhRaccF}+edY@4I`n(pH|b0f()m*$uB1Z~gC z@G(O4Dn{uQfpN|zM=^@MBK_gR z14nPADVI*J$g{qt?09G5>tr#K+)cVUp&h80UO{vWEkTJE6}O+wXdj3+^NlE~@2$-d zbS#jJR;&y0Y;@_tHRnNIM18NYx!%I}ge<T**sNkGhn*Mwmc_W z_gnW-cdyw?sEFaahB~|`sY9@P=@HbS+*SuQY_kqO+6VHqVf&MY&t=IE-+IB82 zX&e9F+ebFuaX(4xuupt_x9z=q9N#ZQDfUF`+RFEs{lfP@d&8$@ZPLztHLI6Tjktg1 zyLSJ|x8Lpeh5f?!%d~u&J6E;F6x+=?G_`H+?5neV?l_X{m{RwfMdjw)d2uVxC+|Ja zeGLfD(~)HJ)DUUBCmqMCCqy`1JD#%lJohzdJWofG%~Qju@!o8nFKy+Cy2jqxc3%U* z^K>L_d8%#i%I1j$yR@EEdvAH}Yp{5pjwG9>hEL<&X`YwTwpT09Im<nbNp zL)lk`WEq>s3c%E*wD;w$I+Fd~>Uiru)=;mbBgxiLOLpV#w2m4-uW03Y%HHz~-?n!m z=6O1jY@X}@s*Mk%dG3=|?rSM?TBL=mIqzQCs>3CFufuWsRR>3stpl5xYU6!r9n@~G zYUPQh;@OR|LUtONGOInY8;@ekuIzDxt zwad%*)GklVF2H}=N4pp&S?3f;I}Fc3jS&4z-Pzt?L1}Dy&*+TSypS^OR9|Ii+qv1| z9QXFUPj$N?Vx80YoBF~_0ONjOvLlk)Rhw7d#@`j&%D2nyoZm_j!nNWU@=dkTE65L}4qN-!^B^ahv$s;_%{JOs=Cn~0Nwd?u zIF+P0^IE}*Q|l--P_1pv_19RL=FIi;vt{|@J{m%bE=fO)sv%0_^T*3?G>u9K@EQ+E z{(<{Pxd#N#Zu~}`4Z%(^4|Y}q^yy8gmUo8|g$gDgAV||`m)eY>tzq*++oa})_Ama? zMBmK42_X;hhaQhS{*aVS3vd&YR>o$G2a*_1ZUVs}-m4j1i%|1}QP)cQJEbL;-zV;$ zWRhY z4nIf!OC5f^{Ir$wJzsuJCj1x4|9OW$UVcqb;7`E+jGbTbfRhv;8bH7W_@BA+iyrVO z1&C4*aIX9ZIQ#_pMO%QME&qtaPn2I|2KW~F*En253ecqjUGBk`$bX;*KgENeERd!x zQJ*9~B#ruH2C!CD%^lh6?OmTcVw?yUW@ZV`Cy>skiRS9T#Jrw4l5b7WprM&u&7%sA zRJXXNcQ<=;ohyBAN@?vzl4#!P9O99Tog1_+%+sG+!HG<0msvQOvFk`EnZ#H%#2n{{ zE6XjP><{Za1)v)*9PT86!5~LH7?OCbCZQ`3*v%q@#6M$lcaVq$H( zm(vU|m7dm@?%y=Og6X$3sftykb+N{4siu8{nl{x3e4X00-M+;e3EyvhK#@-CD`8g3 zu@B_y)qLEIcaW=y)Z#ufUN_^iF*;3~xnpFYP=UQtLz? zE(8U>NC9>PGxOg%+u_iDPvMBh6>hp4w+XG`3hg}SMvYBbkmza*6Er#)FT<(w(sN`{ zMdu$${C^@|*w{$p_VY|?K0Xa!`#tp{S0M-Q;6Utk)aHux@=x16b#nG~XCSxc2p`*4 zsN20z;=@*u*IvqGF^}2^38eL~O7gDY_s{bq(*)h!KmVmcum310ICTl>= zLC5NH3*22XLpyr3GA+S|?_&s*Q*ur(r2wbAo z4S&!>E{1?SmA4jo<*o5BuPxBE$@aoPTU(r*VjAeAC@W|Vin2VcSaU2;mRT&qxx^j&vrdM!LWSz9H}}1K%+CmJ8ns@QtnXvv456u2{&C>F-l zek~fEIeHCeFI0#O$!H) z_$jNW-4%sEqk)o^I8uwG1rKM{zRmW5h0NU|+7m|qLM$0N`hzIlO5XX3P>!ftjZmJk z`lX49ZQY@~^SM7V|K8GG&vakW4f>`0B7U3rNfr1Kep~syg5R6@-OUfaIrley+B+P; z?nb9gI3K4jZ_wZ zRTqGDE&%JA2g?AsjxK(@zN~b++^%vE{ZKs4)96U!)H{QbC8ebND>4Za&`8e$uu6~x z{wuxcu`|%_V5CynHcFNfJi*>pBE_p=pgn#s(>g`JCsgx>-`kqQPgH`N!LC=K@!+~r ztg-N7n(M7OZd_R`CQn@1{=^j+$$-7bXXMEP z{CTmB{>&Jflop$JMlOh+&NjQg*a1a*EL%#K7C!wJ=A^An*s>I1d;wYLPUJRRA(0E) z^n5v3bG`%ZzHs^*YB|Xxm{W>?^E^d>z$yawe(}9WzEgrocU%IywiA7s{u=v0Fr&zH zpeL?%IUtNrMO`OBg<~Z#`ga2Dpnp_cDJ>-N8&$K+Jq+u{7RRW}@TA&GNm|iVB3Y3` z8YZ=FE74hyg7*s+ni&EIQiHE#ifhlFn`S>3JwGhfBVtRJ+G2x1W?IGK+s-B*eM4y} zvuG%rbo-YS@mP0x`JUwU)6yb}ZhO_THJC_)MZUe2gVt?_S@jDsB&T&~G?YLWB&IN1thS6Cq@v-*Twr2di3mdEZ!ZB|J!==qg6CL=E&SKu4;r z$VjXN{&ahG-*f0^T2S@RDtgD}Ss48X5x9c$deM`2^M{MV*$RK()5D@=EAaz|eyJV$ zLx-|6PK$dz#k~(`7(_g|>=biJ2c;Ap9a-XqSDk+3N!Mh+Cjx%Zz#~1ah(Gp-l4PXC zRQg>Gmi!|HEB)_0ebRv%n+036-l}zP+sBz;RXtmkzo>B0qWnci-b%9+{Tf0gF#)Md ztp7~!+g^-UJT$lJC%WsG+|%K@@Mu0I4Q`I+fZ>^A<)|GJl#D|25~e#XxQ9s8Xv~0a;agE_grMda`|~Dh%x#OzXHE& z6F>Z0PLF@<*AL&LaLzPyck}xZzvaNE9?73@o7!@GDDUo)aN7a;F6YgyuQm<*YNSKz zzRupx#N?|!qd$qy47aJZmEK&^t22~dE~2u0^su@(!J||AzOLS`1dl$WKRcfP&vLZq zqa(#64|%J_=r5Lwlayam{In|aclCCZqrZAFjHx;@G^VOM(TVGGmAJk|yw69=R{OeZ z-3fN2&3yKTJ>AjY41uXg^es+OR+E%VYQ4QY@n{51Nuq~9)4RB5N%VK6%G)udF;tz? zKa(s4P8P$M2FA|rpP8CO(s*QZec(Hq5$wFLui)o?JcU>2;UbM=G!_jzINZhs7m}kV zwvuhNz;d*ksFh-NOcBs}@$-7(at@KnQ#$0u5`g=qQd@u1U zyjDy9cGEWxwe}XWZ+n~ZQq~l|B1fK+Yx+B}-}5VC*O>~4cp?NF+9x*b`ojUi@`hc0 zI3QT%p0)iW)uyl0eZJQJhJ5rd91lkrq}%h@qL?(VpFgu9D{6*?+q4pnPbC&<4-L0{ zTHjH)P0Psm>U4U9+q91IFxECLTAZqE)8bPPR)Aqy(`Q4UI5riCqp4I6RuacXRXEax zca4DVos=9V99aZZLBWRe_dx;wgf zSh>s7R}Pu;-<}giW7cw)r>_$79IW`i_S`jJJ>^18B+j%wzKE;6Dv~YC8s((Y%F~UM zPkdH;I+4g&JX#9gs;Lr-^GYGSWnOhfi=Ju?9!OnrJ6pBo@dNF#I$hPEr?VOBRK@yj zCYF)ISbUjFM|_AmMVr)p0Ha`yH{HEgnB=&z*Hz+!gFxpM9rb0 z&5=ni*=nwMfkPkMyICRKMCstz;U+4BGcpc9dG?cMmQS#Igx#WEW;RC^_l>blBSceX z*2lofy&uoa_tmns&t9+^^$EjTJyB;qpYt3{=580?Vg*a@4f)r$!|5+3r(Lc6FM2lV zRLAS-&nEpH;!})6F~$bD`XO#Go~BaOS4}Q*PuW|f>|eE_e^+ajFo`Kk;;Kg}QVU@Q zTv+EINt(5Z#J@dVrg@E~b=U#gJ6iQ)nMvw)qSuW(lFwJo?8^Uf%9IVLj)&#yXjra} zf92}9SFVnC|c$NcyKaQ2hj$aj`<5sz6dyFuW0sw%StEshg1ZK_i zJS6@TF7dBQ;-8bo~X|g4S1rNSEPBEhfEO+ zdZy+9@TwGG9wFS~2v<775l6U22oEpR3t@hDevCiC0%f`;Ez_xvV%$;ig0d=dh)}dD zurrN(u17x7BTsqcO^QtMUaeSnrf*xlT+3o24Y`gGZZ0whXB8=kHmQLao8ryCii>Ul zWBfIQRfA}=T5U#Y%n-T5vFzwD|BQDsEJhBR+>(hnI42I~a22bwG%_(!D2-e&xs-)b zc?_OAD<{n`h>j%3BGzSb#*cR}j|Y1>JZ7^rha5D0Gd1&U%a#G`W^@}FnGDI#0@J!Z zlVy#y4!eOmN*U;$`g#ZZNvm6?9$KMxH z@9Y($V_JZPnrTTeNDZbIliy(XRJoaLru~ol9c3kuRcRk(f(>pjlUCQZGI^Z_&&{Ae zgd;i|NJ$_15SW-;GRX04Tfeq{SUig z_Rbo(_EXTkxJ|@vhi?lU>7fj@#)6tA0OILT9+rzv(R`ZqeN-*8c^j3PWdP_2f`* zhu1j6Dq8BR^j4z#2;{iLI*8|dE71=C6wm7`m+MnKW%g5FYBrpA zM-fg;v&NY_sCu=pTE;{mWWHK%jHy1Af%Rwiln2&henpM5K#I=F;AAITzfLP$tHlX-gyZ%~$QS-rYUjZIv#M7aQM! zw?o$Kb?J7Rv8dd$sMQ2k`}R?j4i6C?dss(3IJFt7K=+JIo-rr(KF3u!!Ca#+dP{TX znpKuN`6C-QU%SuxE$&%7uzqt|nZ=9=s$3mkN%6+_SOd6EjYCnB1#37btGU$V*gyaM;fJjOeTM(McA!_#hqX_< z)st)Xfo8*(eN75;-=`V5j53D~Was|8c^yq0Y=xhfu~_T96UXQT#^+oDy&vOY|1->w zmx_%`H4BQ3C(EIJ;wxT&tAFzf4cpKk8aFb!{dNYhErVw+)U2B)D<1L8S|RK|6YjK) zb_U@Y$+xi%5aRRhObM~yEoN_GG*~jL$Xrr? z@WcWf*NY~W&X2ivvapO7eHX)WgN!xKkaqXv%az6jf)wVbIe2nuslK=rKb~+*8FWHm zA%TSjvRpfPS}^?}?H8R)T-G+PPN`lg&2UbaUp29MRpUHmgQ=8m3{DGU(J=O)#Wo(4 z(9FtYGrue^ntV(!{ig+TsCo_~m5DVY70;v8%A@3YlorfGl+klCCid7HU1#f^)eS9}0KICE^_yuBdVia!TinY9axBU@#K`Nawj!hYWjJ2V_6*(Vo^kbEwW#kH-7lmSK1Bgw4oU2vL`{ahyjX zP}A|M2PAujIW4R7hpjA)tUIi$G;+YiY4|2is-03AIb`BEf+mit9a9>)Oo5k9{6EsZ z15Sz}`@g5VCvIR9GrLPz(qg+avmmRmAR=M}GbjQg2r9aq+BmZq7zbBTR3wO}D55B! zh+;rc%%_-zQxUVmn&X-E^i25seqVLZ^e*V#=l`G2XS(avd-dwot5> z=JfiG!J1Tkb+D$nJ`nHRwJ_eNCR`Y=tHB94wKau>@oqImxCSOz7>}iXhhgqm&Em-M zon?Jr#NU3LqqdN?tGlpGUWMPGy?K+Cy2om_A`?6P9E#Y7eMg~guUJvj&J^2F>nhJ< z5q(M=l~$@@SUe47H5}ho&v9!fIb{{W0&z}~%hWT9^YHKYlmak@WX1(l*ScNu70wfC z?>%9sspW%hdx=>CTLbEX zI9a5pUUh+lUJ2aWc@Vq5Q}5-$YJeZ*!7c#*l?OZ5rM?EFx+7|Afesbdve2$Hu4A&K z+QPYsszJ(+D%u-~(a;kO7i_T@IV%nM0F-Dng;*OL%5GN)F2L|M%bhEEz zBzhWFCHe!n7%O=@jEbu~rtDHsOBOPI#D`O+?Z*y`I(<4fV&PM~A;F!o$o>V3pkiyw zXFNut-ifz&>dm%+bXjDub057ZZC0QY#4@r!(!!sSsCKS{Dl=pYT!|j9S9@1VbTd(A z>h;B@f@POq{Rd_OlOVkM!IZ6lpyCABy+|+TwD`uP9J>xY!V9-Ojb@%<0_#S4ah6XU zhhb*+C}8w-8M4M2Ln7`C$FiKZjyjg!M+ECPLF|U89~wVbm%fLMc|GKDN8~9c`fw4W zUm{4F(Zbe=@a)KpeqUvDV=kjnnExtt!i*KRcK_4R(K>ZDCqC71&JXLV^%$z`g}b7A z%v5e}gOD_t*=00$e|9<3EOmSzr0X7}%P%Jt!gdN=%MC2A^H1LcqQV*?L1;`_xpfov z?kZcq2Vw8c>72DL8Fs2o273oN zs}?T|$Pu$eAqj=PW;I69W08^QT82ygerp0^N%&*sfz~827>!1f+gb~;w#9vLRRFg- zR|>E9Ue+0{D-G1C^VUw$c3GemA{qGLV>hk&W-UTD+kn^bUXQf7`vL~u4-Zr3(hGtE zR|8O%AYY7-LoxnX9@M7dKN9~5_z%J#bJ|+Q`D3a=4&kTLeZlwRm~W&uhApo$ye`0@U-lp9j27y7x?srq4a>$> zC1_D*{8}7culvd0u(?u_VA~}zbatcaQeUQgx-|4sk$1-0jL;~?N(@UB2aqT~{#WCF0{&;>k7Z1GH(mip%~0!jY}YGN5y-+}ca)z*wX+yjZiY+E zXoZ>yxey7$oPna1?FcUBJYd4I>Qc};G=Ei-qYti>$%p0z7-5Qv6luJpLr}{pKUCMK zGuUScRLfE8ZoR)qJLLVmEgl1@`TPG=o(is1$SiiU#WUl-g4MzmSYeo~X8iZ(RKJlu zP)+>rrzZY~bK*b0N^p}K=2R8tNEK$33Uh=Cb2P)aOCeEwT87&-;dw8xS z$S*9;R6LJU%*K;TKIU6os`C`p6h(CssiZC8-kt|wf9PU3=g;DF&eIVenqakzsmeNw z?1L=ps%4r7yH1tffyVM@ha1X0_fJ_M!=>}Mt?PT2k)rc_R3NF#tg!&?5^FTD2Dm_xw!s;)A7%Ja%Ee_cqp-ndbgaREgrkg(LZxvx=y`%uE zGi5xu8ulrGthImT7OA`+O3757ejY?JFpkP#wusT?utiY zykAJ&b%ahlwk+V2h_H>t&j|Vn%E2Ra19Ad&&xtWqm`s%Uu3`e0xME1Bp-Hm#32{cp5fYsqC+=zcT<0=Ol16?5daF z;Qj}?-Ox_AH&C%B7N3mTUql)8|x8C^T|P|Pb?J)YM?2R;-3%h! zK93$&Zy?M4e)~WO8EYsi^(S^K^~)}=dJEZuX4KvVB=I7C^i$QyJvkzj6%kU#U=+BXWV$OSXpFMpU2fXl>GZ_ui$Xwq~1~r>4dk zi^tpLsed{(gnggg%zU2Ya+f&dt_9hV87y(t7`uA&bXTCf*@T){NBLD%Z9VGHsx^O7 zVpWZz!p1uo0qoqp5O&{&S#iTBs5#glJm!fPWraRnoOal^G?iz z;gUEc$B;sTWjeUkSP7QTLl)3qrX@rIID4T4UKRMWr|7B zsN2k1LMjFHlc{_a5!My+8H52NGt=%zsr1xZ*Sb7SfikQE@?qLl6`vcMxf9Z<$BfMb z+)A4#dK;U&dvT3koVPNkO@5EWJlVFsQC+2ZkkDJ{%)ARd7c&*T+wC?np#_d_SJxM& z${md%+0j^}sv%S(K?xTx2&nM6Ivx{m-0LP3{F;sweCI0}BPJYc;5~}GJX-rk$AfVj_UQbb<78NM!kv@|g+3S=3Qp6A~SeJo7)f7UebffAeZ^U*P zT0}$C;t8@No%IitrvgJ%;vsZ+Q&DK}gK~_6Vkzbss9Px%$?o`goLP$QD)SiMjti&d zRt2JOVdi5;U1|zYQR_l@@(JkiY3fn!_&vy!fg857F^Za!i8UqlSosoQ=){_#4I#|1bVuca zbYiKb8?JpZ_U8-D*Jj#DwF{`HdESol;9(YcQ>9 zq|sv%=m5$_PNc`wupd`@M(l$9ZKokZL(}=Mdi!nqq~XM1zI->JnWCl2X6R&8 z0ir57PFOzCa7dgNdrv~m3)Vyl+y#YdAfk>XQ7k~r`jP8rMr!z4*Wkr7-(hu|zxHJX z=NvP?0}~VIfqJFgSLsq&Ls#tYpe?8jQaNGm4xKBh@f{{J&hg(P=l@?>^d~86$GWyG z2ITxl=-paiUt+Ghbtz(zx&2e%_iWzgqK?fumSvre*@8%XH%EJ29Sg#QH0^{+#IkI} zp(;o{1f@A0`qU(BeYNkFicYp18}?fEbvOn@k<%ujJ#zH@zmEZ{8ftc|10*Ij4Uyah zW51nboC;*|s3Ir($~2_#btDeE@q@~5hf$%&;xNMdk=DZUQ|FvzgC4ACk!3d^(`EQ> z0Bvj;s-)VejqQe!NK9S@I_eoUTn?a)396CupHw{@F-v{mmviBsW8UP(95dI$cGPZn z8`~Nq5l?I73_OfruH{iJP`+L98v##a=Cn)Yh|k6e%K-_f+L&OwHbw$Uv%|>)rv=If zRCk)G@qHo6{6@%}%UfKYB%|#@BX#aNlqqLW&ozD35bU7$LP=#v5?F*$#z+VkR*k5{ ziO;C8Y@b7jTzP~)ewxZ|nYfY-g{<3EONMhHFh^#WgCiOSw3X;s2Bdk2;OPDaaI0oMo6S&{D{3}^1a;3p8@u|5r0=OaP* zYQZ|2@A82CEb8>l`@qzstApWhz5_F%Vte2^l-=|oR>k-GMHuhpR z-vT!I(Rx_N#>Jah_HlrW-@2KuuJ~BcL?o&WLgOXhQQ{OC(;f`|F>3{=5`}@(7G~c{ z6ayDknM1wS9)%Cw++c%~Zm>Y=t@d=d63*e?nnU5n7pz)fvb~&B3Xq3w<7s&R6KV4p ze8kh$dLNI>OQ zlw$g-z9Np*0}O#yDWzJs@QpdElzxwE?9vuu`d@oq$^{z^nV&`qFGD(`yES4kz_nN` zEGMy7KqjpVg3;Z&1!6&G;yQrUS(&(&sp`T|dM{)RVmTxqi;|Uf>kEjdLUw))!JJOx zHSkiR7lo_qi^HAvoDH9FO;P=c@$)=o1p};aAzKn9b$O0$NL1>SiDE^qq>t|#N>Psv z4y%N?z6|CTw}wErc&&4HdKY2%X^tT-P_p(0fs+D>a?o)YB70*^8M4ln8g?&~D6^S7 zM&dT=Hp;mnTD4m^+?j*}bn8wKOh=2R^OJ^H-3wTZ^LX+;*z{#6W7b`gSsrp=DwHpJ zb`P*Xv1ca^cs%HOhy!;~Wa)6`hf-}oBT?Xuqb(9iV9c1zy_*7D+csqCFeX;*L9ejR zMt5FG^cQ5Nhiv_ybMuhteigU0Str8`u*KWczL?EeeZs7Q42O_HDirzk2ph^q-C6@M zX;m2ZRcOjn&6JnZ#DNrshSO}=Swy;m6;?f}#~CP99D&q110Jru`L&K{A2v%lkiM3* z{n9@C`TVbHATZV8nXq-5mvF;SWs=^(L%t^#tSH)s3JV`@NlMT)VhXSzV{Jf+inh(k zm5eS8Zt^-C`GhIno>^SSgNY7WBgvz6cx&%+Os#)(ilYpN6a>2Y9KloWNO?spZY zq;KD+4709NXV>km&HJa;I|*>Y4h@DJ%_x1h7SO-M{8QtFUTynsGarJHT0>FPxPf3F zyr)LugPoq-uK8{-dvb~v%~Zr1);55*Qx}L%?Ng8ntno}*4NkoxpSKmnoq6$^a6?=vQ|cR-;l2k+$$~dgjhZAvMR1#T&WX7aZ4ZZ4h4- z#G=t?EWJM>XkjMQ-InjcnbSuhS8YUI>tDYe)Au1;A-ra_ng%C$F~nR6FGpp)G^ zI!T8hU!-+^jDXJp2WQQO4UE`q&^5eA^2nTK96QbTi7^k!Ss^W|mG7!`rR|}jrLgTQ zT72AYy@zsy8uDSLZiJrU+prHng44w0y|4t=-s_+py|6Ubo@zwSYox;-I};A3=c|lh zbk4KFK7_t+(-+s=i6l7wE*Cr}-C^{4sV&*zIln1xB93rF)|&Pgq@J2%iX}oNX02bL zE>I|YBoOMpYDO=hipirY)S+seuj6D&O?#PjVDpDuHqbM~1?=|`Tl4KuxQ#_fT+r8F zAq@K{fH<#K$ZRZ0M&xWOCkrqGBDbsZZI5;+1vrKPm=G}RF<#WzHmGrgJfc48u;kl5 z)(Iy7Rx(8r0kFE62PP1xP95@qHjPW2&bF1u$O$c|ypaOF?TJn}0gfjCeeirou5!Nu zz33TK&*q>OfKHG}pu(Q8na{#MOJsZsrYMBLWT5O5@JOGChakO}li(SNcfpZbsI!}~ z&f~*;3ONL=PoQrbi?7bMj^x{|r2$!N!AFN!fI&+b*{WzEpjvA=QrmTgoK>s2iJ@ea zpMCscc)v>dC5cWyF;ZU>s41;4j`z}=SAmZ*488eQy2Y0D=G*8N3)WTnQTmtzey@o> z9*4lm49*aO$T>aGGp~n}A&7kn9!d{HI(iUH6EJx_(8{0(68*1wAZ<<$!?j&gN)JqT zUo$jKa;&QxMU4i*NdQaK(ec=k@TPNayfDH1TMxW^f-yRj0>J;kkAEE1o|tCVW+*Q<~FG5gjm)bwoft|q=s+% zOchQ6XL*6My}&sHoU#T1hC`a>IF!y#t2KOk;tlhb&#r09oL1Q91U>1Cq@!c}6_>w4afl36eBZMBqFx(BcK! zVDi8q>^e)IPeR65H%yL$Nnb#ZYI^j?z2~zC?M3JS!@7{bMSL7fAM}xak?z*)w*Dg& zrJ25%{zs8?vX|8FL0sS@`x1~!Rj$%VP(=b=($;J7ehWG^rhm@5TfTCjTCo6*r+q2t zIk>hCWNdEcU;$5Mj#80s^&{;Z(9&iI81`j^Acdgj0#H)qKTIds659U*p}nn?Kuu6#|7kpWC(D%!=8X)FLY31epo{Dq!2n{eSSLLZ%f&J3f7&R zsN1xlT>VAQ_y|3H1sG)spqI)x{|?x`5)XX!6tJ&?1639AL6O*7Wxwm)AE$_Nb<{wu z*Kuku(h!I7BCw*tLdz0SUMD$F=|u9{r!B#IE9IZg(j`?|x;rGqZc}U_#7X_Ql|vba z+z*Ij^b)~PS_+`fv&MWlh!l&LVzoL?K$27M5?F#xHz+pDM(*T-pFiEG{Lpmbj0Y?e zhe`v=Xk~LN4s|FE!Y`=GgszI)RFxFNE~VzKMgmco8 zagZEo|<#_r<`@s7}iZ*S)*uObMl~am{%YBfplcV9o?^CNv=o$pv*C0Q>qK ze3sG&nISa!%*cUl4U{U+*KjP0-H<;xj|lxJ%v+!zWsO7B0hg3n zSg2b3Pr^d;cju}&a2}aN!#k82D4H6NUXxU6fqac5)vh9dNjv?I!?j*%Wz*a@u@3(4 zF#WQ&Fo+{v+$VV$Qs54UOPHixG0QlR^LnV3PNWCdDH55eqcBlG;^ZBZHq=R4$j;@T zl2j&SdN|(9M8&ZrBsPHSvNg0Uddxjy`hKqp(1^=MPSu|ptsS!5Eu*T=g!xh@v^B|{ z6<|-RB4F4z5rS0->Sh2rtIGR`RgG{$SSv|%3xl~FR}nyI*vx1+%_9zYyySX_10Gvk z4{^ZbW!FO-GKa#wsP7^V@*_M<@7NGFlD-uYrEkNdK*u)OY4Fpnsdy%l5N;8|6f7nt z=))O_v)bVARBI*bZc&^$gZ73Mo76$7SQyi#Gb=X(u_s%XIt5mw?kv3%8G!v!w2>De z-}?w(5ittlRY7UzV+|$z_JH*+zdc|VIA|9l{@Q}%w!pxp2okVY!#7~xj%Q)~%rYDS z372W#iKkrvQo$6(_r($rFFW<9FhoG<3w*1F4| zC0dqqc1t0~f%yCJzZw5M@kh%b|1{p12MdJ5!8ZJ%s ze=sK)ia+*l4uS`^r(0(r)iPOMml^`Ey3}|+{|63k;JVc5JF=QQXb0{o;eM_>Zq-T`cQP1v#LmZ5VoSys<1Cp45;rzu1$3dw%0*% zP%Oz>2l~R+P6#PB^9XE4^BPlB-M6IbokH!vQOZ_2VeJm4;2XDSb_T(F?TYF1o-%ngqDJNv#kFezh z@k7fBtOw}CDSp<2aHxp!rGKKM1S>59;vpa;V7!ZXIT17y;(&r!ilsy5F{(km7^{KQs+9)6xGzTOT|ayu z#Y(vjy)&cOFZ(mqF2raA+u=bLkf69elw|m_Ac93j;oR>%!(PK0{9{BQtZ{b-0{kgQ zK`K5@NX`R(VQAXNVwW79j2f#N6Uk8+-af0qO{WD{4p_`QY`GTXYb+L?^S9$CfZgDk$(FTgy>yYY!1YDN&_R2 zP>!41q1i20*i^om@Zr<4b}a{p+SRN+aBr_gHzL{6V>V-A89Tq*=vk#NVE=|5h|^jc zsX53yRa_K8bP=$B_tISFp&`Pd`NK=I#zRAd&^Sx8X7eYIreJ5%1Z^L)UbWpu>e(C@ zg%B=5+wju7;-MkJq0zlGA9`qraA-^~%?})jqLLhN(QKjg)-URaZp%SZ1^!-weLhz8Q?+8acNOtn2Ug zmjc?Qu&Ym{9sUT-UQsw!UmkW=9#YK^Th`LbT)iEX>EuF?O$oT9H2K-1-14D#9n7^&I#O5=%J|#3Mn)z z&>}W~XA(;Tg4xWM<0I~a}ph1AxF;mb!@uQ0UreVzlANw1M z)B!G3Dml+@cjo!s&OE>Oc$%uDRk7Ke3$@kk-B5%Ite8hS&q55SS5m8?TW6mDo04L` zbs;fo{jU;7`oRyre(OAXJE8reT_~cwZ%Eq>_W2p?6HI0JifnxZOr7mSutrBgUr|?v zbw2oT6D`Uwm{e8|l1ig^r0CaK@ zb>er7pg1TK1n5gY4%;k9p0jiOGKa~?DW*CU4L16z3vxs*y z!w}B2pMg(qKdejf3ng>ft^=nGgY9CMvHKS=OWXY?0`7-@ zSLaQ)OB3&_j9ezsjtrRSJ+v`*X`j)ddyXP+!~;b@`ZQv90V%=oktVm;zazENx2)CD z*SPhksZE9e|AKy11&?)FoDp)wqsaEFP$c}GEd($_Dif10EQkfg&U6eu?F%aXmEw~M ze{n$c7qqFcLeRxa(Y|1Q+N`f50Y^_Uh=HYB>HG0YC3NDsl-%b3cffDp z--z}cy%#(&Uu5*IsFU#-w(!$O>Ql1Q>v|h?n z$;V{s&SZQMmb&*bCoh!3+HVd(83|};y0kB$Q@_*(5#4XP1qGExP*s<>VyZ;!#2>U~ zAOkTFbM{SP^S$H+zAb6hty6%*S*th{qD810j&=M-1@o+N593WkQnBUrcr1fVm;|2<1>4u`019 zWBT`qIAIy8CJG>)WGB!MAU&sYls~OdSs&+Jj|5Neez>Z!`*(mB%b)4_yXDdQ_TuSw zar~IrxeLhDM!@$g5q)gOlE(4lw3pL1VZU?`E0Q~Ns`Ii*0Na>87^{W9=+s4QSz42=xD1EElj zz@NjA#-(JQ$~OiBLY}suF63znx`aF}K}jgz5De@^mig+RRo$SAp^%(#=po8UgE)Qz zy+t_-Fg8Zcg2Pp;7irT|AGQv5Ty=9?&3JOl`t?R0+Vav zm`hrSq|uYSL@-v+xEi9hQ-h8J_ml$B58K~ z{MwSu4o`h_OvBUcgkwXi5tC|Z26limP-dcm{1t`N>8>RsZr?19Pu-Z(a?V=G#3u)q zn5h_wb1gahs@f#XGA8OV_b9XWPNUQnFeemnUxYML#d>K-HB#HIg|G;}2H}(UZNqo~ zkarrE-BULaanu;On!5mZNC5}^O9Gw59p>15hlcm#!_akA0c1m<{WWq!Wp;cQY=u7m ziChgN730ooAg59|5FbnC+RQE55k2yAg!@8b{tTI~s;!VVpwyKaZp!>C)@a5M&Bqt z)TUl!lw%9aqJy;aZDVeojqVNYXLZ8m2Df**yzHy{VL2O z2fRjL7$jQ^%HDWiNm-ybj$7_SsrpXJ*`x54HI*`;&Vy~=gufqdF4N=a32h=s@538g z$T*cDFfNPI2EpI^-vcOobO?c~J`$M{4#zPF#fnNvg9v6(lcNIX8GOQ%f`NIFE)`)kv86$|=Z&4#g z^RJMKr%}=q6?sms=u`}C{PsV=3dQwMOensM0Ok0!OejMh+0cXG0L0n~0+iN|Q4zG4 zsWc?=lm=o`$AGW1ZhafhBf{Duz$%2tKDaiL{Z7fkPJFoQfr*lM-UG4d4&n)kUs~WH;!weERYZRO#5BOp%gY^_ z^7&1oJqIka-$vA84laTHZaz641{Dsz!o~X-Nk_f3quojtIpcIac4nQxz1yBxJa$4{ zmpWnyMhAPK7LlAc#OUT4h*k!>>Ayh%GjJ}DtkY(+i}m!th(Wsd)2z93wHs>;`RWeGkwxt;p?Ui7qg&wDo1_ zGjl6V0pEzSepWrDr*5jo z6d^04qWJD%sf^0a7)QSt9ZKyZb>|q@M=BZCrtraN23IkwL&lzLjpR>!;>Z=<$R|J+ zax0raH5MJGVr4O)YL{?)4_xIUwF~ZeQY#f`>!lvCu9gT;Md-N9NyQe#!X#>u5CUOb z5=lOeS_FHb07@<5uwW&_Xb}qwZ(TKS5rPO(%nO`aK&sO6!qS4$Lf({8D0ze8{vk5Q zeuJSgG%iq;K!N=xJgjT*P>c%{W9~E|W0tsDPiZNt?NnMcziEsRD^lLB)GURjILZ>P zmljLOaT4bEur%a+ic34F*oqa4|EWZ%@^Gp)^meyAysZuEqRK2BPa%+n?;PIvFAr5$a?Rtmt-abPB~Z7iCGMoGCsq9l!aVPQH63-;k4&4~wTm-G>U#vLngXM(Y*?;}N!A9{947-eP_@w^4;^7>=8H;hQMbQ)kfp zREAi0z)!^rjEc&77=9{_D%|N&j5|GwWUq`Qi23|bj)5{X9{(t|b_m}5=^3egVL5c6ZA-hHta9Rz)+rtq1;eRRhsQDfpTTo4|ULg zkiP~lQ|Ew$SvwT}!|`v%e=+`#;{PoE+wjK-L)#x&dl>#R@t=qPQ21SkH{1C~oqyx= zaOl?kh!yF;=+TTdbkVy84^IRyP!d(!Zj6H@7E*i2Fjg)w?w82!p~(gM=Ka z)WRrhaPfd|EY%DFKpSXxwx&u3ydGRf-0 z{&z6m0mB;UiU;GEmMstBKGo8oe4yt_QQ$}+O$kOu>K#t?yofWW>J_$N&$u!LDnkcG zY0s%AV{VPNGiB=44z`QZ&(yi7;M~lBACuwnN*!vUoi2Y`o7MqqT82?Ktle5FEA-vp(dW!vK!4(6pbWp1BWxoH36UhKl02 zB<)j#3D;ttsMNeJ+^q%t`=I4vvm}OGTW&`Cz8MaUE%yh}MJ#Yg1_YA3TVJyb2!klP zn3>NICTf4fTnp&v1v+Iyys<}pFPK7|9*&K*?u7{D!8XA`-iAR4Eo(RQ$FwxIJ7Sxi zgT#c=x8UEq6tcv|_UVN^Kf$rFvDjA4WU$}p$P=;-L8diUVcyS?xFjc%b96i|e)*SYKKth{24;8;;)Xl!3U-0`3Tp-Pti zjR=d={l25BFl~%|Oa~+1)87N0f#b%;6yTN#**0f1#M`I|-)ecZ?CKmJ1t{fWTcD%e z01lQilH@41I#K_78h9J%6~;Ph|s%#s~; z70?U%`5usA{|*E`T~JJ_$%Ov)b~3?Kx-j8%7n%G)CPX_-@U8a`EL?nX40X@H~JjA;C^HYMv$5jnAeE2ZR%=mVZ0Nf=~u}NTOZ7ra&mf! zk35QT?E->f9ahOC4tV%n4{^Ae+fUELfUr5ig^w%*Fl?UEbldC)HRh2*ysR{sehb%>ek=kPNF>`BRx||DgI8n{(9 z=WamJz!^V3Q_wq&ZfGse>yJA-e#>VMXg4d`Cq1-e@sjdpr>Uk)vG|A49W3}0HupW7 z%Vp4SQS?uH=tsl*W#!GSCNaf@zPyHN$!XG!>B!KGic{%`S}|P^!!Ge^W8yq@=4e@_$QtV|g#< z%@pwZWkkykzLTyi;LH1r(J5Slmvst?Mu`tJH4KVx2$&1x$h(l?-QD9ollLpi&ScE& zSl@~p4qcNm1(5PGq_N)z_*yD=MgdMAXDfh1XgGt_ljX*(A5n4kQ*fp~ z-)t_$0mJ~;LmcpEbSMWp??EnsI6$zwgV@7)H}K7M`L&Rrznnt9ZWBt$56wfxbj-GS++MIdE(b%*BjO`Vt;J*FwxpY*6>2=MimyLv0H&)@@*s zr65LS!$5N;Hl%y0=aU-K)1W5C!kim+D&c@3rcqBHgOhBtl1x<|PEg`&?#=Eu1i6jH zLTQMj79%t>+cts)jKCCeh_P;Gie|Q@xtuh9p&`b?W`#J;-R})uwCo8va=C;!?m`^= zvbQVtqr+L}@roL}fT14d9RM%7d%zupyRKh!o`qS)mJk6q&nM`aQQ%(T9{6r7x5LCA zW~AFxIS6@|6Rsog~0Gk{Ub1DW&dtxxFa2$E+2+%mo|f( z?II^|G2U~>qX(pC+W2>%|8ek7m(V2wpuH6u&b)JRRe;?I)Tc{9)iR#3x#^q%El{+Z zsRFnu%FQ<1>5*PC*liiYg2i4`{1~s|p>3QxOI!unccj~8Uu{IELf5%sX6=XI_{ih{ zzWmlfc!4%Ep8Qy>!~u`vTn}-;V}k1;4wwB1!`_#iG82K8wQ)#s2z**_M@HT>E-=(N zVr!XmKSLGRb760UVb5=hK|0JRvHlnV`~3sDSE$GiVfq9>-mq&RdaaGwnTR^4ui6FG zaee#21Z3G<*zO?a2{|!c6nX_G!qc#$RNEjua}ppNtrhcX5k!@MO+|#`ZK?nna;&}C zmJ(g&YT)E>cga%pRWhC6Qz2oMmm4=2b^k2Y2qD zK#nP9Lhmq>^BQINB=*HQLH=A8=YVxP{@7w-#rRpah3lvAcK61SAukqkV>z2r-Onb47}4~S>tB*53cEC9Iy-ZQ+ zYFj7vqLv3m)3tcl>e=1|p;uf(!8&3lGY+RH=QECFFABYEvS2caco59*oufRnYULpC|`I%Mm*pOo#eg^ZuVnc<0<@KdSAArzfVW#sIG3|DqrW0k22uo(-YXe#+w`J_ zxr)A?+UI82OTHo)p=TCJFebb$>P$UzHBoM~=G;CAxm+sb-Z_oV)-%_TDwjq@B?)CE z-@7hqupo9dEXye=B5(fmtm_dx$8Lm?SqfOstiW@-kL92~eLc(6Otn}m^ zF`UaxRCR=X3x@Ux^4G_5k(g@Cyd9yXAGw-*11rHXy({FYZ6U^5gR*4}!2?-#D?9== zwpw9#WTL{l5cU(aF~fkeu@QM%*xHne|1)P4q*hx&uEZJ>t}MI_9?4Fr#s7swtfjEE zOHu0Qolu6;D3^g5Sb;?vO7OsM=~Asr5@3D$X6l0p$*FC$fl1if=P?P3#r?<(b)!)Z z+e43L@9>f%*Y5;u+FQ|$wClY2G7O!hI6U;sU7%pb>6tYuZ02sh?{w=#PWVed(M)}P zq2ojshs5aB3$1J8L(pM`%sAg$@vKj;V-nUWzG?~%S$QBkwa7|07`8(lil=(96|q$1#SdCP7)BWUEE zjP>b$Bxu+f!9Ydu9Hrafl@5trMjYmrXt7Y+?g+12d*EsJ$0Iv{{9wnrb{z6v&H0iB z_4}`5WqSZW3c?D5{L#DB+`sEbd>wY;{)XnDvR-fPq_yHY>PGO`imNgC(ps_DGKem* zGce%kZu)*&5JBPYuXQ}wb&t~Yqm`R7twSU_$`*!u2#);1i&j&ZF<&kP1U=yMS3y5Q_IRFT~azIx5?5=ORe>lu34DIg0&(kYaC{&4D0 zFRTk=eI=e9!Z0xj5{qoBWTXy<`02U|WA{gHmYcXj0wp$*-CJV$O@iQ3k_=(@@dLO1W7)jbcz`+;i-frX3)Nv=uw&ml4*#axs#Oss$|&5lT1mZ z(vRHNDW74B4 zf5~vbr{^+@^5U}`m7FRh2ZJ0(rz-VCiq-`AR{>FjFoWu<)5B1y&OkSr;9QQvXm{)% z9fY@$v!|NvSPagv1mp`u19qxNlJ!VD7)|d3B$w5O;hm*n!M!itG%9KD_k#n46E_Y< zS`MJwtyKOBtOf zO9`qhWquB(u5xKs`AJ>2%THl1`FR+S%)`U+&QceWheyES$(>hFg?e-6HCCyTH%Oh6 zH>5${{5Ce$AJrai)a>F^fmNsiOSRTw-TD~SF{;3i_+q+I9(1j{ruS6o*0qjW$GUv} zaT8-e(n8))!<%>&=BvCo;?CgzJpRbl7;B%7S&=pKI!F_p^-%UzIFLE?MGf^mNL`wc z9Y;$bcc^CHA{FwDWR3W4i8Ukrq-M&#O{|{bOYy68`K=(S6HXEE95x+QT&Rh5F2}SYmt$UQ#7>xENNzd0k3dwkh6xm&4qehm2;4yk?*FMP|-Dr7v2?E+?e$1IV0C^HQ6{q|#Q-rlDN z41$RGo_dC`WOVad+69baGeixGz-jbMBH4EtA|?Uc+C#Xippy6Z>lQ^tzLK5F*Ka7h zI#Zc-$JJNo>yCVIW|v6dW)~xKvkT1u!MW(TcH*%58cc{{SbY&DL#f&y5rIsdeZVk1 z5V<(&^bFqyI;iN((uu_!3>)ZL&J|a|HiR8|ZjnVq^i+rDN1|K_6ry^J9;0>jTtP4u zb8$Nn4Kosf^pU8C(6uKy4(7~xIOJ}_;(iQbWIqHUn0-Y0eB<&lee;%={gh~RKh1RL zE-d*>B6Pn0g;zl!fei=s1F*5JV^#uVc_04CP|)g(#w+d%X1@R&Poh?!Bl`&+$VAd& zYgsN3aW+E;xuQ*Of@+B13`>Rq-3)O-xBNtMa;fq|vGb{rc3Fgz@)JPrvHVc}EFW-x zPB#UY@>2*3k5aybzgH<=1D356(l6j1Go=^OK`-Cn<>;lq=!O1D9n4s4_Uy%UehXhw z3mw_7@PJxKDr%89u@wNYTt+VB3Kq2xA!=bjk6Hv2x!ArHh+fD`>4lQF(~CqTdMS4F zLiw|Nh%PGH>f$^2dv);x;Jhwa)|De=u&X79v|EgOg;{Sp+hu74j#=22>IN$zfg2Twn{flNju$0oT8hk zqZ_6t%ZKQub6eevL=p7rW)!;y?6x3IL&Ha~T9L#_I_Tyoyb1#Hv7!!K3jb&E7d4S2 zm^liSB~3=TP$f>EgMME2Xdv|rp9vd1&e3qhk5V3bhS0V0{rZu(jsWAOPBP=n4-%x$ zo~XnrXxU@PB9>(|qFoVP!eV0?K0q2HTopIPd45yB>s(3lY@N}L*mX#8t!&FxvVzgM zS%Er^pa`RMqxxdSIo+uIp!VA3he#>;F$PGMVd^l;hvdgtI6UR{cjS{dKmGum&ySy= z>kbkp>7Y;@)ww4>&HwQPGlKwiF{<=vEvQH)P8yNGOby zG{Q|)G$Ng1TG^JV zNwh61e)xOyCJ4BFKbbVSesavyPv%sC>L>RDSM-y2;|s?0*ZpKe%b+h;D(NC`H2D#{ z&`&my&+OyP!v9U?d1Tv2)khXN^-KtKs()Gp7rQM)G~)6p?0u$}^jwNUR&RU?D?|9L zu#d!n_%g2mSdTwvfUP4*g%UaNNkqo-7$Db}Fh$?{HTt@7ECUdpjx|>u*A-94(uyuU z=5gSYEoLxumMKg;u4f3V&N54};#%o)Z4s`D*ddiZ)3Z408u~-k$>8zbmB?K8h{pX^ zCFg|3#!hE-(Xl`Y5M zqMZ@ZxR6BHcSY=28doK;q0GhXv5#XtTP5Vb33+^P{anJB9;zL$n)Kff673bZs-YUgpJDjZACMIwn5hwH2 zk^PEL%4pCFlTh&zivS7-1z&pp(i~`5Mw+$49N~vMJC5+w5i8;R#nj~JH{@dBm!H?8KWE(&2LOmvO z>X|s`RPBV7Y^j}yXxxoN8G5PyTbP$c$mw4LUj~~{<}x&XiBs^ch`8)qPzKm*{klPED=#zT0twcO4P|BLOuXilB z5-5XL3KL6zRQh_%KEyyhDoa0v`Pr_ow-ox}-)rZRJHn23F8LsKE`2?Pq}W7?3fw}# zw0jDHfNo!}GG`yE4A3&$l>y-_W#C{4$}&JZ%JKnsf^HfN+D6fEMNbnPZ-c1 zgPyBI59AB&4aCc7=T{+al#d%gg7P8KVId26RXzs8#nzjMMi~TU=%vaBW*}HVvU`yz z!{j zp*(GOELtSY41%Y(C?z`O%aLN{Ek{`BBrg^9L_|HPSvrqYqVnC|u^C;y_-Xo%oX4hW zkeM>rN$u7}o2C*svq2=lHecra_P{Y<+NdH!lqJr&FCN|fTEahhmJ~2@4c5F7b)%}rrk(V z^7U>$Y9b{SZoNxEJ(eRN>)qp_w9YxbD!XBBwzC`IEOs*)($Q|H|12MHA4oSf1owV) zQ~7WYr<)oR8=8uc9veCY{$3k83~>8?2x)fO56O?Xr%_wFW%Knv^h1WC9CnfPk~g$; zBwn6=2-nkj{xRxVXRTG_#M&|Fl(me8i}plB<3`Y8vXw|Nsj#e#$}H|o)QmPa>8N1G zNU+}|So{D?rMh8ozD(vOF|v{H;>W^A5hX^3+SQ*ulp$jh5VdOyV}zZFT#Ad>*&Vt? zUBHycIljA>DJHY>JgYHXDJ&};maTo=+CJoNxgz46R527G%C7n{WbtP<=F?MK6&qW*huXDq4mAan zboOnOqjFLz;<-nsLtizL9)^V$j>F5d?mrRXFl^O0PYGMx2QSoZB8#3m7PQK!Ccwqa zBckyK&|@%1KQYGaM7Tnkm9VWOKQ|_r9g7Eyi2-0tpD~CN-laI66d69%I=|x&8={{z z5|v*zPm@SHv}?gh?7lzDo(sS#X0@66E|vu@V5|5mo%mZ%bt8|@a|FEz(UH3%ta1tW zbqO0M(Jm{L1Qn7*C&^;9ze%f1)q{qbP*!^u^MZA%cl>q|l*+%?ZbieQLYk(i(lt$L z&SRPa%J_}@i@N3VQrRZ0q@8UFYq8BUAq{Pld7kA1?(uXpW5ouupzzq>B=~!6@C3l^ z+gsB7WqUh|I?$~P`1-Hy?Wxd9cS#fZLKRc+a@t!O4Q%pYWs@QsKEwcC+2qM^F}H|l zl)j*zp`WtJQ;5Z>9C&4$=+5w&vo!j{(&(owEl)G>CS~73PixCgmGFEf&O=Z3mRwKv zZ$zMuqzLi-^>YbJM;41Q8Pbb^;z*63(G9>(KgUxHbTY%nBq*BnCYO!Fgk91kcBxXC z%1iY}VQu8wm{is&QdeXpu`2Omo!^OdG6z6Uoha*UVV1P5Q%`_$`S;qUXj-_@Hbtdk zo6=_#q$IRmpONYDn5}^MwW1!mJXUr~%W7x0!ddM0JjhAAr7dLnfcqr6nfYS37lXpH zN99cTW7u^Wd|S?;+uhCJY^ioWHS3RU!Ap4@?#>92)2b9L1qncAqr=N_?x|()Kt)ZRx zBK(dXrLDnN*BGN|Jr6v3IAwnfa3v-+dJa3)o=jr=Fciv$2V_~M)VlG{@~jcYP6`+RC>! z2DDMj7~Mjm&GSodQasa4(G9O2ecKyMzrfn z$n$C8KScb~LSG=yO+y*i_lv2|*X4Q8r}Ww98-_Y>0o`xk&1Vs?#oDOb79fqkT}D0h z9&B6`(01!j$^}1=rvGH}Ibj{$fBTWojs1Vy8qmg%qyM?<=stKBpHJV&XU$+fyIf1` zx7VDuAfmk>(iV#jo32h?Qmy?kiF(*`JY$)+jnBD~BeNt&zPploxM0&b#PyiS|I#Dm z_TmOU`z|8SdrLYZcUo?s&xhagxq29%GjAlfSH%+c1OIBRN&x ze2)2%{J%o(?4m1d6)dM%oABuZJj>Sex#e;`mx#}#C+NO=A)ixM@L6yZpFcjnU{*x? zH}bJqd+T2MbdgX#;c&mW2XvWV$Y z|D2_a>-^_gtMm|`TRveZ-@`1Y<2%xAbkR=_XlF?5Uo5B3BU#oeZw>9Zq=Rp_%UQac zrF>lj4Hs)eP)3Ti_au+je@^}Py^ub0v*R`vYrkGQZX@pbSxi2cz@7tI-Tf>V&qysa zeHm?a#0oykrKD_HN1847Qie~e`0R8%?P~Z0KKqILOt>T3V}-Q*Whkuy?b8t~zn5H2 zTYdjNQhs|g{nKKx6Q$0aj#>qE@7!}xnw~n1&*^hnZ_g2*R`J<7p8lt9qWrf{Vp>j? zlpY367Hf|kNuOy_DhtGJd&%<~q#Y&V%6lq1_=-X3TQ*L%LTW;#5Y7+sQJ2; zXe+PUvglsm{w|c8j$`aYv}=TN{X{}Twd*B@uFymiprwNAeFCK(s@(|9W5?8JrglGV zwHAV$kt??>+Mo>w#Pnql-&pN1ZLM&5dnvh0&|Z<)??LS6YNu(HK2larAmub%+Ca%J z6Wlbd7gSxMnRhWbpfZ@u01p+NU zn^4Swu9{A$lLJi^3+d`WeVd8v?m#Dt)zvysQo_|a(Dz+PS?@s8#3CCU=oYcF0S;6n z_BqIb9v#ncLjlp|moEF`{w5r7t)N3n2_1&b8ZFT7#-|C5^i>+jGi~XDKhT35>5EIa zQAG-uFqoT@_Wa}ileD9K2MF%sdBn940`A&v#9iPUE(&lGu0oH)CJtn=LVXUqUYHeAr`zH28k}wT*Px_L2i z_xT=>_!bJ6hkOqT)N3PgkNTbx=wrb>>f0pHTLQi2djSweDI(`b|zw(_SlpRGc-};&bx=q4;>zggm-9>BXH{qs~i%pgQ z``fkihw9(?E)}TPoonZ>@_px&5!F<}z61KA?oQ^dAKJ6fqF` zQJ~Ha^pikA#7Eq(0@;X<(C-30>u~u)V%YlH+W8;)N^~ElK1;OWfPV9J(M$Zy%^Qwc zJO3n%<2(C(fY!9Eoxj+ZbfAAaP&dJCy-wJ&x zpb~BVb~S8t)KCpK&MP2vVZbSq+RiHzR zQi1Le=y0PlOj)Yukn#wlli)_JBs9UeTcG=wc3*NGpnJm9%k-m}_Q}Q*g4=Ud_a)D2 z(;cYbB&O&b;|rlYyP1?3qj!Yi2Axf4rUQMJA~XvS({T2!zM0*O*$y;Opo?)D198u< zBJL6cn+pML5a==kYcGIW1)6IN5a{u&Z)TG=&lnhK0j>&MnzV(+5fRoX_pI~HJPFWI zg4=H{aW?=Wmt6r_#*M}?0_`QxGUHf*E)`i;7?TCsPoSHO69qa-pqq^;0u2{vrO_nN zcOuy>#@`~$hd#H@dhrx(m2sLtTW%$^+GvhY^A{H>=xo9Lx>`Xq1^U^cyg(?gAE$7a z2(F()IY*$v+h)Bu-dJN?E>L%Y?lBe%G+QX|F|HG+o5*sXv0R{6KzWMxfN{G(dr7#5 zjE4mJRB#U)k4lPOx_Q=%mm3coxC$6jFBRw!<0XLx3iJ=-Re?UdiIk5TZws^vP?PqU z@m_>|o1%ASVW#g1<76p);32AuaXr@6oKNC3*LK>dcVt|Od8{@_%t&>?%$a&i7*vi+WbvHW}qI%N?;*bf9 ztITMjf%p$4ZXe=C(;Y6cBOG zY$MOZOx#UP99qvNZ4{saK+#f7+n^m~_Vw^Q+8iL1vyrYQ?HF^A2RFtXEYJ+h12<{o z%)JZ!kSx2H(0Fs0g!@gTo@fsDggf3mSa565e?)6<9xl))LV2Qjq(C^^8MrCtQ35?L z&?)9I0zs?5O*O{}^s7LBGsg>5CbFDrP7r8Uflf1z7w9{bf+p>BbFx4;qqc9-Z1Y5c zj_5#WnmNTI=NaZHg6jvpHECy>rwg>NNPU($O`zErjyGv%n`wcb7TgSTIv|W6##7hl znr8`asmOUgAZqC|Ov*QDv&py$!EZPKnbuMlV#p}fYtQY>rgO5zrqi^N{O z8N@U!HW!Q3KYdQz^?<}8h06-_T2C5oGOrWdN0NqH&E+24YV#(+-6OKxVcsIpW}&>( zyj7qxB@K6(t3{SSuoBUvtugQL;MSUJJUrK#YXygUYe2c)T<^i%XFed%P_cps%!dUU zF3>~fqXLZ-=n?aAfzA-Kb zLP>4XzB8i&9V=4*WOfzk)H33JH+u{8p+J6ry+Ff7&JO-YfyN8ZYX2|~&hj5zl&?|x z`H%MCcK74rM@Xi)4E0a;K!^BG^+03%XL_JX{__B7+80tDPW4|}#2V}fv86Ksl>_%p zIqRNt{Bs0?hX*afpo99KgRfRe++z`d`yau^Y_vgbV!7pMcx=Q{4h?0_&xRYxDhbMelo_G z$Pvc)s$Iswn3E}Ej4?KD<6%tG>f@n&n=@VzQ|#?)E+dvHg4>XPM3EZ!gQt`lT0)NrDn&c6Znnh+RefU55Vx z!%bl+zAxRSRlmXTS24%`y`=wMCvV02c`Rzatro7aSsu@z{%xX4Sjud~vR6=!qyJkN z(|rC%hy#88glL%<0kKK)ZxFvs#9IB47y>b2=olDNJQmBbOkr-EJ!y_>BMzcHn^WJ% z*`AdVF~I@X+y5McOHtBIW_hE^LYy?R0>rK(Y#?qPQ5~Yo@LCX)hB-jIJ1i0ASbC%{ z#6zPS;h0O!Ackyf1@ZKT_7JnzcY+wPsyoCoFM30LrfzkGxHV}I#G;XY5G@l!A^wpV z3$gpC;SdvsCPAE>mO3$x5SC?N^6w*jVN7LM#(~L8q0Y_Oh3CC-IB7hL&mS28@qI!B#9v{3 z4on^l>vLdo{ZS(zMkOwUoY}BunloG23Img49(h45fVDj^xkfVXC%9a)ST1ODV7YL+ z#6ra7!mX185tmCA%O#6tk;QhD87`eHww=syxo|5igPi)FHfiKK7}obaeSg#UYJCqZ z^I{vMmL9neqP`y<8hs4boo29@z!AX2aEwAZN37&mg)^eg$!C%@0r-i^XydZ2SYp zY+3a;#IJBHaON@#r^VxfGoPMV!qF2Z_{Rw!R^hz#5_-XWzb}!E+cP+>+up|L^akU^ zJs9Wo$N1Ylj4fYaY_SI8)&h*L$6?$s72~HgjN_|e9C8a|(kqNnyD_SM7=w;IgX631 zO3mFKj=R!OpVUf~Ag)Wbh4_b?J;b|f>bN_y{!be~T=c4?dvg}+*Am9-$EkjFJNi4p zn60okawfOHrE`Sy1s*8@5cQ*eGVF(Vq>O+u`jL*uh&}wG-d_H`)HR-Mgj)Gc#rWsm zjmFv-f432CI~$Be-i?gyUgTXJ#uRL?Zj4#b!9nD4FvcV=sRd(J`C?q&x|T8C#;pR3 zS$rAer7IYprB*Of3%1+9m?CeC-C}Kw@#F7yb|0MlI1S^CD;QtH@b~(Uzq=6fcTC1u zaq>cAs?;uJVN8Rxvc?!2w~{bs@nwvcu3&tYiZOXfNh43e_8w4vz3Lc8-p1JZ4aT%R z7>|9y__U~pyLUy?=5q^0Bcp>1G^q`hqZkk&ZqWlbSwWd_U!kkLm^gm z##Z!O2aM;R7L~PU(`Vl;3$0dB3Cr)xvh-6QD1YQ_j84lj26V!>VJb#vF?=Nyhwa4h z(egNasw2i#V)&#OK3E3FtP{f@MSgpce~K8tR*Vm~!aTdhaC0%dOAN<%!SPJwuPTP$ zit+xgIKHeHf9nnoPZPr@Q*gMk7`|5nhaZXj`J&GK#rV2waD1#79+Qm2ug75wI)<@n zS|2zT-qynNa$wCq#+J2lbA!~(%NQ#bV?0*F4UUM(OFSS}+8+e*;-v^9|0CN8kf*c_ z#t)S-7C}^5r=`%JVH2RWfnUzN!q{am#+*=$vs+v8_1U z(#P2mo(87E93Owd;Z4vVb7a*-oGBu&iepBJ;Q(tKo+5_ZX5etP81}r3!#l-rF_hz; z{L|$raCGP9PJ=zlRA4W=C+9=E=bl_BVzG#Aq5kg4uCJ!S+`E>?I{XUJp5=Y`+X|j^ ze(*1&??sO6i2Y3WI;`?ZFX%&7KQR}ETOY}Sxbtupl%EeRp?h)yoP!*h!_+12<=B+B z+hF|1?l|965pzVmBI0fr96zZW#uZ{XObid|fn%O@#W+q3D`I@K$Wu!UPZq=7Vc3zq zJhuzxVk>ff730r}Jh#Pgw#Z|1eiy8VBxs+Tvmg-{LUd2=2wTlPIr|xwlhO7FY?0Zb z7c{uxNf@5j@I0&s-$n%x&owP{Z^h)JgW-FQ?^feh>jwQXdvRugJTGzB9ZG{^s;a#_ zIC&}b2?r#b6mzLs^^$Z~F$_H1BE2}{midf%)H$N0|ts*Wtp z+1=KWb%61X@cjJ=tiuz|FJOygv~A_)$iBjQc4UVyeS`XhL8?8Z%JAZrN0YJ;OFLrw zJjWj6V9{1TY>LC3#Q2vjQee0Rv>VOY#I_X%*t0RtHZWCTgL*K0esNeK7ppgz|{Y~8RI40o)F zeXXx`XF{x0H_JGW*tqo@fNdJa&TlZrL}7eA4&$K@7`If$xT!Nn$EE!S$ZTRK?A3Jb zjIqm9jG2Sx!nf7eyWfU>%NkG2^E?{Im#>C#K}W2WMeYEoNrH$4r*OEv7+#s{2g7^- zu7N&c|EVcz`=tTayn?9zsYV@O*h{|_XcP`>x?PZzI&XuESP{cJ_NA2G%_W`CBxe0C_ey zOoce4VFtv@4Z~r1f0%~LSmPkB=YP*-`$f#}IS{udwx5n{)smTzU%#g49f?zoj>J9r za|8}A7gs3L-EerbxRT0-rGx&JSW@Q(c%=|5t}iatUku~7)L#KnUsujz?_FLKr`;!F zs@RkD_1OXH&)Jl^S0G*&d&1VbzrgT^I(XIAsm>ZGCrHGtb~t>&4)^4L??1Tb=zEbp zI|6mXbLD2pIsZAn0O@{m&wyI2()Obe55QG}iM`!+3dZm7!e!r=ipMxhIRoqY?-jVt z$8Ed}u_oj%$1G>1yOv|?tEa<}Ub_z-`)@=XD&jd2-TLA9%`Y*UUSX`<6I-5z&esPx zvbD}dP|m1d-a?t@_kV<_w-0!PLTl3u*GX<;jISZuvpp;Ec*G;O4*cTr8|43e1@`)u zZIlPXkz1@m9I~-A#DB*8=XJ4akK4L*ON{aLFt%%sQNLb(Tgz%7XT8L=^EwCIYPllD zx2Ou^A39*HUJv6}2b`+4D8aTV=4>b8swOodbyYpA^Ytd!3;oyxhxd!vqH#k=b!&{{ zSBc?~V(BV1!4}55UTa8oZh>{MZ+^cSyw%tkON(iSsZ;7bS+ z#APCNkB9|gOcfECh>JwbfTLh=a-b;ruo!bu4>!%xMqzW+puoVlWe z9x%QYyFR)PF4zCKcIIqtox!lAc(u!E*)3Cijb&HGG4-}q7>xP9wj*wx)?$18dpquE z8V%E~YSI9Liz_f5``&QGee{AmNJ~FCH?e1rJFRSF z&vqZW0jbWmcOb4A@&L*?^XM@|EC>32>z~8;ybr%aEHipP#Hqvof|#Cg1Y*C@(jd4? zILrc~`@&KX`#X3+%agsn91KU_uLyDX6+B){Ⓢhhkc1HN2(5TWOqfJB%-T`2Sl7D z;?E*_i})F$Jqs$r5+0Ao<16|;4qtwFzu7-)&wdcDZH%4YU`*SC@z@uPzum*wVhzTv z1sGqC!?TuRQ)ive1S3O7{+@wFpf#am=F0m^P7&#r7vBZs5&r=HR0^% zftZSSsJ_>#$ons`)&4TJ+R|$hlv6Yvg74#^Cz&YJvC48l7l>tXB2(Bo|mYw`iym$PSsX5e-&+pIn0cYq$?_cCqVx zk50vS?KH-p#PBgO9M%%Yv|5VMM&y4h#(#q-vje-jL-}Ky_8tUxZts+U-lJ0?-jVAy zV-TcbYy~|!Zy3fJa@GNA=$?FD^nNe)wwKGX18`1pPo67!$fF^TyJ!jBlku$dJ@wu- zoc8S@GtBF~7{+UP_v8mqf_w5Xah_^3I0Q;|?S*3|LWF*x=v6vGd)}PY9DlZ)J*#p* z9`>Bc_l84!HggO_AFl}zXLm@2k~i$nfcWre28_wCH&>)Cr18+h`DGcUHfIYVr+e}S zF?UB1f9-|>0YehbPOHT^f(vY*nfK^$N08jN{cD;FZ}?bv(Ch4CMKiXnE3Du!tn zG{_<9`1k+(5+euFXNJ;w3X zFz%{>al=%MsvpKrX&7g}#P~})jP_05OLjpftmyr z;qpe`$A~?~<~-Tz+o0yWR0Y|iIlo*%gZQdUX^7>ltsqL}HIG`XS(Lq8iKIQ&Vmu+nr|rSvg6$Yb*}ipE zS=%UAH+#7IZ4b5Gy|)4Msa74Z^?T(Ic(VxO$lDknis8<0aQK86PTPaS^{Qhm z*zN?^p-VsImHoc#nU{k+pjAo37⁣X+{uyGSn(9+{2#LZtc(k>*iU$BK%LQZsk>$ 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�D<^xD1Dv+G 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
eJ~3*xTDjUx1V0xzUC07vFwo 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

7IT|m#d(R~>F-9XQ| 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

fUdxtMt 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 K^X}7Q?EeMYv~oxQ literal 0 HcmV?d00001 diff --git a/syft/pkg/cataloger/dotnet/test-fixtures/NuGetCache/newtonsoft.json/13.0.1/lib/net35/Newtonsoft.Json.xml b/syft/pkg/cataloger/dotnet/test-fixtures/NuGetCache/newtonsoft.json/13.0.1/lib/net35/Newtonsoft.Json.xml new file mode 100644 index 00000000000..2da5ea0d61d --- /dev/null +++ b/syft/pkg/cataloger/dotnet/test-fixtures/NuGetCache/newtonsoft.json/13.0.1/lib/net35/Newtonsoft.Json.xml @@ -0,0 +1,9483 @@ + + + + Newtonsoft.Json + + + +

+ Represents a BSON Oid (object id). + + + + + Gets or sets the value of the Oid. + + The value of the Oid. + + + + Initializes a new instance of the class. + + The Oid value. + + + + Represents a reader that provides fast, non-cached, forward-only access to serialized BSON data. + + + + + Gets or sets a value indicating whether binary data reading should be compatible with incorrect Json.NET 3.5 written binary. + + + true if binary data reading will be compatible with incorrect Json.NET 3.5 written binary; otherwise, false. + + + + + Gets or sets a value indicating whether the root object will be read as a JSON array. + + + true if the root object will be read as a JSON array; otherwise, false. + + + + + Gets or sets the used when reading values from BSON. + + The used when reading values from BSON. + + + + Initializes a new instance of the class. + + The containing the BSON data to read. + + + + Initializes a new instance of the class. + + The containing the BSON data to read. + + + + Initializes a new instance of the class. + + The containing the BSON data to read. + if set to true the root object will be read as a JSON array. + The used when reading values from BSON. + + + + Initializes a new instance of the class. + + The containing the BSON data to read. + if set to true the root object will be read as a JSON array. + The used when reading values from BSON. + + + + Reads the next JSON token from the underlying . + + + true if the next token was read successfully; false if there are no more tokens to read. + + + + + Changes the reader's state to . + If is set to true, the underlying is also closed. + + + + + Represents a writer that provides a fast, non-cached, forward-only way of generating BSON data. + + + + + Gets or sets the used when writing values to BSON. + When set to no conversion will occur. + + The used when writing values to BSON. + + + + Initializes a new instance of the class. + + The to write to. + + + + Initializes a new instance of the class. + + The to write to. + + + + Flushes whatever is in the buffer to the underlying and also flushes the underlying stream. + + + + + Writes the end. + + The token. + + + + Writes a comment /*...*/ containing the specified text. + + Text to place inside the comment. + + + + Writes the start of a constructor with the given name. + + The name of the constructor. + + + + Writes raw JSON. + + The raw JSON to write. + + + + Writes raw JSON where a value is expected and updates the writer's state. + + The raw JSON to write. + + + + Writes the beginning of a JSON array. + + + + + Writes the beginning of a JSON object. + + + + + Writes the property name of a name/value pair on a JSON object. + + The name of the property. + + + + Closes this writer. + If is set to true, the underlying is also closed. + If is set to true, the JSON is auto-completed. + + + + + Writes a value. + An error will raised if the value cannot be written as a single JSON token. + + The value to write. + + + + Writes a null value. + + + + + Writes an undefined value. + + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a [] value. + + The [] value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a [] value that represents a BSON object id. + + The Object ID value to write. + + + + Writes a BSON regex. + + The regex pattern. + The regex options. + + + + Specifies how constructors are used when initializing objects during deserialization by the . + + + + + First attempt to use the public default constructor, then fall back to a single parameterized constructor, then to the non-public default constructor. + + + + + Json.NET will use a non-public default constructor before falling back to a parameterized constructor. + + + + + Converts a binary value to and from a base 64 string value. + + + + + Writes the JSON representation of the object. + + The to write to. + The value. + The calling serializer. + + + + Reads the JSON representation of the object. + + The to read from. + Type of the object. + The existing value of object being read. + The calling serializer. + The object value. + + + + Determines whether this instance can convert the specified object type. + + Type of the object. + + true if this instance can convert the specified object type; otherwise, false. + + + + + Converts a to and from JSON and BSON. + + + + + Writes the JSON representation of the object. + + The to write to. + The value. + The calling serializer. + + + + Reads the JSON representation of the object. + + The to read from. + Type of the object. + The existing value of object being read. + The calling serializer. + The object value. + + + + Determines whether this instance can convert the specified object type. + + Type of the object. + + true if this instance can convert the specified object type; otherwise, false. + + + + + Creates a custom object. + + The object type to convert. + + + + Writes the JSON representation of the object. + + The to write to. + The value. + The calling serializer. + + + + Reads the JSON representation of the object. + + The to read from. + Type of the object. + The existing value of object being read. + The calling serializer. + The object value. + + + + Creates an object which will then be populated by the serializer. + + Type of the object. + The created object. + + + + Determines whether this instance can convert the specified object type. + + Type of the object. + + true if this instance can convert the specified object type; otherwise, false. + + + + + Gets a value indicating whether this can write JSON. + + + true if this can write JSON; otherwise, false. + + + + + Converts a to and from JSON. + + + + + Writes the JSON representation of the object. + + The to write to. + The value. + The calling serializer. + + + + Reads the JSON representation of the object. + + The to read from. + Type of the object. + The existing value of object being read. + The calling serializer. + The object value. + + + + Determines whether this instance can convert the specified value type. + + Type of the value. + + true if this instance can convert the specified value type; otherwise, false. + + + + + Converts a to and from JSON. + + + + + Writes the JSON representation of the object. + + The to write to. + The value. + The calling serializer. + + + + Reads the JSON representation of the object. + + The to read from. + Type of the object. + The existing value of object being read. + The calling serializer. + The object value. + + + + Determines whether this instance can convert the specified value type. + + Type of the value. + + true if this instance can convert the specified value type; otherwise, false. + + + + + Provides a base class for converting a to and from JSON. + + + + + Determines whether this instance can convert the specified object type. + + Type of the object. + + true if this instance can convert the specified object type; otherwise, false. + + + + + Converts an Entity Framework to and from JSON. + + + + + Writes the JSON representation of the object. + + The to write to. + The value. + The calling serializer. + + + + Reads the JSON representation of the object. + + The to read from. + Type of the object. + The existing value of object being read. + The calling serializer. + The object value. + + + + Determines whether this instance can convert the specified object type. + + Type of the object. + + true if this instance can convert the specified object type; otherwise, false. + + + + + Converts a to and from the ISO 8601 date format (e.g. "2008-04-12T12:53Z"). + + + + + Gets or sets the date time styles used when converting a date to and from JSON. + + The date time styles used when converting a date to and from JSON. + + + + Gets or sets the date time format used when converting a date to and from JSON. + + The date time format used when converting a date to and from JSON. + + + + Gets or sets the culture used when converting a date to and from JSON. + + The culture used when converting a date to and from JSON. + + + + Writes the JSON representation of the object. + + The to write to. + The value. + The calling serializer. + + + + Reads the JSON representation of the object. + + The to read from. + Type of the object. + The existing value of object being read. + The calling serializer. + The object value. + + + + Converts a to and from a JavaScript Date constructor (e.g. new Date(52231943)). + + + + + Writes the JSON representation of the object. + + The to write to. + The value. + The calling serializer. + + + + Reads the JSON representation of the object. + + The to read from. + Type of the object. + The existing property value of the JSON that is being converted. + The calling serializer. + The object value. + + + + Converts a to and from JSON. + + + + + Writes the JSON representation of the object. + + The to write to. + The value. + The calling serializer. + + + + Reads the JSON representation of the object. + + The to read from. + Type of the object. + The existing value of object being read. + The calling serializer. + The object value. + + + + Determines whether this instance can convert the specified object type. + + Type of the object. + + true if this instance can convert the specified object type; otherwise, false. + + + + + Converts a to and from JSON and BSON. + + + + + Writes the JSON representation of the object. + + The to write to. + The value. + The calling serializer. + + + + Reads the JSON representation of the object. + + The to read from. + Type of the object. + The existing value of object being read. + The calling serializer. + The object value. + + + + Determines whether this instance can convert the specified object type. + + Type of the object. + + true if this instance can convert the specified object type; otherwise, false. + + + + + Converts an to and from its name string value. + + + + + Gets or sets a value indicating whether the written enum text should be camel case. + The default value is false. + + true if the written enum text will be camel case; otherwise, false. + + + + Gets or sets the naming strategy used to resolve how enum text is written. + + The naming strategy used to resolve how enum text is written. + + + + Gets or sets a value indicating whether integer values are allowed when serializing and deserializing. + The default value is true. + + true if integers are allowed when serializing and deserializing; otherwise, false. + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class. + + true if the written enum text will be camel case; otherwise, false. + + + + Initializes a new instance of the class. + + The naming strategy used to resolve how enum text is written. + true if integers are allowed when serializing and deserializing; otherwise, false. + + + + Initializes a new instance of the class. + + The of the used to write enum text. + + + + Initializes a new instance of the class. + + The of the used to write enum text. + + The parameter list to use when constructing the described by . + If null, the default constructor is used. + When non-null, there must be a constructor defined in the that exactly matches the number, + order, and type of these parameters. + + + + + Initializes a new instance of the class. + + The of the used to write enum text. + + The parameter list to use when constructing the described by . + If null, the default constructor is used. + When non-null, there must be a constructor defined in the that exactly matches the number, + order, and type of these parameters. + + true if integers are allowed when serializing and deserializing; otherwise, false. + + + + Writes the JSON representation of the object. + + The to write to. + The value. + The calling serializer. + + + + Reads the JSON representation of the object. + + The to read from. + Type of the object. + The existing value of object being read. + The calling serializer. + The object value. + + + + Determines whether this instance can convert the specified object type. + + Type of the object. + + true if this instance can convert the specified object type; otherwise, false. + + + + + Converts a to and from Unix epoch time + + + + + Writes the JSON representation of the object. + + The to write to. + The value. + The calling serializer. + + + + Reads the JSON representation of the object. + + The to read from. + Type of the object. + The existing property value of the JSON that is being converted. + The calling serializer. + The object value. + + + + Converts a to and from a string (e.g. "1.2.3.4"). + + + + + Writes the JSON representation of the object. + + The to write to. + The value. + The calling serializer. + + + + Reads the JSON representation of the object. + + The to read from. + Type of the object. + The existing property value of the JSON that is being converted. + The calling serializer. + The object value. + + + + Determines whether this instance can convert the specified object type. + + Type of the object. + + true if this instance can convert the specified object type; otherwise, false. + + + + + Converts XML to and from JSON. + + + + + Gets or sets the name of the root element to insert when deserializing to XML if the JSON structure has produced multiple root elements. + + The name of the deserialized root element. + + + + Gets or sets a value to indicate whether to write the Json.NET array attribute. + This attribute helps preserve arrays when converting the written XML back to JSON. + + true if the array attribute is written to the XML; otherwise, false. + + + + Gets or sets a value indicating whether to write the root JSON object. + + true if the JSON root object is omitted; otherwise, false. + + + + Gets or sets a value indicating whether to encode special characters when converting JSON to XML. + If true, special characters like ':', '@', '?', '#' and '$' in JSON property names aren't used to specify + XML namespaces, attributes or processing directives. Instead special characters are encoded and written + as part of the XML element name. + + true if special characters are encoded; otherwise, false. + + + + Writes the JSON representation of the object. + + The to write to. + The calling serializer. + The value. + + + + Reads the JSON representation of the object. + + The to read from. + Type of the object. + The existing value of object being read. + The calling serializer. + The object value. + + + + Checks if the is a namespace attribute. + + Attribute name to test. + The attribute name prefix if it has one, otherwise an empty string. + true if attribute name is for a namespace attribute, otherwise false. + + + + Determines whether this instance can convert the specified value type. + + Type of the value. + + true if this instance can convert the specified value type; otherwise, false. + + + + + Specifies how dates are formatted when writing JSON text. + + + + + Dates are written in the ISO 8601 format, e.g. "2012-03-21T05:40Z". + + + + + Dates are written in the Microsoft JSON format, e.g. "\/Date(1198908717056)\/". + + + + + Specifies how date formatted strings, e.g. "\/Date(1198908717056)\/" and "2012-03-21T05:40Z", are parsed when reading JSON text. + + + + + Date formatted strings are not parsed to a date type and are read as strings. + + + + + Date formatted strings, e.g. "\/Date(1198908717056)\/" and "2012-03-21T05:40Z", are parsed to . + + + + + Date formatted strings, e.g. "\/Date(1198908717056)\/" and "2012-03-21T05:40Z", are parsed to . + + + + + Specifies how to treat the time value when converting between string and . + + + + + Treat as local time. If the object represents a Coordinated Universal Time (UTC), it is converted to the local time. + + + + + Treat as a UTC. If the object represents a local time, it is converted to a UTC. + + + + + Treat as a local time if a is being converted to a string. + If a string is being converted to , convert to a local time if a time zone is specified. + + + + + Time zone information should be preserved when converting. + + + + + The default JSON name table implementation. + + + + + Initializes a new instance of the class. + + + + + Gets a string containing the same characters as the specified range of characters in the given array. + + The character array containing the name to find. + The zero-based index into the array specifying the first character of the name. + The number of characters in the name. + A string containing the same characters as the specified range of characters in the given array. + + + + Adds the specified string into name table. + + The string to add. + This method is not thread-safe. + The resolved string. + + + + Specifies default value handling options for the . + + + + + + + + + Include members where the member value is the same as the member's default value when serializing objects. + Included members are written to JSON. Has no effect when deserializing. + + + + + Ignore members where the member value is the same as the member's default value when serializing objects + so that it is not written to JSON. + This option will ignore all default values (e.g. null for objects and nullable types; 0 for integers, + decimals and floating point numbers; and false for booleans). The default value ignored can be changed by + placing the on the property. + + + + + Members with a default value but no JSON will be set to their default value when deserializing. + + + + + Ignore members where the member value is the same as the member's default value when serializing objects + and set members to their default value when deserializing. + + + + + Specifies float format handling options when writing special floating point numbers, e.g. , + and with . + + + + + Write special floating point values as strings in JSON, e.g. "NaN", "Infinity", "-Infinity". + + + + + Write special floating point values as symbols in JSON, e.g. NaN, Infinity, -Infinity. + Note that this will produce non-valid JSON. + + + + + Write special floating point values as the property's default value in JSON, e.g. 0.0 for a property, null for a of property. + + + + + Specifies how floating point numbers, e.g. 1.0 and 9.9, are parsed when reading JSON text. + + + + + Floating point numbers are parsed to . + + + + + Floating point numbers are parsed to . + + + + + Specifies formatting options for the . + + + + + No special formatting is applied. This is the default. + + + + + Causes child objects to be indented according to the and settings. + + + + + Provides an interface for using pooled arrays. + + The array type content. + + + + Rent an array from the pool. This array must be returned when it is no longer needed. + + The minimum required length of the array. The returned array may be longer. + The rented array from the pool. This array must be returned when it is no longer needed. + + + + Return an array to the pool. + + The array that is being returned. + + + + Provides an interface to enable a class to return line and position information. + + + + + Gets a value indicating whether the class can return line information. + + + true if and can be provided; otherwise, false. + + + + + Gets the current line number. + + The current line number or 0 if no line information is available (for example, when returns false). + + + + Gets the current line position. + + The current line position or 0 if no line information is available (for example, when returns false). + + + + Instructs the how to serialize the collection. + + + + + Gets or sets a value indicating whether null items are allowed in the collection. + + true if null items are allowed in the collection; otherwise, false. + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class with a flag indicating whether the array can contain null items. + + A flag indicating whether the array can contain null items. + + + + Initializes a new instance of the class with the specified container Id. + + The container Id. + + + + Instructs the to use the specified constructor when deserializing that object. + + + + + Instructs the how to serialize the object. + + + + + Gets or sets the id. + + The id. + + + + Gets or sets the title. + + The title. + + + + Gets or sets the description. + + The description. + + + + Gets or sets the collection's items converter. + + The collection's items converter. + + + + The parameter list to use when constructing the described by . + If null, the default constructor is used. + When non-null, there must be a constructor defined in the that exactly matches the number, + order, and type of these parameters. + + + + [JsonContainer(ItemConverterType = typeof(MyContainerConverter), ItemConverterParameters = new object[] { 123, "Four" })] + + + + + + Gets or sets the of the . + + The of the . + + + + The parameter list to use when constructing the described by . + If null, the default constructor is used. + When non-null, there must be a constructor defined in the that exactly matches the number, + order, and type of these parameters. + + + + [JsonContainer(NamingStrategyType = typeof(MyNamingStrategy), NamingStrategyParameters = new object[] { 123, "Four" })] + + + + + + Gets or sets a value that indicates whether to preserve object references. + + + true to keep object reference; otherwise, false. The default is false. + + + + + Gets or sets a value that indicates whether to preserve collection's items references. + + + true to keep collection's items object references; otherwise, false. The default is false. + + + + + Gets or sets the reference loop handling used when serializing the collection's items. + + The reference loop handling. + + + + Gets or sets the type name handling used when serializing the collection's items. + + The type name handling. + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class with the specified container Id. + + The container Id. + + + + Provides methods for converting between .NET types and JSON types. + + + + + + + + Gets or sets a function that creates default . + Default settings are automatically used by serialization methods on , + and and on . + To serialize without using any default settings create a with + . + + + + + Represents JavaScript's boolean value true as a string. This field is read-only. + + + + + Represents JavaScript's boolean value false as a string. This field is read-only. + + + + + Represents JavaScript's null as a string. This field is read-only. + + + + + Represents JavaScript's undefined as a string. This field is read-only. + + + + + Represents JavaScript's positive infinity as a string. This field is read-only. + + + + + Represents JavaScript's negative infinity as a string. This field is read-only. + + + + + Represents JavaScript's NaN as a string. This field is read-only. + + + + + Converts the to its JSON string representation. + + The value to convert. + A JSON string representation of the . + + + + Converts the to its JSON string representation using the specified. + + The value to convert. + The format the date will be converted to. + The time zone handling when the date is converted to a string. + A JSON string representation of the . + + + + Converts the to its JSON string representation. + + The value to convert. + A JSON string representation of the . + + + + Converts the to its JSON string representation using the specified. + + The value to convert. + The format the date will be converted to. + A JSON string representation of the . + + + + Converts the to its JSON string representation. + + The value to convert. + A JSON string representation of the . + + + + Converts the to its JSON string representation. + + The value to convert. + A JSON string representation of the . + + + + Converts the to its JSON string representation. + + The value to convert. + A JSON string representation of the . + + + + Converts the to its JSON string representation. + + The value to convert. + A JSON string representation of the . + + + + Converts the to its JSON string representation. + + The value to convert. + A JSON string representation of the . + + + + Converts the to its JSON string representation. + + The value to convert. + A JSON string representation of the . + + + + Converts the to its JSON string representation. + + The value to convert. + A JSON string representation of the . + + + + Converts the to its JSON string representation. + + The value to convert. + A JSON string representation of the . + + + + Converts the to its JSON string representation. + + The value to convert. + A JSON string representation of the . + + + + Converts the to its JSON string representation. + + The value to convert. + A JSON string representation of the . + + + + Converts the to its JSON string representation. + + The value to convert. + A JSON string representation of the . + + + + Converts the to its JSON string representation. + + The value to convert. + A JSON string representation of the . + + + + Converts the to its JSON string representation. + + The value to convert. + A JSON string representation of the . + + + + Converts the to its JSON string representation. + + The value to convert. + A JSON string representation of the . + + + + Converts the to its JSON string representation. + + The value to convert. + A JSON string representation of the . + + + + Converts the to its JSON string representation. + + The value to convert. + A JSON string representation of the . + + + + Converts the to its JSON string representation. + + The value to convert. + A JSON string representation of the . + + + + Converts the to its JSON string representation. + + The value to convert. + A JSON string representation of the . + + + + Converts the to its JSON string representation. + + The value to convert. + The string delimiter character. + A JSON string representation of the . + + + + Converts the to its JSON string representation. + + The value to convert. + The string delimiter character. + The string escape handling. + A JSON string representation of the . + + + + Converts the to its JSON string representation. + + The value to convert. + A JSON string representation of the . + + + + Serializes the specified object to a JSON string. + + The object to serialize. + A JSON string representation of the object. + + + + Serializes the specified object to a JSON string using formatting. + + The object to serialize. + Indicates how the output should be formatted. + + A JSON string representation of the object. + + + + + Serializes the specified object to a JSON string using a collection of . + + The object to serialize. + A collection of converters used while serializing. + A JSON string representation of the object. + + + + Serializes the specified object to a JSON string using formatting and a collection of . + + The object to serialize. + Indicates how the output should be formatted. + A collection of converters used while serializing. + A JSON string representation of the object. + + + + Serializes the specified object to a JSON string using . + + The object to serialize. + The used to serialize the object. + If this is null, default serialization settings will be used. + + A JSON string representation of the object. + + + + + Serializes the specified object to a JSON string using a type, formatting and . + + The object to serialize. + The used to serialize the object. + If this is null, default serialization settings will be used. + + The type of the value being serialized. + This parameter is used when is to write out the type name if the type of the value does not match. + Specifying the type is optional. + + + A JSON string representation of the object. + + + + + Serializes the specified object to a JSON string using formatting and . + + The object to serialize. + Indicates how the output should be formatted. + The used to serialize the object. + If this is null, default serialization settings will be used. + + A JSON string representation of the object. + + + + + Serializes the specified object to a JSON string using a type, formatting and . + + The object to serialize. + Indicates how the output should be formatted. + The used to serialize the object. + If this is null, default serialization settings will be used. + + The type of the value being serialized. + This parameter is used when is to write out the type name if the type of the value does not match. + Specifying the type is optional. + + + A JSON string representation of the object. + + + + + Deserializes the JSON to a .NET object. + + The JSON to deserialize. + The deserialized object from the JSON string. + + + + Deserializes the JSON to a .NET object using . + + The JSON to deserialize. + + The used to deserialize the object. + If this is null, default serialization settings will be used. + + The deserialized object from the JSON string. + + + + Deserializes the JSON to the specified .NET type. + + The JSON to deserialize. + The of object being deserialized. + The deserialized object from the JSON string. + + + + Deserializes the JSON to the specified .NET type. + + The type of the object to deserialize to. + The JSON to deserialize. + The deserialized object from the JSON string. + + + + Deserializes the JSON to the given anonymous type. + + + The anonymous type to deserialize to. This can't be specified + traditionally and must be inferred from the anonymous type passed + as a parameter. + + The JSON to deserialize. + The anonymous type object. + The deserialized anonymous type from the JSON string. + + + + Deserializes the JSON to the given anonymous type using . + + + The anonymous type to deserialize to. This can't be specified + traditionally and must be inferred from the anonymous type passed + as a parameter. + + The JSON to deserialize. + The anonymous type object. + + The used to deserialize the object. + If this is null, default serialization settings will be used. + + The deserialized anonymous type from the JSON string. + + + + Deserializes the JSON to the specified .NET type using a collection of . + + The type of the object to deserialize to. + The JSON to deserialize. + Converters to use while deserializing. + The deserialized object from the JSON string. + + + + Deserializes the JSON to the specified .NET type using . + + The type of the object to deserialize to. + The object to deserialize. + + The used to deserialize the object. + If this is null, default serialization settings will be used. + + The deserialized object from the JSON string. + + + + Deserializes the JSON to the specified .NET type using a collection of . + + The JSON to deserialize. + The type of the object to deserialize. + Converters to use while deserializing. + The deserialized object from the JSON string. + + + + Deserializes the JSON to the specified .NET type using . + + The JSON to deserialize. + The type of the object to deserialize to. + + The used to deserialize the object. + If this is null, default serialization settings will be used. + + The deserialized object from the JSON string. + + + + Populates the object with values from the JSON string. + + The JSON to populate values from. + The target object to populate values onto. + + + + Populates the object with values from the JSON string using . + + The JSON to populate values from. + The target object to populate values onto. + + The used to deserialize the object. + If this is null, default serialization settings will be used. + + + + + Serializes the to a JSON string. + + The node to serialize. + A JSON string of the . + + + + Serializes the to a JSON string using formatting. + + The node to serialize. + Indicates how the output should be formatted. + A JSON string of the . + + + + Serializes the to a JSON string using formatting and omits the root object if is true. + + The node to serialize. + Indicates how the output should be formatted. + Omits writing the root object. + A JSON string of the . + + + + Deserializes the from a JSON string. + + The JSON string. + The deserialized . + + + + Deserializes the from a JSON string nested in a root element specified by . + + The JSON string. + The name of the root element to append when deserializing. + The deserialized . + + + + Deserializes the from a JSON string nested in a root element specified by + and writes a Json.NET array attribute for collections. + + The JSON string. + The name of the root element to append when deserializing. + + A value to indicate whether to write the Json.NET array attribute. + This attribute helps preserve arrays when converting the written XML back to JSON. + + The deserialized . + + + + Deserializes the from a JSON string nested in a root element specified by , + writes a Json.NET array attribute for collections, and encodes special characters. + + The JSON string. + The name of the root element to append when deserializing. + + A value to indicate whether to write the Json.NET array attribute. + This attribute helps preserve arrays when converting the written XML back to JSON. + + + A value to indicate whether to encode special characters when converting JSON to XML. + If true, special characters like ':', '@', '?', '#' and '$' in JSON property names aren't used to specify + XML namespaces, attributes or processing directives. Instead special characters are encoded and written + as part of the XML element name. + + The deserialized . + + + + Serializes the to a JSON string. + + The node to convert to JSON. + A JSON string of the . + + + + Serializes the to a JSON string using formatting. + + The node to convert to JSON. + Indicates how the output should be formatted. + A JSON string of the . + + + + Serializes the to a JSON string using formatting and omits the root object if is true. + + The node to serialize. + Indicates how the output should be formatted. + Omits writing the root object. + A JSON string of the . + + + + Deserializes the from a JSON string. + + The JSON string. + The deserialized . + + + + Deserializes the from a JSON string nested in a root element specified by . + + The JSON string. + The name of the root element to append when deserializing. + The deserialized . + + + + Deserializes the from a JSON string nested in a root element specified by + and writes a Json.NET array attribute for collections. + + The JSON string. + The name of the root element to append when deserializing. + + A value to indicate whether to write the Json.NET array attribute. + This attribute helps preserve arrays when converting the written XML back to JSON. + + The deserialized . + + + + Deserializes the from a JSON string nested in a root element specified by , + writes a Json.NET array attribute for collections, and encodes special characters. + + The JSON string. + The name of the root element to append when deserializing. + + A value to indicate whether to write the Json.NET array attribute. + This attribute helps preserve arrays when converting the written XML back to JSON. + + + A value to indicate whether to encode special characters when converting JSON to XML. + If true, special characters like ':', '@', '?', '#' and '$' in JSON property names aren't used to specify + XML namespaces, attributes or processing directives. Instead special characters are encoded and written + as part of the XML element name. + + The deserialized . + + + + Converts an object to and from JSON. + + + + + Writes the JSON representation of the object. + + The to write to. + The value. + The calling serializer. + + + + Reads the JSON representation of the object. + + The to read from. + Type of the object. + The existing value of object being read. + The calling serializer. + The object value. + + + + Determines whether this instance can convert the specified object type. + + Type of the object. + + true if this instance can convert the specified object type; otherwise, false. + + + + + Gets a value indicating whether this can read JSON. + + true if this can read JSON; otherwise, false. + + + + Gets a value indicating whether this can write JSON. + + true if this can write JSON; otherwise, false. + + + + Converts an object to and from JSON. + + The object type to convert. + + + + Writes the JSON representation of the object. + + The to write to. + The value. + The calling serializer. + + + + Writes the JSON representation of the object. + + The to write to. + The value. + The calling serializer. + + + + Reads the JSON representation of the object. + + The to read from. + Type of the object. + The existing value of object being read. + The calling serializer. + The object value. + + + + Reads the JSON representation of the object. + + The to read from. + Type of the object. + The existing value of object being read. If there is no existing value then null will be used. + The existing value has a value. + The calling serializer. + The object value. + + + + Determines whether this instance can convert the specified object type. + + Type of the object. + + true if this instance can convert the specified object type; otherwise, false. + + + + + Instructs the to use the specified when serializing the member or class. + + + + + Gets the of the . + + The of the . + + + + The parameter list to use when constructing the described by . + If null, the default constructor is used. + + + + + Initializes a new instance of the class. + + Type of the . + + + + Initializes a new instance of the class. + + Type of the . + Parameter list to use when constructing the . Can be null. + + + + Represents a collection of . + + + + + Instructs the how to serialize the collection. + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class with the specified container Id. + + The container Id. + + + + The exception thrown when an error occurs during JSON serialization or deserialization. + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class + with a specified error message. + + The error message that explains the reason for the exception. + + + + Initializes a new instance of the class + with a specified error message and a reference to the inner exception that is the cause of this exception. + + The error message that explains the reason for the exception. + The exception that is the cause of the current exception, or null if no inner exception is specified. + + + + Initializes a new instance of the class. + + The that holds the serialized object data about the exception being thrown. + The that contains contextual information about the source or destination. + The parameter is null. + The class name is null or is zero (0). + + + + Instructs the to deserialize properties with no matching class member into the specified collection + and write values during serialization. + + + + + Gets or sets a value that indicates whether to write extension data when serializing the object. + + + true to write extension data when serializing the object; otherwise, false. The default is true. + + + + + Gets or sets a value that indicates whether to read extension data when deserializing the object. + + + true to read extension data when deserializing the object; otherwise, false. The default is true. + + + + + Initializes a new instance of the class. + + + + + Instructs the not to serialize the public field or public read/write property value. + + + + + Base class for a table of atomized string objects. + + + + + Gets a string containing the same characters as the specified range of characters in the given array. + + The character array containing the name to find. + The zero-based index into the array specifying the first character of the name. + The number of characters in the name. + A string containing the same characters as the specified range of characters in the given array. + + + + Instructs the how to serialize the object. + + + + + Gets or sets the member serialization. + + The member serialization. + + + + Gets or sets the missing member handling used when deserializing this object. + + The missing member handling. + + + + Gets or sets how the object's properties with null values are handled during serialization and deserialization. + + How the object's properties with null values are handled during serialization and deserialization. + + + + Gets or sets a value that indicates whether the object's properties are required. + + + A value indicating whether the object's properties are required. + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class with the specified member serialization. + + The member serialization. + + + + Initializes a new instance of the class with the specified container Id. + + The container Id. + + + + Instructs the to always serialize the member with the specified name. + + + + + Gets or sets the type used when serializing the property's collection items. + + The collection's items type. + + + + The parameter list to use when constructing the described by . + If null, the default constructor is used. + When non-null, there must be a constructor defined in the that exactly matches the number, + order, and type of these parameters. + + + + [JsonProperty(ItemConverterType = typeof(MyContainerConverter), ItemConverterParameters = new object[] { 123, "Four" })] + + + + + + Gets or sets the of the . + + The of the . + + + + The parameter list to use when constructing the described by . + If null, the default constructor is used. + When non-null, there must be a constructor defined in the that exactly matches the number, + order, and type of these parameters. + + + + [JsonProperty(NamingStrategyType = typeof(MyNamingStrategy), NamingStrategyParameters = new object[] { 123, "Four" })] + + + + + + Gets or sets the null value handling used when serializing this property. + + The null value handling. + + + + Gets or sets the default value handling used when serializing this property. + + The default value handling. + + + + Gets or sets the reference loop handling used when serializing this property. + + The reference loop handling. + + + + Gets or sets the object creation handling used when deserializing this property. + + The object creation handling. + + + + Gets or sets the type name handling used when serializing this property. + + The type name handling. + + + + Gets or sets whether this property's value is serialized as a reference. + + Whether this property's value is serialized as a reference. + + + + Gets or sets the order of serialization of a member. + + The numeric order of serialization. + + + + Gets or sets a value indicating whether this property is required. + + + A value indicating whether this property is required. + + + + + Gets or sets the name of the property. + + The name of the property. + + + + Gets or sets the reference loop handling used when serializing the property's collection items. + + The collection's items reference loop handling. + + + + Gets or sets the type name handling used when serializing the property's collection items. + + The collection's items type name handling. + + + + Gets or sets whether this property's collection items are serialized as a reference. + + Whether this property's collection items are serialized as a reference. + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class with the specified name. + + Name of the property. + + + + Represents a reader that provides fast, non-cached, forward-only access to serialized JSON data. + + + + + Specifies the state of the reader. + + + + + A read method has not been called. + + + + + The end of the file has been reached successfully. + + + + + Reader is at a property. + + + + + Reader is at the start of an object. + + + + + Reader is in an object. + + + + + Reader is at the start of an array. + + + + + Reader is in an array. + + + + + The method has been called. + + + + + Reader has just read a value. + + + + + Reader is at the start of a constructor. + + + + + Reader is in a constructor. + + + + + An error occurred that prevents the read operation from continuing. + + + + + The end of the file has been reached successfully. + + + + + Gets the current reader state. + + The current reader state. + + + + Gets or sets a value indicating whether the source should be closed when this reader is closed. + + + true to close the source when this reader is closed; otherwise false. The default is true. + + + + + Gets or sets a value indicating whether multiple pieces of JSON content can + be read from a continuous stream without erroring. + + + true to support reading multiple pieces of JSON content; otherwise false. + The default is false. + + + + + Gets the quotation mark character used to enclose the value of a string. + + + + + Gets or sets how time zones are handled when reading JSON. + + + + + Gets or sets how date formatted strings, e.g. "\/Date(1198908717056)\/" and "2012-03-21T05:40Z", are parsed when reading JSON. + + + + + Gets or sets how floating point numbers, e.g. 1.0 and 9.9, are parsed when reading JSON text. + + + + + Gets or sets how custom date formatted strings are parsed when reading JSON. + + + + + Gets or sets the maximum depth allowed when reading JSON. Reading past this depth will throw a . + A null value means there is no maximum. + The default value is 128. + + + + + Gets the type of the current JSON token. + + + + + Gets the text value of the current JSON token. + + + + + Gets the .NET type for the current JSON token. + + + + + Gets the depth of the current token in the JSON document. + + The depth of the current token in the JSON document. + + + + Gets the path of the current JSON token. + + + + + Gets or sets the culture used when reading JSON. Defaults to . + + + + + Initializes a new instance of the class. + + + + + Reads the next JSON token from the source. + + true if the next token was read successfully; false if there are no more tokens to read. + + + + Reads the next JSON token from the source as a of . + + A of . This method will return null at the end of an array. + + + + Reads the next JSON token from the source as a . + + A . This method will return null at the end of an array. + + + + Reads the next JSON token from the source as a []. + + A [] or null if the next JSON token is null. This method will return null at the end of an array. + + + + Reads the next JSON token from the source as a of . + + A of . This method will return null at the end of an array. + + + + Reads the next JSON token from the source as a of . + + A of . This method will return null at the end of an array. + + + + Reads the next JSON token from the source as a of . + + A of . This method will return null at the end of an array. + + + + Reads the next JSON token from the source as a of . + + A of . This method will return null at the end of an array. + + + + Reads the next JSON token from the source as a of . + + A of . This method will return null at the end of an array. + + + + Skips the children of the current token. + + + + + Sets the current token. + + The new token. + + + + Sets the current token and value. + + The new token. + The value. + + + + Sets the current token and value. + + The new token. + The value. + A flag indicating whether the position index inside an array should be updated. + + + + Sets the state based on current token type. + + + + + Releases unmanaged and - optionally - managed resources. + + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + + Changes the reader's state to . + If is set to true, the source is also closed. + + + + + The exception thrown when an error occurs while reading JSON text. + + + + + Gets the line number indicating where the error occurred. + + The line number indicating where the error occurred. + + + + Gets the line position indicating where the error occurred. + + The line position indicating where the error occurred. + + + + Gets the path to the JSON where the error occurred. + + The path to the JSON where the error occurred. + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class + with a specified error message. + + The error message that explains the reason for the exception. + + + + Initializes a new instance of the class + with a specified error message and a reference to the inner exception that is the cause of this exception. + + The error message that explains the reason for the exception. + The exception that is the cause of the current exception, or null if no inner exception is specified. + + + + Initializes a new instance of the class. + + The that holds the serialized object data about the exception being thrown. + The that contains contextual information about the source or destination. + The parameter is null. + The class name is null or is zero (0). + + + + Initializes a new instance of the class + with a specified error message, JSON path, line number, line position, and a reference to the inner exception that is the cause of this exception. + + The error message that explains the reason for the exception. + The path to the JSON where the error occurred. + The line number indicating where the error occurred. + The line position indicating where the error occurred. + The exception that is the cause of the current exception, or null if no inner exception is specified. + + + + Instructs the to always serialize the member, and to require that the member has a value. + + + + + The exception thrown when an error occurs during JSON serialization or deserialization. + + + + + Gets the line number indicating where the error occurred. + + The line number indicating where the error occurred. + + + + Gets the line position indicating where the error occurred. + + The line position indicating where the error occurred. + + + + Gets the path to the JSON where the error occurred. + + The path to the JSON where the error occurred. + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class + with a specified error message. + + The error message that explains the reason for the exception. + + + + Initializes a new instance of the class + with a specified error message and a reference to the inner exception that is the cause of this exception. + + The error message that explains the reason for the exception. + The exception that is the cause of the current exception, or null if no inner exception is specified. + + + + Initializes a new instance of the class. + + The that holds the serialized object data about the exception being thrown. + The that contains contextual information about the source or destination. + The parameter is null. + The class name is null or is zero (0). + + + + Initializes a new instance of the class + with a specified error message, JSON path, line number, line position, and a reference to the inner exception that is the cause of this exception. + + The error message that explains the reason for the exception. + The path to the JSON where the error occurred. + The line number indicating where the error occurred. + The line position indicating where the error occurred. + The exception that is the cause of the current exception, or null if no inner exception is specified. + + + + Serializes and deserializes objects into and from the JSON format. + The enables you to control how objects are encoded into JSON. + + + + + Occurs when the errors during serialization and deserialization. + + + + + Gets or sets the used by the serializer when resolving references. + + + + + Gets or sets the used by the serializer when resolving type names. + + + + + Gets or sets the used by the serializer when resolving type names. + + + + + Gets or sets the used by the serializer when writing trace messages. + + The trace writer. + + + + Gets or sets the equality comparer used by the serializer when comparing references. + + The equality comparer. + + + + Gets or sets how type name writing and reading is handled by the serializer. + The default value is . + + + should be used with caution when your application deserializes JSON from an external source. + Incoming types should be validated with a custom + when deserializing with a value other than . + + + + + Gets or sets how a type name assembly is written and resolved by the serializer. + The default value is . + + The type name assembly format. + + + + Gets or sets how a type name assembly is written and resolved by the serializer. + The default value is . + + The type name assembly format. + + + + Gets or sets how object references are preserved by the serializer. + The default value is . + + + + + Gets or sets how reference loops (e.g. a class referencing itself) is handled. + The default value is . + + + + + Gets or sets how missing members (e.g. JSON contains a property that isn't a member on the object) are handled during deserialization. + The default value is . + + + + + Gets or sets how null values are handled during serialization and deserialization. + The default value is . + + + + + Gets or sets how default values are handled during serialization and deserialization. + The default value is . + + + + + Gets or sets how objects are created during deserialization. + The default value is . + + The object creation handling. + + + + Gets or sets how constructors are used during deserialization. + The default value is . + + The constructor handling. + + + + Gets or sets how metadata properties are used during deserialization. + The default value is . + + The metadata properties handling. + + + + Gets a collection that will be used during serialization. + + Collection that will be used during serialization. + + + + Gets or sets the contract resolver used by the serializer when + serializing .NET objects to JSON and vice versa. + + + + + Gets or sets the used by the serializer when invoking serialization callback methods. + + The context. + + + + Indicates how JSON text output is formatted. + The default value is . + + + + + Gets or sets how dates are written to JSON text. + The default value is . + + + + + Gets or sets how time zones are handled during serialization and deserialization. + The default value is . + + + + + Gets or sets how date formatted strings, e.g. "\/Date(1198908717056)\/" and "2012-03-21T05:40Z", are parsed when reading JSON. + The default value is . + + + + + Gets or sets how floating point numbers, e.g. 1.0 and 9.9, are parsed when reading JSON text. + The default value is . + + + + + Gets or sets how special floating point numbers, e.g. , + and , + are written as JSON text. + The default value is . + + + + + Gets or sets how strings are escaped when writing JSON text. + The default value is . + + + + + Gets or sets how and values are formatted when writing JSON text, + and the expected date format when reading JSON text. + The default value is "yyyy'-'MM'-'dd'T'HH':'mm':'ss.FFFFFFFK". + + + + + Gets or sets the culture used when reading JSON. + The default value is . + + + + + Gets or sets the maximum depth allowed when reading JSON. Reading past this depth will throw a . + A null value means there is no maximum. + The default value is 128. + + + + + Gets a value indicating whether there will be a check for additional JSON content after deserializing an object. + The default value is false. + + + true if there will be a check for additional JSON content after deserializing an object; otherwise, false. + + + + + Initializes a new instance of the class. + + + + + Creates a new instance. + The will not use default settings + from . + + + A new instance. + The will not use default settings + from . + + + + + Creates a new instance using the specified . + The will not use default settings + from . + + The settings to be applied to the . + + A new instance using the specified . + The will not use default settings + from . + + + + + Creates a new instance. + The will use default settings + from . + + + A new instance. + The will use default settings + from . + + + + + Creates a new instance using the specified . + The will use default settings + from as well as the specified . + + The settings to be applied to the . + + A new instance using the specified . + The will use default settings + from as well as the specified . + + + + + Populates the JSON values onto the target object. + + The that contains the JSON structure to read values from. + The target object to populate values onto. + + + + Populates the JSON values onto the target object. + + The that contains the JSON structure to read values from. + The target object to populate values onto. + + + + Deserializes the JSON structure contained by the specified . + + The that contains the JSON structure to deserialize. + The being deserialized. + + + + Deserializes the JSON structure contained by the specified + into an instance of the specified type. + + The containing the object. + The of object being deserialized. + The instance of being deserialized. + + + + Deserializes the JSON structure contained by the specified + into an instance of the specified type. + + The containing the object. + The type of the object to deserialize. + The instance of being deserialized. + + + + Deserializes the JSON structure contained by the specified + into an instance of the specified type. + + The containing the object. + The of object being deserialized. + The instance of being deserialized. + + + + Serializes the specified and writes the JSON structure + using the specified . + + The used to write the JSON structure. + The to serialize. + + + + Serializes the specified and writes the JSON structure + using the specified . + + The used to write the JSON structure. + The to serialize. + + The type of the value being serialized. + This parameter is used when is to write out the type name if the type of the value does not match. + Specifying the type is optional. + + + + + Serializes the specified and writes the JSON structure + using the specified . + + The used to write the JSON structure. + The to serialize. + + The type of the value being serialized. + This parameter is used when is Auto to write out the type name if the type of the value does not match. + Specifying the type is optional. + + + + + Serializes the specified and writes the JSON structure + using the specified . + + The used to write the JSON structure. + The to serialize. + + + + Specifies the settings on a object. + + + + + Gets or sets how reference loops (e.g. a class referencing itself) are handled. + The default value is . + + Reference loop handling. + + + + Gets or sets how missing members (e.g. JSON contains a property that isn't a member on the object) are handled during deserialization. + The default value is . + + Missing member handling. + + + + Gets or sets how objects are created during deserialization. + The default value is . + + The object creation handling. + + + + Gets or sets how null values are handled during serialization and deserialization. + The default value is . + + Null value handling. + + + + Gets or sets how default values are handled during serialization and deserialization. + The default value is . + + The default value handling. + + + + Gets or sets a collection that will be used during serialization. + + The converters. + + + + Gets or sets how object references are preserved by the serializer. + The default value is . + + The preserve references handling. + + + + Gets or sets how type name writing and reading is handled by the serializer. + The default value is . + + + should be used with caution when your application deserializes JSON from an external source. + Incoming types should be validated with a custom + when deserializing with a value other than . + + The type name handling. + + + + Gets or sets how metadata properties are used during deserialization. + The default value is . + + The metadata properties handling. + + + + Gets or sets how a type name assembly is written and resolved by the serializer. + The default value is . + + The type name assembly format. + + + + Gets or sets how a type name assembly is written and resolved by the serializer. + The default value is . + + The type name assembly format. + + + + Gets or sets how constructors are used during deserialization. + The default value is . + + The constructor handling. + + + + Gets or sets the contract resolver used by the serializer when + serializing .NET objects to JSON and vice versa. + + The contract resolver. + + + + Gets or sets the equality comparer used by the serializer when comparing references. + + The equality comparer. + + + + Gets or sets the used by the serializer when resolving references. + + The reference resolver. + + + + Gets or sets a function that creates the used by the serializer when resolving references. + + A function that creates the used by the serializer when resolving references. + + + + Gets or sets the used by the serializer when writing trace messages. + + The trace writer. + + + + Gets or sets the used by the serializer when resolving type names. + + The binder. + + + + Gets or sets the used by the serializer when resolving type names. + + The binder. + + + + Gets or sets the error handler called during serialization and deserialization. + + The error handler called during serialization and deserialization. + + + + Gets or sets the used by the serializer when invoking serialization callback methods. + + The context. + + + + Gets or sets how and values are formatted when writing JSON text, + and the expected date format when reading JSON text. + The default value is "yyyy'-'MM'-'dd'T'HH':'mm':'ss.FFFFFFFK". + + + + + Gets or sets the maximum depth allowed when reading JSON. Reading past this depth will throw a . + A null value means there is no maximum. + The default value is 128. + + + + + Indicates how JSON text output is formatted. + The default value is . + + + + + Gets or sets how dates are written to JSON text. + The default value is . + + + + + Gets or sets how time zones are handled during serialization and deserialization. + The default value is . + + + + + Gets or sets how date formatted strings, e.g. "\/Date(1198908717056)\/" and "2012-03-21T05:40Z", are parsed when reading JSON. + The default value is . + + + + + Gets or sets how special floating point numbers, e.g. , + and , + are written as JSON. + The default value is . + + + + + Gets or sets how floating point numbers, e.g. 1.0 and 9.9, are parsed when reading JSON text. + The default value is . + + + + + Gets or sets how strings are escaped when writing JSON text. + The default value is . + + + + + Gets or sets the culture used when reading JSON. + The default value is . + + + + + Gets a value indicating whether there will be a check for additional content after deserializing an object. + The default value is false. + + + true if there will be a check for additional content after deserializing an object; otherwise, false. + + + + + Initializes a new instance of the class. + + + + + Represents a reader that provides fast, non-cached, forward-only access to JSON text data. + + + + + Initializes a new instance of the class with the specified . + + The containing the JSON data to read. + + + + Gets or sets the reader's property name table. + + + + + Gets or sets the reader's character buffer pool. + + + + + Reads the next JSON token from the underlying . + + + true if the next token was read successfully; false if there are no more tokens to read. + + + + + Reads the next JSON token from the underlying as a of . + + A of . This method will return null at the end of an array. + + + + Reads the next JSON token from the underlying as a of . + + A of . This method will return null at the end of an array. + + + + Reads the next JSON token from the underlying as a . + + A . This method will return null at the end of an array. + + + + Reads the next JSON token from the underlying as a []. + + A [] or null if the next JSON token is null. This method will return null at the end of an array. + + + + Reads the next JSON token from the underlying as a of . + + A of . This method will return null at the end of an array. + + + + Reads the next JSON token from the underlying as a of . + + A of . This method will return null at the end of an array. + + + + Reads the next JSON token from the underlying as a of . + + A of . This method will return null at the end of an array. + + + + Reads the next JSON token from the underlying as a of . + + A of . This method will return null at the end of an array. + + + + Changes the reader's state to . + If is set to true, the underlying is also closed. + + + + + Gets a value indicating whether the class can return line information. + + + true if and can be provided; otherwise, false. + + + + + Gets the current line number. + + + The current line number or 0 if no line information is available (for example, returns false). + + + + + Gets the current line position. + + + The current line position or 0 if no line information is available (for example, returns false). + + + + + Represents a writer that provides a fast, non-cached, forward-only way of generating JSON data. + + + + + Gets or sets the writer's character array pool. + + + + + Gets or sets how many s to write for each level in the hierarchy when is set to . + + + + + Gets or sets which character to use to quote attribute values. + + + + + Gets or sets which character to use for indenting when is set to . + + + + + Gets or sets a value indicating whether object names will be surrounded with quotes. + + + + + Initializes a new instance of the class using the specified . + + The to write to. + + + + Flushes whatever is in the buffer to the underlying and also flushes the underlying . + + + + + Closes this writer. + If is set to true, the underlying is also closed. + If is set to true, the JSON is auto-completed. + + + + + Writes the beginning of a JSON object. + + + + + Writes the beginning of a JSON array. + + + + + Writes the start of a constructor with the given name. + + The name of the constructor. + + + + Writes the specified end token. + + The end token to write. + + + + Writes the property name of a name/value pair on a JSON object. + + The name of the property. + + + + Writes the property name of a name/value pair on a JSON object. + + The name of the property. + A flag to indicate whether the text should be escaped when it is written as a JSON property name. + + + + Writes indent characters. + + + + + Writes the JSON value delimiter. + + + + + Writes an indent space. + + + + + Writes a value. + An error will raised if the value cannot be written as a single JSON token. + + The value to write. + + + + Writes a null value. + + + + + Writes an undefined value. + + + + + Writes raw JSON. + + The raw JSON to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a of value. + + The of value to write. + + + + Writes a value. + + The value to write. + + + + Writes a of value. + + The of value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a [] value. + + The [] value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a comment /*...*/ containing the specified text. + + Text to place inside the comment. + + + + Writes the given white space. + + The string of white space characters. + + + + Specifies the type of JSON token. + + + + + This is returned by the if a read method has not been called. + + + + + An object start token. + + + + + An array start token. + + + + + A constructor start token. + + + + + An object property name. + + + + + A comment. + + + + + Raw JSON. + + + + + An integer. + + + + + A float. + + + + + A string. + + + + + A boolean. + + + + + A null token. + + + + + An undefined token. + + + + + An object end token. + + + + + An array end token. + + + + + A constructor end token. + + + + + A Date. + + + + + Byte data. + + + + + + Represents a reader that provides validation. + + + JSON Schema validation has been moved to its own package. See https://www.newtonsoft.com/jsonschema for more details. + + + + + + Sets an event handler for receiving schema validation errors. + + + + + Gets the text value of the current JSON token. + + + + + + Gets the depth of the current token in the JSON document. + + The depth of the current token in the JSON document. + + + + Gets the path of the current JSON token. + + + + + Gets the quotation mark character used to enclose the value of a string. + + + + + + Gets the type of the current JSON token. + + + + + + Gets the .NET type for the current JSON token. + + + + + + Initializes a new instance of the class that + validates the content returned from the given . + + The to read from while validating. + + + + Gets or sets the schema. + + The schema. + + + + Gets the used to construct this . + + The specified in the constructor. + + + + Changes the reader's state to . + If is set to true, the underlying is also closed. + + + + + Reads the next JSON token from the underlying as a of . + + A of . + + + + Reads the next JSON token from the underlying as a []. + + + A [] or null if the next JSON token is null. + + + + + Reads the next JSON token from the underlying as a of . + + A of . + + + + Reads the next JSON token from the underlying as a of . + + A of . + + + + Reads the next JSON token from the underlying as a of . + + A of . + + + + Reads the next JSON token from the underlying as a . + + A . This method will return null at the end of an array. + + + + Reads the next JSON token from the underlying as a of . + + A of . This method will return null at the end of an array. + + + + Reads the next JSON token from the underlying as a of . + + A of . + + + + Reads the next JSON token from the underlying . + + + true if the next token was read successfully; false if there are no more tokens to read. + + + + + Represents a writer that provides a fast, non-cached, forward-only way of generating JSON data. + + + + + Gets or sets a value indicating whether the destination should be closed when this writer is closed. + + + true to close the destination when this writer is closed; otherwise false. The default is true. + + + + + Gets or sets a value indicating whether the JSON should be auto-completed when this writer is closed. + + + true to auto-complete the JSON when this writer is closed; otherwise false. The default is true. + + + + + Gets the top. + + The top. + + + + Gets the state of the writer. + + + + + Gets the path of the writer. + + + + + Gets or sets a value indicating how JSON text output should be formatted. + + + + + Gets or sets how dates are written to JSON text. + + + + + Gets or sets how time zones are handled when writing JSON text. + + + + + Gets or sets how strings are escaped when writing JSON text. + + + + + Gets or sets how special floating point numbers, e.g. , + and , + are written to JSON text. + + + + + Gets or sets how and values are formatted when writing JSON text. + + + + + Gets or sets the culture used when writing JSON. Defaults to . + + + + + Initializes a new instance of the class. + + + + + Flushes whatever is in the buffer to the destination and also flushes the destination. + + + + + Closes this writer. + If is set to true, the destination is also closed. + If is set to true, the JSON is auto-completed. + + + + + Writes the beginning of a JSON object. + + + + + Writes the end of a JSON object. + + + + + Writes the beginning of a JSON array. + + + + + Writes the end of an array. + + + + + Writes the start of a constructor with the given name. + + The name of the constructor. + + + + Writes the end constructor. + + + + + Writes the property name of a name/value pair of a JSON object. + + The name of the property. + + + + Writes the property name of a name/value pair of a JSON object. + + The name of the property. + A flag to indicate whether the text should be escaped when it is written as a JSON property name. + + + + Writes the end of the current JSON object or array. + + + + + Writes the current token and its children. + + The to read the token from. + + + + Writes the current token. + + The to read the token from. + A flag indicating whether the current token's children should be written. + + + + Writes the token and its value. + + The to write. + + The value to write. + A value is only required for tokens that have an associated value, e.g. the property name for . + null can be passed to the method for tokens that don't have a value, e.g. . + + + + + Writes the token. + + The to write. + + + + Writes the specified end token. + + The end token to write. + + + + Writes indent characters. + + + + + Writes the JSON value delimiter. + + + + + Writes an indent space. + + + + + Writes a null value. + + + + + Writes an undefined value. + + + + + Writes raw JSON without changing the writer's state. + + The raw JSON to write. + + + + Writes raw JSON where a value is expected and updates the writer's state. + + The raw JSON to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a of value. + + The of value to write. + + + + Writes a of value. + + The of value to write. + + + + Writes a of value. + + The of value to write. + + + + Writes a of value. + + The of value to write. + + + + Writes a of value. + + The of value to write. + + + + Writes a of value. + + The of value to write. + + + + Writes a of value. + + The of value to write. + + + + Writes a of value. + + The of value to write. + + + + Writes a of value. + + The of value to write. + + + + Writes a of value. + + The of value to write. + + + + Writes a of value. + + The of value to write. + + + + Writes a of value. + + The of value to write. + + + + Writes a of value. + + The of value to write. + + + + Writes a of value. + + The of value to write. + + + + Writes a of value. + + The of value to write. + + + + Writes a of value. + + The of value to write. + + + + Writes a of value. + + The of value to write. + + + + Writes a [] value. + + The [] value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + An error will raised if the value cannot be written as a single JSON token. + + The value to write. + + + + Writes a comment /*...*/ containing the specified text. + + Text to place inside the comment. + + + + Writes the given white space. + + The string of white space characters. + + + + Releases unmanaged and - optionally - managed resources. + + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + + Sets the state of the . + + The being written. + The value being written. + + + + The exception thrown when an error occurs while writing JSON text. + + + + + Gets the path to the JSON where the error occurred. + + The path to the JSON where the error occurred. + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class + with a specified error message. + + The error message that explains the reason for the exception. + + + + Initializes a new instance of the class + with a specified error message and a reference to the inner exception that is the cause of this exception. + + The error message that explains the reason for the exception. + The exception that is the cause of the current exception, or null if no inner exception is specified. + + + + Initializes a new instance of the class. + + The that holds the serialized object data about the exception being thrown. + The that contains contextual information about the source or destination. + The parameter is null. + The class name is null or is zero (0). + + + + Initializes a new instance of the class + with a specified error message, JSON path and a reference to the inner exception that is the cause of this exception. + + The error message that explains the reason for the exception. + The path to the JSON where the error occurred. + The exception that is the cause of the current exception, or null if no inner exception is specified. + + + + Specifies how JSON comments are handled when loading JSON. + + + + + Ignore comments. + + + + + Load comments as a with type . + + + + + Specifies how duplicate property names are handled when loading JSON. + + + + + Replace the existing value when there is a duplicate property. The value of the last property in the JSON object will be used. + + + + + Ignore the new value when there is a duplicate property. The value of the first property in the JSON object will be used. + + + + + Throw a when a duplicate property is encountered. + + + + + Contains the LINQ to JSON extension methods. + + + + + Returns a collection of tokens that contains the ancestors of every token in the source collection. + + The type of the objects in source, constrained to . + An of that contains the source collection. + An of that contains the ancestors of every token in the source collection. + + + + Returns a collection of tokens that contains every token in the source collection, and the ancestors of every token in the source collection. + + The type of the objects in source, constrained to . + An of that contains the source collection. + An of that contains every token in the source collection, the ancestors of every token in the source collection. + + + + Returns a collection of tokens that contains the descendants of every token in the source collection. + + The type of the objects in source, constrained to . + An of that contains the source collection. + An of that contains the descendants of every token in the source collection. + + + + Returns a collection of tokens that contains every token in the source collection, and the descendants of every token in the source collection. + + The type of the objects in source, constrained to . + An of that contains the source collection. + An of that contains every token in the source collection, and the descendants of every token in the source collection. + + + + Returns a collection of child properties of every object in the source collection. + + An of that contains the source collection. + An of that contains the properties of every object in the source collection. + + + + Returns a collection of child values of every object in the source collection with the given key. + + An of that contains the source collection. + The token key. + An of that contains the values of every token in the source collection with the given key. + + + + Returns a collection of child values of every object in the source collection. + + An of that contains the source collection. + An of that contains the values of every token in the source collection. + + + + Returns a collection of converted child values of every object in the source collection with the given key. + + The type to convert the values to. + An of that contains the source collection. + The token key. + An that contains the converted values of every token in the source collection with the given key. + + + + Returns a collection of converted child values of every object in the source collection. + + The type to convert the values to. + An of that contains the source collection. + An that contains the converted values of every token in the source collection. + + + + Converts the value. + + The type to convert the value to. + A cast as a of . + A converted value. + + + + Converts the value. + + The source collection type. + The type to convert the value to. + A cast as a of . + A converted value. + + + + Returns a collection of child tokens of every array in the source collection. + + The source collection type. + An of that contains the source collection. + An of that contains the values of every token in the source collection. + + + + Returns a collection of converted child tokens of every array in the source collection. + + An of that contains the source collection. + The type to convert the values to. + The source collection type. + An that contains the converted values of every token in the source collection. + + + + Returns the input typed as . + + An of that contains the source collection. + The input typed as . + + + + Returns the input typed as . + + The source collection type. + An of that contains the source collection. + The input typed as . + + + + Represents a collection of objects. + + The type of token. + + + + Gets the of with the specified key. + + + + + + Represents a JSON array. + + + + + + + + Gets the container's children tokens. + + The container's children tokens. + + + + Gets the node type for this . + + The type. + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class from another object. + + A object to copy from. + + + + Initializes a new instance of the class with the specified content. + + The contents of the array. + + + + Initializes a new instance of the class with the specified content. + + The contents of the array. + + + + Loads an from a . + + A that will be read for the content of the . + A that contains the JSON that was read from the specified . + + + + Loads an from a . + + A that will be read for the content of the . + The used to load the JSON. + If this is null, default load settings will be used. + A that contains the JSON that was read from the specified . + + + + Load a from a string that contains JSON. + + A that contains JSON. + A populated from the string that contains JSON. + + + + + + + Load a from a string that contains JSON. + + A that contains JSON. + The used to load the JSON. + If this is null, default load settings will be used. + A populated from the string that contains JSON. + + + + + + + Creates a from an object. + + The object that will be used to create . + A with the values of the specified object. + + + + Creates a from an object. + + The object that will be used to create . + The that will be used to read the object. + A with the values of the specified object. + + + + Writes this token to a . + + A into which this method will write. + A collection of which will be used when writing the token. + + + + Gets the with the specified key. + + The with the specified key. + + + + Gets or sets the at the specified index. + + + + + + Determines the index of a specific item in the . + + The object to locate in the . + + The index of if found in the list; otherwise, -1. + + + + + Inserts an item to the at the specified index. + + The zero-based index at which should be inserted. + The object to insert into the . + + is not a valid index in the . + + + + + Removes the item at the specified index. + + The zero-based index of the item to remove. + + is not a valid index in the . + + + + + Returns an enumerator that iterates through the collection. + + + A of that can be used to iterate through the collection. + + + + + Adds an item to the . + + The object to add to the . + + + + Removes all items from the . + + + + + Determines whether the contains a specific value. + + The object to locate in the . + + true if is found in the ; otherwise, false. + + + + + Copies the elements of the to an array, starting at a particular array index. + + The array. + Index of the array. + + + + Gets a value indicating whether the is read-only. + + true if the is read-only; otherwise, false. + + + + Removes the first occurrence of a specific object from the . + + The object to remove from the . + + true if was successfully removed from the ; otherwise, false. This method also returns false if is not found in the original . + + + + + Represents a JSON constructor. + + + + + Gets the container's children tokens. + + The container's children tokens. + + + + Gets or sets the name of this constructor. + + The constructor name. + + + + Gets the node type for this . + + The type. + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class from another object. + + A object to copy from. + + + + Initializes a new instance of the class with the specified name and content. + + The constructor name. + The contents of the constructor. + + + + Initializes a new instance of the class with the specified name and content. + + The constructor name. + The contents of the constructor. + + + + Initializes a new instance of the class with the specified name. + + The constructor name. + + + + Writes this token to a . + + A into which this method will write. + A collection of which will be used when writing the token. + + + + Gets the with the specified key. + + The with the specified key. + + + + Loads a from a . + + A that will be read for the content of the . + A that contains the JSON that was read from the specified . + + + + Loads a from a . + + A that will be read for the content of the . + The used to load the JSON. + If this is null, default load settings will be used. + A that contains the JSON that was read from the specified . + + + + Represents a token that can contain other tokens. + + + + + Occurs when the list changes or an item in the list changes. + + + + + Occurs before an item is added to the collection. + + + + + Gets the container's children tokens. + + The container's children tokens. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Gets a value indicating whether this token has child tokens. + + + true if this token has child values; otherwise, false. + + + + + Get the first child token of this token. + + + A containing the first child token of the . + + + + + Get the last child token of this token. + + + A containing the last child token of the . + + + + + Returns a collection of the child tokens of this token, in document order. + + + An of containing the child tokens of this , in document order. + + + + + Returns a collection of the child values of this token, in document order. + + The type to convert the values to. + + A containing the child values of this , in document order. + + + + + Returns a collection of the descendant tokens for this token in document order. + + An of containing the descendant tokens of the . + + + + Returns a collection of the tokens that contain this token, and all descendant tokens of this token, in document order. + + An of containing this token, and all the descendant tokens of the . + + + + Adds the specified content as children of this . + + The content to be added. + + + + Adds the specified content as the first children of this . + + The content to be added. + + + + Creates a that can be used to add tokens to the . + + A that is ready to have content written to it. + + + + Replaces the child nodes of this token with the specified content. + + The content. + + + + Removes the child nodes from this token. + + + + + Merge the specified content into this . + + The content to be merged. + + + + Merge the specified content into this using . + + The content to be merged. + The used to merge the content. + + + + Gets the count of child JSON tokens. + + The count of child JSON tokens. + + + + Represents a collection of objects. + + The type of token. + + + + An empty collection of objects. + + + + + Initializes a new instance of the struct. + + The enumerable. + + + + Returns an enumerator that can be used to iterate through the collection. + + + A that can be used to iterate through the collection. + + + + + Gets the of with the specified key. + + + + + + Determines whether the specified is equal to this instance. + + The to compare with this instance. + + true if the specified is equal to this instance; otherwise, false. + + + + + Determines whether the specified is equal to this instance. + + The to compare with this instance. + + true if the specified is equal to this instance; otherwise, false. + + + + + Returns a hash code for this instance. + + + A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table. + + + + + Represents a JSON object. + + + + + + + + Gets the container's children tokens. + + The container's children tokens. + + + + Occurs when a property value changes. + + + + + Occurs when a property value is changing. + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class from another object. + + A object to copy from. + + + + Initializes a new instance of the class with the specified content. + + The contents of the object. + + + + Initializes a new instance of the class with the specified content. + + The contents of the object. + + + + Gets the node type for this . + + The type. + + + + Gets an of of this object's properties. + + An of of this object's properties. + + + + Gets a with the specified name. + + The property name. + A with the specified name or null. + + + + Gets the with the specified name. + The exact name will be searched for first and if no matching property is found then + the will be used to match a property. + + The property name. + One of the enumeration values that specifies how the strings will be compared. + A matched with the specified name or null. + + + + Gets a of of this object's property values. + + A of of this object's property values. + + + + Gets the with the specified key. + + The with the specified key. + + + + Gets or sets the with the specified property name. + + + + + + Loads a from a . + + A that will be read for the content of the . + A that contains the JSON that was read from the specified . + + is not valid JSON. + + + + + Loads a from a . + + A that will be read for the content of the . + The used to load the JSON. + If this is null, default load settings will be used. + A that contains the JSON that was read from the specified . + + is not valid JSON. + + + + + Load a from a string that contains JSON. + + A that contains JSON. + A populated from the string that contains JSON. + + is not valid JSON. + + + + + + + + Load a from a string that contains JSON. + + A that contains JSON. + The used to load the JSON. + If this is null, default load settings will be used. + A populated from the string that contains JSON. + + is not valid JSON. + + + + + + + + Creates a from an object. + + The object that will be used to create . + A with the values of the specified object. + + + + Creates a from an object. + + The object that will be used to create . + The that will be used to read the object. + A with the values of the specified object. + + + + Writes this token to a . + + A into which this method will write. + A collection of which will be used when writing the token. + + + + Gets the with the specified property name. + + Name of the property. + The with the specified property name. + + + + Gets the with the specified property name. + The exact property name will be searched for first and if no matching property is found then + the will be used to match a property. + + Name of the property. + One of the enumeration values that specifies how the strings will be compared. + The with the specified property name. + + + + Tries to get the with the specified property name. + The exact property name will be searched for first and if no matching property is found then + the will be used to match a property. + + Name of the property. + The value. + One of the enumeration values that specifies how the strings will be compared. + true if a value was successfully retrieved; otherwise, false. + + + + Adds the specified property name. + + Name of the property. + The value. + + + + Determines whether the JSON object has the specified property name. + + Name of the property. + true if the JSON object has the specified property name; otherwise, false. + + + + Removes the property with the specified name. + + Name of the property. + true if item was successfully removed; otherwise, false. + + + + Tries to get the with the specified property name. + + Name of the property. + The value. + true if a value was successfully retrieved; otherwise, false. + + + + Returns an enumerator that can be used to iterate through the collection. + + + A that can be used to iterate through the collection. + + + + + Raises the event with the provided arguments. + + Name of the property. + + + + Raises the event with the provided arguments. + + Name of the property. + + + + Represents a JSON property. + + + + + Gets the container's children tokens. + + The container's children tokens. + + + + Gets the property name. + + The property name. + + + + Gets or sets the property value. + + The property value. + + + + Initializes a new instance of the class from another object. + + A object to copy from. + + + + Gets the node type for this . + + The type. + + + + Initializes a new instance of the class. + + The property name. + The property content. + + + + Initializes a new instance of the class. + + The property name. + The property content. + + + + Writes this token to a . + + A into which this method will write. + A collection of which will be used when writing the token. + + + + Loads a from a . + + A that will be read for the content of the . + A that contains the JSON that was read from the specified . + + + + Loads a from a . + + A that will be read for the content of the . + The used to load the JSON. + If this is null, default load settings will be used. + A that contains the JSON that was read from the specified . + + + + Represents a view of a . + + + + + Initializes a new instance of the class. + + The name. + + + + When overridden in a derived class, returns whether resetting an object changes its value. + + + true if resetting the component changes its value; otherwise, false. + + The component to test for reset capability. + + + + When overridden in a derived class, gets the current value of the property on a component. + + + The value of a property for a given component. + + The component with the property for which to retrieve the value. + + + + When overridden in a derived class, resets the value for this property of the component to the default value. + + The component with the property value that is to be reset to the default value. + + + + When overridden in a derived class, sets the value of the component to a different value. + + The component with the property value that is to be set. + The new value. + + + + When overridden in a derived class, determines a value indicating whether the value of this property needs to be persisted. + + + true if the property should be persisted; otherwise, false. + + The component with the property to be examined for persistence. + + + + When overridden in a derived class, gets the type of the component this property is bound to. + + + A that represents the type of component this property is bound to. + When the or + + methods are invoked, the object specified might be an instance of this type. + + + + + When overridden in a derived class, gets a value indicating whether this property is read-only. + + + true if the property is read-only; otherwise, false. + + + + + When overridden in a derived class, gets the type of the property. + + + A that represents the type of the property. + + + + + Gets the hash code for the name of the member. + + + + The hash code for the name of the member. + + + + + Represents a raw JSON string. + + + + + Initializes a new instance of the class from another object. + + A object to copy from. + + + + Initializes a new instance of the class. + + The raw json. + + + + Creates an instance of with the content of the reader's current token. + + The reader. + An instance of with the content of the reader's current token. + + + + Specifies the settings used when loading JSON. + + + + + Initializes a new instance of the class. + + + + + Gets or sets how JSON comments are handled when loading JSON. + The default value is . + + The JSON comment handling. + + + + Gets or sets how JSON line info is handled when loading JSON. + The default value is . + + The JSON line info handling. + + + + Gets or sets how duplicate property names in JSON objects are handled when loading JSON. + The default value is . + + The JSON duplicate property name handling. + + + + Specifies the settings used when merging JSON. + + + + + Initializes a new instance of the class. + + + + + Gets or sets the method used when merging JSON arrays. + + The method used when merging JSON arrays. + + + + Gets or sets how null value properties are merged. + + How null value properties are merged. + + + + Gets or sets the comparison used to match property names while merging. + The exact property name will be searched for first and if no matching property is found then + the will be used to match a property. + + The comparison used to match property names while merging. + + + + Specifies the settings used when selecting JSON. + + + + + Gets or sets a flag that indicates whether an error should be thrown if + no tokens are found when evaluating part of the expression. + + + A flag that indicates whether an error should be thrown if + no tokens are found when evaluating part of the expression. + + + + + Represents an abstract JSON token. + + + + + Gets a comparer that can compare two tokens for value equality. + + A that can compare two nodes for value equality. + + + + Gets or sets the parent. + + The parent. + + + + Gets the root of this . + + The root of this . + + + + Gets the node type for this . + + The type. + + + + Gets a value indicating whether this token has child tokens. + + + true if this token has child values; otherwise, false. + + + + + Compares the values of two tokens, including the values of all descendant tokens. + + The first to compare. + The second to compare. + true if the tokens are equal; otherwise false. + + + + Gets the next sibling token of this node. + + The that contains the next sibling token. + + + + Gets the previous sibling token of this node. + + The that contains the previous sibling token. + + + + Gets the path of the JSON token. + + + + + Adds the specified content immediately after this token. + + A content object that contains simple content or a collection of content objects to be added after this token. + + + + Adds the specified content immediately before this token. + + A content object that contains simple content or a collection of content objects to be added before this token. + + + + Returns a collection of the ancestor tokens of this token. + + A collection of the ancestor tokens of this token. + + + + Returns a collection of tokens that contain this token, and the ancestors of this token. + + A collection of tokens that contain this token, and the ancestors of this token. + + + + Returns a collection of the sibling tokens after this token, in document order. + + A collection of the sibling tokens after this tokens, in document order. + + + + Returns a collection of the sibling tokens before this token, in document order. + + A collection of the sibling tokens before this token, in document order. + + + + Gets the with the specified key. + + The with the specified key. + + + + Gets the with the specified key converted to the specified type. + + The type to convert the token to. + The token key. + The converted token value. + + + + Get the first child token of this token. + + A containing the first child token of the . + + + + Get the last child token of this token. + + A containing the last child token of the . + + + + Returns a collection of the child tokens of this token, in document order. + + An of containing the child tokens of this , in document order. + + + + Returns a collection of the child tokens of this token, in document order, filtered by the specified type. + + The type to filter the child tokens on. + A containing the child tokens of this , in document order. + + + + Returns a collection of the child values of this token, in document order. + + The type to convert the values to. + A containing the child values of this , in document order. + + + + Removes this token from its parent. + + + + + Replaces this token with the specified token. + + The value. + + + + Writes this token to a . + + A into which this method will write. + A collection of which will be used when writing the token. + + + + Returns the indented JSON for this token. + + + ToString() returns a non-JSON string value for tokens with a type of . + If you want the JSON for all token types then you should use . + + + The indented JSON for this token. + + + + + Returns the JSON for this token using the given formatting and converters. + + Indicates how the output should be formatted. + A collection of s which will be used when writing the token. + The JSON for this token using the given formatting and converters. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to of . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to of . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to of . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to of . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to of . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to of . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to of . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to of . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to of . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to of . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to of . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to of . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to of . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to of . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to of . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to of . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to of . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to []. + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to of . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to of . + + The value. + The result of the conversion. + + + + Performs an explicit conversion from to . + + The value. + The result of the conversion. + + + + Performs an implicit conversion from to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from of to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from of to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from of to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from of to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from of to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from of to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from of to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from of to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from of to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from of to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from of to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from of to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from of to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from of to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from of to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from [] to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from of to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from to . + + The value to create a from. + The initialized with the specified value. + + + + Performs an implicit conversion from of to . + + The value to create a from. + The initialized with the specified value. + + + + Creates a for this token. + + A that can be used to read this token and its descendants. + + + + Creates a from an object. + + The object that will be used to create . + A with the value of the specified object. + + + + Creates a from an object using the specified . + + The object that will be used to create . + The that will be used when reading the object. + A with the value of the specified object. + + + + Creates an instance of the specified .NET type from the . + + The object type that the token will be deserialized to. + The new object created from the JSON value. + + + + Creates an instance of the specified .NET type from the . + + The object type that the token will be deserialized to. + The new object created from the JSON value. + + + + Creates an instance of the specified .NET type from the using the specified . + + The object type that the token will be deserialized to. + The that will be used when creating the object. + The new object created from the JSON value. + + + + Creates an instance of the specified .NET type from the using the specified . + + The object type that the token will be deserialized to. + The that will be used when creating the object. + The new object created from the JSON value. + + + + Creates a from a . + + A positioned at the token to read into this . + + A that contains the token and its descendant tokens + that were read from the reader. The runtime type of the token is determined + by the token type of the first token encountered in the reader. + + + + + Creates a from a . + + An positioned at the token to read into this . + The used to load the JSON. + If this is null, default load settings will be used. + + A that contains the token and its descendant tokens + that were read from the reader. The runtime type of the token is determined + by the token type of the first token encountered in the reader. + + + + + Load a from a string that contains JSON. + + A that contains JSON. + A populated from the string that contains JSON. + + + + Load a from a string that contains JSON. + + A that contains JSON. + The used to load the JSON. + If this is null, default load settings will be used. + A populated from the string that contains JSON. + + + + Creates a from a . + + A positioned at the token to read into this . + The used to load the JSON. + If this is null, default load settings will be used. + + A that contains the token and its descendant tokens + that were read from the reader. The runtime type of the token is determined + by the token type of the first token encountered in the reader. + + + + + Creates a from a . + + A positioned at the token to read into this . + + A that contains the token and its descendant tokens + that were read from the reader. The runtime type of the token is determined + by the token type of the first token encountered in the reader. + + + + + Selects a using a JSONPath expression. Selects the token that matches the object path. + + + A that contains a JSONPath expression. + + A , or null. + + + + Selects a using a JSONPath expression. Selects the token that matches the object path. + + + A that contains a JSONPath expression. + + A flag to indicate whether an error should be thrown if no tokens are found when evaluating part of the expression. + A . + + + + Selects a using a JSONPath expression. Selects the token that matches the object path. + + + A that contains a JSONPath expression. + + The used to select tokens. + A . + + + + Selects a collection of elements using a JSONPath expression. + + + A that contains a JSONPath expression. + + An of that contains the selected elements. + + + + Selects a collection of elements using a JSONPath expression. + + + A that contains a JSONPath expression. + + A flag to indicate whether an error should be thrown if no tokens are found when evaluating part of the expression. + An of that contains the selected elements. + + + + Selects a collection of elements using a JSONPath expression. + + + A that contains a JSONPath expression. + + The used to select tokens. + An of that contains the selected elements. + + + + Creates a new instance of the . All child tokens are recursively cloned. + + A new instance of the . + + + + Adds an object to the annotation list of this . + + The annotation to add. + + + + Get the first annotation object of the specified type from this . + + The type of the annotation to retrieve. + The first annotation object that matches the specified type, or null if no annotation is of the specified type. + + + + Gets the first annotation object of the specified type from this . + + The of the annotation to retrieve. + The first annotation object that matches the specified type, or null if no annotation is of the specified type. + + + + Gets a collection of annotations of the specified type for this . + + The type of the annotations to retrieve. + An that contains the annotations for this . + + + + Gets a collection of annotations of the specified type for this . + + The of the annotations to retrieve. + An of that contains the annotations that match the specified type for this . + + + + Removes the annotations of the specified type from this . + + The type of annotations to remove. + + + + Removes the annotations of the specified type from this . + + The of annotations to remove. + + + + Compares tokens to determine whether they are equal. + + + + + Determines whether the specified objects are equal. + + The first object of type to compare. + The second object of type to compare. + + true if the specified objects are equal; otherwise, false. + + + + + Returns a hash code for the specified object. + + The for which a hash code is to be returned. + A hash code for the specified object. + The type of is a reference type and is null. + + + + Represents a reader that provides fast, non-cached, forward-only access to serialized JSON data. + + + + + Gets the at the reader's current position. + + + + + Initializes a new instance of the class. + + The token to read from. + + + + Initializes a new instance of the class. + + The token to read from. + The initial path of the token. It is prepended to the returned . + + + + Reads the next JSON token from the underlying . + + + true if the next token was read successfully; false if there are no more tokens to read. + + + + + Gets the path of the current JSON token. + + + + + Specifies the type of token. + + + + + No token type has been set. + + + + + A JSON object. + + + + + A JSON array. + + + + + A JSON constructor. + + + + + A JSON object property. + + + + + A comment. + + + + + An integer value. + + + + + A float value. + + + + + A string value. + + + + + A boolean value. + + + + + A null value. + + + + + An undefined value. + + + + + A date value. + + + + + A raw JSON value. + + + + + A collection of bytes value. + + + + + A Guid value. + + + + + A Uri value. + + + + + A TimeSpan value. + + + + + Represents a writer that provides a fast, non-cached, forward-only way of generating JSON data. + + + + + Gets the at the writer's current position. + + + + + Gets the token being written. + + The token being written. + + + + Initializes a new instance of the class writing to the given . + + The container being written to. + + + + Initializes a new instance of the class. + + + + + Flushes whatever is in the buffer to the underlying . + + + + + Closes this writer. + If is set to true, the JSON is auto-completed. + + + Setting to true has no additional effect, since the underlying is a type that cannot be closed. + + + + + Writes the beginning of a JSON object. + + + + + Writes the beginning of a JSON array. + + + + + Writes the start of a constructor with the given name. + + The name of the constructor. + + + + Writes the end. + + The token. + + + + Writes the property name of a name/value pair on a JSON object. + + The name of the property. + + + + Writes a value. + An error will be raised if the value cannot be written as a single JSON token. + + The value to write. + + + + Writes a null value. + + + + + Writes an undefined value. + + + + + Writes raw JSON. + + The raw JSON to write. + + + + Writes a comment /*...*/ containing the specified text. + + Text to place inside the comment. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a [] value. + + The [] value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Writes a value. + + The value to write. + + + + Represents a value in JSON (string, integer, date, etc). + + + + + Initializes a new instance of the class from another object. + + A object to copy from. + + + + Initializes a new instance of the class with the given value. + + The value. + + + + Initializes a new instance of the class with the given value. + + The value. + + + + Initializes a new instance of the class with the given value. + + The value. + + + + Initializes a new instance of the class with the given value. + + The value. + + + + Initializes a new instance of the class with the given value. + + The value. + + + + Initializes a new instance of the class with the given value. + + The value. + + + + Initializes a new instance of the class with the given value. + + The value. + + + + Initializes a new instance of the class with the given value. + + The value. + + + + Initializes a new instance of the class with the given value. + + The value. + + + + Initializes a new instance of the class with the given value. + + The value. + + + + Initializes a new instance of the class with the given value. + + The value. + + + + Initializes a new instance of the class with the given value. + + The value. + + + + Initializes a new instance of the class with the given value. + + The value. + + + + Initializes a new instance of the class with the given value. + + The value. + + + + Gets a value indicating whether this token has child tokens. + + + true if this token has child values; otherwise, false. + + + + + Creates a comment with the given value. + + The value. + A comment with the given value. + + + + Creates a string with the given value. + + The value. + A string with the given value. + + + + Creates a null value. + + A null value. + + + + Creates a undefined value. + + A undefined value. + + + + Gets the node type for this . + + The type. + + + + Gets or sets the underlying token value. + + The underlying token value. + + + + Writes this token to a . + + A into which this method will write. + A collection of s which will be used when writing the token. + + + + Indicates whether the current object is equal to another object of the same type. + + + true if the current object is equal to the parameter; otherwise, false. + + An object to compare with this object. + + + + Determines whether the specified is equal to the current . + + The to compare with the current . + + true if the specified is equal to the current ; otherwise, false. + + + + + Serves as a hash function for a particular type. + + + A hash code for the current . + + + + + Returns a that represents this instance. + + + ToString() returns a non-JSON string value for tokens with a type of . + If you want the JSON for all token types then you should use . + + + A that represents this instance. + + + + + Returns a that represents this instance. + + The format. + + A that represents this instance. + + + + + Returns a that represents this instance. + + The format provider. + + A that represents this instance. + + + + + Returns a that represents this instance. + + The format. + The format provider. + + A that represents this instance. + + + + + Compares the current instance with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other object. + + An object to compare with this instance. + + A 32-bit signed integer that indicates the relative order of the objects being compared. The return value has these meanings: + Value + Meaning + Less than zero + This instance is less than . + Zero + This instance is equal to . + Greater than zero + This instance is greater than . + + + is not of the same type as this instance. + + + + + Specifies how line information is handled when loading JSON. + + + + + Ignore line information. + + + + + Load line information. + + + + + Specifies how JSON arrays are merged together. + + + + Concatenate arrays. + + + Union arrays, skipping items that already exist. + + + Replace all array items. + + + Merge array items together, matched by index. + + + + Specifies how null value properties are merged. + + + + + The content's null value properties will be ignored during merging. + + + + + The content's null value properties will be merged. + + + + + Specifies the member serialization options for the . + + + + + All public members are serialized by default. Members can be excluded using or . + This is the default member serialization mode. + + + + + Only members marked with or are serialized. + This member serialization mode can also be set by marking the class with . + + + + + All public and private fields are serialized. Members can be excluded using or . + This member serialization mode can also be set by marking the class with + and setting IgnoreSerializableAttribute on to false. + + + + + Specifies metadata property handling options for the . + + + + + Read metadata properties located at the start of a JSON object. + + + + + Read metadata properties located anywhere in a JSON object. Note that this setting will impact performance. + + + + + Do not try to read metadata properties. + + + + + Specifies missing member handling options for the . + + + + + Ignore a missing member and do not attempt to deserialize it. + + + + + Throw a when a missing member is encountered during deserialization. + + + + + Specifies null value handling options for the . + + + + + + + + + Include null values when serializing and deserializing objects. + + + + + Ignore null values when serializing and deserializing objects. + + + + + Specifies how object creation is handled by the . + + + + + Reuse existing objects, create new objects when needed. + + + + + Only reuse existing objects. + + + + + Always create new objects. + + + + + Specifies reference handling options for the . + Note that references cannot be preserved when a value is set via a non-default constructor such as types that implement . + + + + + + + + Do not preserve references when serializing types. + + + + + Preserve references when serializing into a JSON object structure. + + + + + Preserve references when serializing into a JSON array structure. + + + + + Preserve references when serializing. + + + + + Specifies reference loop handling options for the . + + + + + Throw a when a loop is encountered. + + + + + Ignore loop references and do not serialize. + + + + + Serialize loop references. + + + + + Indicating whether a property is required. + + + + + The property is not required. The default state. + + + + + The property must be defined in JSON but can be a null value. + + + + + The property must be defined in JSON and cannot be a null value. + + + + + The property is not required but it cannot be a null value. + + + + + + Contains the JSON schema extension methods. + + + JSON Schema validation has been moved to its own package. See https://www.newtonsoft.com/jsonschema for more details. + + + + + + + Determines whether the is valid. + + + JSON Schema validation has been moved to its own package. See https://www.newtonsoft.com/jsonschema for more details. + + + The source to test. + The schema to test with. + + true if the specified is valid; otherwise, false. + + + + + + Determines whether the is valid. + + + JSON Schema validation has been moved to its own package. See https://www.newtonsoft.com/jsonschema for more details. + + + The source to test. + The schema to test with. + When this method returns, contains any error messages generated while validating. + + true if the specified is valid; otherwise, false. + + + + + + Validates the specified . + + + JSON Schema validation has been moved to its own package. See https://www.newtonsoft.com/jsonschema for more details. + + + The source to test. + The schema to test with. + + + + + Validates the specified . + + + JSON Schema validation has been moved to its own package. See https://www.newtonsoft.com/jsonschema for more details. + + + The source to test. + The schema to test with. + The validation event handler. + + + + + An in-memory representation of a JSON Schema. + + + JSON Schema validation has been moved to its own package. See https://www.newtonsoft.com/jsonschema for more details. + + + + + + Gets or sets the id. + + + + + Gets or sets the title. + + + + + Gets or sets whether the object is required. + + + + + Gets or sets whether the object is read-only. + + + + + Gets or sets whether the object is visible to users. + + + + + Gets or sets whether the object is transient. + + + + + Gets or sets the description of the object. + + + + + Gets or sets the types of values allowed by the object. + + The type. + + + + Gets or sets the pattern. + + The pattern. + + + + Gets or sets the minimum length. + + The minimum length. + + + + Gets or sets the maximum length. + + The maximum length. + + + + Gets or sets a number that the value should be divisible by. + + A number that the value should be divisible by. + + + + Gets or sets the minimum. + + The minimum. + + + + Gets or sets the maximum. + + The maximum. + + + + Gets or sets a flag indicating whether the value can not equal the number defined by the minimum attribute (). + + A flag indicating whether the value can not equal the number defined by the minimum attribute (). + + + + Gets or sets a flag indicating whether the value can not equal the number defined by the maximum attribute (). + + A flag indicating whether the value can not equal the number defined by the maximum attribute (). + + + + Gets or sets the minimum number of items. + + The minimum number of items. + + + + Gets or sets the maximum number of items. + + The maximum number of items. + + + + Gets or sets the of items. + + The of items. + + + + Gets or sets a value indicating whether items in an array are validated using the instance at their array position from . + + + true if items are validated using their array position; otherwise, false. + + + + + Gets or sets the of additional items. + + The of additional items. + + + + Gets or sets a value indicating whether additional items are allowed. + + + true if additional items are allowed; otherwise, false. + + + + + Gets or sets whether the array items must be unique. + + + + + Gets or sets the of properties. + + The of properties. + + + + Gets or sets the of additional properties. + + The of additional properties. + + + + Gets or sets the pattern properties. + + The pattern properties. + + + + Gets or sets a value indicating whether additional properties are allowed. + + + true if additional properties are allowed; otherwise, false. + + + + + Gets or sets the required property if this property is present. + + The required property if this property is present. + + + + Gets or sets the a collection of valid enum values allowed. + + A collection of valid enum values allowed. + + + + Gets or sets disallowed types. + + The disallowed types. + + + + Gets or sets the default value. + + The default value. + + + + Gets or sets the collection of that this schema extends. + + The collection of that this schema extends. + + + + Gets or sets the format. + + The format. + + + + Initializes a new instance of the class. + + + + + Reads a from the specified . + + The containing the JSON Schema to read. + The object representing the JSON Schema. + + + + Reads a from the specified . + + The containing the JSON Schema to read. + The to use when resolving schema references. + The object representing the JSON Schema. + + + + Load a from a string that contains JSON Schema. + + A that contains JSON Schema. + A populated from the string that contains JSON Schema. + + + + Load a from a string that contains JSON Schema using the specified . + + A that contains JSON Schema. + The resolver. + A populated from the string that contains JSON Schema. + + + + Writes this schema to a . + + A into which this method will write. + + + + Writes this schema to a using the specified . + + A into which this method will write. + The resolver used. + + + + Returns a that represents the current . + + + A that represents the current . + + + + + + Returns detailed information about the schema exception. + + + JSON Schema validation has been moved to its own package. See https://www.newtonsoft.com/jsonschema for more details. + + + + + + Gets the line number indicating where the error occurred. + + The line number indicating where the error occurred. + + + + Gets the line position indicating where the error occurred. + + The line position indicating where the error occurred. + + + + Gets the path to the JSON where the error occurred. + + The path to the JSON where the error occurred. + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class + with a specified error message. + + The error message that explains the reason for the exception. + + + + Initializes a new instance of the class + with a specified error message and a reference to the inner exception that is the cause of this exception. + + The error message that explains the reason for the exception. + The exception that is the cause of the current exception, or null if no inner exception is specified. + + + + Initializes a new instance of the class. + + The that holds the serialized object data about the exception being thrown. + The that contains contextual information about the source or destination. + The parameter is null. + The class name is null or is zero (0). + + + + + Generates a from a specified . + + + JSON Schema validation has been moved to its own package. See https://www.newtonsoft.com/jsonschema for more details. + + + + + + Gets or sets how undefined schemas are handled by the serializer. + + + + + Gets or sets the contract resolver. + + The contract resolver. + + + + Generate a from the specified type. + + The type to generate a from. + A generated from the specified type. + + + + Generate a from the specified type. + + The type to generate a from. + The used to resolve schema references. + A generated from the specified type. + + + + Generate a from the specified type. + + The type to generate a from. + Specify whether the generated root will be nullable. + A generated from the specified type. + + + + Generate a from the specified type. + + The type to generate a from. + The used to resolve schema references. + Specify whether the generated root will be nullable. + A generated from the specified type. + + + + + Resolves from an id. + + + JSON Schema validation has been moved to its own package. See https://www.newtonsoft.com/jsonschema for more details. + + + + + + Gets or sets the loaded schemas. + + The loaded schemas. + + + + Initializes a new instance of the class. + + + + + Gets a for the specified reference. + + The id. + A for the specified reference. + + + + + The value types allowed by the . + + + JSON Schema validation has been moved to its own package. See https://www.newtonsoft.com/jsonschema for more details. + + + + + + No type specified. + + + + + String type. + + + + + Float type. + + + + + Integer type. + + + + + Boolean type. + + + + + Object type. + + + + + Array type. + + + + + Null type. + + + + + Any type. + + + + + + Specifies undefined schema Id handling options for the . + + + JSON Schema validation has been moved to its own package. See https://www.newtonsoft.com/jsonschema for more details. + + + + + + Do not infer a schema Id. + + + + + Use the .NET type name as the schema Id. + + + + + Use the assembly qualified .NET type name as the schema Id. + + + + + + Returns detailed information related to the . + + + JSON Schema validation has been moved to its own package. See https://www.newtonsoft.com/jsonschema for more details. + + + + + + Gets the associated with the validation error. + + The JsonSchemaException associated with the validation error. + + + + Gets the path of the JSON location where the validation error occurred. + + The path of the JSON location where the validation error occurred. + + + + Gets the text description corresponding to the validation error. + + The text description. + + + + + Represents the callback method that will handle JSON schema validation events and the . + + + JSON Schema validation has been moved to its own package. See https://www.newtonsoft.com/jsonschema for more details. + + + + + + A camel case naming strategy. + + + + + Initializes a new instance of the class. + + + A flag indicating whether dictionary keys should be processed. + + + A flag indicating whether explicitly specified property names should be processed, + e.g. a property name customized with a . + + + + + Initializes a new instance of the class. + + + A flag indicating whether dictionary keys should be processed. + + + A flag indicating whether explicitly specified property names should be processed, + e.g. a property name customized with a . + + + A flag indicating whether extension data names should be processed. + + + + + Initializes a new instance of the class. + + + + + Resolves the specified property name. + + The property name to resolve. + The resolved property name. + + + + Resolves member mappings for a type, camel casing property names. + + + + + Initializes a new instance of the class. + + + + + Resolves the contract for a given type. + + The type to resolve a contract for. + The contract for a given type. + + + + Used by to resolve a for a given . + + + + + Gets a value indicating whether members are being get and set using dynamic code generation. + This value is determined by the runtime permissions available. + + + true if using dynamic code generation; otherwise, false. + + + + + Gets or sets the default members search flags. + + The default members search flags. + + + + Gets or sets a value indicating whether compiler generated members should be serialized. + + + true if serialized compiler generated members; otherwise, false. + + + + + Gets or sets a value indicating whether to ignore the interface when serializing and deserializing types. + + + true if the interface will be ignored when serializing and deserializing types; otherwise, false. + + + + + Gets or sets a value indicating whether to ignore the attribute when serializing and deserializing types. + + + true if the attribute will be ignored when serializing and deserializing types; otherwise, false. + + + + + Gets or sets a value indicating whether to ignore IsSpecified members when serializing and deserializing types. + + + true if the IsSpecified members will be ignored when serializing and deserializing types; otherwise, false. + + + + + Gets or sets a value indicating whether to ignore ShouldSerialize members when serializing and deserializing types. + + + true if the ShouldSerialize members will be ignored when serializing and deserializing types; otherwise, false. + + + + + Gets or sets the naming strategy used to resolve how property names and dictionary keys are serialized. + + The naming strategy used to resolve how property names and dictionary keys are serialized. + + + + Initializes a new instance of the class. + + + + + Resolves the contract for a given type. + + The type to resolve a contract for. + The contract for a given type. + + + + Gets the serializable members for the type. + + The type to get serializable members for. + The serializable members for the type. + + + + Creates a for the given type. + + Type of the object. + A for the given type. + + + + Creates the constructor parameters. + + The constructor to create properties for. + The type's member properties. + Properties for the given . + + + + Creates a for the given . + + The matching member property. + The constructor parameter. + A created for the given . + + + + Resolves the default for the contract. + + Type of the object. + The contract's default . + + + + Creates a for the given type. + + Type of the object. + A for the given type. + + + + Creates a for the given type. + + Type of the object. + A for the given type. + + + + Creates a for the given type. + + Type of the object. + A for the given type. + + + + Creates a for the given type. + + Type of the object. + A for the given type. + + + + Creates a for the given type. + + Type of the object. + A for the given type. + + + + Creates a for the given type. + + Type of the object. + A for the given type. + + + + Determines which contract type is created for the given type. + + Type of the object. + A for the given type. + + + + Creates properties for the given . + + The type to create properties for. + /// The member serialization mode for the type. + Properties for the given . + + + + Creates the used by the serializer to get and set values from a member. + + The member. + The used by the serializer to get and set values from a member. + + + + Creates a for the given . + + The member's parent . + The member to create a for. + A created for the given . + + + + Resolves the name of the property. + + Name of the property. + Resolved name of the property. + + + + Resolves the name of the extension data. By default no changes are made to extension data names. + + Name of the extension data. + Resolved name of the extension data. + + + + Resolves the key of the dictionary. By default is used to resolve dictionary keys. + + Key of the dictionary. + Resolved key of the dictionary. + + + + Gets the resolved name of the property. + + Name of the property. + Name of the property. + + + + The default naming strategy. Property names and dictionary keys are unchanged. + + + + + Resolves the specified property name. + + The property name to resolve. + The resolved property name. + + + + The default serialization binder used when resolving and loading classes from type names. + + + + + Initializes a new instance of the class. + + + + + When overridden in a derived class, controls the binding of a serialized object to a type. + + Specifies the name of the serialized object. + Specifies the name of the serialized object. + + The type of the object the formatter creates a new instance of. + + + + + When overridden in a derived class, controls the binding of a serialized object to a type. + + The type of the object the formatter creates a new instance of. + Specifies the name of the serialized object. + Specifies the name of the serialized object. + + + + Represents a trace writer that writes to the application's instances. + + + + + Gets the that will be used to filter the trace messages passed to the writer. + For example a filter level of will exclude messages and include , + and messages. + + + The that will be used to filter the trace messages passed to the writer. + + + + + Writes the specified trace level, message and optional exception. + + The at which to write this trace. + The trace message. + The trace exception. This parameter is optional. + + + + Get and set values for a using dynamic methods. + + + + + Initializes a new instance of the class. + + The member info. + + + + Sets the value. + + The target to set the value on. + The value to set on the target. + + + + Gets the value. + + The target to get the value from. + The value. + + + + Provides information surrounding an error. + + + + + Gets the error. + + The error. + + + + Gets the original object that caused the error. + + The original object that caused the error. + + + + Gets the member that caused the error. + + The member that caused the error. + + + + Gets the path of the JSON location where the error occurred. + + The path of the JSON location where the error occurred. + + + + Gets or sets a value indicating whether this is handled. + + true if handled; otherwise, false. + + + + Provides data for the Error event. + + + + + Gets the current object the error event is being raised against. + + The current object the error event is being raised against. + + + + Gets the error context. + + The error context. + + + + Initializes a new instance of the class. + + The current object. + The error context. + + + + Provides methods to get attributes. + + + + + Returns a collection of all of the attributes, or an empty collection if there are no attributes. + + When true, look up the hierarchy chain for the inherited custom attribute. + A collection of s, or an empty collection. + + + + Returns a collection of attributes, identified by type, or an empty collection if there are no attributes. + + The type of the attributes. + When true, look up the hierarchy chain for the inherited custom attribute. + A collection of s, or an empty collection. + + + + Used by to resolve a for a given . + + + + + + + + + Resolves the contract for a given type. + + The type to resolve a contract for. + The contract for a given type. + + + + Used to resolve references when serializing and deserializing JSON by the . + + + + + Resolves a reference to its object. + + The serialization context. + The reference to resolve. + The object that was resolved from the reference. + + + + Gets the reference for the specified object. + + The serialization context. + The object to get a reference for. + The reference to the object. + + + + Determines whether the specified object is referenced. + + The serialization context. + The object to test for a reference. + + true if the specified object is referenced; otherwise, false. + + + + + Adds a reference to the specified object. + + The serialization context. + The reference. + The object to reference. + + + + Allows users to control class loading and mandate what class to load. + + + + + When implemented, controls the binding of a serialized object to a type. + + Specifies the name of the serialized object. + Specifies the name of the serialized object + The type of the object the formatter creates a new instance of. + + + + When implemented, controls the binding of a serialized object to a type. + + The type of the object the formatter creates a new instance of. + Specifies the name of the serialized object. + Specifies the name of the serialized object. + + + + Represents a trace writer. + + + + + Gets the that will be used to filter the trace messages passed to the writer. + For example a filter level of will exclude messages and include , + and messages. + + The that will be used to filter the trace messages passed to the writer. + + + + Writes the specified trace level, message and optional exception. + + The at which to write this trace. + The trace message. + The trace exception. This parameter is optional. + + + + Provides methods to get and set values. + + + + + Sets the value. + + The target to set the value on. + The value to set on the target. + + + + Gets the value. + + The target to get the value from. + The value. + + + + Contract details for a used by the . + + + + + Gets the of the collection items. + + The of the collection items. + + + + Gets a value indicating whether the collection type is a multidimensional array. + + true if the collection type is a multidimensional array; otherwise, false. + + + + Gets or sets the function used to create the object. When set this function will override . + + The function used to create the object. + + + + Gets a value indicating whether the creator has a parameter with the collection values. + + true if the creator has a parameter with the collection values; otherwise, false. + + + + Initializes a new instance of the class. + + The underlying type for the contract. + + + + Contract details for a used by the . + + + + + Gets or sets the default collection items . + + The converter. + + + + Gets or sets a value indicating whether the collection items preserve object references. + + true if collection items preserve object references; otherwise, false. + + + + Gets or sets the collection item reference loop handling. + + The reference loop handling. + + + + Gets or sets the collection item type name handling. + + The type name handling. + + + + Initializes a new instance of the class. + + The underlying type for the contract. + + + + Handles serialization callback events. + + The object that raised the callback event. + The streaming context. + + + + Handles serialization error callback events. + + The object that raised the callback event. + The streaming context. + The error context. + + + + Sets extension data for an object during deserialization. + + The object to set extension data on. + The extension data key. + The extension data value. + + + + Gets extension data for an object during serialization. + + The object to set extension data on. + + + + Contract details for a used by the . + + + + + Gets the underlying type for the contract. + + The underlying type for the contract. + + + + Gets or sets the type created during deserialization. + + The type created during deserialization. + + + + Gets or sets whether this type contract is serialized as a reference. + + Whether this type contract is serialized as a reference. + + + + Gets or sets the default for this contract. + + The converter. + + + + Gets the internally resolved for the contract's type. + This converter is used as a fallback converter when no other converter is resolved. + Setting will always override this converter. + + + + + Gets or sets all methods called immediately after deserialization of the object. + + The methods called immediately after deserialization of the object. + + + + Gets or sets all methods called during deserialization of the object. + + The methods called during deserialization of the object. + + + + Gets or sets all methods called after serialization of the object graph. + + The methods called after serialization of the object graph. + + + + Gets or sets all methods called before serialization of the object. + + The methods called before serialization of the object. + + + + Gets or sets all method called when an error is thrown during the serialization of the object. + + The methods called when an error is thrown during the serialization of the object. + + + + Gets or sets the default creator method used to create the object. + + The default creator method used to create the object. + + + + Gets or sets a value indicating whether the default creator is non-public. + + true if the default object creator is non-public; otherwise, false. + + + + Contract details for a used by the . + + + + + Gets or sets the dictionary key resolver. + + The dictionary key resolver. + + + + Gets the of the dictionary keys. + + The of the dictionary keys. + + + + Gets the of the dictionary values. + + The of the dictionary values. + + + + Gets or sets the function used to create the object. When set this function will override . + + The function used to create the object. + + + + Gets a value indicating whether the creator has a parameter with the dictionary values. + + true if the creator has a parameter with the dictionary values; otherwise, false. + + + + Initializes a new instance of the class. + + The underlying type for the contract. + + + + Contract details for a used by the . + + + + + Gets or sets the object constructor. + + The object constructor. + + + + Initializes a new instance of the class. + + The underlying type for the contract. + + + + Contract details for a used by the . + + + + + Initializes a new instance of the class. + + The underlying type for the contract. + + + + Contract details for a used by the . + + + + + Gets or sets the object member serialization. + + The member object serialization. + + + + Gets or sets the missing member handling used when deserializing this object. + + The missing member handling. + + + + Gets or sets a value that indicates whether the object's properties are required. + + + A value indicating whether the object's properties are required. + + + + + Gets or sets how the object's properties with null values are handled during serialization and deserialization. + + How the object's properties with null values are handled during serialization and deserialization. + + + + Gets the object's properties. + + The object's properties. + + + + Gets a collection of instances that define the parameters used with . + + + + + Gets or sets the function used to create the object. When set this function will override . + This function is called with a collection of arguments which are defined by the collection. + + The function used to create the object. + + + + Gets or sets the extension data setter. + + + + + Gets or sets the extension data getter. + + + + + Gets or sets the extension data value type. + + + + + Gets or sets the extension data name resolver. + + The extension data name resolver. + + + + Initializes a new instance of the class. + + The underlying type for the contract. + + + + Contract details for a used by the . + + + + + Initializes a new instance of the class. + + The underlying type for the contract. + + + + Maps a JSON property to a .NET member or constructor parameter. + + + + + Gets or sets the name of the property. + + The name of the property. + + + + Gets or sets the type that declared this property. + + The type that declared this property. + + + + Gets or sets the order of serialization of a member. + + The numeric order of serialization. + + + + Gets or sets the name of the underlying member or parameter. + + The name of the underlying member or parameter. + + + + Gets the that will get and set the during serialization. + + The that will get and set the during serialization. + + + + Gets or sets the for this property. + + The for this property. + + + + Gets or sets the type of the property. + + The type of the property. + + + + Gets or sets the for the property. + If set this converter takes precedence over the contract converter for the property type. + + The converter. + + + + Gets or sets the member converter. + + The member converter. + + + + Gets or sets a value indicating whether this is ignored. + + true if ignored; otherwise, false. + + + + Gets or sets a value indicating whether this is readable. + + true if readable; otherwise, false. + + + + Gets or sets a value indicating whether this is writable. + + true if writable; otherwise, false. + + + + Gets or sets a value indicating whether this has a member attribute. + + true if has a member attribute; otherwise, false. + + + + Gets the default value. + + The default value. + + + + Gets or sets a value indicating whether this is required. + + A value indicating whether this is required. + + + + Gets a value indicating whether has a value specified. + + + + + Gets or sets a value indicating whether this property preserves object references. + + + true if this instance is reference; otherwise, false. + + + + + Gets or sets the property null value handling. + + The null value handling. + + + + Gets or sets the property default value handling. + + The default value handling. + + + + Gets or sets the property reference loop handling. + + The reference loop handling. + + + + Gets or sets the property object creation handling. + + The object creation handling. + + + + Gets or sets or sets the type name handling. + + The type name handling. + + + + Gets or sets a predicate used to determine whether the property should be serialized. + + A predicate used to determine whether the property should be serialized. + + + + Gets or sets a predicate used to determine whether the property should be deserialized. + + A predicate used to determine whether the property should be deserialized. + + + + Gets or sets a predicate used to determine whether the property should be serialized. + + A predicate used to determine whether the property should be serialized. + + + + Gets or sets an action used to set whether the property has been deserialized. + + An action used to set whether the property has been deserialized. + + + + Returns a that represents this instance. + + + A that represents this instance. + + + + + Gets or sets the converter used when serializing the property's collection items. + + The collection's items converter. + + + + Gets or sets whether this property's collection items are serialized as a reference. + + Whether this property's collection items are serialized as a reference. + + + + Gets or sets the type name handling used when serializing the property's collection items. + + The collection's items type name handling. + + + + Gets or sets the reference loop handling used when serializing the property's collection items. + + The collection's items reference loop handling. + + + + A collection of objects. + + + + + Initializes a new instance of the class. + + The type. + + + + When implemented in a derived class, extracts the key from the specified element. + + The element from which to extract the key. + The key for the specified element. + + + + Adds a object. + + The property to add to the collection. + + + + Gets the closest matching object. + First attempts to get an exact case match of and then + a case insensitive match. + + Name of the property. + A matching property if found. + + + + Gets a property by property name. + + The name of the property to get. + Type property name string comparison. + A matching property if found. + + + + Contract details for a used by the . + + + + + Initializes a new instance of the class. + + The underlying type for the contract. + + + + Lookup and create an instance of the type described by the argument. + + The type to create. + Optional arguments to pass to an initializing constructor of the JsonConverter. + If null, the default constructor is used. + + + + A kebab case naming strategy. + + + + + Initializes a new instance of the class. + + + A flag indicating whether dictionary keys should be processed. + + + A flag indicating whether explicitly specified property names should be processed, + e.g. a property name customized with a . + + + + + Initializes a new instance of the class. + + + A flag indicating whether dictionary keys should be processed. + + + A flag indicating whether explicitly specified property names should be processed, + e.g. a property name customized with a . + + + A flag indicating whether extension data names should be processed. + + + + + Initializes a new instance of the class. + + + + + Resolves the specified property name. + + The property name to resolve. + The resolved property name. + + + + Represents a trace writer that writes to memory. When the trace message limit is + reached then old trace messages will be removed as new messages are added. + + + + + Gets the that will be used to filter the trace messages passed to the writer. + For example a filter level of will exclude messages and include , + and messages. + + + The that will be used to filter the trace messages passed to the writer. + + + + + Initializes a new instance of the class. + + + + + Writes the specified trace level, message and optional exception. + + The at which to write this trace. + The trace message. + The trace exception. This parameter is optional. + + + + Returns an enumeration of the most recent trace messages. + + An enumeration of the most recent trace messages. + + + + Returns a of the most recent trace messages. + + + A of the most recent trace messages. + + + + + A base class for resolving how property names and dictionary keys are serialized. + + + + + A flag indicating whether dictionary keys should be processed. + Defaults to false. + + + + + A flag indicating whether extension data names should be processed. + Defaults to false. + + + + + A flag indicating whether explicitly specified property names, + e.g. a property name customized with a , should be processed. + Defaults to false. + + + + + Gets the serialized name for a given property name. + + The initial property name. + A flag indicating whether the property has had a name explicitly specified. + The serialized property name. + + + + Gets the serialized name for a given extension data name. + + The initial extension data name. + The serialized extension data name. + + + + Gets the serialized key for a given dictionary key. + + The initial dictionary key. + The serialized dictionary key. + + + + Resolves the specified property name. + + The property name to resolve. + The resolved property name. + + + + Hash code calculation + + + + + + Object equality implementation + + + + + + + Compare to another NamingStrategy + + + + + + + Represents a method that constructs an object. + + The object type to create. + + + + When applied to a method, specifies that the method is called when an error occurs serializing an object. + + + + + Provides methods to get attributes from a , , or . + + + + + Initializes a new instance of the class. + + The instance to get attributes for. This parameter should be a , , or . + + + + Returns a collection of all of the attributes, or an empty collection if there are no attributes. + + When true, look up the hierarchy chain for the inherited custom attribute. + A collection of s, or an empty collection. + + + + Returns a collection of attributes, identified by type, or an empty collection if there are no attributes. + + The type of the attributes. + When true, look up the hierarchy chain for the inherited custom attribute. + A collection of s, or an empty collection. + + + + Get and set values for a using reflection. + + + + + Initializes a new instance of the class. + + The member info. + + + + Sets the value. + + The target to set the value on. + The value to set on the target. + + + + Gets the value. + + The target to get the value from. + The value. + + + + A snake case naming strategy. + + + + + Initializes a new instance of the class. + + + A flag indicating whether dictionary keys should be processed. + + + A flag indicating whether explicitly specified property names should be processed, + e.g. a property name customized with a . + + + + + Initializes a new instance of the class. + + + A flag indicating whether dictionary keys should be processed. + + + A flag indicating whether explicitly specified property names should be processed, + e.g. a property name customized with a . + + + A flag indicating whether extension data names should be processed. + + + + + Initializes a new instance of the class. + + + + + Resolves the specified property name. + + The property name to resolve. + The resolved property name. + + + + Specifies how strings are escaped when writing JSON text. + + + + + Only control characters (e.g. newline) are escaped. + + + + + All non-ASCII and control characters (e.g. newline) are escaped. + + + + + HTML (<, >, &, ', ") and control characters (e.g. newline) are escaped. + + + + + Indicates the method that will be used during deserialization for locating and loading assemblies. + + + + + In simple mode, the assembly used during deserialization need not match exactly the assembly used during serialization. Specifically, the version numbers need not match as the LoadWithPartialName method of the class is used to load the assembly. + + + + + In full mode, the assembly used during deserialization must match exactly the assembly used during serialization. The Load method of the class is used to load the assembly. + + + + + Specifies type name handling options for the . + + + should be used with caution when your application deserializes JSON from an external source. + Incoming types should be validated with a custom + when deserializing with a value other than . + + + + + Do not include the .NET type name when serializing types. + + + + + Include the .NET type name when serializing into a JSON object structure. + + + + + Include the .NET type name when serializing into a JSON array structure. + + + + + Always include the .NET type name when serializing. + + + + + Include the .NET type name when the type of the object being serialized is not the same as its declared type. + Note that this doesn't include the root serialized object by default. To include the root object's type name in JSON + you must specify a root type object with + or . + + + + + Determines whether the collection is null or empty. + + The collection. + + true if the collection is null or empty; otherwise, false. + + + + + Adds the elements of the specified collection to the specified generic . + + The list to add to. + The collection of elements to add. + + + + Converts the value to the specified type. If the value is unable to be converted, the + value is checked whether it assignable to the specified type. + + The value to convert. + The culture to use when converting. + The type to convert or cast the value to. + + The converted type. If conversion was unsuccessful, the initial value + is returned if assignable to the target type. + + + + + Helper class for serializing immutable collections. + Note that this is used by all builds, even those that don't support immutable collections, in case the DLL is GACed + https://github.com/JamesNK/Newtonsoft.Json/issues/652 + + + + + Gets the type of the typed collection's items. + + The type. + The type of the typed collection's items. + + + + Gets the member's underlying type. + + The member. + The underlying type of the member. + + + + Determines whether the property is an indexed property. + + The property. + + true if the property is an indexed property; otherwise, false. + + + + + Gets the member's value on the object. + + The member. + The target object. + The member's value on the object. + + + + Sets the member's value on the target object. + + The member. + The target. + The value. + + + + Determines whether the specified MemberInfo can be read. + + The MemberInfo to determine whether can be read. + /// if set to true then allow the member to be gotten non-publicly. + + true if the specified MemberInfo can be read; otherwise, false. + + + + + Determines whether the specified MemberInfo can be set. + + The MemberInfo to determine whether can be set. + if set to true then allow the member to be set non-publicly. + if set to true then allow the member to be set if read-only. + + true if the specified MemberInfo can be set; otherwise, false. + + + + + Builds a string. Unlike this class lets you reuse its internal buffer. + + + + + Determines whether the string is all white space. Empty string will return false. + + The string to test whether it is all white space. + + true if the string is all white space; otherwise, false. + + + + + Specifies the state of the . + + + + + An exception has been thrown, which has left the in an invalid state. + You may call the method to put the in the Closed state. + Any other method calls result in an being thrown. + + + + + The method has been called. + + + + + An object is being written. + + + + + An array is being written. + + + + + A constructor is being written. + + + + + A property is being written. + + + + + A write method has not been called. + + + + Specifies that an output will not be null even if the corresponding type allows it. + + + Specifies that when a method returns , the parameter will not be null even if the corresponding type allows it. + + + Initializes the attribute with the specified return value condition. + + The return value condition. If the method returns this value, the associated parameter will not be null. + + + + Gets the return value condition. + + + Specifies that an output may be null even if the corresponding type disallows it. + + + Specifies that null is allowed as an input even if the corresponding type disallows it. + + + + Specifies that the method will not return if the associated Boolean parameter is passed the specified value. + + + + + Initializes a new instance of the class. + + + The condition parameter value. Code after the method will be considered unreachable by diagnostics if the argument to + the associated parameter matches this value. + + + + Gets the condition parameter value. + + + diff --git a/syft/pkg/cataloger/dotnet/test-fixtures/NuGetCache/newtonsoft.json/13.0.1/lib/net40/Newtonsoft.Json.dll b/syft/pkg/cataloger/dotnet/test-fixtures/NuGetCache/newtonsoft.json/13.0.1/lib/net40/Newtonsoft.Json.dll new file mode 100644 index 0000000000000000000000000000000000000000..978356df0e77b16c5c346dbad44d30c67f8e6d9b GIT binary patch literal 576040 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