From 0436951054f74db7d90178126ecfef80bb6171e8 Mon Sep 17 00:00:00 2001 From: Deep Singhvi Date: Fri, 31 May 2024 04:51:39 -0400 Subject: [PATCH] (fix, csharp): support `List` deserialization (#3745) --- generators/csharp/codegen/src/AsIs.ts | 4 +- .../src/asIs/CollectionItemSerializer.cs | 76 +++++++++++++++ .../csharp/codegen/src/ast/ClassReference.ts | 17 +++- generators/csharp/codegen/src/ast/Type.ts | 5 +- .../src/ast/__test__/ClassReference.test.ts | 22 +++++ .../context/AbstractCsharpGeneratorContext.ts | 43 ++++++-- .../codegen/src/context/CsharpTypeMapper.ts | 4 +- generators/csharp/codegen/src/index.ts | 2 +- .../csharp/model/src/ModelGeneratorContext.ts | 2 +- .../model/src/object/ObjectGenerator.ts | 3 +- ...ndiscriminatedUnionSerializerAnnotation.ts | 67 +++++++++---- generators/csharp/sdk/CHANGELOG.md | 6 ++ generators/csharp/sdk/VERSION | 2 +- .../csharp/sdk/src/SdkGeneratorContext.ts | 7 +- .../WrappedRequestGenerator.ts | 3 +- generators/java/sdk/sdk/sdk.jar | Bin 0 -> 270121 bytes .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../SeedApi/Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../SeedApi/Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../SeedEnum/Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../src/SeedExamples/Types/Directory.cs | 4 +- .../src/SeedExamples/Types/ExtendedMovie.cs | 2 +- .../examples/src/SeedExamples/Types/Node.cs | 4 +- .../src/SeedExamples/Types/Response.cs | 2 +- .../examples/src/SeedExamples/Types/Tree.cs | 2 +- .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../Types/Object/ObjectWithOptionalField.cs | 2 +- .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../SeedApi/Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../SeedApi/Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../src/SeedMixedCase/Service/User.cs | 2 +- .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../object/src/SeedObject/Type.cs | 8 +- .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../File/Directory/Directory.cs | 4 +- .../src/SeedObjectsWithImports/Tree.cs | 2 +- .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../src/SeedPagination/UsernamePage.cs | 2 +- .../Users/ListUsersPaginationResponse.cs | 2 +- .../SeedPagination/Users/UserListContainer.cs | 2 +- .../SeedPagination/Users/UsernameContainer.cs | 2 +- .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../src/SeedQueryParameters/User/User.cs | 2 +- .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../src/SeedTrace/Commons/DebugMapValue.cs | 2 +- .../trace/src/SeedTrace/Commons/MapValue.cs | 2 +- .../trace/src/SeedTrace/Commons/TestCase.cs | 2 +- .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../trace/src/SeedTrace/Playlist/Playlist.cs | 2 +- .../Playlist/PlaylistCreateRequest.cs | 2 +- .../Playlist/UpdatePlaylistRequest.cs | 2 +- .../SeedTrace/Problem/CreateProblemRequest.cs | 4 +- .../SeedTrace/Problem/ProblemDescription.cs | 2 +- .../src/SeedTrace/Problem/ProblemFiles.cs | 2 +- .../src/SeedTrace/Problem/ProblemInfo.cs | 4 +- .../GetExecutionSessionStateResponse.cs | 2 +- .../src/SeedTrace/Submission/StackFrame.cs | 2 +- .../SeedTrace/Submission/SubmitRequestV2.cs | 2 +- .../Submission/TestSubmissionState.cs | 4 +- .../Submission/TestSubmissionStatusV2.cs | 2 +- .../Submission/TraceResponsesPage.cs | 2 +- .../Submission/TraceResponsesPageV2.cs | 2 +- .../SeedTrace/Submission/WorkspaceFiles.cs | 2 +- .../Submission/WorkspaceSubmissionStatusV2.cs | 2 +- .../Submission/WorkspaceSubmitRequest.cs | 2 +- .../V2/Problem/CreateProblemRequestV2.cs | 4 +- .../V2/Problem/DefaultProvidedFile.cs | 2 +- .../trace/src/SeedTrace/V2/Problem/Files.cs | 2 +- .../V2/Problem/NonVoidFunctionSignature.cs | 2 +- .../src/SeedTrace/V2/Problem/ProblemInfoV2.cs | 4 +- .../TestCaseImplementationDescription.cs | 2 +- .../V2/Problem/VoidFunctionDefinition.cs | 2 +- ...FunctionDefinitionThatTakesActualResult.cs | 2 +- .../V2/Problem/VoidFunctionSignature.cs | 2 +- ...dFunctionSignatureThatTakesActualResult.cs | 2 +- .../V2/V3/Problem/CreateProblemRequestV2.cs | 4 +- .../V2/V3/Problem/DefaultProvidedFile.cs | 2 +- .../src/SeedTrace/V2/V3/Problem/Files.cs | 2 +- .../V2/V3/Problem/NonVoidFunctionSignature.cs | 2 +- .../SeedTrace/V2/V3/Problem/ProblemInfoV2.cs | 4 +- .../TestCaseImplementationDescription.cs | 2 +- .../V2/V3/Problem/VoidFunctionDefinition.cs | 2 +- ...FunctionDefinitionThatTakesActualResult.cs | 2 +- .../V2/V3/Problem/VoidFunctionSignature.cs | 2 +- ...dFunctionSignatureThatTakesActualResult.cs | 2 +- .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../SeedApi/Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../SeedApi/Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../SeedEnum/Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../src/SeedExamples/Types/Types/Directory.cs | 4 +- .../SeedExamples/Types/Types/ExtendedMovie.cs | 2 +- .../src/SeedExamples/Types/Types/Node.cs | 4 +- .../src/SeedExamples/Types/Types/Response.cs | 2 +- .../src/SeedExamples/Types/Types/Tree.cs | 2 +- .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../Endpoints/Container/ContainerClient.cs | 12 ++- .../Endpoints/Object/ObjectClient.cs | 2 +- .../Object/Types/ObjectWithOptionalField.cs | 2 +- .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../SeedApi/Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../SeedApi/Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../SeedMixedCase/Service/ServiceClient.cs | 4 +- .../src/SeedMixedCase/Service/Types/User.cs | 2 +- .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../object/src/SeedObject/Types/Type.cs | 8 +- .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../File/Directory/Types/Directory.cs | 4 +- .../src/SeedObjectsWithImports/Types/Tree.cs | 2 +- .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../src/SeedPagination/Types/UsernamePage.cs | 2 +- .../Types/ListUsersPaginationResponse.cs | 2 +- .../Users/Types/UserListContainer.cs | 2 +- .../Users/Types/UsernameContainer.cs | 2 +- .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../SeedQueryParameters/User/Types/User.cs | 2 +- .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../trace/src/SeedTrace/Admin/AdminClient.cs | 7 +- .../requests/StoreTracedTestCaseRequest.cs | 2 +- .../requests/StoreTracedWorkspaceRequest.cs | 2 +- .../SeedTrace/Commons/Types/DebugMapValue.cs | 2 +- .../src/SeedTrace/Commons/Types/MapValue.cs | 2 +- .../src/SeedTrace/Commons/Types/TestCase.cs | 2 +- .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../src/SeedTrace/Homepage/HomepageClient.cs | 6 +- .../SeedTrace/Migration/MigrationClient.cs | 4 +- .../src/SeedTrace/Playlist/PlaylistClient.cs | 4 +- .../src/SeedTrace/Playlist/Types/Playlist.cs | 2 +- .../Playlist/Types/PlaylistCreateRequest.cs | 2 +- .../Playlist/Types/UpdatePlaylistRequest.cs | 2 +- .../Problem/Types/CreateProblemRequest.cs | 4 +- .../Problem/Types/ProblemDescription.cs | 2 +- .../SeedTrace/Problem/Types/ProblemFiles.cs | 2 +- .../SeedTrace/Problem/Types/ProblemInfo.cs | 4 +- .../requests/GetDefaultStarterFilesRequest.cs | 2 +- .../Types/GetExecutionSessionStateResponse.cs | 2 +- .../SeedTrace/Submission/Types/StackFrame.cs | 2 +- .../Submission/Types/SubmitRequestV2.cs | 2 +- .../Submission/Types/TestSubmissionState.cs | 4 +- .../Types/TestSubmissionStatusV2.cs | 2 +- .../Submission/Types/TraceResponsesPage.cs | 2 +- .../Submission/Types/TraceResponsesPageV2.cs | 2 +- .../Submission/Types/WorkspaceFiles.cs | 2 +- .../Types/WorkspaceSubmissionStatusV2.cs | 2 +- .../Types/WorkspaceSubmitRequest.cs | 2 +- .../src/SeedTrace/V2/Problem/ProblemClient.cs | 8 +- .../Problem/Types/CreateProblemRequestV2.cs | 4 +- .../V2/Problem/Types/DefaultProvidedFile.cs | 2 +- .../src/SeedTrace/V2/Problem/Types/Files.cs | 2 +- .../Problem/Types/NonVoidFunctionSignature.cs | 2 +- .../V2/Problem/Types/ProblemInfoV2.cs | 4 +- .../TestCaseImplementationDescription.cs | 2 +- .../Problem/Types/VoidFunctionDefinition.cs | 2 +- ...FunctionDefinitionThatTakesActualResult.cs | 2 +- .../V2/Problem/Types/VoidFunctionSignature.cs | 2 +- ...dFunctionSignatureThatTakesActualResult.cs | 2 +- .../SeedTrace/V2/V3/Problem/ProblemClient.cs | 8 +- .../Problem/Types/CreateProblemRequestV2.cs | 4 +- .../V3/Problem/Types/DefaultProvidedFile.cs | 2 +- .../SeedTrace/V2/V3/Problem/Types/Files.cs | 2 +- .../Problem/Types/NonVoidFunctionSignature.cs | 2 +- .../V2/V3/Problem/Types/ProblemInfoV2.cs | 4 +- .../TestCaseImplementationDescription.cs | 2 +- .../Problem/Types/VoidFunctionDefinition.cs | 2 +- ...FunctionDefinitionThatTakesActualResult.cs | 2 +- .../V3/Problem/Types/VoidFunctionSignature.cs | 2 +- ...dFunctionSignatureThatTakesActualResult.cs | 2 +- .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../Union/UnionClient.cs | 27 ++++- .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../SeedUnknownAsAny/Unknown/UnknownClient.cs | 4 +- .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ .../Core/CollectionItemSerializer.cs | 92 ++++++++++++++++++ 244 files changed, 9987 insertions(+), 208 deletions(-) create mode 100644 generators/csharp/codegen/src/asIs/CollectionItemSerializer.cs create mode 100644 generators/csharp/codegen/src/ast/__test__/ClassReference.test.ts create mode 100644 generators/java/sdk/sdk/sdk.jar create mode 100644 seed/csharp-model/alias/src/SeedAlias/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-model/api-wide-base-path/src/SeedApiWideBasePath/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-model/audiences/src/SeedAudiences/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-model/auth-environment-variables/src/SeedAuthEnvironmentVariables/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-model/basic-auth-environment-variables/src/SeedBasicAuthEnvironmentVariables/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-model/basic-auth/src/SeedBasicAuth/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-model/bearer-token-environment-variable/src/SeedBearerTokenEnvironmentVariable/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-model/bytes/src/SeedBytes/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-model/circular-references-advanced/src/SeedApi/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-model/circular-references/src/SeedApi/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-model/code-samples/src/SeedCodeSamples/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-model/custom-auth/src/SeedCustomAuth/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-model/enum/src/SeedEnum/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-model/error-property/src/SeedErrorProperty/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-model/examples/src/SeedExamples/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-model/exhaustive/src/SeedExhaustive/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-model/extends/src/SeedExtends/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-model/extra-properties/src/SeedExtraProperties/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-model/file-download/src/SeedFileDownload/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-model/file-upload/src/SeedFileUpload/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-model/folders/src/SeedApi/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-model/idempotency-headers/src/SeedIdempotencyHeaders/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-model/imdb/src/SeedApi/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-model/literal/src/SeedLiteral/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-model/mixed-case/src/SeedMixedCase/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-model/multi-line-docs/src/SeedMultiLineDocs/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-model/multi-url-environment/src/SeedMultiUrlEnvironment/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-model/no-environment/src/SeedNoEnvironment/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-model/oauth-client-credentials-default/src/SeedOauthClientCredentialsDefault/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-model/oauth-client-credentials-environment-variables/src/SeedOauthClientCredentialsEnvironmentVariables/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-model/oauth-client-credentials-nested-root/src/SeedOauthClientCredentials/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-model/oauth-client-credentials/src/SeedOauthClientCredentials/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-model/object/src/SeedObject/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-model/objects-with-imports/src/SeedObjectsWithImports/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-model/optional/src/SeedObjectsWithImports/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-model/package-yml/src/SeedPackageYml/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-model/pagination/src/SeedPagination/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-model/plain-text/src/SeedPlainText/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-model/query-parameters/src/SeedQueryParameters/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-model/reserved-keywords/src/SeedNurseryApi/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-model/response-property/src/SeedResponseProperty/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-model/server-sent-events/src/SeedServerSentEvents/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-model/single-url-environment-default/src/SeedSingleUrlEnvironmentDefault/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-model/single-url-environment-no-default/src/SeedSingleUrlEnvironmentNoDefault/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-model/streaming/src/SeedStreaming/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-model/trace/src/SeedTrace/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-model/undiscriminated-unions/src/SeedUndiscriminatedUnions/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-model/unions/src/SeedUnions/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-model/unknown/src/SeedUnknownAsAny/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-model/validation/src/SeedValidation/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-model/variables/src/SeedVariables/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-model/websocket/src/SeedWebsocket/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-sdk/alias/src/SeedAlias/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-sdk/api-wide-base-path/src/SeedApiWideBasePath/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-sdk/audiences/src/SeedAudiences/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-sdk/auth-environment-variables/src/SeedAuthEnvironmentVariables/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-sdk/basic-auth-environment-variables/src/SeedBasicAuthEnvironmentVariables/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-sdk/basic-auth/src/SeedBasicAuth/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-sdk/bearer-token-environment-variable/src/SeedBearerTokenEnvironmentVariable/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-sdk/bytes/src/SeedBytes/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-sdk/circular-references-advanced/src/SeedApi/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-sdk/circular-references/src/SeedApi/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-sdk/code-samples/src/SeedCodeSamples/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-sdk/custom-auth/src/SeedCustomAuth/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-sdk/enum/src/SeedEnum/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-sdk/error-property/src/SeedErrorProperty/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-sdk/examples/src/SeedExamples/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-sdk/exhaustive/src/SeedExhaustive/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-sdk/extends/src/SeedExtends/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-sdk/extra-properties/src/SeedExtraProperties/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-sdk/file-download/src/SeedFileDownload/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-sdk/file-upload/src/SeedFileUpload/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-sdk/folders/src/SeedApi/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-sdk/idempotency-headers/src/SeedIdempotencyHeaders/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-sdk/imdb/src/SeedApi/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-sdk/literal/src/SeedLiteral/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-sdk/mixed-case/src/SeedMixedCase/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-sdk/multi-line-docs/src/SeedMultiLineDocs/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-sdk/multi-url-environment/src/SeedMultiUrlEnvironment/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-sdk/no-environment/src/SeedNoEnvironment/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-sdk/oauth-client-credentials-default/src/SeedOauthClientCredentialsDefault/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-sdk/oauth-client-credentials-environment-variables/src/SeedOauthClientCredentialsEnvironmentVariables/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-sdk/oauth-client-credentials-nested-root/src/SeedOauthClientCredentials/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-sdk/oauth-client-credentials/src/SeedOauthClientCredentials/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-sdk/object/src/SeedObject/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-sdk/objects-with-imports/src/SeedObjectsWithImports/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-sdk/optional/src/SeedObjectsWithImports/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-sdk/package-yml/src/SeedPackageYml/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-sdk/pagination/src/SeedPagination/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-sdk/plain-text/src/SeedPlainText/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-sdk/query-parameters/src/SeedQueryParameters/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-sdk/reserved-keywords/src/SeedNurseryApi/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-sdk/response-property/src/SeedResponseProperty/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-sdk/server-sent-events/src/SeedServerSentEvents/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-sdk/single-url-environment-default/src/SeedSingleUrlEnvironmentDefault/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-sdk/single-url-environment-no-default/src/SeedSingleUrlEnvironmentNoDefault/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-sdk/streaming/src/SeedStreaming/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-sdk/trace/src/SeedTrace/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-sdk/undiscriminated-unions/src/SeedUndiscriminatedUnions/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-sdk/unions/src/SeedUnions/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-sdk/unknown/src/SeedUnknownAsAny/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-sdk/validation/src/SeedValidation/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-sdk/variables/src/SeedVariables/Core/CollectionItemSerializer.cs create mode 100644 seed/csharp-sdk/websocket/src/SeedWebsocket/Core/CollectionItemSerializer.cs diff --git a/generators/csharp/codegen/src/AsIs.ts b/generators/csharp/codegen/src/AsIs.ts index a7869cdcb15..914c4ec6a42 100644 --- a/generators/csharp/codegen/src/AsIs.ts +++ b/generators/csharp/codegen/src/AsIs.ts @@ -1,5 +1,6 @@ export const STRING_ENUM_SERIALIZER_CLASS_NAME = "StringEnumSerializer"; export const ONE_OF_SERIALIZER_CLASS_NAME = "OneOfSerializer"; +export const COLLECTION_ITEM_SERIALIZER_CLASS_NAME = "CollectionItemSerializer"; export enum AsIsFiles { EnumConverter = "EnumConverter.Template.cs", @@ -11,5 +12,6 @@ export enum AsIsFiles { RawClient = "RawClient.Template.cs", CiYaml = "github-ci.yml", StringEnumSerializer = "StringEnumSerializer.cs", - OneOfSerializer = "OneOfSerializer.cs" + OneOfSerializer = "OneOfSerializer.cs", + CollectionItemSerializer = "CollectionItemSerializer.cs" } diff --git a/generators/csharp/codegen/src/asIs/CollectionItemSerializer.cs b/generators/csharp/codegen/src/asIs/CollectionItemSerializer.cs new file mode 100644 index 00000000000..4a62e649bd9 --- /dev/null +++ b/generators/csharp/codegen/src/asIs/CollectionItemSerializer.cs @@ -0,0 +1,76 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace <%= namespace%>; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add((TDatatype)JsonSerializer.Deserialize(ref reader, typeof(TDatatype), jsonSerializerOptions)); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write(Utf8JsonWriter writer, IEnumerable value, JsonSerializerOptions options) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} \ No newline at end of file diff --git a/generators/csharp/codegen/src/ast/ClassReference.ts b/generators/csharp/codegen/src/ast/ClassReference.ts index 3096fcf01a9..3cf6fa8b90d 100644 --- a/generators/csharp/codegen/src/ast/ClassReference.ts +++ b/generators/csharp/codegen/src/ast/ClassReference.ts @@ -1,3 +1,4 @@ +import { csharp } from ".."; import { AstNode } from "./core/AstNode"; import { Writer } from "./core/Writer"; @@ -7,22 +8,36 @@ export declare namespace ClassReference { name: string; /* The namespace of the C# class*/ namespace: string; + /* Any generics used in the class reference */ + generics?: csharp.Type[]; } } export class ClassReference extends AstNode { public readonly name: string; public readonly namespace: string; + public readonly generics: csharp.Type[]; - constructor({ name, namespace }: ClassReference.Args) { + constructor({ name, namespace, generics }: ClassReference.Args) { super(); this.name = name; this.namespace = namespace; + this.generics = generics ?? []; } public write(writer: Writer): void { writer.addReference(this); writer.write(`${this.name}`); + if (this.generics != null && this.generics.length > 0) { + writer.write("<"); + this.generics.forEach((generic, idx) => { + writer.writeNode(generic); + if (idx < this.generics.length - 1) { + writer.write(", "); + } + }); + writer.write(">"); + } } } diff --git a/generators/csharp/codegen/src/ast/Type.ts b/generators/csharp/codegen/src/ast/Type.ts index d9dcb0e1f84..c6fea5e6620 100644 --- a/generators/csharp/codegen/src/ast/Type.ts +++ b/generators/csharp/codegen/src/ast/Type.ts @@ -136,7 +136,7 @@ export class Type extends AstNode { writer.write("object"); break; case "list": - writer.write("List<"); + writer.write("IEnumerable<"); this.internalType.value.write(writer); writer.write(">"); break; @@ -157,8 +157,7 @@ export class Type extends AstNode { writer.write("?"); break; case "reference": - writer.addReference(this.internalType.value); - writer.write(this.internalType.value.name); + writer.writeNode(this.internalType.value); break; case "coreReference": writer.write(this.internalType.value.name); diff --git a/generators/csharp/codegen/src/ast/__test__/ClassReference.test.ts b/generators/csharp/codegen/src/ast/__test__/ClassReference.test.ts new file mode 100644 index 00000000000..9cc0e137df6 --- /dev/null +++ b/generators/csharp/codegen/src/ast/__test__/ClassReference.test.ts @@ -0,0 +1,22 @@ +import { csharp } from "../.."; + +describe("class reference", () => { + it("generics", async () => { + const clazz = csharp.classReference({ + name: "OneOf", + namespace: "OneOf", + generics: [ + csharp.Type.string(), + csharp.Type.boolean(), + csharp.Type.reference( + csharp.classReference({ + namespace: "System", + name: "List", + generics: [csharp.Type.string()] + }) + ) + ] + }); + expect(clazz.toString()).toContain("OneOf>"); + }); +}); diff --git a/generators/csharp/codegen/src/context/AbstractCsharpGeneratorContext.ts b/generators/csharp/codegen/src/context/AbstractCsharpGeneratorContext.ts index 0f03d1736e3..57b4932baab 100644 --- a/generators/csharp/codegen/src/context/AbstractCsharpGeneratorContext.ts +++ b/generators/csharp/codegen/src/context/AbstractCsharpGeneratorContext.ts @@ -15,7 +15,11 @@ import { } from "@fern-fern/ir-sdk/api"; import { camelCase, upperFirst } from "lodash-es"; import { csharp } from ".."; -import { ONE_OF_SERIALIZER_CLASS_NAME, STRING_ENUM_SERIALIZER_CLASS_NAME } from "../AsIs"; +import { + COLLECTION_ITEM_SERIALIZER_CLASS_NAME, + ONE_OF_SERIALIZER_CLASS_NAME, + STRING_ENUM_SERIALIZER_CLASS_NAME +} from "../AsIs"; import { BaseCsharpCustomConfigSchema } from "../custom-config/BaseCsharpCustomConfigSchema"; import { CsharpProject } from "../project"; import { CORE_DIRECTORY_NAME } from "../project/CsharpProject"; @@ -76,17 +80,30 @@ export abstract class AbstractCsharpGeneratorContext< }); } - public getOneOfSerializerClassReference(): csharp.ClassReference { + public getCollectionItemSerializerReference( + itemType: csharp.ClassReference, + serializer: csharp.ClassReference + ): csharp.ClassReference { return csharp.classReference({ namespace: this.getCoreNamespace(), - name: ONE_OF_SERIALIZER_CLASS_NAME + name: COLLECTION_ITEM_SERIALIZER_CLASS_NAME, + generics: [csharp.Type.reference(itemType), csharp.Type.reference(serializer)] }); } - public getOneOfClassReference(): csharp.ClassReference { + public getOneOfSerializerClassReference(oneof: csharp.ClassReference): csharp.ClassReference { + return csharp.classReference({ + namespace: this.getCoreNamespace(), + name: ONE_OF_SERIALIZER_CLASS_NAME, + generics: [csharp.Type.reference(oneof)] + }); + } + + public getOneOfClassReference(generics: csharp.Type[]): csharp.ClassReference { return csharp.classReference({ namespace: "OneOf", - name: "OneOf" + name: "OneOf", + generics }); } @@ -108,17 +125,27 @@ export abstract class AbstractCsharpGeneratorContext< public getAsUndiscriminatedUnionTypeDeclaration( reference: TypeReference - ): UndiscriminatedUnionTypeDeclaration | undefined { + ): { declaration: UndiscriminatedUnionTypeDeclaration; isList: boolean } | undefined { if (reference.type === "container" && reference.container.type === "optional") { return this.getAsUndiscriminatedUnionTypeDeclaration(reference.container.optional); } + if (reference.type === "container" && reference.container.type === "list") { + const maybeDeclaration = this.getAsUndiscriminatedUnionTypeDeclaration(reference.container.list); + if (maybeDeclaration != null) { + return { + ...maybeDeclaration, + isList: true + }; + } + } + if (reference.type !== "named") { return undefined; } let declaration = this.getTypeDeclarationOrThrow(reference.typeId); if (declaration.shape.type === "undiscriminatedUnion") { - return declaration.shape; + return { declaration: declaration.shape, isList: false }; } // handle aliases by visiting resolved types @@ -126,7 +153,7 @@ export abstract class AbstractCsharpGeneratorContext< if (declaration.shape.resolvedType.type === "named") { declaration = this.getTypeDeclarationOrThrow(reference.typeId); if (declaration.shape.type === "undiscriminatedUnion") { - return declaration.shape; + return { declaration: declaration.shape, isList: false }; } } else if ( declaration.shape.resolvedType.type === "container" && diff --git a/generators/csharp/codegen/src/context/CsharpTypeMapper.ts b/generators/csharp/codegen/src/context/CsharpTypeMapper.ts index 994474b7397..f9039163f92 100644 --- a/generators/csharp/codegen/src/context/CsharpTypeMapper.ts +++ b/generators/csharp/codegen/src/context/CsharpTypeMapper.ts @@ -55,14 +55,14 @@ export class CsharpTypeMapper { }): Type { switch (container.type) { case "list": - return Type.list(this.convert({ reference: container.list })); + return Type.list(this.convert({ reference: container.list, unboxOptionals: true })); case "map": return Type.map( this.convert({ reference: container.keyType }), this.convert({ reference: container.valueType }) ); case "set": - return Type.set(this.convert({ reference: container.set })); + return Type.set(this.convert({ reference: container.set, unboxOptionals: true })); case "optional": return unboxOptionals ? this.convert({ reference: container.optional, unboxOptionals }) diff --git a/generators/csharp/codegen/src/index.ts b/generators/csharp/codegen/src/index.ts index 62f7498b4ea..656ac0b50da 100644 --- a/generators/csharp/codegen/src/index.ts +++ b/generators/csharp/codegen/src/index.ts @@ -1,4 +1,4 @@ -export { AsIsFiles, ONE_OF_SERIALIZER_CLASS_NAME, STRING_ENUM_SERIALIZER_CLASS_NAME } from "./AsIs"; +export * from "./AsIs"; export * as dependencies from "./ast/dependencies"; export * from "./cli"; export * as csharp from "./csharp"; diff --git a/generators/csharp/model/src/ModelGeneratorContext.ts b/generators/csharp/model/src/ModelGeneratorContext.ts index d6716545152..684012c55f1 100644 --- a/generators/csharp/model/src/ModelGeneratorContext.ts +++ b/generators/csharp/model/src/ModelGeneratorContext.ts @@ -27,6 +27,6 @@ export class ModelGeneratorContext extends AbstractCsharpGeneratorContext; undiscriminatedUnionDeclaration: UndiscriminatedUnionTypeDeclaration; + isList: boolean; }): csharp.Annotation { + if (isList) { + return csharp.annotation({ + reference: csharp.classReference({ + name: "JsonConverter", + namespace: "System.Text.Json.Serialization" + }), + argument: csharp.codeblock((writer) => { + writer.write("typeof("); + + const oneOf = getOneOf({ context, undiscriminatedUnionDeclaration }); + const oneOfSerializer = getOneOfSerializer({ context, undiscriminatedUnionDeclaration }); + const collectionSerializer = context.getCollectionItemSerializerReference(oneOf, oneOfSerializer); + writer.writeNode(collectionSerializer); + writer.write(")"); + }) + }); + } return csharp.annotation({ reference: csharp.classReference({ name: "JsonConverter", @@ -22,24 +41,36 @@ export function getUndiscriminatedUnionSerializerAnnotation({ }), argument: csharp.codeblock((writer) => { writer.write("typeof("); - - writer.writeNode(context.getOneOfSerializerClassReference()); - writer.write("<"); - - writer.writeNode(context.getOneOfClassReference()); - writer.write("<"); - undiscriminatedUnionDeclaration.members.forEach((member, idx) => { - const type = context.csharpTypeMapper.convert({ reference: member.type, unboxOptionals: true }); - writer.writeNode(type); - if (idx < undiscriminatedUnionDeclaration.members.length - 1) { - writer.write(", "); - } - }); - writer.write(">"); - - writer.write(">"); - + const oneOfSerializer = getOneOfSerializer({ context, undiscriminatedUnionDeclaration }); + writer.writeNode(oneOfSerializer); writer.write(")"); }) }); } + +function getOneOfSerializer({ + context, + undiscriminatedUnionDeclaration +}: { + // eslint-disable-next-line @typescript-eslint/no-explicit-any + context: AbstractCsharpGeneratorContext; + undiscriminatedUnionDeclaration: UndiscriminatedUnionTypeDeclaration; +}): csharp.ClassReference { + const oneOf = getOneOf({ context, undiscriminatedUnionDeclaration }); + return context.getOneOfSerializerClassReference(oneOf); +} + +function getOneOf({ + context, + undiscriminatedUnionDeclaration +}: { + // eslint-disable-next-line @typescript-eslint/no-explicit-any + context: AbstractCsharpGeneratorContext; + undiscriminatedUnionDeclaration: UndiscriminatedUnionTypeDeclaration; +}): csharp.ClassReference { + return context.getOneOfClassReference( + undiscriminatedUnionDeclaration.members.map((member) => { + return context.csharpTypeMapper.convert({ reference: member.type, unboxOptionals: true }); + }) + ); +} diff --git a/generators/csharp/sdk/CHANGELOG.md b/generators/csharp/sdk/CHANGELOG.md index ba663928752..7b957160924 100644 --- a/generators/csharp/sdk/CHANGELOG.md +++ b/generators/csharp/sdk/CHANGELOG.md @@ -5,6 +5,12 @@ All notable changes to this project will be documented in this file. The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). +## [0.0.21 - 2024-05-31] + +- Fix: Array and List fields are now generated as `IEnumerable<>`. Additionally, if the + item type is a `OneOf`, then a new core class called `CollectionItemSerializer` is used + to deserialize the values. + ## [0.0.20 - 2024-05-29] - Fix: Enum serializer is now added to enum declarations instead of enum references. This diff --git a/generators/csharp/sdk/VERSION b/generators/csharp/sdk/VERSION index fe04e7f676f..236c7ad084d 100644 --- a/generators/csharp/sdk/VERSION +++ b/generators/csharp/sdk/VERSION @@ -1 +1 @@ -0.0.20 +0.0.21 diff --git a/generators/csharp/sdk/src/SdkGeneratorContext.ts b/generators/csharp/sdk/src/SdkGeneratorContext.ts index 330db097b5e..280cbec9bc0 100644 --- a/generators/csharp/sdk/src/SdkGeneratorContext.ts +++ b/generators/csharp/sdk/src/SdkGeneratorContext.ts @@ -63,7 +63,12 @@ export class SdkGeneratorContext extends AbstractCsharpGeneratorContext~vjmYJCyGcz+Y#msihiJ6(18ROW#?(Ug6(>-TSUoA;L zzP0s9OHb`xRc}=(NP~bv0|7xo0)Yi|YXE&bfPZ`YctCx;WJOg3=_KXE7(jp&{hW7RV6D5Fy3&6>lRLsH}plWYzXZX)6 zLUtw|;s9r7fTI(=v9+O-Q?ZJ!Jc=MHA4pUG!bs|-LeC=f0B1N8Qyr+WWP~g>Dd7|E zIlRmFi!*MX)gZt9!s}jwtyt!bbu~gNM1P;Oj>Czr!>sJKUR-hQ1bUPJ|FjCUT(#h02QtSFX;R5~-Sl*HM;Q+$tTCn4<<(OP=2q zY;X$CJSk^c50~+FHP7#MB+h88MCzttnwaIRDJ>J_!1SwRkkPCw?b4;P`D>;%NN8qX zk~X;w-S2scY#ui{(G_va6ue#Nk*aquhzKrCxnYy`ub@~%zvPQnm9E%`D;}6|s0_b} z#bi3zx8`Rlv)_yJ4(Mx9IE19fuv@Z3wvYHubR5sQ?TkG@V~4C@m0nS&nrf^~M9s!q zX8OyqHTf};yUrXh72&$H=aFc`-pg6P2)#=e84>o&gm-!0$DVv&nIot2j#3`J4lpi{ zuoz=%WblyQEfvUhd3&(VN0gey$ZdzHIK*6_FZwJt!ssS-@rni!o9}V2xus!x^?qoH zsi!x<*xxbQVXVQqs+4XBoR~*cLNII+zKuN+#F-DJL!raxZ})8!BJ7HH8+-5<)hp18 zT>Lh9^*-?`VYjyEq|F)@;8IzK(lN43L5HZC%JXpq-!#l7h5BNL>tepE-~ee~8Z|ei ztLJ}q*lz|O$UXt5_hDogANx`JzZsdNjg5=5p^-H}3GlHQ0Jg^eva|oOD$;*g-v3+? zaod)rzw6z)XnQJ0rjaz`l5$?pK5uo>vC26w_Zw%b*6_={rDD&YGoH z$*yZXt{|QYqZ+IRL{N;P_?-33HpVj3ySw>%fWBejK22R2rV6fa@rs^ub9l*&w% z@s0&b6gYMg440$qLWW8(seB6Qzx+9@KVxHQQlyMxpf2`3?>Y0A8u|Av`!s3_zV0_o(OGFm?7u3^=`bRLGHyDqVL^tsPWZbcd!KVh zQLz{)1zgjH4dA?m@RN?{1+b`1tOl0y)aU!itu>d(<)i)dt-r`Op6{@pi0h6ke^|HK4JQpoT)clyz0q7TH!vlg=mT~7Wvo?6JVwfy~`_gj47|$WpK)>hBDW2d6 z^?%cK^}%zvJrN0@KVV_Ps1qB_oszqEM=adzl%hhBQGs^iciGRTbX1EH@)l7-MIRpJ zd|i^Nmf5{Tl?5O4cMXq4U@nr0hErOE(FQl0l+*My6CW>*ALv$=(vDZc)Nyt}wtp@( zdD01jf0l}u>5?oU0l&YehlTD%o`M3?0T2^z3LCGkOua8)!M6O2d1&`|%^7YpBV+_8k6RDH!a^MchHh}wg!0t-E&Wb6wA`5Iu&4n zHMdX53e{qlE&*Ua+MSfvI;>!n0aQeiBdF3g?Y@%!$ik#~CJm>^%7Tq{STFFX z^KcK%=VsQ#9>E>6f5X`2CK$5k9&3z5Sze4>8ZzmcUE$m|Dx`W{{#Jw(tByH}Ap}UM zbzq&&EFm{Ex54a16yaA*RBCj=23FTAa^W-1j%Dxff56eGzI;5%%#64PE)R-%I&~)( zmYRR54Q5%hj;3Z|Oo}5oU^@Fov7ayG2KA}pZsA9rcu&UQXLwrp@&q>=%Gp)Y{rC+! zh&`)3Rru~te?|qO52r2kfhzg~mH7WZs()Y-{>?MX8QS~@r(%Usxqe1O+|;SY;wg++ z5TTuKpWwGhLiH$axS~#UTCal_@@iSPHrj`0ef+JWGXsB`y#+4EwS-XGS zhV;n~6j@vB2Z+*;)L%?!92)EAwQR(ycl>NWny58zK#WR;-|sh(`{dRB^U@P+Vljad z2J!>bHk9?Z!!hCDOXP|&2Ww{INPU+`n==ho%pa9>NnFibx15`_>gkI@r8=*F2?j;N z<)e|nfPmuRfPi@a7SnILN7=+m*u}}&&PLeI*3`m`RLaTD_7BIFt)^{JQUwX*!RIvoWqs4yOr@hL=k}zc)Cb+5r4ec8&0UYF_IAHTTR6HcNcP zTX?ohrCWTqOXb^7Yy?V$Lk4{ChX!QeTCg`v2FQ(PX_n;!Hx1nCbf%J1@yjYLs-o(m zf^Ei_+{%MVpgst=hPTAp`{??M%TuDIkHUmeF% z1U!QrWa1_}4KK<}KLb#uF{3~%wo%D2xl9)zj%gTsW#&z3jHEGnj25&SVdL3uT5Iz& zoP6yoOPt8hl4`Wn)aZ;PN?V+U58CTh3Vh1AZS$yxVT79SP;`fcbxIIOY0WZqP)kf1 zt608V&Nf@c0B{Dm)QpHHgNCRMIV}6zjj?Q(^I1jaoKU9^Ez=GHR#}imhA7m?!b;Z0 z8ckabG)r42#sDLXHB`pt72OpXSvjx0Wv^+wGX+WPP{=UAv&Xg}=)bhYSRzKiS%PD5a}N~2hT!3jl0B#hQ*{*x${;4Se#nQNYa~w z86k?rzCOwp4#;>RY@fEMuIKCitWTV0{(*>G8mqkawUpDNKQpCiq;qWQ6A?Jlj;+nO zE~S;6Yp0}U)1GWrN-)o6%yxO+iDw_{zHRr5z2<||{)|kHRtTum22D&AQYo#@484|Q z7@{41pmzdtcxC@=K^A||3fpHS&vNI~;XrYEEN;c!JXwN6@0;uJL)hWDCEn7p82r+$ z(V#D%(wGx1G!A&@%b>OK#FxskN5(55Cq+L~ZgZJ3(Kb%-7f9cp96R%$E)C%}q?;Pc zoPwKqZgl0fO`LaOqT1KZn~lwBDh^jnOCXNZ17_WAUTOot>hNxuF@Ip13U2SSYDIYA zC*PFk&xvrzfW&HxOGI2Z-%rLF?(ERa3v3P1Hk^5d0EV|5fQPo8F|RH`<`+`BE zlxE@appHUvK<|`lV?AHzaPl@F*)a0O1El9Gsv$?Il3`I6n^lNS*Tg;5jcZ~^Ti>iP zvO#TBBZ}{3WyrhvgzAI{jlKpm1e-CSLm!Qe4xJt!QT4qfp-F?5WjV0fgYk2&0M!zN z?S{gjgTG`iSqZFy-Su;~HFKEMOy-^oq+cK>4@5iZM<^J3$jx+!pW;4;l-)tGO6T@*#*lR~rhUPf zmLlv2+>w9pFh32W|8ex06*T{Ipy#nun6!SY!g@{zf@qiJL&h}qQ;$)vD(hmO zrqRF*rpYt1X17pEt<~4Nkh;#GgMIrHa-(nv&2GUIyZHSMY}!{t+So8x?8b1q!ak9OTqtp|O??EHk~ zjzVx;GE(r80QR^|2ZJv#0jD1#nYUUAZ`S~jFiOBM0718Vd`0-PN8FGLK3)Crh&vz0 z?dQKeYX1_8lKvjBh*{VgTK{p_b|w9uwuWr>&cvb>=RE}zVlymYu1m`bpb!dXvQACG zptNPUmS$2lu(+5uPfNe0V7vkOC0(Bt&x{HxOk7HeVr>QyNaqi1Qg1McLDh_=bdK#l1@0Hdhan7>MxB(N?`wB7%*98X!>c-FgM3fd-1b84`V znqo^okDN8`bk)pAuW2m9u`y1RcoSkSu+rT2ci!^m3N;WULavpamXBh^R^(vN#n zt7q66Lanfbee9xiI7P_+?Oq6B;s|DM^PB99{C9fvYw{HGYru`&Hv6mkS0zd}`&8>h zu{Dy*?tYLeZr%YcB;8@&WgrjH(=rtt{=WoLXldb2f*+dE6fO{uz~7q9-|HRK8ZY{| z^JwpSu7(EbaV99pkQszTpspzF(<-xJ;ZW$pU^4!Q(LS7-;AxCJ4Hpwbd9qDS467@a z1lUGr9VOLugK8*@)$`rfHddRL!}6~bzr3x_A17ctMlXQbza2I_Zg4qWa&0E zdVIzJ(h2noo(h1d$lD5Zd{TfU7!nuK@lkx|y&$aIX4QFyhIT09$t$gKGa!>i$)-R8+{7 zs<&*nml8B5O{mk&_eHXE9LIavHczQu53o&S1$Yx!Ck=V1vh|eWQf^tg?1fq2e3KEm z6RP1jgi6mCD~d*qA*L~n*m&0(j52ISF}m>|Mb2QG=#Xw$CBB>%D=Sw-ms>&K1bXXY za$2*)qK~L(4!XlKLu|R~GF_k-aDAR6q@>C3w|!r0qH0m;Z6|*j zMa@msR2oBhX>b@D$0SC%>`!>EQFFtN+CM;B+tR7jU$xmt5H3mT0n>QFN?(qW#vGRm zo~KDlwGPKv9mJ(D?={H7avOtxnkaO0BaV028_Fu^K7lyf4$pKMo>sOH(&0$G7jaB^ z?GKJi?f;f)Cu5OoZ>3#Vi%U;TA4}m(JK%O*S=+X1KXik4{I;tq;ig-j=@|eK zcJOVcH!in$ldmWp%Tv1NlCH!wdZ?XBzE6{Sqp8>(dQB~04M{geTAyjl{Q6pt?iixC zuy{@jT~nG>R-;{AU9bjw+^sHH*ExJ=b)%8c-zPH7{#t{(X^D75@hiJ zr0ssmfp22KCn;F2!P-m)z1{vA+`r^4Y9ABI=eq<>lBO-&PT1j=Bth@ zZ$+cXnw;DkH?jSokP@ieB#7fRB2};lmWQHbzZ6dfTIoXzEsgR1l6A}Md^>8W)k6ol zrpOLewg7k|k}f)-|3ZSr!_hRd3sV~VMZ9jnF@Dwf>R0~c8S-Dc5&FnQy56qVlRL(q z-a4KHwMtXQ6*IeHGkzNi5z50`c{t^tCYI^Iwohyo8Of&BnOaLZ>}&u*;W#GI8cI5`rT;ubb=j_O)?m}tl+}Ul zoxi>ij%J#Hdr# zszBj}E2p8nPH4LG;zYW$>If@82chzGX{hbkClr2i^qG^5wZ$tqBkkQahAEr@D*t;Z z8=cFdN~;N^2Opgu$mB0ix{-bwDHXewjoaI=CFz^I__`19pKIf)@AuHytM+YwpdMw{ z8t9o))zIxfGdCQC7qM*Xnzw4KE)yTM543Y_`Zd%LOOvmbets?5^@NKwo^m8OaFto! zuyctC6(@u76sQx-JRt3Q8la{}{ADZjM~$_260pg40_=ZM1~ z)YZy*WX<0qh}ytk#h)Zy_ia3iOHDzrTwsipZfI!;nm^>Bd{gc<41gQ5+46 zA)O6=?v9tSwxnsYf)pu5f(0*8{2U#zA+2D$N&c)SvahlrK%_qS$~xxH+s|qOH~R(W zIi)TZZH>talTA82zCNRm#|IAoCYVE#MI^U~T-pDq6ElE51p840q3*5#-N%D7qnWJY^FHbZ4NID7Q~fWYBAw zpEMMKXymEHuW>?^5XmYxxZ&J)9mpXTHEb9Aufb0664K}rF#cx`{z-*Z&tgzt)@vC& zgJ{=4Dy>F&u(7G-#dNOcf!#K^UU0vE&YcV?Hw#t9-3)DNMHp}G33?*D+=c9t9O=Xp z_et+)69;#VP9l5em!}Xigm!0S0GoUIRbdaYvF{}LQ>R&Eji)l|YNVv3j+i+R+aG2u zkwt?HqmqFz%jqV%lY5IPru4@zSha13xn0_tJ`|N5nVcy)caDwzWjDg)nP<^0X*=h8 zP-+Il@pFtiHE2YSquc_B+ucDY7Kb#a;7)U+>TDB%&af4%DwI}s4IEw&0QPAqeSS>T z$;(8(r>i6!`_(9g20@l!U>->0=sX%}vOZJz$U7c{-I;7A+a`OTt;~na#Nb*H^2#aDy zVb3&m%mGs^K{vdT%nLrLM|w9Ox2Rr7H^5eFrFVdXOBQtti@Xer4O6ZfdX2BdiakD8(cZ6S7 zPLCdbIBSsw1QMCz$1Cc|bpVTu6~^%7nTzSjCEn-*D${^=$)GgI6M6$_m4x~SYaz1q z#<+Ji)=0Gh5zxgj%7^gtBjocVG@hG){M>ktwd8gAbCdmS*-ZSw>q2Eg4`aec$KYDE z5PYXT-Sy~1U)P*1Zv?-`o0gQx%l%803?g^^jO#~VCH}2|J@LXyXOu;&@2$!7-FWha zT?G;2y|eBVhdo=DPc+8}(hLXT;!iJk?|%`HI>(kO#6Pl{;t!oq?r+1>e`PiQCdvMu z*#I1Wm;C-J%N8sAUMuk#Oa>q&BMb&&$nqWy4kbc#5<&$KWqe~eq6a9~uV&b!5*+?s zmYX0pGMW=P&(EIlx;+@@?cx3W={LErB$h8kE3MLmxb`DLp^Ki`r&v_zO5qfZ zlCHo1n39<)_lL}Fn+Bw<<6|7p23+;1$et}}U2x*8Ht-8|e0GC8m|{VZt9M#S8;T+E zBAT(WjvZ8vH|9}XcKDA533MaaVgC7S3^+{q;Wk(5WZ^CaHKeA>CWk(%LW_XH_#Z|! z8vt7UFw#_SI&r)%O;e?i1q?dOfG0XD=K5w=;l5-Zi}i0BhlS&ePrGxKx(vJFC`{vP zZ}4Rd#VGm4z628hk&BwQ2J4VW{nS(}OesqETTJ#X<-LDOv*C53AJQzlE3GS)avogL zv5nH6Vy7m2*rGrsZYS`c6VWT>IEP?xARrG!ARw8)MfMNPPsGm6_O~+XZwZFep9H{v z@cTz`OKnvhM-=xBTnI&oQdX!OwaG%Tm~b8avUvd;4f# z|C2lHWl$Z)tzjcEL0=v&j3Fc~sG@c8kAh!{ft(ELDMAW+I#z=Bv!vC(R*Fpl%Eh8pymO~nd`u9$pfpmn%?gNy|lP`mh5;MdH;lP0d7wxoP~k1_`;rZ?86 z^y!%-%AU-LSq26aSS#Xi>-BB6llIlbmSs_f>gPwx*6WZ2v$UV3R5m`qb!Ys96rz5(Ha4_zR*fg6}g%7cX zy?1!^49sRBW+f&OOe!V@G&YX)r2x35?YJF z$KRyoc2PVEi)bO0)p40sFQwX5DwdG9NwJ)Qi+78XO|SaWDxjz4~TjG`Y%Ns@H_N)S!(n&X$et+Gf8wy2#6PXVOMqiS-j2(Mu?pIl!! zkYp~T`WU^m?pB*)ipo;Pm*^e!VJ(Tr^#?Y)f(R^^RecvQJ{vas)nh zp$;9f)fB5V5cbd{5pGuwq`P(G??-vXaqmtPE>{ztl+@-j0csiLA)DeWMY$bL}XLcfh7AsaAEiDE&vn@|xfm0B#;Tvwk9xr%CF^f`y! z(Q|~wNZ3?YDTZt>3|BW{C36x|3ZJcpD=5PDHY9UelmYf6=(QAR?G78XxA04Z0V0AJ z;}^YS}n4y?4Z~Wjl8>v_iYY(Xl ztcrWsWI1$7G#=YUWc^sFmVFwn#_q@!$zQ`PDXa>qI7HB$AkxTtfOL3S5PsB(7!8}6M1==yQ~`a)U13Bk0`0DoZ74~ zEMbkTfAJ+S&`(o-)t+}TnYKx68##A*^QlqvV_Q0IaR3iJQnhC2VrVkrc*w_q^||4L zf1LjHX|gl>;5El1>)?g&*7m1T3D0EGg9$;wp$#j(y>&!vG;>og`2i%PGtUV}-lERkL!Vt|g-dJYN+%23 zLnpp-b3-smK`hQ5hn<(rEN@SR>xqsPqdXQnMILzzJ9m?DZ`ufyVqe{F#LjvgckOsy z-n*MEesuyl9LGQ0OuQxdn)n*lbw&|;yU~8D=a@uXYJ9&Jmx6M~dZ9zwrB|GI>JI-> zF^9IQs%oJwTil^ju-;AmDkI`Yl{yqjg?j&oC_jn!yUcphds9~G4z9=&u1V_X#kb9IWSU7Q{D zCdPnxvJ@UtOuaJv+1*7|IuOWwL?}HU5sJv)y1U=}n}VaAJ;2e~I5y@3!YC`5viVc5Lx^wLCR>*y`I$nO~teqZ=UI4iGr zfygZpvePF{y=rF*lD3%@+@9QSwE=!f*ysa7MR+Pds2V_Kc@U_Hv=$j-krSN3y zid&odm>VAv+T+9f^Cg@)50vr6q@d6HU<4U22Da$86T>m@27IWiDkqEh0F)aUtl=UH zrc0*-4kzyV;ptamJ;ycVptr6 zgok6r9Jt$zVF@yN4&#hO=E_Od+l#i)N4tDx$C@ym*gs62&s>IREIx>6?ZMdRKpwoO z?7a9$6S1{n$KNM&wx1Bhu;Bej&Y2i#3AJg5ze48L<3cww5DLT_r6WqKB-5tU8P!Qq zXtn^y8YS1`T7LKXv`wvX8=(GYS`mJv)|wx*7CvaH{4FhI3tO{~1}{fzQCn9FM>|`a zj|Q^e14+_9LKInmv$>tge?*mvzZLrtbAIo@p~mlYXH@*?)#&q2L{vl`5ZM7q0%%CJ z(>3ejPXr=t31fwl5n~ty@HNgpA7tA3e(u@e2g>_YN;D_LX{r#TbSQfh1qlnaU zvO_Y#lSzd$j$7@?a=t4^+R9nToZSAJX03=BoV*FiwMYm&)vv+sBf^}}Q#uC(=muny z_GK>&!7xOZ{G9X}8q#?qb@HZHiTL%YTyon%q`h}3BdGU$q=kGhMGD8tKp`rX)wn!R zbs7})=h3f1htEOWfp5(umbErCIE&vR)4)|WK~VfOsZbc(1`xLvM;Qov< zpph8S>bGJC?EjB){lC?gC2cL7mCY?|{#jo>RYp-qeP8cn4`MTLr~IrQ#11Om*lY=A zLj*PmZXGQ(t>q<2Z#ZtsabYWPb|-v#_l)8Evz*{%dg964rR4nZO*UI@a-9~jFF@6_ z)oXIuY4Z7XV%PTV?Qxj^NUmRzaU=~yH_Xmkt|vp%$JZ-V?486|sXC>!m8FJ@S<7&^Jo5IJ-_c|dv`--Z@ZjXW zX{Rzhod+}2PdyugCa>PlI&yy}(A%q8(U>vGIA` zd>PaRFPiqG%6=^}WtTb2{g}9dGvX6k;FHLpFRp@v2EDlbm+dPtqY^mbq&C4p=fSoFkEO2S0c!Z2xCpSQvZ=iqO1D=|5fhFPCfikS)ddkz zsH9st?sIPXbr_aD-FhiGao9))!~?P;STp@D;~$UUL!&TmBJl~SYipRW+l^;qId=>2 z@jp{uWZD(xSmdRxBHD$(EvwU#x1D zsmG*?(KCFD@^PTn1cMEkhXFKJFgLDqz|3AU+PUJg`j0j|8Ms!}loVRVuwE6N#783W z9Zu~XB0R(UB{Gu&?Jgl8Lwf#1R(A2vLp3M!-)9M&)ngx>B<{IFrh8=-7T2PEVSaCn9=^fV?q1$P~&}8qn-us5^&CPglOJlD- z|2(6H{NYieD>0Gt$a^-L!9Z}m?@Q(8I+FQikJAGD8rx@1pW>KVlF0J`5JEtbige@4dy1~3qSkm6Pw-?bu#ZeSKt`{fH4}xij=N;Sda=mSgL_~XoVy>BZg;VsQEfkT|$$B*}*tHI64gk7Qgx6(9)8msoU78t* z1dV*8`$E{^x{bT#=gBvLoI0Q!rd+eJ!*nT^>g%%_MRbDQaQ2Mg; z&6S*MXpG=Q)rFaU!Fu_J;vY3)a7dkUu=;M!RC$YE_Y70|n)k788%ONY7H`w_-8AP0 zg&d%sn;;`Yz6X8=E43&pOrrhqfLEV~MG>i(FoZj@;sJ5F!*@y7&t&H-jGAtk=BirJ zDLKQ&fL|zRl=kwM%JrBgNT29GG#=@{^~wL6#`9nMxvD?DSA9{x=#-T z>Sej#e3QHmCQAE;0V^#WayGFwLHnWaAY2tjby*RTBcmW6GOjD@>aHsjV)i|K$ zAsOiB;fjs4}O>On|ynH)*x$O0UP0Kbl^nlhVJZZYK$CoL=ysp|@&jmrxRZ z^*;*>_(l#q0Zn<`<c}EqN zyL;@TS04Mr?TY>_ElFGJj|lgF>5l&+<^?$Z;d=+wHkENyQQvHrz9OciY)V<7fvpOB zp(~q0mja_@Wdj9;7J6+WP5tW9fOBb^#{BcB5}~R4DR1IQ2~Xcy4D3v1_RNcM_UOBBsn7`(SxXR!?B5Nl#0TUVv^$u))ls&VKJGmPcwoyxztnj2~N%64E zB9391E~9euHUP}5)z`q2HN}4BCpSj(g?v%#c`8J{e785<_4y)YO7bcV7haHhy%0f3U7{VtwWu8l_u*9suOZZlL@49_aOwDT|a5p ziO51@f)1m(VrDA^UB62)$u2|^8ExWf4!&$@Lykz;3i>ta;j@?Kg(r%fqg93%K8CG2 zemv*`&W}AEN&5{1^%L7irZUC0!Pz^s{$MEpV^+@ON=`a?pX@AKxW`&E-sF|cuuTa;k%;7?$2qQpFDq?}$lr8H6;yqJ2$Xt_)aaekhC| ziBuY-?H}G>^TM6m4U@5#bye*gn({5;vr*V4`Cj7W=;5e|nJ%-vTSHP8#?rWDA{ro{ z&OCScrfb_nYH}3DMO>Webx_kyWmQ!6B`(=zy9f(BMq&OP0e=Au#+|ZrMd7 zTU?@?KjqMO1{g=>LG1pyYZF{y<9NbhNn;97tc-wRJf55;+La>dQ5G|HCFc4qs98D1 zaXer%ts3w>B55p(%_Asu-&W@q9YWOuT?qB!_5A`pzbo1A z?xo7gZ$^^e#i~znXEDLcYi>I9qKq%ug0JukX^+eRO7ZHZ`x4?^I4LoA_}M`FqL4T5 z%w8kP(?_R+WuJT(V2}ZI0G1&idT zKgH?b~6 z;2||`A-qEcQ-DsUVbwt7mWUuODrxzuB6T0fB>snk`>*oAzkJ$X#*6-A*yE4WGC7(LrB?tk zWb-~=q$p3FI-14>+B7Hx3;JF%B|IF)Z8)l@G@LRvE+8q+~7ExA;!i^r^qXL}Rl4sDNwAcK<=2g9mZ?)+R-o;uU&0VkRS zUSq%@Lg+(iATi&tHJz2v?I>*qr5pcPF_Sf9bgB#eyx5qUwj6E#?WA_B0Od9wAk|(M zY#xJe4p*3$4IjAn;V(5E(5v(XxsShN=pzUJdk^wk1MqLE$sc1@|I|+YLo)ft*o%*- z!6(H}Xl#1C_EQ62F;EcjqY}Pg7JwV`Vo(;9tk&414)h%SQOmLX#VHUqgujwLk@=`s zI>`_#4+LL_mWOT-O~fHlgbh~4GB=q$ZBsrVTLnv?tBC@0N`N_{TODjeb&+Kco4ww( zF(tCCp@Fw?O@$Epp_%l@5Mn+WIa_()Mk?yBQS?0zS#OYp%rr@!DHO4Vh;c+9PeMqI z4RI(_g`E2qbVZ4%%NHjGeV$%%zbKyGvne$@BTXWZq0e$m4r4GQ&A`(}VPZXOwVB8i za=6(rpv8K>lgbE&vE*TyfLJo%%;Cx)*jV6{^~JdEE><#KL5jz!+twCCsCY1U|M{O$c?;Z5pv-F8TF_n~^Hab4Jz0T|a`HW|*8; z8A{g&_Pj}}4~&_Rcz>X}+;UFBFo36@NmwH4!Q0)7XcjsNtw(K{#Q#djU*QOr-OC=4 zsCb2lXecM`pLWXc8Ue_(D$h9-H(eV&;D+qh)KRJPTgS+Ys7ZV_BilAGk)5z_)d?q( z>Jc=yn0mGbRlzU1eH@Ahc)`lktWIlRy|5X!?O6)FAB%06Jbmj4&%QYv50RI!N@uKi}e~5r>T$%lmp|nA*JV}Hk z1nb$XuFyi$*j2aegd(lNg{ADZ2W2%G%@mLM9WcuC*wmZIL=izyMC0x10OPT_JI?5_ z^F~E?-gCLY@erwlKq@t<|8IMY0)mK+kWG1d&bc5vqO8(vgt{cl!Y0dk#N4%QljV9z z{qnquKhaQ#0AG`fCqkCg{x16RpiiDEW>X{Nc4mzY2BQXZnQ6ge3BC2{rquUl#FGYZ zvUrBsBzRJEze$zyeyImvhSH!I&ws*iTx4r+vIGp?&zOXPFix;tM9lyS-%JzLeKIc$ zc^H}`rHxv<%3$6oT7G7g`Ucl33s4uX)BU}bdf|2ucK^JibP=&z2Zj#GF4GIu-Y1~jod<}MydwZo)W`5 zZ#!y|>-L?i9{5!}Hnf~7@#l9M>24|bc@@BISxyWDGfuI}3hgOsH_6=uOiO`F10R&YQ6=B^G^IM~;E|lzfsKQ3zBnzzh>Ve1IFgA}-hcEUE{vd&YXo8^0yq>PT-b^TVKP zaA_-&e*FToMe#%5E}zUE38{8x%Jsq3ecc#G?388zqZv5WBL@4D{7@GvU8C=&?h$+S zH2M;J#d`5+jQIVCGh%v>PiH+Wa|v&wW$B^d=`Z$S${szx|B-baeYEPz{_PR`w?*|o zE1%VBRv*eIrmq~NBqWUpC~9$n+DeE)_?(_K619l`5|AZrSmS)+_@|iVv!V3{jh|h9 zdAZ!Ld-7jd^t7@qUfO!fXOF$uN7?GQjnfSuvmQHB4?P&nZWs9{{UENWOmI=~j`{~l ze=?P;EC0L}#Z67P%aJ1vNhig;fr2G`V)w}HCTnlYd#<7$Mf{}6Xr z%vm$&kiDH`r*3oT&v#BYpX_XHJN`6Nk%YR52x}d(ZJr3;U$?{8J?Mnq!r{mgV+>_0 z&zR-Db>pe4QbPBGZ~NSB&gCkMsD!p|U&I+)- zG1m;sCpx^h!0cAM5!zQq-WNxS7&KE-#e@mAif+5HqxY@xDkLq$jTdFMdrV?Rz)a_p8G;f?&9grQG4x1)K*TxzZDtH2vOG!k6P=e>NO@eJGN@T@i$}#ait2OWL9vJD<^KH^^G{9*rpA{2N02 zDl}7RE?#EPB4fIaw4IA}moD4$*{6v$8kACMlzVT%pO|)Q%Iz*X4?9vURu!34yZVfF0dfC1c}7_F z1yeF4uH^D&wK20;H)x}4d72{3BsZUK^#N4z)%>08t8ZwIu6f}hFSkP8J@&-Z1R;V+ zs9`6! zQ4gek{dJIPeV}o99YmNua;#UB-^zp^r*OW;e-RF^LfLqE>5C2BMj1E(iBeqB`QAdr zB~CNm0utZDggERT!Rd{8#T^@aluaBQYw;K^&acMc{sfx~Q3`tr)=R=l#_H6_To(f^ zND01;*@V`=^Ou4AhWCpIzKL09Ro(?&b^>)P3r1_^0s1e6?d@ic zkp7@`NuRUY0Nr+%m&}_oZ$Dq234q|Y1(B;UYeW5|E7Bzl?2uC(2EP^gmy@Q}kWc0R zoJ=h1XPft)7MZqaN?~IxMEy>R%~UDoWSOKKU7Xnj4zyVY+7)dK095XjxjX+h!%;;;Sv2XP1 zf1s%d&pJMgI7U9bz(Pjk@;yWG=RtQ*LNhnzOdY4JNf6dupj+!^r1@$k3+bP`kmn|M z1DWBUMTK(RB(o?DX;(n6WzOYmz^$3__M?QFy(HDLKllR9%uGGGUU>Zn6USZsO;xd@ z)B8_LcuJKJbHGUT_r|vo8JglEzmdeknq9_QaNFFJ22=A&*bQ|m=Cs7+=SXHqKJi@A z3(H7>(C_8Q%|1)_2h0lzV7_9xgMeIRLGJ}8&FoEW9(V}71kZaXQKnRXi4@*Jf(P~b z$#yyRyH2!xB7eHV83eJSiacNFYlzoQB(J>ofIajN;Qr{*+k8s{Yk7*-f@MLU6WuxJm$@ z$zFeJTz!Z9>*4;()MTg+js6pxxzb=tA-SsEvfVcJDbW${1UXk^ot+GSu*BnMLD}|8 zD5D^_vh9^-*tcR19l{>pK4;>}F zQVg%AJ{1SyB84(fO;OHft*3SBzSZf_7Lsk?bea-8=(a~QYLB&5RKJiFj53^Oydjg^ znV+ao#hfK*9OnMU5<8q34h3UtF$ryWoO%C`vv-WHMC-OiW81cE+qO}uBo*7X%@y0W zRTbN|Z6_7f%Rb+E-#usFyYFf5{amfBAFH)7)|{jF(R-hhHbWYBsz*;&9tmW>dDUl) zWltVWP9oI}&>x5k{Nyfk-*uhyYq%Jw9z34dFP=-#o!^zObD0PVs5jq0hDZ_-4F~*$ z`JT#x_2Hh{ev?Mvr~M*$g8A88RucRZ^Lp1uppFD1 zn+N0_qyCUsr%CeVbk&kXoKgp($5wr)!OL#iC*cWL?)X zuBDmWwwT@d?Du1_HeCk44&Z{-ntZtN;X)7ngzLjG`8EG0mQ^s)J<+gT!hp(S?jICWt-;D5d1 ztGMZg-Rb3y|2+B!IPPMTWr6{2kL``hKn3hrmJ-Bn*%TyVdzR}JjXv&CSdZcl>6_D9 z-o2a>lekq{(f34<{`U-S!d=d@eGq}iTWkhL7rE5kgPMW;m} z+_%k(?eE(ozKCwkdk_kP=N3!)8O^W;G^Pg**}1QO+l7@a-uOv>;lTVa=>Gpf@BBAF z_}BdZ7iac&hNW1EU-2v6fIoGHtyoA`fTxbh9}G4JNfc9{Xs!UJ$o0ExlGOoCz3TdD zobe9iO(9aM&^U+)4T1Num)kY}_WIj6Es&n@a99iC8=NI;JraL<9wH>%S!=soL5>=U z;S3g4$PokbQh^ClHoR!IBky!bFW>&)_mbJ$Fvid;k5wk|LYerm2(iN#B6%lD3g|7; zTj;RaMr7^KS*T-f9k)CBHF8+v>`WwB5r|U1$!};PaIq5Yjx2)#I#RUd9}?7;!AUv^ z_xt%A%&D?8UzsqY3AI$xi_h`eH)q;C1?);78t@Ws3Kl>^g)t4HD`JaY~e??FHCxo|i z{7d|0;_m#P>n}A~yLlm`&m|XBOAz{EzO_DR=*I|kv|eKM;xQFvWi@p$@CZ~~uMCEj zEz54<5Z*tbu$b{&_7d+@1MZn3W#-8bfrz|_(^H)Hms6iFuaCI?!)>_VLGIP*)at2} zR@K@YbV0ULGwP@MKv_J>Uy(*rQfqEWySFzE(#MRkvCzd)U-K!oLsTcO6M(a<1C||bA>N@T zRr(2Krl39Fgfb;+07t9R`RZOMMAvB@r0fBwYT+TlZ3_E}Djx1tL( z>W{#0NRt8_?+s)v{QWVg4Z>>afayPWXl`Nh+ZKbza0DDXxAQ8#1nxCVqgEl+npN@* za2guROUECKNV$4)%@6fpCCnk%dPdd0D5I`BEZ}X?ILFk@v~6bvps~3QQouEaDG6XT z#x-#*Lk-c-?{PnsX{K0@krWy{e83PnH#|{Wv${TD|2ykbMo0wX`i1I~V1a<7|EY2Q z9Sik8qWb@pl~Ju>qlv4I0 zr;?J9ZUiI1y+lko;#lT_svdVR3d=J-YOj*&i@L}#{Kbv{e-B7#fn}G>fLO*3b!2=+ zUUs%sYeJu20O!QO8p>%8C9O2lTyr$QwCHETuMx2hbzt1n+J`SpadXK|A{3`!F#K^@ zV2_1mllKf5{1Q7UoF}daI>PI-z0`18b~%sG8m*&1-lZ9~^++x!bhxGf@;ag#jO>S- z!TQzw$M@RjB4f#8#`;h~;J=Mri9P|Gso^LKoz|!BX-x2J>tABCqvqnLP(|+}nOv0r_ARxejGQ$&e@2@ z-$Ff5WB9Ozv}(UXVW(Jh%sIyZ;IYnP)#s=HmA@Z;&H!LNaLV3u9kT|4NBWGy$a(Y5 zQGK77Q~b7$X+Z!_GP`cHXT+*#X$GHdk?95~SvC_;zek3&Kuy=!gFK5-1SC_NxVI#f zpZ;=6l>Sb7G9|m@IjXQ18_iGa0i}Lua0`;s=b=>gmd&*JG}ZE6uS%LU z2MIrbeP!>6d+(&N!UNyXaC0nCpFPl4w3*D*w-KG0z1KzMuA89o=qcZJ-d8&_ED;B= zxsxQf>GSDWGi+-+~_Pw?))*Q6!%X3*q%+MUdue6k58-Myz8Qwyl%d z4%cn!Og5Q&g=F*QMXi0tJ(Y=-T?hqjCUD2mz)3c`oiVm`%NquLx(>m`+< z=6Y31YTf8m;Bbgk8<2gZ<&a1I7Wod2UFBJt=}~IAS%U3jL>eW}=nYHg(M#L`+j2vU z-X3ii|Bc`c^1mN$mw23e`d<(`1{ny5{htoEf8B~ob|(MQ)&7;qBw=XmZ0G3lpQ}#I zQ_Tepv_IhS(ZmgK;hj`@aG9h_8oEkRR5If%JdxF|u&jvTKN6Wo^Hv70-g?%2wo~VQ z(<_dfN^{>NA0K+iCJ54Y@$Oo@{M>$CPyYO~`5X5a@H>SeoKx#&CPUlFxDOlRtZQNfGO-1 zNX^$#xeug?hb-?tj+kUrTn{FZg&H}EgaNh;U&UonfG&@l%~x4lt&duFv2VY^1kqIy zwhWtjPfn=6t)g*M%_ub8EEzk-HE>@-Zngwn_0Y<$aVSTV9vF0=nG`w4q=dkg$T(xn znU`-54moI*G{Z9#he!l}ckRLrm39_@mX{puQ4vO#L!d?)1D@|S(Ux? z`5KmTL|Z4#frs`Yp3sQs{l05lwlU9A0X|7i3m$3hRP?n-zV08yJn5 zecva8s+4Ph1j6xq5ym2?8WEW>!d-ia)?Izb%3Xg5*IjkUAv)4Ms`9BN+zkv&4m0p% z8*ocdGrQy%{G%%lQA{uOmRJDgwmw?%hI;vl6_{7knaV9OdKy0}7AMqZH5mkTB8PKN zLzKP;YDX5^VAl$G7iRsZzt1aPKPw)esUpsAu;qL>^<*j#jeGUva zrY@NC+VB8dxkQeP)Y=bU6(5!slh?6&lJ*bpWlN@cwJs({W@~CzjKnX=&#&@tRM06+2Ydxwhno^skdjgX*x(095 zrdnU*nZ;xu);949bC8N?ZQy)8lTuTLhP3XDvAYrJ2OJu=%)~bK1JRj_4UUxg=BnsG z(R`JK;wKqTA5Cq{ei-zqBXW3GS=9}SQd=bV3cN1W2N)mr zzi%*Ms7QBs4m)SJxAKxEEIWyNVqMAGtIY1>H1g;Vp#aW?N3L7dVR(P$ITA~t$wyUi zkdpcplQGJ2dQMl%g#rJDZ$^Dr4E$vPRwhDOO~R%ztF=D=Mj0$o#P~&Us zPx6j0Yj=I*w~*@XAfaxaI>mroZ7$prwJjiQFIN6RnB0;`1?i)-^qS|KEQD-diYU{K zD5EKz+{tv3PxVb~&0P$~Ht!Z9V-AW(IN!txxhfN>+dPlRtbZm2S`;_bKKvIhl|@Rw zJ(eV&!*X~=SYuR_m9#OxG+fJE*bjxL=i>TaN?09gP+<=>ab??lu6r!EnGy992Vzzl z=UrPkuO-4ksN1HzRpn5x3$39b&{#+R71WKip%Rg0{1J!jlK|Ow{fvDcN+mS^$@f1L zElLK_+XG89??E=P1>OR3UXoN^kWK?GJ75Yt>|96oTS0`~ zkskzt`;gXw(&s?c^uJsG{O!JS4|cfH`9g74Un|)EdByhcUF`p^a*(z)wfj5ru2z=) zD_GD+Rb*a>IwZwlJPyakQ78ywT97nlpp2xmYN3Q6s; z&v-i1!%jeP8ZizCq3*Kq)Hr*Gnx9F41A0=GUn70Ce4!>4%8FD1YEjB69UZ~K#~K+U z)(NnYO-+x|=X1=$VZjxjjv#47*T8kI`Yb?%{>xq`6jIn>h%X|R5(8F^EZcOsP z)YXGOng+feoTOb9Ka<%D106QsfYj&rq)dS%lZJN(s_qy&A9UZ`z_1c!;XMig^3QpD6#+(D83X^^d$h z*_Y?%|7`B5RvuRn`HI)2ar{ygQ!#9`F)4Gp8utYPPzc2a#QGqU$L;A)ZR!yPra}mJ zB(Wi(g29J^SHyXFN~P(Cp&zKztV9XC`+(6VZh-6GlW};XZihtl}GQv}J|B&7NUT7?Ue|ZOP2< zh#MGco{1SwSMc&DES)6Jr2ks|O@adlqmODG{j8!aeeB1oFCT)P)dg{B5=kGJT@;L4 z9fSD|N4`6&B}TqYFP>WfnTE(u$WqH4FW%PFTz+iF^Hdkv(W%(L>Pysp|ChtZWESjz z=RX`ifjB{>^23X|RrW51i_Kee(K^uCH>sac#?yKCKXr|iw&R(`{d+Ow5XYHTLc^=z z4oMA5esA3{vnj$r2UF3!5nC=*k z=H=Nd9*~|$$pKKpUy{VJmnc%w$b)m9?2TqqS?Tr9>(7h^5hvI-sV4-R&nE$ri2N1I z6)*XTYt5pDmp$QRg}5=*S4z>~iditPy(8sXQFVi5E2^OMdPYENInZmPKKV1CTTT+E z!sp~5%Ucv{42mcXL;?oS1=c`B%ay2&DG~ z{4eLUf}zRij>j^6X}Zf8Dd=zrOt#b4Wx@!UNe^_merRg7jh~LM!7S4(aM(< z)v%=YXGyVYor09x3!B-rIaL>6i>A(!B<`aHF(-MIleq#+FM3yD71p$4U8~|2^IXS5 zH$q(T@~UJsE!uO%d@Qz#g`;Jq@AYeF*AMh-4v?(@} zi9LE2`~%)Cx%Aun-^5ZUwY1TTUyare2?WIQPmT8P z)Be8`t^aDaV)bFTcq+l$CzzyznYuw(pgLqOnxzC(!Q9as;FKe3m)0_CW&CX zi7KhLArH1@Xwo!SVU&Fj3&afBI?PBN73AjzMB#~&@^ey>W)AewQQL~h^R+_+4f2f5 zQK!~|E>9Ci1UeYd(8Gomw4p{U$}rL?pV*Fx=Bll}xfrX5eiChzW1Z4oC7gGb;6ARt zcLSw|a)@bjzbbi(ua6$XfzGno+&5@7ule-Ls)f-T*^MRBr-~YT%|$jya}~&4z2!4N z@w&75(R-WGC*b!eVQXV(yU>A3tI^85hOUFmIMb{2TS_y@9eC?Iny4eU4R64Pczs`% zo1AJf%EW33#&04Dk;QVpAqmk<`<`Y|TEZ6Wm+_Wg9z3K!3Mp|PSl(_kcXaBZxqhY{ zRrzyCBmSrsq~CG9d_i&~hgD=>w)duD($Mymg1M>{z2fkEu>BBi-l~(i|Nt%JUaqV>ad+v!OWT-`qA>KXNn( zbH_Xu>EzqL-Sb_vHC?2ba8KSoDe+s3RoYx9>Z_d5nH;aEdt8r? zefS@c#AI1SX^X@F`N&Q2;mBdsrsW7Q!^FBwCUN(Ky0E&`y12SrCV4KQwEUoLimV}! zD+My&znMO?`+Yl!l#VzoUEVbVJAme6#J ziFMOd%N{2;ij<)5o_?G8lw!O#;S3#|4)^KiSqTzv|nAIQ+*_$(S>S#+)qjtbbxElhbaf)9TOr;|HWae-n*; zop!Ijb$i>fQKph_K~sYwbg^lrqWzjF6?AjW+#OLAB#Q?l1TyKkK5AqcBMM+xb*6rp zhP>)AnLzwb6s3Cs6@Y~=YqOpp#jSa1PM<^)k9XxJiV7*oGTST3j4X^reFRZUo)iq| zX9clPKA2wgo!BF_;J(*bGiD`wnbaW8^&Jx^!1vMz#G!0N7tYp)nmzocuX5TJL4 zOpgp@aj2KoN~ac>p3Olg^<8vRz5FS0J>Xz^f0@Qx<`+v8r+k`D2YpBjxIS2V$9GS5 zBeljeU8~S?<;tbGdX}>?4pEmVWw=7^S|tmXSSBkJ$_BAuLRO{-^0ocIjtkS`i7)pt zRyi+F9wZrKAW(Avtqh(j&PLlE6mR}aJ~<&3)#4}I`Z*BfFnbX7z}P7X#qgpL-2Epj zxlX{3%nX5%HX;sqw5FSyU{AV|te3amXU!TK3AFuLBMWgq(jj358= z#7-s?dL^cuf^UDH*^{$`RVwZ_-Gklk6Pmu+Pv!3}S0EQmr32@*v0)~kpw-Fz8v$|6 zp~LAsu6Wm+|DEY$FS<&_`sy;^uhZcl^~V2~F8eQi_a8^ZUjXVq8%(+W3pSy3EtkmS zel5n}{U?4^}8At`?_N_JxP&$tE0TJnre#OYyM3 zVW@b{?<&@t1)ogSM9RfDH}`#Bf6kv_i&z!NxEaf077&sO1=+t6W+HWLWy{_Z+0KWI z;R(Mpb8`vB{4C@dNNqK?z9V~wV^hcxR@_)XV&UL#55q8irxwcOwI36v|=Fw0g3$62=njL`Tu69_+Ng!OVzKOC0`5>Oe3mmG#!AJ z1uU?1Wpg$7x=1hw76=G<MPMM%oif|E~Moh?r?ex#ZLxIDs^*e%c0y9PM6)#BUc>`KgG7n+(7v z++-p5rUt8#Nb>@={KHv?p_48-C6?$+iD;(bVq#I74Jk*Pz|0EoX9%CCEEzZ%1BFGEz8_FS&Uf4u4&x|n4$k^w z((>pX_z@;7+`1%iI-vr2mV0U%tnQZNIU0zuUAormmI`Zx$)2UDb7?(FWaYNibD;@K zVq$4uOs>2rCb)D9iE_>G+*hWNvf;7ZW&#Ls>ZB9`xOV8!-Z!Q!^Ywv0sJ8DU>=t*{ z8buO=?OAmfOM5~C8m$^8%vN$M3iYMZ#l{?pQ;4@!no}}k#*PApD>>@M>rI8(;X{wk zKPEWT`8Vm+RZ2P_qJ_M9rn!Evd>^gb1Wp#HD3N+xV-rYfEN0O$g=g)*j8PTsYjDp1 zI;RE~Cj#vPDqd?IS*^f`s7#T+kFj#;NYm#ZHvYaVHn0*yuioF42jTuD^zwD8;bGB#huY+ zb-OYoeB9}@qI^oH5^7Nj@tEoKz|x_Ystw>zu!Jl&I^J;p72E-1ce3yxF0=twu7Y21 zeIVuMJ4+~p0}OmqGxtPqg5kz1_l&{eAA#n12$I1Y^IgJ$ckWXHXaI< zoUi87n}$hHa6Sg4s3M$#<}LObgFECM%WyvpgSt=e=(ZwVQ+kqS?Lr?#W!M;U_nXGZ zw?hh?Lqx2-B&NJ2Pxca}|H|(Gx4-bYwcqzQlC1=^>vu|-(?5oMAUfg(t>otUVN;H! zie^kPttvmW);1S@TO`MNd0G{=66j2p!3U@I_66utweMD0mHx3|gVYN|yhdF&2|lGi z(J2JgUsxJ3j;tbAfiYPC)#-0l);WKJHrYj3P5uLMi1EH#o=H_MxdWmc{L|pDjNEz0 zxbJ76gtv%$E)QP}L&`9zmo3>_m(jV!B7jI>M!B< ztd}0D@S-(isszm3Fm@ph$C^+k84ygG8oi*sH<+Heb2hCre*iCp0S3^byHMC^zL*+* zX{Gj7A;A%sq0DCozNWGhrn+kLB7UoKWAvJVT~$E`gRi{wYY7pw%Sj1K?Th5*yw@`^XAPCB{#}7@C6j>N_vd{Uz)c~0k2I8(6vX2?g&X7a4+wWY%5(x(<3 zFG7Ou$|ca>-JFd{tDDdc&?vrdrdyAH{I1`&-g>U#74dj(i2PYsl8I8jyD?V@mZKeF zrPNV|8(ka$x`k<;z-PvD--5XOgHU>gyn3dhAj$dA2Krwhu0KtI&dI!^S_M_SSAO#j z@Djl9h(O2P#tyUM+ug<5LDmU`^LU53@h2qoQSNqjJ$nJ`(e1uv-yN&{; zYUo@>t#_{JcxgCSZ`L(b+DN~>!l9?vs?6*<5dF@~hE{40 zIEC4#?t1wSY>jLfnkwZAa1%S*dqI&T`mzArMtVz zp^S}^H?t)fEY-6BhIY(TPd)WSHlZt7t6SeiBs4fDumgWfGH^XL#Y|BP*0s4*7I<>g zoJtCHQRYQoO!3#^P!_hLC%5v{qKIfA3T-(H)hJ2crsPr0)oOSObXJ>qqT>T+#*y9V zL3VZv3H%y%?U#E@6unUp+sY6)@dWK|xKEAlT>o+2rlPfUg@*~Zb7((KE>t3pChEcfQzw&7 zsQW?SKDEWKlw>tD`uH>v-`4U04o1z;V1xL&?EH-6ZIrm4&Pz}EAK8*v#YzTM+Mw^!3C!{s_idh1eV-Uf5KqPO z1cPR9ClVse_nj$~<;g5kPL(8$T`KK)dm`o2{8vqZeSM5G1K z5$mJ$EL~uc{doK35pb7t%jjpRz?k6h1;gmEB7PpPbcDfG`EF!cgfe?{?a9>~#VQM= z1=wIq@+9`2@T6$FK(MV;m&T-7>c?5evDtA@?qD)(Vnth~2b7;+b15xFVE5#@L_ifGU}(pEjT1 zz&z5GeRai&}OD3R%MM)J9D(T zZR05$7`@D}Twh9~nWF7CTE{T-A-Vv@SW+>Z3&dc}>{H0wkCDl`uCv)qw#-3K(e?*8 zj^#z`-cYYG6&WO1*_pRn+Ah4Q9+F#&_>Z#C8l$%3Gah2BjiJ8^U@z~1vM}@my4teV z$94uedPd>CooMsgi*HlNFi@@1cyDv-j^ba_@atj{Mlp@oJ!px`go5uo7$n$r)XjW2-7EQ&qe}REE3X*jmKl*dE_Lf*(sHL1o60aW16KDIm|e z0KR}Gg;wk^68hoW$oEqXeb&XF0sLF|Ig8_uLGMrTX=OS20iXOys%Ta_HI?i$jRciQ zNmrc{DJ|5(d&7##B{YFPztgAby@5V==#)mcpo-}NmW2o7V z7bpZ?XspBD1f9P|(<{3no*=ZjGY9OyRYF-ACOmn)7M0k`D3)y)uHrWO4X`H|vn(*> zD#TJxj7U=^Pg+(Y*~ggLPIyxvwR`?R<83QW)B=CjR%i1rQk1ow<*a-{g7u0Zx#C5s zB=&JW`F-?&)IWJ;vX(^W*QO@@q)JxXD&dKjGfQ!&Xh_h{$aU9VPpkuQ@5+4Qs?>TsHc$J99T5rcZU~kLW(;1GDB$V0@u}y*h#6m z#z08!jNbe=B{{oa((qnLP=G7Zy8Hw|3O+awEE9MuH)ErlNJBa6Ho-6xSee!0fjV@< z7WujbEh!FIzeY69AB+zund^Cn_E*W1`saJ5UQDA&9V6mC=*o7I?43BQE9?wsI$<3t z<|<+qJWDBn5)sbPeVW6Qy)DQ|IWe;mb9uGIb+G*Nz4%UQe z+JPzSarGS+c^wzm-zYM(9Z?aVM)RpL-q3mlT(IV?pH6cwT2bC?27Gzzx0zu&n?)N} zsh{gtIae-N!#{#&BC>pb3rt{1Xkit?H0SW{+LH7@qF;Q=`gP@mJZ&FthBVsAAI{24 zY=gQSgS5_@KNYpnjroM~DzFCoraX?&Hgb-4$3rr<1>1GVKlRPsE>0E$a0zY-OHDi#qSowmg-PoxF}z3xZ-(lLRz>+ zdGL@kW<(l_O6&jT2$mfxLu`(GY!8+#8|ceqb$ye9xLTm-e+@5%QsV`W?8WNCWd$7F z^rpNXQ7c&v6h32`;e<44CB4D&TYc6J=cDg|cW`>S4$(C3}P#_1Ml^o<6m4Y9lHp(H#0y>o}LW0@HT6ItL0q@ph1Wz2j#HMbwiDJ-ac zVW`TwPGKKeDN4T#uv&%=@(7_Q{h>FfE741bFFS|JPyVQz7#pg?ky6AN6Y9B!tVA0d zjdPI8YrQ}qa(LYAxTc_nH*jhtYQ}ce+ttl=pAU(r<}l#12=!{IC)tIPOI8YV>)Hs_ zq#1=xC$`C(eP9TncY{yOT(8QSpP}HR&HO>K{kx}}>QP>_`5M25e4#Bx=w=a2aoHC4 z^ImO#F3aYa6ray_3nV?TA8;b-Eli1Ql$I9wRqR6dZXwa>IR7K1DUtVFCw?``^sci8Tn9*6R zhI}nk&37o7qb?=Try?7tArCcu2@FHWUGW$gvCh>@Vgz%mA*A}DjPAtQPHa-0UGX|F zk~(pWp2YM#I7OXzU+zg^t6iz?Ef#u#ug~4_YcOI3PEK)Y4z=dRRv=e}+o>uqELV!V zz}_J`KWQY`NP!8)WKLKXqq#~F-K>T#$%~zfEr-lb+M{!Fi;vqM-o2!$Ve2h5r1x`B zk7IW^AKoti{B2SALllQ-=ZodU`C{7sXO`_BvC4l*Q}}vh%Wj?tEz}^chS0Fi*4P_< zDAYB=MMdsDqqdN-r34;GCGO=co~aKc>lG7U!)Qusp2$PH#4iVB088PMh3_K z(`$^9Pf1Twcw4)?@Z<7oW}sI}3;&=!KT)JJ4|TYFACx=?mc*X2FNgVxNzrza?g?AL zS45Rk-JZ{N?uVy^bs;0^q`oD1eX@WI74N^W$lH1% z=TbeedRn~sN~rgIWPD~4tbStg7Ju{%6fbVe(WfBb2PW>{+NRCv+MG`;WbT)nWP4XaZvDUD}mQPZU|)|S?|a`a8s z4q|HRm5KZe6TkPV)0l1@XklxkvR0vK&6p8nmk+5}%v(a~`ANS$^pVws%7<#CPa2s| zDO|YQ%LvMaQl?U9U}GJ{^FPA$v#SMoS0#L-bU}cRaxz6elx`p2$`#_C}^5}^u zw(w2gL*FQPhS6|3w&}n1HHOX#peBQEUk(s)!aD( z5ReoN5D@48AFTT?jJv1}?XI`z@;OcCSvWh-(emR5xa`&;_NuY$w_hoT;zJSxDKT{8 z&02l#4`ea?8OV+P@D`%5z%ox17D&mVb6}|}Hu8Z(EM#DFDNPo#svRX3nN9Mo!6~-V zGR!khS6%5ItoJ{(X-=QTw>htK+)|zXG;TTN_B<^$PJ^z9fPRD90m!KB#~s`b-@TxE zyqEKR$`SZo4RYRK5_Anm+3hj1zXO{5s&{q25xlp+ea1iEjy-%qGV`S(h=E(*}v(O*_9HyNRR_dDC& zS`mM4b_9z*7(KkVg9zPkM2Y{b2QBlz5F&2f>?A_k$!zO3%&y}E43gd%p>hX1!W^QE z(W`|hWhfEk(}di?sFNo%#98|8pvPEN)P-4gt4TiMymqaGX;zp6(^vJ~FA&8^ATro< z(i<(P(Z*H&a7}uk$EeUQbF*-6mXO6-zH%nx>Ec9z6^Hh;qcbJ*EXe;cCuO-HVy@P2 znp=QaDpD9KQ4O{YpU*4eMXKDt_A|LoNd5{oMi&AqV>CjE7f%{%SB=l%w^AQgM3#}l zn<7)?cQ!O!cmf4-lKNSj;F3>gI&^GK2-4A!+p>CEjHptPaw)zPGPX+a(!hLgvpPon zm{50u+A6qXAf%Kl#Npwf(e?TK;Dj8gv4)7Y1ehb{JMU>|RV0yfxOu07v5VvcITJI+ zx}7cjILR2LXv&jedLGg$O*+YFF}Zr!q51L%XPUNicNPFti0T`hh6j}ioNh~5H!E^R z8dK<7%=&y6Hf#C#RkDJ3LGM?VmP`>J9(GKK$|)G=sy54pdV?7k4zp4Dci-AV@%L62 z*3QTpDZ0cn3cf`R+Zb&CSLT{E8oOq5vgP+lqTWSRLepETXGtRo1JC!i1S}*%q`1g1 z(b--l5|V4vQd)KlLw(mZ+EO=fzU;(^*XpQaJ)-Toa@S__JEl%@jibm1 zXd51=(Q)y}r8vQ88O&ms`d=}eXGv-?w6P}QtgB`)J+Hp#QD4wHSv}+Dn`b;;Mqs-k zn2uUbt?VX2ilCMRJ-4i;yZNqr>>YXbiFlRPuUkW;wjV|wPa#@2pKR?V1=%!q9K3VP znG|O6BF9cNDQ@k5BCf+7DArEeh~DpuiUzj_FH|?KmNR+y`k#r_ZHkxH%yKMKbl zCq)L=1otJVqHI)lp^lZ-Lof#mUc&JuQCQs){avrik_?&fSabk_ zw{y(Ag>$O+d@^b@S~E2WcG!5=nM4^4YvN}`9P2i)D1(GFzJpHwK7X6MBvwBUT=WUn zU|KAc!U+28tNo*bgdEmZK?qM>!IOyy(3;KMM6qd-kgFEne zg>x#YGDccrsPiM&3#+DYrSJ>+`}Z$_v6#2$_&=kk>(boy3Kj5ki(}q@B?XJK9w<(A zbKGsw|K1wFp?h7c*DsxH5-+t1E-vg=zY|rkWp}056?hgl;+=1whL_XS{Yht?+ELne zv%~OP8eehOiDzohqOaLWF}p-*kE--lSl4AE=DA^fhQk5d)J`e&1wJlz%pB}`AJPUB zu|u-db}fHiVQo-{I@nH;566VOuJp_uLea8Gx0GO`KgTW!n0>8q-la*i)W^AdYIp;l zryDo!yeSvqWI+;AyfMtVBjL9Tj~p#moWW^;$Vo=2#02Ay>gK?=e%jgrhzowA{K*i-{kA+O4@t3dh(=={iM8 zHCv3FU@PmFRsBF4n!3eQ154^dn!Skg0%?h#mZlHni`g<~Dm?5h@Y-f*J&;R)7cN;% zWEs=xMS!<*TUEwHQgcb0S*TG{Yms1SvhZpGsGrFt@KJ#$5RN+IX%BV=GTK)Fmt6 z;tAb1Xp@;3(7-H^z?1#xYQVjs7g2quc1t;;_nCNekg1yMK$F?Z^-G`mQN>$(46-q) zd2m`;6kMzJGV6@Y%VR-m&{*4?)^ya#6o^y1FrTP2aH@@ z0%0K!6}AppekB;gdPv4vIMGZm_b?W1&cC2x4vL(G3yoZb3!U7t4UPO{GZN(;y)DRM zQ_myuu#Abk1GTixW+Z~%Pa|@iAcw5L^(K?<`6V~N7$@i6(xXoed!`!5to0_%zfpH% z&_|E$R`mr;UcmNfpU$LVxo^ORg}A)Y8lzJN^Ldqlpc(MXhO~Dl8s#1B*}>2Zw4fk) zw7P|;4TDWs3)8ANO41s`4Edey?3T4{S?q>rA2rAh?uDjw*9TY~a)9P?eugsr{`FYN zr%L~U))K`6yxiIynEm)(L95VxVAsU$+km&p^%C87SHI1G&)9C)&HjfRxBbsK1pPh| zcy*XX&=T_`ii#;96D3|Vr7xdPCpXPjlthacu$mcx8YS(H8MYdEP={gwjeBb}|9~2S zY2mL4np;q~=b)GP@&PZoHe4{(9q9n9n?-7uB|@Y+m=ARG8{nm>Agz&jnD3kiy|&-O z`@0TB^d@oeIM`3XMt?2}M#rt>IULTspk;u2umv{xV6Y`cA0cmD&SK9-AIwIh6~0ml zm=?4zi=kTQ42duoc8)}I(*-tvuxJSkfAdaJJ>iB;`A#4kU;mD0ccRh5Zu&@{8wvq# zPO)v7hD%jx=acYpBzvJdZ4h7=19)8;mi4aeeW+Gs+ECm(wyDxiXf!QsI4S@w{th5x zHNP=wIU=lU?hz;|XzJW-&S}$AnMfpus-%3*EQ@=dLsQ(#zUk zlfI4Tu8jw4nUN_nlteE^1_#@VP7tH$!ffiAya!@m*hgV%rfKBw>vVZ5W{FyU8#C{!C#mhWqk z-Xpn=EMv|`s!~K|iVFg}KsDYIs;x%(VRu=fbgDh=7(i$$7N|C1Duv-s>y>*a_+itf z50Di5e(H-wfgY03DFcRa;a*WRcH}iybyp%^bo5>ISmQ8uR|V;GLw9|+QT2gD*T?a^ zs_F^i0Q-7vAGHvTx%$|OS#kEZ083^u7Y?Jg8&s|!1Lffd)vR7LM;#*)zdi0Mz9U^1 z;L2y%r&J}vn`VRiIxHtv)F&=8_n< z$EBBy)*z9uv}ddy5?u%lvxpJrR7~r*b(G;A*OGI254&Hb$f|ucqnE?BgJoq(-VK7cZ8g2O2F?|eOnX?8 z%baw0km95X9QFicMQ(kyVRJ=Tmri{_;hiTq4ttvils~FeKCfDa zYwB>?aK0Y)Bq2hLYWM^x>czvGI1~H?sui7&W6J0p$Lkeu zZ8*B-nm4Ed@APN*w>}Ncq;nE4e91MQ{H;lSTZEMgif2t_hoj4DHrln;-0AQ_tIU-b z$k-f@x5MU;tmR&mUI#|DVV@iBtvJ)+53MVAph`SMqwIa+2Oa@`(pW^2gBPSBJi;OA zVaYp9C_=Lxvz1bPttp)}kX$WqF>Ii zlLvvp#QjTR!y@lSe<&^C#i&HZZFU5pY#XM+lSlN0TQ|D=pTC*qLo;*T^u82k zyI&~_|L72w%es!kn)l6(y{SOlF&{MVmkWk^iRqc8^B83g)_ySr%E6+j2aM6oodCV zWKw+6%g4l|ut{9!BK(ZPo57Gt|;5T3k2)t8^i(OkX&7db(L`4_>w z?VZkWStH|G57Gi-bx&k+LT`B@U$RJhnTkRCRebQr;)x;^OsH1AckLh85W76@1c$7< zO#C%PBxhH|OkhNK*>q8~2e{To4FD^c`}j4Jikufn0%ufA*9z3HV_W8XAJK8ar6o)F z+vEvW*Xl_1xVp@6PQw=lXrI*>nKPK9Z?og|dQe(*-FnqSW67Q+a z_!3M;j7}(WV6hLl*upJx4{5z-6dNVAm>n$COK(UBE52Ja=1G`IP9$m<=>J$z{lZom zof3NgH)5mSD;8Ms_fh@%ZOZ%4)`tHBg!R7>$<<&_gkrrBI_Zk_>*; z&@Tm17$~v?fQrnudP&laB~ICGqQ{>-+Pj?NTlBs5Pd9&8(-`+Xi@SPVPazTgC@utC z`c81pc=nv=e7(IK=>zo+9$@UZuLVIgD&oW%;vi#@v2I4q&9OVBM-^Z$IHgA-Pw0BG zmF;cgU5rS`F`CLQvC2Af@cN;;|Gt+e!=H%5z z= zd`Eo_a-a##8p{Z)@1E4?xb#kRkean07?1P`?kP65XKF!K=1PUFTm3zAYe1fQCDngS zYWHqpyNEQ=v}8&hN}-N*lJXl7(ddAzqmVd56-mYpl_}{Vn&{-I>{^kg!_-@}!oE8p zAc*rwJ692{Da;ySm-hO$k>E@it-*1oo_63`B|DC}+buogR#w?c03lP!aM%n(=6XP< z!lrq2%ZL>*GqHjZOszQXxZGUcJJt{t0|}+YRk*T@Y0t^c)YM6^_rLK(V1z>9Elnv8pBNC&x;e zSyP*K&t@+axqp#CIBt(uonN|RbmD?5QWn+=2igj}ZbKyti@wQ*Qrbnt#mrt#5Yies zc?~MCU2WxEA?8;pY5yRi5K&w-G*BD?qGN>V@qP!zm0b6ffg{BwqX4nRw$22L-h2P( z6o658uW+6XviFbADjO$ZopA#__YTAK2yC>hv)KykByH4S)>$nUW>K40Ay$N8qjLH7 zQQe1!xet&&69f90=pzxw4X?Kf$fT$>4~pGR+!uM+D;`4OH(XbcWZm>tIWZfxm!{mQ zN6G)fr-q5&|MYy+(0mCsq+KILY%f0FQp_##YAiI2FkHABzgNb`eBzkCMH+BZWNL=X2^6gFTR`UvUpHvfcEsW>YJSD=oR zf=AT!`8gT04m@?XgXpCe99<4b4w|b1`60vY<;Y{eCRvW+EyDEjDMT>yzAsCU;P>nJ zPCa5W#|KU}h;8Z2BkYkQ8f2RC_L@pSc7*s<H|B0JfiGFkGL`F6xm`=AJNWBD+!l;1}J#eA%n*!RDf>ft-Ok?589VQvM_NR zQdVmOHEhPBMv^^8>8l_Nan+x6R!IGMp)D%44BN+}MJ`4UxhN?e@5sxF>&H5+lByEv zI(H^G7k5$I0u%qz* z2|sproh)|E#VMBx=qqpMME-c=Vwqy&*L!Skgcr2Lhc2@AiNd~)VS zW9()=aVhhu{a$?cUqJh9O)KIE!~-(#o9PVanGA3D{|Ybu;2AMP{h?N=F;s*QCtS^# z{F0*f98l2QvtSOvwWh#CBPKOLoCa6yNel)__(TycI*%^)_Jjg+Suu{;TF4>&rftdM zPfivz5}CMuudXCbT#e%v-Up0FJe$~`=x>Npv5X(oO4hNwyj}uwtE`dXthgXA{&=`Vk3AH3vmPUlhroY zeevrCGt^@Ku66+#(B$uAZ1G2vO+!5L3)Da5_n&%-u;%?_%%it0c?0}2LpW%Z3D8x6 zP@}8t04h76AHH1elA|?2T@o;vuPQbz21sYj$9xKAeHJwdcUy(Wc-QiCU`M2#7a`jP z=UyE_;2I-jqC5D@jr5({&_V1HFHSvzxVI|FL|rn{}0f&ukt`A zwvaYd@;sQ7v`S#eDl`%j4uXh6kWe7n>Dn4@P}MKo?rn)bsN#cx@Vi9_O^`Jz2@)uK z!6Sam567N1e_!9OxC1`gHAkRoDXOWeDXWpubZ+7oZr8gAKW;N_cbBj1&cVjOpV>GU ziE|#;8dv(?h%!LP^(<`H-=2sk5(i&_U5d z*!>q}oB?bkIsN%CooNrz18e4FC+>jFv&)D^)~X^kvu87fh{ReL*KgQewcP+@luAwuT?E{7lvsxDD03|4MM}N z3m<+)ae;&w7d@x@-c0QgMx{qt!FK1T@Gy(i|m8$uT)$E=%2eWT){;Y z3Zeg%=?MOMzLuCTrHzQm=(yazw$D3xxxc*r^n7`?2YTL90;0vJ5kf`!@s9mqoMj^q z`pwuur60?XL{&!h@9OJvdTx$N11=w?rqX*lkO8U-1XT#OfXYWKiZcZ2&edSy ztTRjxg8YSn+B|%e>5Q0)9}{!vl9Pa2Q_Vwi22V|KbBd$B z8=Xm6n@?7Y=|hs1alD+)qN0G$o+N{Bo=UdUBbb-I6d`yuVd*8sg&l(l)>g>XWGjcP zIP!vNhZ(z*P+aRMEMk-)BPS7}DCfK>ald#v{(FO0#))yu@h^%CA5y6r{Vzsi!xWKg zcaHhejAhRd?Nm!s+V6aSWDBvP+2DMbC1Sy-W|*?|&)W1<9ID1dV_S8ULGI-UlXzvL zjNJ;zXw#;*maB_=M0@ARd?U9Y=(2U?;;|5eu{Xoir*qAm?4z+aL}d@PDO}}P4B6qFsQ&+m{dm)rSH975ikYs0!{8YDhpo@vJ#dpb7_iUp^H`e2Aedp z0da{D>L?JkP=zb4lh6XO;}jax;gOK;HPVAQqVzyvLET@s(6myp z;tgVZB(+NBSwab!YO;sA$&zm0A6yY^_j_hcK&+tfRs~T6HS~0ekkZ_Wg!IcIUjOEZUVV%NMyUFKC1J;1(`HwFKTGB|Gerjn{HtaGm)BPyImO1B4H{ zK^l5NcP^g}&{DwDNFHvGl|~!w1yGEx{=hU)vShMcRU|mkUpol_7gd${keFf*-spWE?#w zlnO(8`3@JB?-IR<jprRr~O2hysCrn3xqPl1Dlms)|j&7>A_#W@s*w#p^TWNP$p;u~51sK(=N7d*q zEw`#&ZC7qp>8e!np7f?^G9e2fz4dmyWOsd;cbsIS<9UDff&`a01<7f>B?JWo+koL8F4;ZL+EA*GD#Sgu1o8Y91MR6_W09e6(}QlD z{_@)O*6o5r`IYaAL*c34g2eHTY5VKM(ESO?>cTuzmibK1B5C3`K0n#ynYyG;_X^80 z&+v`S(r3EWcYLr0_X7|Y7w&M~a{m~q6rtcL76sMu(_JaNGGs+tFoOG|_q&(N?DS`p zKK#&!m@r~sV@R(md+UX51FP{}d_k3AAZH-$IolGt+7sdq6#&AzvRB98`MI2ntrWH; zRG2D<++i~vYqK)eqDRq|qgnWOPD2en9_$%$bJcrL2p+s>bD#nZ3&!%g%T`2{4y-t}B5;!BfA>ldf%KP!K zANz-LTj%MZZC!+M=y-mkPMw>GYRla=;+LvLhsut$nO6y%b%8Y)N`Qh12qjTrNSa; zS)_|$GuM4aH8}(6L1Duk5HGIsc6ye=symTnxQ9dC#l)(5HNTtX2Rpo`ZTAeztz&|| zQ8Qh>v8bzp*VE2Tghsl&C#N3E9A(*Xl- z73Bl4s%bnzYmQs-!p;)i)ZPl@;|H?HTISicrDb~Pu)=)CR_Ceu->WFY9F2822Yj0P z4mn69lBu{4gjLw3)_-G~FD{vp=JJQ7NBP8k2Z(yr4IJ%2)1;~!TFaM>Pq|cGs@&Wx z09HhkanFaFv{yx14i}(UM-;llZd$6=rq+GEwDNlz_zZ=_y|W;z>GEXK`e|ZEwMSNN zelE@T5(imp_dEk@F)Q)j z+R=4ZBcOFp#p0l?J3JBnoeWv0PmX8k{)DapHT^JCCmvK84eaZ@W&g7k=-+-T-z{>+ zNKV;xOQ%CS%f;Islc=Y1c1SQ<)^|D3cWaOCwx@-@9sJ_-fFIbQ3?dVl6zj5a6%3R73ACZP=v@$A6gHwd6V zrMF!~QqNos#2VRhlrprNM&6s-yG@AEhu^5?e$+}fR=GJRako(v)*Hac`=l%VN~zNr z(=SUgjTsL`Q8g2X4pX?`?0q+4z%29pi|*fI6b@8D*}CY%13y!`nPx2H)ZY*a9Ph9@KkxzvMgM zh;DKZ7kDI5Z2wxz^)@I&G)HQ(7)-(Aq?06BkW7v#S|pkn-g}1Nx~A(a0!mZxrqWrY zEB5AAhyqh7KzzELjYvDrbVNg&n>0#vg(T!ld8QdMTUWH)4~Y`|B1Tpegh@cbnk%XA z5tO!tTjZDpOP0h8uQ0`QU(gL*^maBiDVB|C$Ple*P0FWiXM=Rd%YXnG5AkNJu;;93 z1$EU31hpXDJ(2Jz%TO=g^(@g0Encl>lWeerCK&>2F%CIp;-2iwd@9w#7DH^LIV{SJ zqa>MielB%D9qYHfw@d5z-MJA)>&c!bzwM)$I~5d-Ep4wIX}pSRGZFAYkZp3GxUomj z>ta8ipQ3bMRpHAXeGvC|$o|7GSZmn%JH-X4ODAbXw*%i9UqqFCqmDB2eCrV1 z8$RDm82KWBbbsQdfURbJ&FKc$VP9@?NDs1bn}`1BTsA^N-F@D8jZRlLiC~Cu(lj*H zP@Iotq-?IeX;#7`T+kVR%OzlT(?7<-E%D?epHr}qGhq&e^-5e94GYo{iY0DV794V_ zNV)J#vfwNuEk#5TBM(qQ+N!>WCFkAb|Dyq$xV z2P9l~4CiB@JJHh_hgw>Yx_H7f7W7Zc0mTNT(dvDK3LPQ*u++2KHihO!DGJN9ar3s2 z6ya=bC-SDuZl=xzD9(K3xXpKP+V$o4G2B-;FE+CLMG4&` z&eLN-Fn0viiVid9+6d0DOwP8^Y-O2gab2Y7g*a2hP}c}fhbSkNNT|g~DVFFC4p|k$ zj`A@5#X@zQxTk#(i$XeK1_08e5m}i zbG!ELMS9tNmN1{rp}d4arsJ9B*QP{{thXbyoy5VYClXC+PFF1m_`v))sK&w2bW%E@ zj@1w?N62GnR6RzC0hj~^EUrO`FrXh^YwXe!*=dTWQ$e2y;}yfyl$8D8CHju{2VOVA zi~i}Uz9L0IHwPr=w67tiBNrB#c^6D^KCV&WcL~+G-i+b_AtZ&_k)|TqfWbA9Y7-++ z$t1KR6fQI(sW@t|G>Lo_8{wAKSWhGH$VO!8AybavVfHejK_(xhyh6Psa|m?Y?|UAt z){BxdG#1!mqaMEMl_+8QZJ*1FA}-&0|4Id3mH{;yxD z&(qgZTH;Pf1gF_cmy?@spVvLkH#uwW+r9^~KraVrlADnwcp!b(Ag%e?#eGsZ;40LK z8e*z|s7ywd?DIGMTW|HL+F`~*vdQ67|0N6A;1m%oH{e!jVcysUNe+jk)gKkbJh0zk zqOcO$bU+%o#ATJ$tM&QK1y*mtUUitggYRwsbLM)s2o%ZkU+jRgD5x>hTS39)Ql-o#6Vy58_ z2f=PG=}^I5SF?2%)c`}z)?gHIkj{8XxyW*R;B(dh;?=U51nOpD{1;eWJ_D_!o?g!J zlLPce(H?@-wvry=(GsS1*k{2dB!96>lD29O32q^->fF3B$j_JnW3;+A$9b|bhbnju zYB}#PVk+ar;WVBKqQh9zjS9y#K2}*w+Tyo@Uw55) z_JfzVs*U06bMSFi9@zxcClfS%6_ISDEY<;G}%jQ z`T)}nD(~2$$+GrbZAXy0pmP)2h-!U`)Q zbRO25wuwq*+>DVvQ%wC}o?286-c;$;nQ0f|OP{+1p!kL0Q(xy5GXxvEn6%#8PCCAJ zN_C?6Mdc}O$8NNesOZ6Oo<2YAk8$|r4$$8w-=7d3MF^9uGVQOxwX@)&|$^StbY+f`YtgK z6MyiF9D61IbKKFyf3VJ4Fi-txRFWc;ED$?NfgqI+ql<1|bElf{@{7Z6G-bFZ@!5dG z`-yR74)2q9I4sOuwO5xQ2rbjFX03_{1hzTj(3Gm>0!xp89^KY^sfw8g-BrGwVzrpk zPPH5h9y}4($hax=y!x8pOC#LZB7D?&fd*4)7V?V-pvzv24Y*oK1^7M^I*@lV#&kKb zd(}g~5I~3ZoJarUJim#13_mRp9`r9G4jjHIdC{}Fc^DB}A8wtc$l+c50C|E#MlNDY z>4Hg>F1lbHqeU90dgq;sRaeZeoz7JeSeU=e9Ut_FFK~qcMZMnOcMwq^9D8*Jz%0C5F>~U=J>kjQ zkJ49sqV}T4 z7p{KdUY`y)qAK|H(VyOU17o5#5cFsW~-n-XKQ0 z`OWD&4&avv1&*A)bw|_hM$^gdOS6poMzY`)yM?IP6}-qBlH(1yGoVQ;2ud6GvJ0Bh z{yJEMQ~r>($^$%b$UB+)urpRKJf!^nw^kwlzt|SAovDl9V)rBx!v}{Cj+51Q-Q%A|JwNS5kXT!U}fxwhuZ_pvNxoE5+a? zSu-LF5~y2A!^z}b_Fc@O{Z5|`XnpV%5zi)_5wN?D&HJj+=nYlTCZ2Gu)&+yduX1|K zL=Zcf@!~;4Eq8PCi0j`h$s4knc~I8h`i@)yRS` znSv#__^66`<9pumBtN!9&U%~q#t$#!aKgY;9qovN7-V$TH!D`?;*u2Zjku+3K>DB9$x2GJax>-zUl z?NT?(Olqfn;Y(71L>KKBsDA%85niMgJZkzj!+C#8LW%#l()>qtnW}@0y`hPcsiUi@ zvx|_uiKn=!i;Jm~^S`RXDGg~GY*CD_VLfl$5!p-@NZWNGf|6CoL|b7BLdZZ8(wct9 zjdt0MjBhFQ0W8n*P2oP1-=YV$*TD5#t(NPM|>M<{6~xwZqC)D1_p zlXb?}heFM}y`Y#h)9!t7ay`^3YbL$40;X5y)Qr8j5xBHmgYff0S7%&=P;}` z=dh$ii|2P&q!|-W#~}TQ$1hbH)XaY!FP- zM(JR^JEi%mR;G9iwU!$3w^z<^y|N|)Op|wypjd{v#5wePrK#wLrK2bvo$R?3Q4F)N zFP(iquc7vYLq22=PX9-r=a||f1}1ZZk8=E1dkq;KZ6zi-xG9Wsg;M9_xtHf~HOPZ# zL6w+PBm!weyDHh!;=?ezPZ12h{jW);lM3UdqTx%Oc#9n_4_Qm!dT z)>g5WNTDSUSW~yh7qU}9=?_yGrLUuhp7pXB+XQfJd@y^v6e;Zriv)h2DkBQw{`wn1 zBADoYuy}29uNp3)=aH%G6bBC`7}ghlcM&+ZwlHP6G^1wm$mw}Ia0q{02qlvos2$4yCqcQuj{3adAc`G}2qfnd>1b)W>q zxqyJpfG~ARaa-;ynH6|^;Mvj=T-e`V-Y^0}s~wQ`rfm6Z&eExtmLr#q^I4- zry%W$O(A8y?I8)`B%N{5XcuYln15-=t(+Aq>OH@iDw{GpZp_D^EV)e)h3)wdq~ufE zSGrsj*TfXG!3EBa`@X1LiY5Qnnp5`eS7=@i-p_2UH8cKGd8K15nP9>J&)eTA_DEXJ zXX7`V&oaN9y}&(V$I!0yiHcD9NrM5SHnRjld%)nEd0BXahW@0YL!feE3D5hI#(NVQ zr&TGF>6vaO*Dp(Ka5L*#Uy$XH(+Brb7B3|{GZMQ?yyzxe_)ONqe%fW0gyJ9jBNOsa zbypEaX(treBby}TT~z6&u-E+*Sz^!b26j~ccUvSI`ZS!cipr%sny)09&k@Dt1T-p2 z)SMuXAb}v3cLluSU%Gx6RD*3o4Em?=foMRR*`|20p5@YGs}i82=7(@wnLcaMrq%HID!j(h^usvTZB9@QROH*4|VQ* zb8w4r@DiiyScW7|nw{anFx0~_a#H0W&xAT@`UT)rHU!EkPp3xti}NNxvFeMQb3&Tn z#a^%ch<9FBRE45Q2;16Jz3z?iJ)k+ z8Fc6_Uj0wzeB_8lv{!Dfd5^9CzljusC#se|-%cpYZ;`_NKYbYf?>2-r-^~AS?-Op? zEU6`dZJ-eS<^oE5R2~AnAZmQ2Qen9$?0Hwyg_vBAo2fV8sLDfx=k|vW%Kjx8$PZdk zD(bZ&%$aP?1I(Kh`@BAcIp+29S=vtAxtxe=F_$<++GVNC+4+GF-2^EyX?T3sa3c~A zwB%#&5kXC2mn6lGGBB}_$^NsuNV%C2HrmO6mmp=c*-fF{dq1-vsiVOA%DN+IV;cm| z5c9#V2HEclQ^8L6ieq6!d{684bgnzN$CYV3Y4mO2t9^-67!#N1lN}A3@2D5`gWSL50mN1em4BuCV_K)v66eOxJk928 zIt4KJc`h=L^gyQukdCl)3z-gah(YO z&;Rt<{kH{E-oeGv-p-js!o|hmzn}bjmrKhxt^B7TLeA1dtgwo};D8V`ljKT6A72y)4kAW^LWPdeIdy3-dS-llJKH~Yv0{14y=M&+ za<#JDj3URq90qrryDIZaa^OsZxZ2t}Vn%?eiA)qAlLxAip^ax5JihNpuDxSYbj)MQ zyvPm-R;{l9x5|-V6u`6Sj|_v-C`Nc_KRgmiyCI5UZxS&>$8MDCGBqnxE$r&%u}^^$ z%?NiUGUFOppEPJ&Fmm~h#zEBb4wl4Ob}370D2U*u+-V}Zz6_YWXpZj+CK5&S#Iq1V z=N>3vel0i`F);O93k5F`shbL^U zv>(B=8a&4gt6*_V;8KtFf$*kLszR4as*LsEA7F6hP3gNJM-TEs+HmXv(uvHcRSPh@>eNnyt$)-{gI0)PMYZK0*ENg0qQt=bRU3z7+9p zF6{=`)=-+orzPEwr*n2br*d{SF~2+7S9X3F!1O}*ALNJTLq8Jm4E2gZ$Y{X+E}^@u zZs1P?zU9L9B!&>z_&X(6|MxBZsfHki@nXZZDo?WxWX}R<+YtC>89a#41HQI#?j@K3 zF93e^H2i5U7f1)XAHfGDATIb;5&~@33nFZ90mx^#KXy~6fFpwvCGA+*+4+wOW6D(V zy-zN%U0ATKrRp4PAx5+anwb`f)+jCHkV-E{(hQ_1A^VW?t;H67&eZMCkK+5c!uZUghW_DIq2Bl` zTDd#tZiXS~GnfNR1?%BrlT#cXCrRQKEZQ=Y$Ws(p-!*8H6cW=ymBgeTA9T! zD$~jcByG{SD@&}z>`AH4KtEm2ib4dyB7#M+<*NtvEo64%QG2n(FeDt85jZ;MZJDi} zrer~oCaq%4@6=(B3Zew`NV0}r<45chQWKzPvP!bbEt#cMi>Q+FrICph z6qRBpl-C(XxMVOLGpWi(Ys<<)HV{;Tii!}uWpouGmey2)kAt8jxeC=+6GK|;-p-NU zjK_(}wZq?7mZbDgy?7j$YW4LaEnQnZl=bpVzUG_b)LH8;a*@*45Tl&kHI0Y2$P;{j^jB6#F9Q|~F}4R}sp=fRK5@pOth>R&me$G`gvG_YOZ6~J1*3P(>ptu#XK zX!JZifvtyVDmaZ|>=YhyBE2`z{6-4;D&Dz|ach>gG1tg)%l4!4vE=*-+?EgWjWKVM zZNT9&K5R9^?km69BU(n6;cQYj$S_Fi>8dSKN|oH_l2u4#@?6nW#shyQGNaga^1vbV z#HR06yU~Syd9-sE)udIFQx#TN+E_cdhCX1C9`R_JEiq6iY;lyFi($z9elYYv)q@ts zv;g9R2f)7mgg2a^MGPz3J!8NL3&z3un7M}naH3s61QS)W4r`Hmz}{>hSBLLW;6VRQ zGkk@z3llVvi>qGo#~A*x;{2-rUoGwJ6;#L$mN71!#P-V?z9L@ zPIab;yB0NEK*3nA$OJncBVzW}i?dY0hzAQ;xrK#(yXrJOmO?MLSWL3bbD0>#)4=Mn zkitS$*m|WJn3(bXyK0B5$F3BO+{>&*4aujZ@+-}C@#+V>fqXi0gKRRYTTm;5BvKJ& zG5EtUv29n{0Z~*vblx8zZA0|IT>=LLb9qmUA-{p8ov=@Goll78q}ngJOa8O-8vs7k zrd84U+!su1+wP0zgxes1?buLwt94bO{Pm@M$1!^_I!Z@IpAlVCEgu5CUALk0|eN^i}-riPyn+fB8RqImzh%g$?wq@0bsJ-mXlgW zaV+C0xlP34Whfe#$eLQ@$ZQhM!fkV1_9e_w&TxW0dqbk9C4#3Tti^R)%(6~nJm=41 zA6H$x&Rx84xe(>KM&hSA<}(DiMmA9l+fR{0nvru3%NuzrK`=?zcUAl@z*g!1&%M96$@B8NZ%}HP71TT`#;LUj2dm zN8)~&t_i5?2=u@y%uy-#UZZmi@~r&kIWl-2x`L|zajuGPwd1v@2c6O^{L3c5>q@Y^ z#I2m0U7+WSK&1iqycbr%-X;di$eta%C7@hJ(zmNOe0#^>RmQ~Rk&ed=9`280SD=+X z89U*A*AbFFK8^6u_kVU9mH1p{KjV~CDjA&y(Z$Fz)RzfvW&UZt5Nr)PZ5-il4bZFF z&@&3p`@cmTIv6~(<^GX=`PN_x|C6x)Pa5q1GkW}Y5muwvFE{Yr@HMoqBmfG+<8k*} zkp6mT5SW~lij^YLr(Y>dYyNt9ix&UnA8ku9!jY#xjDH4*WGwDCx;{D{N(hWT>g1yUWJW1+)5 z2hI%$8A22IvwT%&9DsUvH3hSB(;pA@2uFgM$7(W2-NH&JXl2xGie|>7vhGR#ae}7R zPPqHF*$V7i{36q7VKA|IPL>BK!0$zok-nrQjfMFP9GFzNcdyc8x1kbFht{G@u4Y;# zFkD%>7_W0s3Yl0sFCqeOh`(?tgqg1x+IOrF*mtttIwGIxpS%ikATaOdOkxX65&mra z#L%%RI$|raLSi)hx93*)g~89Y0M1dU1fI=NFiMZO4}wAg&XRsmG1__ z>HH%9SN(jnE7f1{J*_MJrj>F2$9MOSX`OY(-y<-$txb|}@U!6rKELs~)?UhRYL`GOc z&#O|W)=Q~=Zal=+Gy6C0JtL<4C0~9mD}Y+guIQluT6m)<{HkiRS}EU9x|(*mG$*-O z$1+ph2To{TF(qqINS>#tUe*qEo>`ij=meJhT9NG^dDV<5izXnzZ=I$4m_`j2onRpI z4#30!^0aF7V!Qb&n&Au8)QF|tj*NL#DJ3rfgltE>0kclj4W+`FS^IZjmG;B-ZV&~S zdS2LgwdsU+q#g=}QEF8UqD5EJnzO5suSo`_ImGDM>H$Z_W?8s|#Trq!T8@{l$*;B9Sj#qWv;6hGdHo>#&{4f~}5ZP9godSj#YeQdd z>*`Y55ql1LqUS2I+)7hfb@ya#l%X!GnMasVKTg(ndl zV2rV8)L*Z5m3TW=-oQQPyhy&xT0NhV(r~4e()g%soa$S$UeMKF!_$)3pJ@{P&F62g z*F&ToylH#ou?S1wE#Y7;}8Nab_36FH>On*3PR(*w{a!ZUhF{@HIPU zt0gr<&0aUR$&0jKBWWQ$!r zzPR{mmzHc6EU)ZO_y{s* za?UD*4Z$CX_6M}Twaj%x(FhD9^xMS#3KbZ`>aeKZwiAvr9beH-R3LlNA%u=M#VWa= zIRvi@;`c}0hu#I1pBMYo;~gw~1#9xum6b+>X4`%AmIAK zdXvUR?be8Jdl4AJ))GE(tKQ-Hee8i$o8)2cRvu~Tyn;{HAlDPGu}PBYp{S$^3Rh6|YSE)4=W z%Wrfo*pacCc*%|5gR$x4jJF4u<}l?jPB`bpoV`|HM_s@Xn_oX&*7mb`(z=^(-%k3l zkrFi3o|XM1d~Y=Cw57%zS*IPjZ=))=q(Zcs3i#QQ)E&~DYW#f694=G0!(rlFR=OdJ z{T#5TxzD|+@`)I|Zc7J6gSgO28ge;qa^FjEIkwR&ifJyHleApO;p*%-(!{))QTjJe zHRO0n)_OeKB<;GVwN}$F?I`Y&7CJX;9OsGZvgQuZB$7Ui`%wD>Fukzs7MV(mUST#t zz2NMaXJ0HnM&a_*prqbc`bYo&q3j*lGmW-v?Nn@=729^jwyjFVwkoOEZ*1GPZQHh; zH>@vx_SJoL@BVi8Ie+1K)|zY1wZ^zd)T1#)tqpE92l^^U#_qzENXTTvcGD5aq!m|{ zAW68e9QPl8+NT48?XeUv^(m6_bcE@Vl!r%-kY)I7M*?Hck#q@VaU<5n^ky64bmtu8 z+-V4PT1nD2|wu0c3+wyxgKG5!bs zbm)8yeqUFlm@@sGP~%r@`agDLLd6j1DUb2w)5@;f3VPOZQ#o_%PxJOGn7uVaHPWAC zrE8asKs80`L|Fu}CFGzG6EK42&I%PfPY`6E9Y81fZ4%b~e-0cZCYM3$_RHBd zLdagc;f8Q)xL#Avk_EfJu%TxiryH14)=warJwEDeXzfQGG=CiDHO~aeyK##5kVmX$ zoZc0#J8ts$RejFIW+ulLOHbiOKn%4;hlrx+x{b24Mw zBz%jc*yO9;?9+584Nta+^$tZ$;Cx%CFu~(-ZphV>plqr~JGa*pJoXaj@Rm&;xC!Fw zD%qC-)M|u+8q%)!M?EyjNc|z5nD`XRs@O(yeQgenK+^56rPSkViZws06$|mlsI5vm!oq{&*1J)_D34;4j zgEe?`&$N}A(`%NOp@CLtys-#0=v*{SjsEwM>qmSzAWN6#b3r3=XSx4r!uob8F zQ-c`71^14KyC3_8;D~t;)~`%t>%IZQ{LA%Ytzp%5QxMN{_h3Qj6!vO&JJJj=%!U0) zvk{}|H#}&MVW+~5R20*6vP1{>-@^^*hiRsI5=AXV$(6KU)UXsy2$cPFAx_R)m$;#L z}{qzt1uoZB&N9=`>TmLXCD$1E} zQPa;X*2AzH8%acjarw4ny%gk8 zZpbh*1An7NP{L7EQ&Jet9)yIMn^3bPObf-GlO%gO=Z83**k)d=@C99{OBMP7EmSWB zgUI7qX2bUg3uCOW{BufLvOyeBMVI7FO8tiiCM#5tjoyW}w3&m>q~;c=QifQV=`>b^ z7M_~q^W}Rn6Yotk@*mMOlT@wrIfD+mel`^8PavR`$d{QRD~L}Eqe)7!<75i=A6V#i z3GR5qR$tq=W8+@))&s4T;?LOBsZxG)YeMKYi^k9T*~!v@n?%VbQJ9!bb*C&$<$bQa zU=@(nDx%WI6tLsSSk7zW^mdsX6Y&R&(t1>u{WwS8Qk0z_Uc=)OQOPoO@yL>T0^J7| zM}}q3-U&(w{uZkK8z=CJ;d5^lxy#u?)IAsgB#_^Ew*L6^GrN`G3lZEEdrvL)-Rq+`o<;7m=B^ayU+DtpeKK&yFSJ8T(m+VXqOn?S3ZgF0*n zdutAKLk7!9j%$=eDj@^@Vo7|0U6S9roRFX3&K=j3+P7TrVT!1s6W$4m&|@Z*3)Qh7 zT0-};q|z{v%ztBJPiexa3ti>@6%-#pOZq5(%E7_ri~+1D`CM3yl{ZFcH#WFf zSk*Q*7|R5!(hU|iHF}l1ZtFC@b+s%!WxQ=obWC(e38Qu&y=`?K+aA9kZ#Yf!yLIt> ztdUZJ&|xrO;ocfDOW(jSAUfSjF$fF}is<6+?ipbTL`|2h?DZ+Z(?~k{$o9rWKnjir z07_P>c3Q#-USB7>Z2-ZF#Dt^2$*SxUEb@zb>x*EB%F@+Tjx zvm3CY-y;ivlvidIL8G%`*^kK5Y}QA(qTizn)hVy+D$`E4pjb#W?n=FO;JQ|*y^3xo zOczKn=5o6=gf`GGCd~XrJI$cva=Tff8Fl1W*NYhM@`g)8f83c+qiw>^nECOWqd)a~ zI(xg9x3S?*mp%odWs|LSK0cDZeG}t&DCt?aGE_wxAe{vpXr^q*=3>7lR_}@t+&EuH z1wi(9(t^`)Q1;y#etFWc;ar0r;QDtZHyC%JRmULSd_J9vtJzUtUn~eK=@1J*peMda z6|X+Ew5XpYS=cwXb$>z$p9`7iyj=jLp+8)*PN~&ATy+71QLFRxUyM`|;!UC=m}0kc z{!dY=E`|k=hW_~$R*^{ zBL0*$eE9Rquulg5w#4V`PHNPfkfxV>A=~uKXm^7ce6!Zh_oB~F(G1EXDB&kwrxpp@ zJBd*S2Y#Lj_HnBtJWI;G-k52wAD_rxhe?KZD?|#SFj2#<%05+{>a)U?8UW6pe4Y%I z1e?Xv6TIVlV_Ql_1+H-p=t~on2Av~6`CvY|d<>YjnmKr}8`ikY2xCpwoANq875(9h zgCBj?;T>Ti3VROeKflfMaxAV~t_BvAp~NF(T6u*~5nUBSK`M7yLQw$hoBJ0_QH2;Ny(0?fAn4k3Vl5G=9-G~U&qp(U}||2SqlM8zNw>VeQY{}jVM>- zoC+%`E}W$s7P`Wm3$n@wS)rKnnS9?xgswQ%{KR%G}^x(<`y?zv)0T3cmsUmto7(_PxC`tPQ4v=WaVw?+M(ROZf(Bpa5o zWP2lD4l3hoahdHOL`gpqh>kSA+{OAPOv0bLU#=#w;{#)O(Y`;TY&;VaWJe9^u%`4p zW}?gp-`;|SlAT6N zOH_mg#IGan<^$4~L)}40AQBG8`AfZWzZI~W!fzcM*0S7Ud;S`W5Y4}X7&1zp;BzTv0+xzsZy6FH!isI<4=?*hP&5IR-ddVA4Ii)45?+`ZeP=l zphz6Pa%%2O32|L;(soU%u6_7-nqeho2$b;o3`>NFO|*q|aL{?%es)uyU^0oZ3}a||p9x}C^av;9pnTaXDH)Jk613&Znw2h( zzG8zC#zxZWQZu*-IL@h-W7!LNRi}l&QIe^iEqEqaCZ1_eGeZO1kRh_xgwQ>w2mr5X4U(oBmpC&KOc0jP$235!fnXlk(4xQNVh5%uYW z7$?`PM}&y{{R-d-QjI5J$p+gnq{ADXB*R^3;?S-3641}{43TCN!%M0D;v_W6xz(4R zkyzGpEjpn?h)@Z{srOUAX-KD}F%Jjg#5ui|0&HDrQUTKkDx%)7^{Ey0Ow=r?(DIPh zn7nmZ%_|IB7Ue>*QIN?;i#xDq=QW4>4ZHKqdE``XwMydL8H1wDYQb{^>4TOW{=d@) z3qwhb7`lQsqBeh~E??sISy1LS-c&6i8jT6))}*d#S5W8wG#X|~Jj9Up zAdj2YZ>d3Itu+{{G+t}* z6Kb45_HC^>{*Tp6;0xpQgRVms22 z9dU^q_X;)g+$@}{xWa^_W5>=X7nD?Q!!vCe25n(LXo)s#id|uuAeL!LO`;35N6F*d zg~St$M$bD%Rno#m$*&{;%L{>?MTrC2>x*7mh+g)ibf(5&huX5C&{yI2!Eepw8R?|; z^}Ab1^xk88JnW-KXV>g#WenA)+~|r6M-)_F*1e|b5K9;;zIa!@FZ|K+xx_JkrVDeo zh3{&j9bVo_JG441s_u;XzHRPiZ}tnZik0zK=?wIccNWJp1WyZN^!?5j*Ih3^yP>*C zm*|B)1!)J%Db(|&MKS!WXBS6jWd2>3Hw;=RfTN8F+dGBZ`oON+@U2* zSn2AUnhKP2(#A}9k~cQCsm&E(_-bG-tZ5$4^|woDq8WzsZy4{qL9IUC&9$Ivgu(k< z7e4UhP`gj=3VCE<^GL!Dd>|6LyA9TyW?06==tA5Pnt`jTW*3TyNd`e~dwN9#8C0sj zDll2D6$4Yv&~FqdiuB}DsGOI!Y4713vpH}yPi6A%zH^M^h#R1q;fwO?4AWjarM3E9 z9wauiG?uLzFDPI2!&{iY#<`1BG1OCI`D^++)}r4Ju+X7m88&K06XX$Y8i$E7@>eFy zdqT){qN8{C_gF5SsBio_yQ5-0Cif|14L_r$UHlN=Vr#EwT_o`-W1*ib=9#C#<(TKL zD1NQY=IutbAt>Pd66_nAespnw1^q3_Q7Z zXcS?(?Z}Iu?HQUo?r|Mm*-!HZ*QaSE7b~8*WM>X=Z{%3EbB3i^BtG{ax=bhAG!J8w zi*>HgXEur#2k>gm7cG>GxGP?0c*>wZOFpDBb)}psko}Fz=k{YIsM8Z6w{$a`#P3V?r}zl zmnHCCL0M7KSPE69R6A(^LX}>@7((q)s-nPB4b`r|(ghVuxsf6)m~81+gO2DdB8d=` zH6vSXHsbNO42G%!dtT>z3IqQ7d)4D`Jo`Z~hI zqOuZf`LI&+KK4?rVyqPJ;HC5B7U|}V{!8#4wg=H7QQmd`L!#0f>BA;bzk~x-Fw_n6 z*+)y{PkGeNZ3+0?&BLIOp3- z{q_BROWgi5i{-I^zwaIa1Z0UE1cdefeq#8~IKn~AuQ6fS<@1`(v;XAJz;_t9)$aiy z%%m1f*mwb&ro6GVFcQ{cTiD_Xb3NwbSvcRqGmGTTC@l6kY%#Hh<1%AIq(Es<^N46jW2UU}66koSRaW!LFm*X_?6PJf-QR;vWw_J#$&?RYkB z0>1Gzf>3-arzuF?H?U1h-dhL?1WdoyYy+lutKr`pAF?@bIDa#IR?>ZDB89+v_lB&) zd(Q$WyhnSIKY*}ZG-L+xN7scfP=dI(E`p#yPySCO@$7!V(T#eR=ZXn_tDS5gAeP|T zEdo&&^+$8TOB2%e?QT2Edlu66^DdOY`%DPY=s-8@H4z>#Ec8}Iun)+I^U)spDI)%t zI{$Cntnc`V@6U&BmRCWGtoS2pFu`&O#;oUk5`CtdJR;s3RepWtlHrhqxS_*-D6Yy4 z&<78WF%iqd#8w_09F{vA%RjmAu%DarwZN0fT2Znp!zW5q^)g06sp86p+%pW&X3=N~ z+vq`hxh76DoMw1a8oF6gk=W5Z2nZ2hP3oZFS6(3r$?3SCB(98*5;Vvi$9iAF*ms{GHuva}xQ8gsTQd7^Uaz@1pbS!B>4coyGNwQ*wh z=a-0P*|O1-cw;4z#YI!rfuMnDsd&DY2@hI!Z?S)t6P-hIwRCfx+2p}0e zC>3szXN%1yh~;(0GRw^22DquQ65*7_Vep@>SQUzfpGQrKfwwD{jzo%>a>-LV@?2;( zNKjUsFqZ~fFu~0Y8>>vYYq2wQzCBs2yVg&~C*ZVDFfRy;&?}!@Z#Eas4K-=FA#~O& z_iW_SHw8aYQpD%iGV4vQrfDy7D=QhO(~ROpQKG4rdWNq)Pkw96XqFSilKi`M;7nt= zinCYNYMmp&L0eJnoqRys{!o>`o*+x+j@NEx+b~2j?+|OOc9rE8x?it zNu+UrysIKI{)yL6u%nP3S_X;s=Fl@h9GTLB@CCI8b4zQ13qe>kFB_yWEFmwlRG#$4 zO$>oRv(uo5-DGe5t}s|qnp8%Mu0Ej>PDR)4Ol(x9-Y9G2ASTVBnqFF^s*&mr4oCw+ z3s~-Dx?`d2e-okSytQrgM<7(y4>bg+tm{ip$Pb|_VztGjY+*{>F zdC-QsW_Y&W9CEnQ8gnpNg-cL5bD<#Y^OEI@e5ST8qwnF~In<_HEm@?9OWA`cXLsy% zt5>o*OltKEsn`l?DCJq?QGrkkUCrIm_8E20FrG`3?I1$JEgM(e%xR@BMa_g?G%2gm zwkxw*fK;(jT~4z^BV<~1IrCJpQRfW3YD%#zKVx6ySj?Gm;1<$1x*w0(ei0m*T5D4O z1c(|fGiK(9m?|CleJ<35y*I0M8Ciq)sZG&fU; zsYINDQ1X@T(!7`P50@p-S}}Hh@t{g&ifqG+$y=wRx+>7;VwEhTlBQyf!~44JaL3_e z=N850T#dCSrC;ML9hK+v=2E$7nm_AaGL#WV!XCB<%z|(J+|>AEX5#BiuP9#3kGY_c5wVdNuYEm7SwCmWTE{lJ%xIG$Qhq zkF?@dQgPPjKoh?^J?2KE6#i8i8$@(KNO}=jlH&a})5-_)p`^WfOfV`(UrW&3;P9+b zsFhL_G*~IiVkB~&LOH}WHLq60m8u3)AE|)rV*O_4v6NBDFt+y?)5F;@TfTNcRIfBGdta zE9D3L3@KiFBzUb10K8rY0NyA8_`187;N~EBZ4X^N&k+pfdL!4DV0#&lN;vR}3suAe zlBfIh0(#lu_9M6Wj;J73@`To)fcP;_-(aR{wGC;#`w)p3Us}dfFBpvXTvDj0naZr6 z670GP&yIM@q<1PwdT%mN3%G{Ehjvxq^QtmNB{7gW;^8q(aEA$`erIwrJU0lS-%J|! zLI9z}YW3<%1jVMzviv+sWK_xGU=6u1@G-vukhi(rrYK^T^E(FPvJi87k*F{g7R z>gYu{dRZvBB`H!D+p#5tYMDNW+R9@$x_D?0JypeR|BguiL=b6nP1lDqwhxUm?87%v zZgV5Vp-X}cvfZAjmT7Un=d-oHmlwxG)V1}NFJy_{|ZUn&FZATX<51vn)vc93MR~+}X z|B!ih7YV=t;_`-IYH_jGhV5FFM+9eVREELBiMRPVG{9KW8Eq~#jG{?q7~-?eoIfaP zjq_#Pc$K;Wb27*o^82B3rS<1j{$!B!%((O1$5;GL6e3?g{+-3efEm+BD=09R4@m3} z;NC%K$r|pF|MOwXcLMS|H1aWNaB^#_iDO%eH&fpOXnz%vQ%&QI@^IIe+#DE}qd_(D zygy<}+#Ux6b@>ppe3xnPW4!;>?XT~h$UePX=J&+p@W~*Cm4UR&&mmukpYbgC=Sk#G z`LxlY-*+F}2$4T(TFxU-?E$%T>YN+`u)b6^;=WKzYvt(q_lCb6Gx<+rrDFFjbYl(R z)~vST5Qx3%rm`;fG%z5r(gkG~I|Me4_MY7lv zH2%0XDQeAT;`?Zje19Xj{mAge?mpf~CAx~xG|K5T;@uzf!tuGV^5T7#)NLg$ncToC zNX$+Zn}!I4@%6!6u33*MtTc77!AxJ#OCEf@;4pI#!PJ4B3E%?<;#{A4hzDSuz%kBE z==UuiY)f^9B*LX9;H9^!myp{UBEO3~MJuF`D4^>+u9e&6QK&yA#;#wPg6<56bVbY*_p!z11L(o(@Kt8r zuT+{d@w1%mCp?d-l-NBA1hmaF`n1adz&Kf;2rq083%8ta9%Qnw83sxb5}>Qpm~;uC zTh!;TmkblF=$Be}X7^$9wlVsCYhaNu9R1Khif--GMyf6v0`0hXzBflwSAqlVvaSEt z|AfM3?jS+kzx~k0h>sk5wwRRL18_Ue!ntzsMxW`7+`98k?Sy|%v*g0sEJc&4#(tp!E%fFlA_g@@e->f0Zn^88AxA=??IJr}!hK|IE{+0aQvF5PcHi!)N zTimDqi|3`${^0?EhEM$e`s!pZ>98RFrRDAT((=mvzs`{V?x*@Uqt3rcMgNWYu;ib+BJ+F`I7Mc$7|XyT(7`egs;@VbJ0fN?V6+ zG;k@%%9`6<3zvXz`%Ag^Ov=(FWGA{P4Dle@2>TYxRdBw%VWq8yKW5-c5rp14=Xy(E ze{NsFaJKhIgA0FK%_T8HA~X|Acwxx#ry1tqMFgtVa}C4}GHb9j{y`n4FcX`4mce*p zw^uIn{->yFh3HeqiZ1~#(-%RU=YRcS{}WKY^FPPV1VVQy1(7Tv)78>zW1vHb&4ME% zZ@=!5x5kjCZ??4Wn(}-=eSCXFYA|>=G}CV2nXff?%je;L{`KX=uarxb|8>2d@%9e| zFQ@PO%Mm9?wh5^})m78?z@ON|q>@J3{gJ_|(Da+}lNkvq$&h4$@?Ba41$O)35%*ap*7)E-IY^(exfM5>p!%0>>isKtQECaaX`)zLb~0g!(loSeDZZUBWAnplUWWG?R4kWqn*$wg^nTVzB zdwe}#ZDpi7h%;&>Y@RzfpY-uxNNNInc9u=}c2hkpm(vCkrZz{&YmdmmfBXeuBTHn# zU(eKPM?KSZ5l&>C?z{@M_{yK@9pbbLHPvS`&C4p=Vu{5#-N?8Jk1mvll5%;IF0N?A zwe*T_s*hu8nsh@u^S+Fc1L-v#o??Yxgy~W2gtwyB05dL^MLy+Iv2j~#niCsd#XwW` zF-$`*2&{;#ibjfAa=_ojW#Iv*YG-6q|BW4tCk18E3qt^tG0*JR60LAUE%Mf4<5eY* zQ4pBi$a>X_tll?r##B>gg06urjyERo_bg5zJ5EkM1SVYcZ7Z*^*EnS*M5Ui;sipAq zF=K5xzDSx#FOdMY;smGYn)OgAU1SRT%zR``hSM|3-$0K5sw{}4M#(UAk>e_TlQD$$ zLMNEiBMS{Jp>f0O2PbLN&zCrL^1uCsn)z{d@6&DKKZ_I*((=-3+5s z&Fvax$F6Brdbd@1vYT5Ib6FM);woZ^ z9yu7SF+~w>DcK2e7Ln05*p3ktBF#0;xIXlom^0qJzO=l@PUw+@(+^3pg|S-;^w1+b zVziVN98&clkFh}78sH8i^t)(1h-Zn72wGz&^q$Dtq6F!Vy;Pd|D+qgB$-_mA*vPPK z3HJ>CUz|V5rY$kr_=-%PQavH3KLq99(!cz7i&-)0P`=+|k^^RomZ7^uoX+Tl0aIQ6 z6hi4V*6)!Q*y5B^v^QI*KURm(fRd{#Qu-OWN+8UQ*<$9guRXhu`>lOdM3b> zp|k=E$y*V(;OoEa+pu~s3fq|4`WL%5;z78b72=faKH;8iZr%-AENap&uFmWLSGN$( zJy_v2(Wo_3}KYS&uGHG}C@JIt>DzL5MI@G}ijXpJjI@k$J?Ih&w!w`wwzd@}TH{ zKy2HbJ#AZCqNueyNl~Ptf-t+n7vdg32IERXc%(itxaA;q>VKZYPEPT*o`7eR{;V<`{2d&NqY9? zGN&Ie8>(_1#RBcNME`T9Y2P9kZ#0k78>$QR2E$9|ae`g*s|eaxAeP{30{IjS+Wz)J zTE0rZ2F`lz_!&~)Bk~P?#quS|YY($8Dg%HZJ(V`FbdlPDME7D>y*(~{fzv-`ZWKWH%Y|W$jM3G z$mYK{G)i&`pv>qQdt;z^ce(C2dw&A-FaD1+355w9^##JzBZj=4-nRXn>mS*Im$;!} zWE2C0Ys;MTsmZ6q$LqX)Ub;YYAQu`HRBWAVf$^OK!;HJS)g!w2LrUQZScy-{*OEgZ+X_SmzHgGg?29tl(Apn^>N0f(~%wmibx97neE zqaOD|;e4C7W)F!R7G?`n#U(8Bzr+sdt1!A<1#3af2oF3B#PviC9P)?gf68;EFj+RJ zv|81bq#esginjQeYkycZ!wok9A!Yl(Y|V^w*htP_hj@tS|9t8*TRXkKz)WUtYFFV= zcgF0W#(`4KycM57Tsx_aItUNRL6212s*3nzdEA_y7xl4Zoq&_p|ud?A)<`tpFHf%`~=I{T&`78=e*o2t#wQSvC!t$!x zmL8f>nelv0OVwheyCx7U34+|EBgqlk{QR)7DY3Rgp zF@H!>2T|A*5^@E?3D}z#s!NiQuqlg{9f4esTDxw{2D+*==&d8w~z&OD~Twi)?O)!CgjnfP6?(&b>5rHx{Brj%~(%n$C>_P&jBeXi}q@QG<1gK*`} z&t-fYlZ2hN9-%Ze=EKrEq%j_G-swg&DnOlbaC0SwYq_2z4}RK0^q{v)<=>MFIf}^| z-&9LRv{}+Esn@;ErJ;LkJZBTY>(Ef_d*M+Yjz+1btME`^DLYJ5(^^=S0v}~mq4>2I zY2Is?{L=;((T-oPN>38b**F@0WYx*_PcDxN`=CEY2&-rb*jYKC2h86)q)%`y6GGh6 z_IJU&Gw-6rK8EZb(^vAIQO~&RqRi0GRcl37okH|F?A^mUGi-8XnMIeRzzU@=|H-*H z02gLH^R*oQeiaJYe^uH4RiTiwwf?d${{Jw?{;?wdEtL(O8J&O7Wo)O+kEo^Qcds-X z^HVGoyf}w{y6gsw4$_ST&h^9|1>{obl!)Eb2T$>{eD`1A zD?$%s*2FHMHvTxiP4pYQlZaW!7(^vs|K7aWXc)ef5@cqC=v&PwGSSJO*j(puV(#P{ z7AYIz=mge0MEC?HdC2pQnh&%@$lD>VOv3UDJ%nw*sXS+M3Hx<2&ve4RyQHBPJa!tt zh+JFiLznU*`P{bDoGvYzXf@T?_qW!wR9(Ep%W{RnJEQeq#qBiUhu+5(ln(4|9Qk+~ zvQ$phbgyFs>V<57z;xPFFHc|_+=gG(o@PgP?dR^r2FGja4AOGoNboJHOWzxrza$Km zxA*`HO*A?9^Dq~%Twm@E?9mR@JrNgI3J)?HR{-{wHW8OP_flG@L#EMjAFsmfaw-pK z@Dh>nz00+3+8^xe5TkSDj^i{II^7+w$85NR6DH@+Us>?ej85NzqkI#FYWVaN2ABe9 zbGDta!#?bWvwCYjE;634K?-PIWbP(pLnM^r`{!l zojEhRFNpo3fMsK%@v`G-x$j7$E`!T78F3)EQh~tFsjO6fFW>DfelLpd_uGB|i2Uv* z6OV&dZz7YnJ$E3YEMzP!X;e9^KFppPgo@3`jy7Ii3Z|U8b9J*3Ba17aA%f{?m^Y~CAu3{MMr;)nWK`+0-ihMMYet4CIPN$gnAYp4QH~;I!nZc^Wr_bhprQ_!G`Rf)G^g*e%|^jQPrsK zr-KH4z(|6-?EySDV&qxTRhH4spjSQoCkzV%$Qgx#*C4m8!Tb?CZkU`l_vDCW6T@qw zP=YM9h3%HyPAaW^9}68|>0!uiwlZBkNZEfs8URTJfFV8E3xy;l%fzG!BujP zILfzj8F~k*QS8abc$wCg(Hp_6NoL1D2tE9od>v8&3U8JNS#4LL#qzUgng~q$&tS6>Mg3p1a%lPiVrV{&CU%wO7M4>iPFXe)R0Z_UYyOjs-s0(4rt~RC z(O#pD8_S!4X5#paK}CDNMt!3T=M<0v~sm0KdfSU;Uf1 z`M?kdhcHQ3qH&DrF;yrbj$k`Sf878Inz2!P@hf!6J7IHf#WsEW!8yH{p7jz3y?Ix< zR5Qf(=cZ(^WtvtF=~j+tP%*>71A0zcdtvXGq)NaaP`B#PV^Ob;Q}39g`ojg7v30io zQKN=3y4V>-ezsDyh0QaEvkH}J$m}I5xU~4AX5E(`8HH%pWAYNwhzaAxa?)--`ubyW zUy&&n*8OUAx3zdyEjA~IrJv*cL-!Ag*9A~~t7uS(U3v>vz26#?Whm3dv+`mcfRdn3 z6zV;wfEh;7Y)A~ zX|#S_%y;e|q&^tvU=6}KEh1F!4+LL%r+8q*lCkJ0%2f0*j~cNEY(huzBW*BfH{5+d z(955<-@C|=3}UBwxuV-qjq)x`5q7^v3z72~^|@u#G|i0Ju0`nAakpS{=DHZ$NCb1# zaD`#f(ETPq|MohC{G;fY&@AMDN==|p&n(_Hc|6j@7WA){Y zStpx<8sr+?2cF=>me(l7b}*A}fx80wePFr+&yukjy|8ueRNP3j(d41AJI9ohEZyp9 zczN9sWgGRWjiD2Un!mPlHqMj6m%_rAnDh%;=gFFL58Xu3Bj1C6k~8JI{4oMQIh3A@ zj^RZaIUyae1$z6Rid^UjdC^ycD(@b>%&Uu%#v7 zGUMl6f9qQlx?=^Wm5x0@3bcph&Ug&@{3p_sVyaX4=2yM9W&9uDbN^BE|3%yIkLF-d z6V5w++2t>h%pK)85hUEYVTS)Vkw{ZTSZwH&;$B1JdnQBwc!NtA2c#0WzEt&Q2vM0)ORX>vf(jpD&VZv?S}CuAZen$$a|0$8SHp zowgr$O?_lLO>;kQyk)xSd&Bftw#|nScBlu#b}(dLj~>6>y{Nprr+ROU@&_v6ETKj{?+@P_*I~X;F1cn8+T$;c%h6VUsnxH#4c9jyE z+_FQJexi<|*$T&od26D@IsB+I?~@*@Lua(kYW(fI*1Oc>!R6M}GcE8m`s^1L&p!?H z=w(7BVz~56C%^pd#?86rwh5zyNx(ZvaoP85Viie@$k;5&fNsH8h>ann!MII~IJj(V z+QKQNke9Fs>pakDW!MgV51;lMCo)5OCSH3(KY(OTXM95y{;`VAOf8H!ND@%XD3AvuN^x0P)DlS#vrZ>0pyt@LYL0E*yAM+<02yJ{sNKAYwx@sc_THm_&oBjyHX zRLEO!X}M@W%daQ;x$>~6leceiHBid6+8`YFs{zj8C~=4dVxtxx0q7(su3z7&oo20vFr~Uo&t&J#|s3RXZU=e+n%xN#2kJ#m@S2pxPX3^bbHK#i$Gw|2a zyks|ycA#X!T{)*Wb4RGIV>vB1=1t<}ffZ-GTNt>tx^3mNqh#R*b9nXc$YmK(lNP<8 zMVM_zwS!<;6mN$0$6G^EldZr(XDvFL+dz?^r7^BS^yIZ{?%`#QC(P*xPnhNXGzrS} z=CIzufHY#ztC2C0y(l;I^GlT)cT!{cdrkenOL@uJ_M(MfR!LNvd0ImCL^R$$+mNHB z9#!Lm0QsIT4V`;xafH-G<8jF1++GY)G`sxE0zK}b5asd6qK1;$m`U_+H!w{sMr&%7 z+|Y}_P1y;4gXX~faLhe;Q^}`+Y(c;F#rF^9Fheo_7_|L*r z7vm%1KEil`i+V1o@hF)gom_@`2Zhykeqq6-@{$_<)e13Z*m* zJu%w|g6%bK+XsT=b0$1>tvz@5fxKfb2aC;a1CNl1@rjrW^TJ^Bg#snNnb|g9n=X1= z`)DW2UtNBuVpg&U1fht-ul-OZnOc`KBjZMevccUKH;l@=;*HL_ ztD2VZl})vcJBwbsx?`1IM-D;-?6M7sDjv3=aWE#aBLfi7eqr=XQ^a#eX+A}^OuQd? z`}x$GZ=3UF9g^L_*G6!=;5eGdpKu9H@*wVqMhiTgGco0uAdB$yaTS?p3MfUIH>ehy zqA#3aW^O5rbBBx~Q1N8tVgx4TWh6L!ubP*(B%Vko3nQQC^gJt_r_q)xnUGmy)6So- zY)~Keh&*qJ)PTk-a_u_-g8ohv8?MK#oWB*bJVeUcr>8@u)L^Vlw`{bQw+{yVj)&727V8r#*q}xiYH}=rW*QwGWy#Z(c0lyi4lM=@OcU>vFar*6zF}=jFU6v&nPWU(a({ z494>%omP6k#)s56x zyhgQObMfq+ZbuB45eNkazD|g%&NPSKt5pq+WqU=^$yPjcngikD_MIfI5b44+LtS+NC53L-r zrH(0eJ!mLSoFk>JgAjd#ks%5SMAfR~zy3Fi|n#6>! z7xP1G5PVCzeVxeSK6vbR#J6f}BGl3%OgDM?&*plhlyd{y?W6TC(R0YB*@GqGOp3x@ z?;)fpM`&7pc0UvaL<7;c16*+^Ck^}cPovAEpB5?i|1cy)b_WFCg(D6#&!bwWp^)N4 zq|M+`z{n>pFRsbC3(FrWvWnl=9YRF4(&4+muE+&H4?o>@f;Q)X@`JDe$(g~{36`Z> z`Nj$j?%32E%Zj9@mhOh^?}i>6ie!*?U+v{HRoXJRIUSIW4eg108<$&;4(nP^`AVqm z5y|Byk9RD!JrS>pw4b@%(=7Rq71vaCJQ1~3DqRt`s&Cw};@6DWZYj4mB~uskmRV8B!%ucI{o4t5;E0fv86H?ShQg41gA``=_KgIpbSVfpCRx^1$s`n3sBw+XuQSoW0dP7>H z;#ngA1fmuU@iAb~@uL#0HY>4VN#kVRY7|NmVI7F5nN(D>J|zPmz?8zJkX6yah9&U# zE{6mI|1I+N4ZdiLV(i`3h!U;^x;Ju5tjn+iP~9bdz^NJQFN0j*1{{$|#vm`_`Eq&( z>rp2p64m{a5stu=Dh#12@C5dkMWlL+PhZ^4m)`vhq>w3}%Fq_CMj~Z1{{kz!?wd~L zw33{m*{VfyE5CcHr56*V^aUf5cR*I}G=1iuckgi3@}o5|{0V(1d#CUvKeo{Od@p87XJ#@i38n#No{owp!-o$^}i zODqo!UzqIL2ls3U?i1KZlcaU_=+*s_%dw!c1N((s1p*X7;}OB8Uie>zkPfhbdt(es zLBOhE8a;|_>CYeC)~7era5FSY(H53fJubU-I){~u-V7+qPo?0d)V*zDN0JGO0O#m)-5W81cETOHfB)nSJ>hvV#h-aFoX z*M~LMc*ewsIcrrtRsZ@Gq8z_(^24(!vnP6Ade(y^MrrP;%FKR3wC6&#R7_i|jc1|f zv!y^epwBCBL>f_9LCf<^lxGg&%~{pE42|dyM~<7*cduH&)RT?&RH;U8xH@Je8|fK3 zEK@y7hlK{9RHb$<`@I#?y6A9qIby7O+%0j|ZK9BXLzR}bRNZ`oC--J`Q~M>mx#K~$ z4^V!4xAB3H-E>2EtlTJABh|e1?!9BCn(5y|?Es5Gz2O3v{)(_seas4XCnF%)B2plN zP=)0@Dr-I=mzm>2qxs60bBK_TVxyCpJgz6Csy+I*lJo>y| zY2JWkE~%zGu}yx#iii)F@H^L(4;qO$3yHYqpcfqqdtzshNrq@E;~uw6rA+6qbY-ne zKvl(EHXGX73#r5$JErZ2Xq1=^lhU1Ol<6!cD#e+${HAr3FX8E+>?XV=wq1C?0`tN= zO!6#jqcVP0VsBRBATzEj^5kU6;N3HO(jOmK1CF9RM49vyhWy>wpR*oxSLhxL1uQ!~ z+(F`H4vtK*{qZ;rIev^g_R6k5doRq4GLX!1Q_`dC0O$Zl6SrdfwAJI$bYwO>nFd^Y zW<2(Yh~=rnck`U(%-T$A>dI7y_bi+7T%`K*pD;=HMiT`wB$7`?{F^aV_slNy;9R1a z9CHDob0XM93VQ;c*hsUa&j|eCl&30OaxuG*FO6~`j9NU23x{;w#%UvLtu=<(!NI3^ zTm2kcsWnb+Cb*-3Yzl#nE~&QcmN5S73odni;|h5rHMoj4&4m6c-AXwl0<0?P%41^@ zIJ~x%#C~&z=E9le{w3JI$<9n5{C$K^S||71k4q&?A=$&;FMPPCILQxMmHG2@*Eo%{ zSTj>56!FiOk)QY}>c~qtcUpyX6A#j=(ezlePA7cLqxo!(c)1aDA0Ckz%)y8b)L6qt z$+hq3n6-hIShZQTV|tgq_-kBl4mKBt;=JxzLLTWh?Z4JxtT&sk;B9IyhQ zivDO%(^B!@T_K&LUv3YD^!61s*|2mVWqUkz$WZ#1%>`H!uxZe~RX>zE+x7}Ci_^K; z_OmQwy0or2^fqA-FLNNYtvPNq>75#dc%qdKLOw!pV%B5o4~l(!-TReigrn^kaew*m zkAQrA<4|*eM32;v$R$4T?#$XC8F-m&5&Q{PniX-J5C8(bS4cKLI=IxE!3^z ztA?-gY5NJk1L5m%-6tIpI6=uu0An6$5I87c>_jC(5n5FxH zo<)qfVm6@8H{!I+V= z_QvW%;Yxuw#`)0vl4$I=KaBIqsDexVM5oPKD#prTq8Mo@ZP~M;>ZzOuM>sZJlG0sNP8u-n41?$9ZSE z;iv^)+C<8|__EZkhY&s&h^fyf90++#NBVNPFjIaI$C zr;Z-q2$*N{Ys>>=G;@1$264#6G-3-|W)wd8Y(M!>o@Q}iWqEYa))XdTj1(KZ`@C*- zn|%H}n!M=rpncwBMe+s%VK8z;Lg*tcGJLb84v_|`29EG4!o?`=GZNB$oCRB#ePlp? zAbuk6=CJ)?q#?xG-6niS;u9KBXx}{~;S+mTNXcgX$j6*2>As&7hU zst{$GVnbFmONzJNG)u~L(cxI37pQSnSgTNRw&<%Aae5T>lO*f?xjgu=60a@0i)*uU z^YcW2Qv_y1UYrTQA}Y0>{E3efUzH{aE7aBmDX-3p_RD%d!Lz7bF)R8hyt}&?k4Ri; zR|h}tW)Qy7*5=N_W)CmE?R88ruZUh3mxYq~RP&a@$fKfra^PKu8&1Ibz-Hc(rN-0N zhu&sh^9>=C+L9vM0vh{}a|Nv0cJUcCR6d8@mKtKY6nU}r=s-vOSga?E+Bw&EqQn44 zZf5+8*#s+NAZY;P=4oJcG_{YFG(jjWeOO@eczbw7fbbt^M94!~3#Rz!5wpw?h2)Vv zCmM{n5p>ly(&8vc6^)|9!gxZYIg|bLd}y62YOZa$E?X=7l2OG2Wt%YvbE@?K39+7=i#ar0g=&+p{QP>`? zCE%ilkBU-F*)b&lTsmHTZb#wVif@HFCgF_#%t3hRYs~T0*u|`zZY(i*8cg|Ucaych z$yzQdl6G#HVU7nD;fAK}(WE4Y{r9S2=p@tg1E&;Qk_dZq#XW=Bk>15{e6o^sMUvAx zP;wk{sQOmSgni6{)zdi%)jx^0P;}tbnUbkDaELb93%{%}_pQ+pVxo#%P4pa^D`^9U z_gtf#?E!4NiaT~cy9=sPsZU7e6$UIHycP7OcSG21xvC+OOqFG#3#_R)rsW`Y4n=`n zdE`lUkn|}#i~?X1?;PN`olf3If0nrNSW3s6fA2bu)5t5^j2TEcg~nO%yANys{>W#1 zjO2dA+WRdUfTPm*{4|LjaA{JT|GQsjHmtG`vtjPw0B4*-(Gu1+&vck<>$Y(#1rN{u zcG{{lqb`=bV9W?gZXOwKzAgYAt`?E}o=jl#d>ZjIs`KYjeG(0nZxtz@=L(fRG!6oH zlzn=%yxg>%1@~3y$pz~q@X%`ZL3{6(@A`a9$?!-P;r$00Z&@S8)%5E6bilWx`x7S{ z^uE6W-|MRowsr-#8(H1WvJ;qKUf_Rllg@OfCL{-|@P|*K;Y8LrR~AlRWMxP(PeyaA zBLbR_SL1&)R5-EJuzF$gn0p=>+S<99F%O9+u2_mT94-ER;x=VZ^-d}uhS2aYF~_<& zZcnP1D?K)hh(?2+exL8A|dc+@G(+n<#1+dTmMWn)PJFc z_iu?_am6PV3%64N5WeNGlh|!^?wJ41A-BlgzhzBzq6`}$dz&ult6PA*p?+O6*UMaR zwKmuO{d07ZF3xTG#b{i3OP~RL+y6A{u%RO8{B(A1G}YL9#**&O$&jdsfmGvxgJRQB zu|JlD~C6V~pXDtj6rpc2=w&<`P5lx2SQ7b{X zM`S|M%GhE}t>?eoUxljs4fo3BQIC?j9HDu<4CUSs)-G5><^~q1=s(?eEY>V%TxG*+ zr`JYH+t+lX3|mdyD90LxLIN*U8Fd-EV+2G7w~Dj;-Z#FBf$AN9#E|VdAGhNPEP_DF zW2wvvB5wuNAIhb_nBT+C>zJO|RB85Ag;4N?;~;X#QDSDpePHd( zY9HG)rHwmQ3GWG;u_jsDJa>V*ILZ6ii>~A@RK+)=2yUrv4*(GX3%;E6KSeWP#-0s~ z34}@|_>?{T7c$f@P&t7ikF=o=VyNCY-SI_+GAz_Y#V%6DjOH5o?)l`dfr%sEtcz&I zHG48HQ&K0Oew%Cwb>GOd>^RnMIdT%)rRl8kmGRpw)0&`r6HLxrjDG`1D%TZgo%M%yaPAdV3_)7uIq(K$&T?pey7h zj}!bNFcKxqXb*lKwF(-rV7{wO2@?m38rGM)}h_q#vSo_;EdYZe{?&!PTIU7ox z^g&-=rqX!SqlaeXu3=%4g|xs&Q*Lke!i5aL1nyGn=$wPAjeU1GQPn%}7hXb)(IXp0 z3{90TIGoVZblh`2$BT2!GvZjNY+e)qqC_FOEG%HH)L5RmcHQ)&O3W16p^t~nmMsd= ztwT@cj(7n3(#aUPAza*~SVWTQ{`-6UF4KE>*|scNzFPE%*UdNKDsdb-FZFt(BaR0? z&2LFe5F`i#Fr^M4;>3t1ir?UgL2;R|OLA6sX>3YtE}?ABo85Su=bInpZHOA1cx&HL zb$IJuFmc=)6mA3YE_p75qG z9~W&9TpJ9G*!P`lX5(WSF=m6+KJeJM3d3%J>LPP}qf-R$hiC<}$aA>{P-TGJ3LxHl zB3|bITmoTugiwWHC`H@2fx1YE9NFanvM#A5((R%_@PiZqp=-$;;5N4Yy!N44=9ljg z$5I%|8(vGLo_h>IOnmd^3MqmcgJfh;4NxfErE`Uf9~E{V&fhkoaVr`1!73Nopib!M z8=jQ!-FIVy6Cn$t`Sj1Yr1`ORY)@ zr*`;&3%_>=ugnk1PL@;wWmQ9pcEBKoHntckQ;(VqgSCEOHSv4V@JO`FS8p`x z5AJG>(4#ecEs?9?h;!B`p+qKXB^I>2|H^^hxW_WPmw_RS0~70dVSpF6=GnCkH`Iglh@vKt5^#!}h~XD#$Z%>-4E!PbexO$}K%< z_i<7(tp@T{Y3NY|M!m=mQkWJ$2_WeLjJ>~De@32CD*+g=N4hmY2AfHf1-04_sXs)K z5b1e$fT{w7J=B?KOxyU*IQ=0m66+_M1Uw&ohBjaHiJ9iL&?+Yr7kFxsD@Tr>T;tpN z?GcNzrL$>K(E-%5w9NRoqQWDvl%iw*IU6yBOx^)kS4X`R5$^Cmc9CQ51-{pQuKkX! zvRt6NfltDeTTd|80Rp>()py#Bnjq>9@4B^93pMB>L)u(HYYCH&rs}3hnMYnnI&uaq z=01a&uDDmw$_Tk&fh9jscl{{8+b~S5W(IK|VV|`CTW}e=7vUc0izDovU2YRj_Rvnu zOJ;@?upDkpJo2*pMt1g(iUq9F9SQ2~1>y6$TIZZ^%KNN|^#wW^`YUj17Rkv?LtgW~ zRV2^Xl4@jz^pf*MT7N)lMm!uO_e`NnvCysu`L>AYdS!$ zidj2P5O5ON;REs=@wU%zcDsU120*a4{)Ae>0Mm{ewhNSOKa|}}+gUahEY9qcZa9Mm zGdc0;(la5IHIZ3(XE@6lwIrBy$fp z1eAq7^AhbS-N%70L-%pfy-1m{`fNUh1vjLWg;)wir`T_Uu%~0Eq*;MEJj4%Q3lMJ; zuz*izp_jI>MqC4$wWFaQDtFYeCH|-cd3L`HxM10teE#jn5ivavWZfyL-Z|a;&e!2d zXz?s^WC-0oM+$GjPfI(S_O~y3aK1=CCHshW6;@s?1V|z5``htOe(DD9MAd?DG)T9$ zRN{-*zROjrRrW+ZfL8WIJWwrdkMKl4Ak`5Lyo_ifiG=EDt4{@|js+Wm>P(R$nPBZ6 ze*Tj32sk6`P`oMF!Dni3hE=8@KVsC^sh2a8PQCv`WUww z4D$}&fiibCz+Lxu4BceI#B>={`sBhzJsV=PKgVJd#^2Tg<;R{KFi3!8kuf_3ECQI~ z=m~1iT!dBqOoV6ylr&7}!<4twx0mx^k0{LE;`kn4Ny~^;G~-7toScMPNLVK?bx!4U zdZAM`xydW01zGWNNf?Edr9gAuc3{~lPl0@SSY-iT7z6)4exl-PNlbcqLK8czJN@5{ zxunLqFqBCSw5t%MsNdx#t7(Dk-r_PmVZ3rW3ekYF{i}0Wg@uJab+8a^7ZrDH@=AMc znkJ7Q!nFg^N(XBUn+u-xr$&=k8X@1RMccp7NeHFQ3|sF*xva$rpSChE$ZamTPoyR+weF(XzX$I^$1H#VTAHZMW#&bv%Y-==FAEx=9A%x%znHyDEjGB-7Vm&X-xM!#+`sXDXGN-_KQmvh-s zK}rgdC+qB0IF6+YNXSLISD^VC^6N?`Erx1FVF>H0etV(T{ym1~SnCmrA<9l~A*&iI zc?$)*?%7aWP|^g-U!bx8yQn^oTemJts6w#G5~g>Z&6lF+91)gXY4nVlq6hb$9GF~; zVNFu19$A*gT;mIop3X}yY4UcfwX5k9U6oOA|03MqW(BP1N072MK6?%gY&R2=1lr(u zO7Lp{%7k>XQh#UJc0#S6LyB&?u5h>x=ZwDSZg`V$!b7n`~aB{+V)-f^URE6s;HiHy$6WPW(v}Hba+F4lZ$`HNI1K0tmb*zNnu*E@=NG? z)K`0*Jub~z;*dIx0&a2{eX|0w_Xvw>im}&g3MtN2L%o|aZ$A9_)$=v+*Iyx11*S%r z*wAkA-d=14Ng9XFd7W$mqIFKY2%b_y@Qkb1Z5-n6iGCCo=KLl0hT1j!B^#wo=;oT) zY5}Z|P=KtlGX6Ma1WYH&y0pwngDlu(w|H6UM3Vg)odt#OijpipAZ@hLmT`<)y5@}7 zvW24h2M(koUzs6vx~aERU&<{8Bqek1cgPo`Pq;gk+$&WF2njQ9wLYUpYA&dy@pQLw zCl=$HBD;YJY09kHSHHsd@NPX0mT{aC`dZRLF;RzkVxK@Gn{YW zF@|nmf~qrs=l646An9^RXuZMFXuDYNHzX^G=tZIF05#dELyL#R!f5 zXINhvCns*HE(_ck?WjT~h9Y&Pfz!hzkAH?CBywN~0 zupfM+SzO|2Qbud!_D+cld{Tjk~0?TPGW)VosE2-#<^y^ez*Y*m5^~^Merc0*Q7kn7}WmWExGo^33|vN zk-V8PXFmv;pxo%5c?q}<3`^Smxkr(=yY}jUCcJ`(8`=|UN#o4{P9=f>C*cMe-O=jA znPcW1Y=T8Rv^Sl90qBOT%`jol`7R&JmDGv?+r8-7L2ZPzGsSnG!L9LpuWrokVSf-A zHJFmTld+;g=mllQdId#Hb--}t0tx(n*bRbofXNr`vog&HW||oYQ5WU+j1Sh=i|_AD zb=@5~QuOj2{B!WSKX3LV}o`G}N;0ybY0|uE9xtv3`gw zSYPsbKkTDn7Y1wB2Y*WoBS(rFAs915M^j7;Jxz+;8rz@{$mho?B#yOIknyJ-&byO* z#1X#DT~W2-y!;nFKiw|kl-ceCuO3CG(eoDINlUdue9xXR$*i?@aM_*#Sv3nyb#mTo z19_KxXylw+tFFRLud%bJyL(S}VhBNo%cs3aAm$v$E0kt4;2Tf|)VC^zsIcE%NzZRv z%$5JG%U3cO@`_v)RAyh9Hgr6ww?-66{uxH<3UixdL^nWV(DFKso2t&EGL9+YOsjGd z`j8?Yj3X+W*j)W>`nz4P)`D|(N<$jv+2OoSeSEC0ztpoPQ{ArqV7rVG#QNym~g$p{@`;==!z%)XyQLsYGNXPjY36)IQPG6 z73ybmi_juS8RJwaD6f8l44mqDoc44lTxAP+>C$Y>0iz^=4KBLJQUgtvl;62DehQ$~+>f{e`S@3;ud2d8l$7;oOYNIcu_eBStL-L`6_t*`{(=Dw~4(iqq&)r9i!D3*MZT*24H6A!f0XkHTuiQ#oo!85ggKgntTZZ#rIA6#CAm-#`@ARLlTYIPfY|GLF0Cm-Hd=;8AHZnOb8;c`misja1 z17(sM~7Tt|FBA?b5>{NeI+i>X54!%ItD zw}&ooQ+~b`{PcdCO1msh%b3v2=9}iXm}=?V_Dt@)*)GWjb>RM}Hbysr8&+E|6doGl z+6eUF$|s4Gf|SU}-AR4!R3CCpRleb2)@KCTAvY{XtVYok-$G&Fnx`WRsd~F$G=!FM zA&MX$;W{Sxx294IQc?%XB?YQXw&Em*v)R-oD>;JMt1`zxVzlhY(QHMwuiZ?>ROE;#U2eUW# zJI{&^oZ%eB% z)d62pzzQ_><4e(7r5$;Z&39DJ`$7Wj!~r4xGM#i=?Ev$+rQ^%)Y7+$40CQE!B4X0A z7&BDXcJ{K#LBJ3e3#s;7syWV{yKmi;fL$RD12qyFEl45wJ2k1LR zDNO|qkWi9{BT#AcquLog6^A#e4%|bD-;S*dqPGF}Nc=4m?@u#U3bsHDzGE6023L1?EVJWB9&rrt%HQNWe3~fO;5BP_$`$ zbKFe89SXl0o_YL!12A+SRd?)`NnqrbMz?(D4&R^`3xkgY{of)L?rwhxZo+|l{}FEa zeOO4uk%Zq)nSCmWbV^HI1bNLBYdpfLq~wFQY25tA&fXXXXkZG?d;vAi5X_Z3TG949 z8F1Z0x3+wgzqgfc^rDY%`5_r$GOuZ${WL%G{IQ0viDGjo-$@ECJrM`V0codz1sF zQfDE9ebk;PMXr@`IPYZFnyFgy^>xAc)m-QYic|HQwPAo-1Xv*Bw<`ShWNMJm;ikcE zJsR*BX_8zAi(%vxNY-OlIdXCFp!yvxc)sgnUQsJt5KljbLnVfW^Uy84$)ui@Q{=sF z@)qB3;3PmRNoz7DtWvpnka6=G3i%tY5>UO~Z+>eEx{h6qfeb?7MqwU|J~MwlVC<+G z^`uV~y2u1a8}$;=xYia;50?cMDYE0@jT*Oc*C3xQa$d89udA;gonAzxN|m=oQau~P zJOPv4r4}IfYZ6n8_B!j8FnwNWK+!Z{;U>pI?7Pj*;_ExSs|$l|$0dhDm-O{Lg&QP; z<+t#YSyUVz3N>gVfa6M2lw2|hjzc9SaBfzd06~!w3s^doi}42?$Ee-fly#ZIa_PEX zF!M%aq{PI0B*y|$6#*xuxd%f&YE!-XZ}@e(%>1Jb_4B2w?kAjZv&pnH;<-YEfd z-nob4rDM#sVq{mNm4kIdu{cz{VQT!%UtNQPKf1!1TLUiqJiMo)UIKa`*f^66gk3ID z9m!K~TLLvKl735PT-7yEX`y7t9wC4+fMU%U-t@`1axOxg{bt;cDi{2?CTQxi&3Hqt zO~8h%iEAKA-wvHsy9j2g#U!E@9@6M-&Zd{dk=KU^@+=HI)7Nmb~>TdOLnX~y}P{7 zy#SKGHQv06+xOl`@VkY^E(pM6Z!>j%j4)W()9=$IN8AVV+k=8gTDhL639#G_Ma~Gi zyk-^DU=SDD8f#W~n{H_lV->%Wat-i&;4VUsQonMtgMp|WriZFMMgGizGG(6k@lBkgw>Fe}&-gLk|A=`J@=QkBC4$+@!5;2$K>jS= zCQ-9(BRf!W#mpjO{Xy*sn;~TtN~b#X6Z20|><{qC-|9}5BA8h+^+MJH(7py5S&=60 z)If5LmUysOk#iK1UrJ8SksJ6Dj8(ACKzV)~N!QluoXl1VB!bunk*3wl+>Syfi)ptM z2cNAJ@yMOEP6yR~uve_v{dElf?iVm2s;Q)K3}Mj*Vu{oHH@ z7{(MSjjl){5T!bVTVsYn>vwnp9T}UFf&tuwBbE5}eVzFBLkc$q!4w0fMJ6< zAQp-Lhu}Yk3jY>k{8y+!{V#+HZUAS%|7Xn6S#>|D@zn|J^p#E$`hU5Qgqh3#ROrZ< zdHiP!u==$#ni#fkb5t7zKA=ny8KWRMo?`}F6h);RU;_#(IBbX=f|Gh_mch_=VSdH2 z_(u7G^CD*MAl~yT!QK62VoAx(6k_nWx$d)d>~ppGwAs<~>G7BH*LkbPAaf;VU9c4j zmQs@gAdaINJ#Ju;B>b5UzdC5(7_+<9VYB~R@LRCzoDIu_y81doTksW3@ZVz9y^q=+ z+BXUB<$|Q4Vz;*Cqi%$pgrUsU6wram;)>U)?3<*!Od^MoheE~SQ#f*OyG9}|XqMR7 zgJdS&IW#06e&lYPO^gCu5#lw(Wt?m^#L>d-ZnwqL1d{1hPV*gnS6ivY2T@yg0{IA^ zDzIaL>xlLk&OV0p758jCepP1qBt3x-xhX$hp>hN`GBao3^qf z9Q~@=27-?#c?E$6O@NPt(q9ffLI{5=zSR3nmU}1Rwm9bX46>?~IgxD)N9)XNo9qY0 z#Hf8Lt>-cEZ+Mt?ESdZZFYk&tt61xT9ma-*#nPH9b88U8#{pjb7w7U!IU`5--Oab( z&WM+jqmXX$qF8~`!%~^XrSCBx#lQB`8fJ1o#*_JjBedkx8Jeq^l%8pmE?o5|71PAL zBW#1=*T)tUZFVE%xd91IE4_z8{tQopr4uLkubq^*+HD(r$>urce!F83pPRh&`}6B@ z-6~0=i#IR&Y4R;WSvQT>OmswZlCHU4Bt{X3mkue)3O5~z)5S|&yT5i*3hK~GTI21U z7jH#t@ky-{Pz{c;^(m=uDD9`jg=crNm*d43=-6Wbv3H*mt3h9awN1;0 zEHg_eL+D6fr`F(Ww=G!$AaU4dabrQ`gI#aUgq(&(g3C6zGy~HyC{oV{ryk#VwrE8w0 zxk6%kG0z4y7j`#GIYoAtwGlg8S&kO%(W*cjGyrTX#Ty8%y3`QCJ^ke-NOI16Z?PcH2&NC z|EI}HIsXTD?!RyjMTt5JXhP^CpCXLo$&hf;T|0V#PUj@~p=_yhgMo!8Xtflbsd@6_ zJ1pxqE!f>j-KDpENIM}c*;#hdMe8ej{IgVv`ss_|1x7_q3 z9K;5JY6DIIb=bpeN$7krIm|XsI$v}4l%llwp&5_{O|X4xWIQVbXr2;`Q^(y3SNQob zF?uAH;>=|leyT6?U&J#{e1I<@(&>KSu0?j&u;e$`hPF{!hri0jM4Kk+Bn%l|QsK7b z58!Pb<~>6SXS{$ z6^m&-^lU*pSFgkD!XsAH>-|PrZt?88Wo$`wEI|=t1|MmT<}=h|5T*z=X~seZ)bOZw z6-XhoP&VWw+>pl~k%JJd9^(^U;~d5liAI4hg1|%H8BMW^_L&a^HKCC7(|5g*Z*uuc za8h{0)F=_XvaW`xwz6O?4tR8W-zTz=8-$sKRGs{2q;(Hm^kwUZh+U!F3l>H{77|*q zia1^rNyP~e^UZH0U$ywia^?sOh5`!z{*!!k_9wfB!Ix9=|8hz)|1VBS+04<^%-Q9? z#H6bB{{|mY{}12ypPOTKJ?D9Gbp8x%T4oYhY6v)bc5+2Z1{B5atY8W|F!Vd6_;e$~ z;)Xgbi?B}XLN&|cpM`=2KGdu(#XiRp%o|B;WcyToQ}<@>O+3dN1szY)o=+c_Js{P) zzM#;|YQ1b@klqpX0eAZ@`^KQ$x-_}Jt}h%`5jF62T^%O-zPwYV>f8h~LUQpLLR+~V zT<~nV>YmVoK1Ls$!2`gevlwrq=I+PZxeKeslId@Uj-?sf>mZoKr+9mZnq8T^$YoS% zh>er)_Z+5F`$HzTG^lwV=qJ%I6G!2`z3che8&yo`#yit-FdR79NzE>1iap+=)(PC( zI;_R}L#Yyc-`i1y%xLhWGidP z$ONS9YC|jjOB8IN*Be;oa-0LRd`H0!<3mWPE!yx5-MuLc(fiI=5)O$*w?9uE;5M_= zpw)saUdQP~%9f>b6YOA3s+e@?9=5?$__1t31&!nKQXdWLbSf>SI3pr=H8W}=%GJNw zWlJ`QSIjt=^((l~*TWWC#Z?s)WpzBV3(Ok`6VRtmH!89Rq@Qe9>s zUd@IS6hC+_7(JVGgd`>|ED}_wcf(MknVOX>ZiYUJC4l~Hc2`#pqj`Ea1Bea@MeW)s zY+=h^MhyT~u4%g{PBPABWWP!5Q|WoIv8E%*_JF=dV1i>8FcaA$?lMK$f%S3;6r`;t zOOJ9|64pMA{WRH`W~j$YphW#4-CO~SA7P^GW&Rt%Z5)3~>68NWt*8E1v zoY9wyvO@y_(f=3hSlQm*UrCWL4-*ASg_M#;`>p>=XJaahqwjgj8LXl^5^6J=@nI zNmXWyUOyK<7na*t&+A)7eyxs-Ol>&-Ja(Vv|F^k(Z-1X=uR(SFx5;(20-$usO(3Dn z$e79Ytq?+LMG)M^u>06q)c4nrtI^`mtu1RSpb$8Jx1y9sDp|59?|`*?5zk>KG!8NXwqO9cGq9Z+v6fWjEOV=BH zz*KuS;9_Z>!K~g6cNT1Z7_F;TE06`yo;=)gwuep+&jm9n97en_ZCf(ZNDv$$zsE&w zDIDR?-m1|54oBDfgM^BO6 z*8rD2aEGd|ctfHee^c+TaZ?_+jNZwBY`-H1YaeETG~m&2T;ktyizq_kVDX_|UD!xh zys55MASXuy#JZ*i5)mmj%PzC)Q6BSz`GW(k@L+=yFuX%!(7huSaMlV$;>uJ|R?(TC zwKLtHBLL2bdhG=S<~JQMG;} zNCT4T8KH>uOG?7hvY{C00&3;6zs0B`fJI^sVH9;zan5oPCfZa~q+&>|OVzXn|Quu`1* zHr0wh1LS#~pV9HB+BLcNcQ?;K%}k-@u`AFirL( zcS3%tW+tLpJa4qaY4MzJjtkwUWD8^+)Tk&^GWxeWq;bdnx9G|sqs>v5?|V~A#Sv6Z z_}wuZ?L4WqtjO}BQFp%*GAsqVOh1QM#loyC7>%mv6iyFDgt8l23k#y!#QcrXIBIit9Ug6V4GSWmnR#0Q*OtzfQiBtf6tI5B0ZIz8P9X@ZuvOdyv z`J5BE=cEbT)nf3Pacg4EyfQT*I4T{y$O0x-&;#V&Bgh#QNe6`OTk(lGy1ID?8juTN z)&ZV_+^<5zPtShsI}9SMdX5}G8f8maQvGGTx~{WnDzt_(t`gGnvMI#P4l^4Gc6_f# zfhI%h#WIjrvG??^^iaxQK@MY?(QW)aI@&s;`MAJLNj|)L(ae^|_Q+ zxR*71h>8ldE@qznPUaPVDgGP&Gx){D*k}lky^T#L%eeD-L&0?!s}XN)4o4r z2a-k4WiCn>mUi!A!P}MA#Xk zp_~3@7wUs6mzHL)bV;0X|t%{A3>f1H4ObkNlp$HNPDS?HMe`klS~V z@i{EJ1w}ygu4Vr7|exCql@wu-?qcG%)ZR4tS99x+F9H)XL^=@V9f{xg!}h z1L4j`URLJMRzvR}pRM)X5ELYGvou@Ud>pCWR9h73m-ZPHpXGR^UL3;cPW=e6oV(sA z$jQOVHg18R&RKJZ%Yn29JR;7*wOlMJ}?#6zCcu= zb)dv>jdSjf-Yrm}uL@{z?_00~{>22cH+z#G zzBcnF+ed=?2#qm&lj@`JCfQekB)ze~$)Uy$>-qhx+b8r~(fh^;`Ex`N{SEC?`NrNm zE+Xrh1*_vG3Fu94664SOEIzEyd{+hXb+sorKS?2GsWwy6juW#(WscFdgIs)lVYq}s z-85CqkUyrlWN71_Y=^AYY=c7bM_Iu%z{ucHmtWWu?lTV11Sh#Dm55HcFEV&OADxDn-o&36iH_gFDGCNa22QIwk!^? zf~eElW7Y}PteC+sS1HXtqH$rF94~^hnkZ5!rA|pdRV5zr2K7!qp;yFyIu)K^Mc0;$ zK-ZSFgQkxgB~3_)%1@hG?Qdo)K2_b?2%Kf)%0RCAIyQ%~7Qn5pXa$ zpX_e6E9oOKh=l-yzL+#$am-GauB4*Jo8_QcMY*DnslRoK2*@HZli8%*AP}Ng<`^jX z+x3kgy~O{vy-Pnw^Xd@~fvM_E8&rD<=l1WomCr6rz#-eSHu#mKg(N9{3J1R!<$Qh+ zm|3^t{DG9&rBKZgqjiKR&zSk2fnFWvq}c<;)BC?&#hR{HZjf$t>L)r_XwHnMNfqhNgztopkyG7yI+f$xB z2DR|+Ti@lbVih_w0v;tZVw#-2ap4Jj6yQb2v`z2>$CW2gqZ=p=?B(_oW-P*1V6p?( zf=irQ%SngL07SQP)C`!IY3mviT{uqmFB^(2kss_56 ziNo5ptaGzC)U4d|oee<6-ugZ0mQX!SoSUgx5?dig-Y;~iYo&jp<8W2$exJXCsd*TL zq!vkOsG6t<~EKWjm9hjZd4uhMLO!;8(m?$D6->)LUI zsOL3yHx~ZIiNf3<6`B+&XNg0mocORnwyggmrc|);IWToyvUGmn3oE8Q zK;m|W`m*V_R39w)8_UuRcZ#f*E629ejP99@LkzcIN_ClqW785IK}yHA`+;z~B#L6s zLSJO?Qj23`GcUv-&6|Zj34mi1NLhHBte|Cdb`jTqMRV5B_0rk6u71X<8=QN7@YO6Y z%*q2!NE{j$@JGjZW2lQchOxLf1v2J^pg0Qz!U(#!1-ehOa2{6? z@e0nL)U?O%@Duxx6p#Hp*%<|4{tR>p21RagrJ5nu&q6|JJgVCA#28qHRpHKc;zLQA zv?`iKFs@EgG_{p%*er9|N5{|O^^>rkJ{R-EN$N9cG*##^YA(srf`zPRFLBbWr#Ah5 zkWmFu7pR0j{U^WNj!yiCsa4=3fFopNRR;B{cMk6zCfs*0Vt_sJY4Tte2dW2CK5_=F#PM*+gt$7oiMI&f$(j5`-eh8-;EPBo|6Uo{7F*?0`F5RRFIArCE45RBc7r15 z6CuQQ*mrD~O<$v%5SS3n5SIVL*f}<58b({XlXPs`wvF!Cwr$%<$H^Ppwr%r`ZQJZv zoyp9cnyGVYrs{lqe!x?^*1h+-)*@v?l;o0z#~iF4FjZd|+`ofbF*K7?KU3W6XSHPA z+x^Kry_7SpAYnnFhU!otUy0%&?j&cy2Jz~EcKYzH$`?Z!WipqBkWF|IV_#NNQJc9< zG_*AU=rc=isc4EWFk-Y-FOPIX(%G+L@5xKyRFHYP>rWX7TqoIE=k<&YV-tvh5QF7P zcAGN>-8rD)7nHAfK;x&s{ZL6_bmRkXrr{T!VWC|J><{N+bxCV}-nH>!$aQnR_Yu%j zIRp1nEJ;=IO4lQnC@wVhQY~INbxrmYvv<&1Silzk+7#?nIFo%V2GBoXAb!vg&Qv~d zbfdE77=j>_6!0jVtvu8K%HjL`cTNdeJ`+#s^{C$U zX+AT16zbIiT10Na;qmre31j7Uuvki7zEF^O&j*se zr&L25ziZrU3%OM?zj(~AR3tG`HET(%HFxZ}S|VJ9u$8V2HB{v35BcT`K0#G?lQxWt z=xQu}T9quH(NRmLL4Oe;)k<_soWyLdqvh6<^Cwvg7G ztaV3PigFC*vv^-qFIZVuK#4CtWn5zOS&PZ)n$q7NK6x1r(s}Fd1q#sJAZo)$Cr1a; z)6x!QWhf}E<}TPtGBy*eTx^Rx)j2xs8!I=My3(uDN#ID<$ayhRBtolT0S*(DMbwl1 zV3(#M5-hQY6Poo+<2*M0Oe}o*=bh577=2xR{yOyjrJH?vQrHthvz>5R$c~2@BPpOj zo@&q&r}q}T&R#43E8IP}iRu1`gK>=F(I353sDuU}HGoCiA-1=+hiV{mT&EWhWz`g1fe^sUrl?^2G}SOve3l)o(AtB2Ct>lOfXx(9-_225 zMSZ{PXz$Zeh(~UWZe=d58GzGHZl`IXFu>|zIm=)X7lA;4uHJ_gj_r`u*GAIUG{hQ( zGD5A6yEWkTHcbCf3FndNOI$s6b%Rz(i5Og=&@1N{7bCVKHqy2u1WdtukiJy0LVt60 zArp|GYF7FkTsrvXmRovPgmD|b1Vl_@!?hO;w7D+87N}XC!mbU0VY!=SJWDKNx(CA9 zkgpVfI02L9fYJ0FWMO_)u(~~*yumJ*6d|G((yF( zmkuhjGVr`<-U{5VduRoXKbfwytgxw~s5(0{7MbTPxE>zsJMWQkzZKU|a~>nK7Jqi5 zBR*`tV7zPawE8uEAC-FT{9HaV6|RKl@7Rbm-Qbe_S@|5*mDOdRY%Z47;HZT7?7(rc zWXnpzQ1_7Vv+YHWPLBHRHzFQc^(hc!m|)JhYe_t{=+kxk%R}8%MT0{5rU#SrK7DfAR-#`DT1UB^m*=DMB`+ngZTLe#3FBR1fDg|?FtxJO&2i6L z$1oPE>eZ~gLpEIFJDf}; zL1a|EySacwO`_8~eZ;j3h;R8Mx?VAqD(FsxBF8Gor(ycSqp%(pjpPny$c+0gL}syB zfR`|anNU0}9V0)v95H4y%y9p9625%L@0WpcZZnvUC9lH9Ls${Dvm?=vrdxT`<#fZyj4jXn* z^{E@6`3)P&(4uQ#4mwTrOj3;y+IoG1mvrF0BcEpUPnl54WpKskpNQQkSxUr~r$@P( zUx%HjMj>(=?sPs4dN?bc1+f>9AOk|Q%=;Kuy=c%M1zZF#RzjZw=mzNkS;!mbd*!a9 zYO8|FOQ75i(7H>eOYM2u;0A@w@yGQb&~9M;%W*D2sE2T+*;4;Eov_kd>&N^*o!3#N z6dF@$ZW_J5$cCb_hmxd9BhDPkq{oFqZaWIJ6WA&!hJ|sf#~pNs4yV>O(c>d4npXZh z3Te-*ChMSn(`+5`?u1J%3Q*Do?AEY7P%xH-8(}((5<=!T0n4~cPg}+3HJa9)o!!WA z54Bm_d4pxDNVA~_$3cJn^PHCQ=AR90;Y=m+U5<7)*a)cgD3w1}nUs7U4s(=0Xo4y) z@7oyneEfQUShwHo*1NXF0U7pNL+b8vep540UxC_&J(R^988MGA^+AvJtLO}L&q0te z44eMh?!;4P;+X49aFl*wepYopbkadD^=p>9$4NZq88JR_^Ki5rb6W*SXFpLjv=DcC zY;uf3zsccS;WQ|Q_{ac3%9dZLIMjfzSOh1=ZDV1l&}X(h;)7GjL8QjlJ~^x&ohiWY zq3*|Gzn05<5(M%NGOWFKDkQgjpm4mwLE38AuA>H1YryYO%iYato91{U4dk@atV2dFtZN`hR6~D&mogr#bU+3uxOEsq%7IJDQ zCTOBDeVtel4`=w43SlE)kQ;rR!4oouXfxcgK>fD|jPW==Ll`YBfHZet^)H_KwB2EQ zgDy9(0#*L&^^Jb)0kxF4627>S&NNGE8=hj)bsraW0jD42IN4?2Pa#YS7BexNLR8_N z?D&Z@3q)zLiONgRjiS{A_iS-j!-h{sys2^S5?Ek^Rg5!%J!i7kbS?T(gR>N-oP(S! zzAGB9|87DyWlB;kWB~>{b9`lOzT`t=uu&1U7|2>!smoSAM_fvaHk2%be@0RZ9BN(cgD2VQ@8I35_2~ z&P)Rlxe3wdX!wf_{uKz$*i5bXUi#LSNn;>vz!|KNZvWWo(Az))5QGs}t^ zE(=SYYQ&4iv&g{e!Pa)5$r-ZrNI`$YneM~I^XMHQ@rfKJ8hJY!F-lkD8Or8)bUF__T?n2CvTGNL6kz#1qr#cUzL+`qW za|W(M+Z}sR6kDhFhP5J{`*-!EP4Nu^mkV*zM7eH`1FLma%;`&E(<&3NVH4@tITgff zbG2&1i|f9=yvwlRwQ1Xl{=8}j>~7)p{LtGp_eOc%&;x?CwBF`j;q#ez#{vb023zEB z%dVttTCRpMI^ngiU|QB7Nv#M+aM1F<$l;9n5k?-{0v6^mmOrCce?VSLl|MUaREqCW z*c{e-g)VqcuI;s@tHYrLY{}pj+ITy_`VAQR!#F$eK9hOa#_l6*j+Gm>+oE0%Y}xEM z+pg>pY(~=Q*mS}@J1UKpxXvfH5h4neM9+rQ?u_G%5`x!X;+xbYr>137qH$^ ztx{|L(r0Sj$ZIfR5UI!ayfd-fz1nAM4H8cwKJhkNCN?gP(thlfWf2?2qBbs#((Mc8 zk9#7?efMVaW<={|ee!+^5X6WinEfJH_zE3ctteaza>96Zh%(|1%hko=?RCjQ&J^N1PiQ5z5phkWD`~^2wrO7>l;l_&;(iPApRkh<;WRP_()QHV?!8WrJHN)+RHhxXwBqYy|?I()aaLU zCe}M1-$kzx);rSqBIz8r?%>U~lfbJb z%*t!DBpPE`om3yX>(}AS#71?lG2(Ap#*NN#>6pbH2K*cl?0~~<2XtVQw#gE?F`sar zhQG!ck>r>-9WgPNu)4XEUQ?RT;*=*qm_~2 zN#E=6qO8x49l)}Kb)*|{wl-&lQPVR;g-PJRFe4k;5BqR~4!zxw${Lpi)?x6jz$5mmzfjrHFDIvlImTbtS`yE-_0;~4*!oFHTV4||BZwKA$YmLEcqX1H}9 z+N_ndWi$?Ght-vA7n%|heJjdPh3!=XHwA3wR-HG8#LZRh=}a9ffYq(!(fLcxeBE#E zi9eHECn412lxfZRDeHvq=BNwv=^0brAN-cV?@|PjVFH+p<>km8ipYdBh{XaU5Je2Q zlhYXzfm>n19(3J|Ym7yc8O}4(>X!+$I5rL^#U)Jue{G{CjD)eHei7-%53OmiBZn1A zYS^UDgfQn~H{}w&5^%Sja=~QGS^>z#XlD#rBx?5|hn7*L>HVb}JgO$0@X}m?n>cKl z{kwTw!+^K4U?%RXsNta2mi;JAzV23QYbRA8U1AHMg?nA>Ny}LDafl~Q$meJAA8&e% z(%0F)4(u_RlQJ4-cCl7;mwhE*5GyK%J9o_#F{RtO=jztmiftHkHt~>OdysJ)d>-P{ ze{825$=c)@)Tsy{U)vn#xE=6{fP>lHuBh$YWCR~i!ed}-=PtxN(siZ3!Eh>J#}?VU z)-jS;DMe~J10OiywsqnS$6&8}OsPzj+B8kGogP8jiHaCsr+7X~DZ@tChIQ$*tX-YX zm~tRyN7pGU-te?_vrNY=zy?QnK@S8tqcr2eQC_gDfW)+%=kVYe(}yYICrnqRx4Q0i znj|z(Z5_si-8avcn3%$PMNkT7NPD+Gz>LM3;_tA(1XF*f=?DsC$DdG30c{7J_!g$+ zofRFNV6H1(&~lkwCgVU8V<=U+0t;!rbC3bX-}_X4bp7AzbwvZeWA=Owcp9ecmwu@C zJL-!PfP)O}L?#F@E*#=dGnC%Gh?~TcfEa zgE2H?v#BtNvzR5tQxMNp+GIqEol;5>e=;O0?Di=v8pRGBtm=|8w$$5`D|T38=wHC< z3kQ}%@9nsd;hTS$pOP<`%GvOE@KjxlU9CfkG*h8))M1A1#qF({UIW0*ox==yTuVK7 z*pN}fglXN(Ihwa|c*RmpaByAkM3#D8Qw@hx)wRG`s;Z!T!`+xB5`f^*2|b5(Tg-^tU~!a%w1BQwR3bq z98C+W$pl_-DFl8|Ef1(oUoz6Rr={jefBFbLvU5Zz^F_WWkS58<3x8Qj5F5svk{N!@ zLXhBkoM9K>DwHh5_7UV8gJs9>!4DCry&iykJ8C{Lr@jyl;Z(3HoZcKkDWQ?YIpv5& zDbp{5@`pr)q`TiLSP=Mvq!?|B2KwnGp+!z#v+!;MkH6xAa=t?(YiX(xg|QH-3PN$m zv0zPy`~^RrW|bT8Ng9tHh zk8I4z`9$B`!VizpRl6cx;C%}G`!8K|%}>|Cv)>Tg5Ah#Axc?i2`Tybj`QPLCO54)_ zZRzvNM?Yrm5&=mK1WXkKa|)bxH2-G+66ntaq{O&Ua)wMvjn&H$exzH0^R-TlST*Zv zTifPptwu7zN;PfmO8%l}OKtD9<(#Lc$7f&G#>UL8H51O+e~<6R=G$H0L4r5WzBkWi zPp@B5J{Wy0j+v;n`QadRzCyz>(<8Cr)%W>}}V5;Uz{uM|cn@6KeUQnTwBW~@=Iy?+W z%*HCRM98=bh{yyUdaB07WA$BO+7gStM_CFtf!cj*6!xX-|D5?TUvQ z#sw?0RphPFtQ=;wD0}3hogA`JXBNC5ZR3Ju{~8u{*(5k;WG@QIB3P+fG@@pf$=3V@ zrEFFX!wu}vbs@G*_TAW|DzJm@PArzizGankK9hWkJ`cZ{Rp^+rE;o+aQ$ zbC}hmbek85prTTI>Qt0TZKD!Wq#UNY7K6r*i`B+=QE2cS6-(XkkwCB%ilaIp7b;R2_%}=>RCfXIZO76B!^tf}KWj`=Lc59RP#9n&VM%ooV zbDuG7T^I45%3*Ga-lSF|ww>B_h_?uw7I>ct|8>eu0)}O~{PGn^cr6nmB$cU-1wOgF zJX?IOL+F=LmWe`HDN_}R;so|ss6?Wev9ocqx42!eZ!WJjwKp5DWYEh_S>tZFH!ruc zp=?fh`@Z{b=P@pxT!o8*=J)Un6oooa;oOH9>Gl}tkjmKGTv=J|Y_5~sRaslv=vhza zESEA<>&slMb$Qnw$2Pw}K#;*UPyKV~ZB>s9?&5iK;Nw7w^<3EyWbHotXYd<#cyiAn zcnsJC#ys!=#|M$s+K-__((uCkn*(tOv@0nqe0d{KTBOHd7RScuAzm+6U&=EDkYqJo%dvk5Zq$?W|vZ*Ae!_lNUo|his zT#aQ|le%2`(LMCpGC$^}??-KbslO8r;z*#6U{2F~iMJ?0(F%AV#J62Pv8li*N+F#Q zV?YL0+}OgO2nFG>aj~$Y90en$u&|0cYPOk|0P4viUQPd(GmAJ7shjLN(&7#Tf8w`B z;?uw^O0anw={mV1ea2#QeegVbfC5oVf`#<4(Yd?0F>>y&ja8WX+rX+eBIzmh2k=M^ z`=P?E{^_TR4ya*xo7Z`7P~vL#?OyFjmp3=*vChmvKmEE1Oz2Vb#zw9d%07ttp`44J zqM?HACkL(+Vlg#GPkl9_G3{!blR|DILiYA?IIDJtsSwuHMMBc*rfCZ-|VdT%N8a|n@edR`x8W_XH+d)f#^Yhnh>Hxr>;Hf zbS@G{EOU0e9P>d1nj`SfG3DemvUVa;=uY~Cj`1YLB)ci=aaXz4xSm$iYK{Y<{3P=f z7AK{eNV^`il{QH~TO@0vq^S6Hy==&OEhQz3=8qxLezJ|kkFyK)(}SPGC}Kxk1-EH& zYI>}7G!M{1k8OV?GWkhm^DaQO>VW$vf{3!l{m>+pTWGGbDL+%;fw^71&+kzS*tiuy|K?cH z35UABHJcl{``#ywFTpeQ19);y;%Kjgc=~KA-b0s^ehDU7Gp4E!)N}a@)3xDXt^|qd z9T9=j8SR5=NKeW9${G3C7ISis;EoD2XvsVM8^=lL)>z*MesYiW&cP3=ay+JG^HVuk zE0*70+5`LndfTq$558{!QooW?3Fl%}z0&;#pm_`KFxc2KAGtRcG&R|!6vQ6O=H<`K zzfW4~DsSAMLizd?Y}tO*v-TQf54;5ZiXnQ5*}dwgh$w$!VLl~`e=S_Ve5yWu$>#e@ z?E2F@Fs^;shx{Ym+gAChA}CZ=Ac00(Ac9^j6puxy7%Yr#I#3RiI$f^-P5#z^&Mb+Z zIE*&Hje3h+8OLI+z5tyrtylvnhoI-g?I?8)pgtO>QOzPNDcd(;j`l=dP-Pa*DhP*Z zxoA=mvEU;Xn54mERb`g$5=Abp*k@DJVUWvJqA^R2$4 zZh%mE7EWU&LLV8S`OGFAiKjN~qgV+5AE*R0fj<1M2(>H z&w`h@f=L)0$sUWd2brCnWfg}2PCnx3Cy~hjjbgx3 zfgZB8%3Pl@c^NgPbuknUbRz#0N@PHDvsAH~SBUYYg|iu!ZdkIaDosy>F+#l@`o%DW zC|kJ^DZc6ug(_R)GXR6<9I5(p+^7){R{Yvrz7INA6ON$j0-y(+Dv5IP_OvP3s19?~ z>mu{2)GO-@g=F;udh&GljZ|NT>_lHQK?>xM`RALw(B~-ct`tRnqkDr(7wZ>5m6Omh zD2fKhPzAChp*mU`zNl@zr#{Au)=}gCw)=$3!mu597^mrU#xHGC(it{v zW9fcjSCY*}tsGiPH&!#$8M3J-fuWyu{o8#Pr_Zu0nH$pd)r+dGHRMcLOi?joSOn2lk!d9XS*46y? zG5x5673Y+Y$;!R7O-x7HA?|36_09L4t>o}|xC5-7e@q=hv3;;!yFD7;rV(WFdQE_t zJEcx4BWRS-0@^{$W(9&oD~bMBySt{!3!R*K32_s)6Im8BgePiQ zjD>i=)Yne-+mYiF*YcSD2*}-#9M=7x2^A%!wzr6EJ$|f8Gceuciy?-a`+CXcQ&g|Me_fWXDM(*vCnv|` zmvl|FlQ+RV?7j@MRQD-Xy!^Prb3h=H^fK=%BYR<4Z=YE3MkAQNAQ>O`lEAq{u?)-{ zAMs@SXcIR0YQm@4#_?e~tvhYX>4GL3ivau4-;k1j|2$*}wpNMmSM&B!UORNOONAUA zrR2Rlyvz+gsJP>YO%jdzbIjzap`}+1Q@cjEFQ$uE$(GrMkEu3TiGe&ut$}2QR}pbA zrC;64e@iprP7CD2ppTUjhNnebOysK>DxqeQsZ83_4>s8|YsgK!S$lJ49YC3o-(Xr# z?x@$a?lTU614nuP>KO7;S1{45j_)E$ZdoTLCZ)(9e|%#HgV5-25(Zk31-jTWvYkfRg~ z>EsOu`UWw5SzgNJZ}iopFKyKNloPZ&Dc>5Z+Mc3`K%LkmXw}cyUcdg{k9BK0YHA&u z`~LS^&1r_Cb(N0l{E(W}vznr%wf%X;jSZQN00Z^*9jGCeNzqBxe@)6f?N~pCu32%@}06^jX}BI~v@`;*U!6c1C3l?Y|b$OpGfW zYaXubNO1;TyW9t$jyXnEBZm03?pnpsft`o1i`vkt+Qnf{Bc3nDv-xQ!%5&ZYBf)y6(| zoZWyC-5%0RmJZt$>^4c0aAX*&HGG)XL4O{co#*9iXBFxl-@v6u zzHt6w%}#a&1Nmi{!@D#uTZRxkn^lu+6Rqa?;F5ySF=610&DweP-Bl zAXV{Py?lx-V)0e1FYse_Si%J2H7jD$-mlpL!{{l34u6!+Oes>AkKi0ZzgCU#d<_NQ zG^jPZ7BaopAZe!H$FZ7b*3%<3a(<}(FQ+Ok6<*bRRLsrHhdO;)CMqoYhI@mZU{T1A z-cybT!^!Q}f(Xyx7_yM`QOiepl&W=lMn=Norx!iOg1lg942^?&==rWLO=g1A4KdKR6m^FYcDLAp0j>MG`8dsEhIDgJVO=)V4bM1WwOmA z8>8QAO3WMkt8>jJF2J)qfnJ{RIErpgvRoy|zDAE^e7K$@VmYj*Dws%-b#%*|=^M&wmKe*BtrRnalPuH4^vL4f=aG7(D4OpqjM`qd?W z&vBto?Ua6aA=_i+{#crWc1KVnkvX{M>xhueSVZZI8lY&1&0A9j{L@ta(@A!cuJfLd zO(KTBmBzcN9}~{)r;(S+G!9!D`*yo_F2UyAj{c*DIC;BzUih;UcM_(3@WM#wpitGo z)DNAsh}OL;qOPFapKAB_ybC#;1N6T@j#{++z$2%xDYb#lhdr1STRqQ1LsJ}lp^IMDRCT=C|W;h)A!sXM^5E^+B6bKEdgvoP{=fduw z^o#pyjhCbWz?l7{YNg*F&Uf-hxrzRXubd(Ni7%W%{^-z?G6u`YUB&6_E>_a6pry^r z6b>EUPe{i}d;#s+kp#oo_}Y<#A*G}No_ywBpynMjG=8AT+L4E(?&{=ytkxZ23bYXj z#yx+^$s_0jz=dxq9G;jkVBienvpAxhU5La^a&qzX=$N9&hf<3{`CPw)ACq-Y#ze=D zq>@9KB5VCrNWw)=fh@uGfx`_D$TosW=$HrbT+i1hIZ*nDyD)e|@NH2`F5yeg+_3jZ zk#8_9TeO-(>U)Yh(Skj(yEuGfpSi$h59F0S@*G-KecSLQl~0nEH}N}cj5ijwVPmd= ztZD;t1m;T7&2L35Oe_l27_MTgSFCY?nh=j{iZN|1So0N_=vc*JDw=HIZ7de6Ush;8nAl6+jf{m1;Covdsn0)v!+b*GTZlfOG_qzNXDd^M7vAc$q01Z3~@Y*WwMue z$m|L&G^{41q%Nu?k<~4APyN2x9!+~4a68_fo=v6>I*4o7{wZJM1zcG5q%1fdR9h_dBXNj9^eh>L~4@B3TFiXlo10fHh3K9Q*xGTV{Tvh3W>Td1qP!b6}j z+aEyyv0&-})E0o4C(5t`m(+zZW?uZ3i$A9HRFhAZaUc2(BPai6U-J#*xi{+M)YT_` zyYD#!^%q*{KIOj5hs5HZxe>V@^5f=8xc;eM8<^>&I646kmC8_x|Aj6`i29&*@S8`J z&}Z#-Nx9v3z8niCH^QlXh`da1olks0>6t|7$`%O1Tm?p^f34i2`y_)stavQrp>>au zP$||)^|Qj{DBpGk%J%g-+~Kxq_OEcmb`1$FDC3<#&mS~4dO`Igr?4x*&@74TEn%y} zQ}G-Bj=e3t^X0)=SUXQ4Y#jT~cR*<^OEdBh(2#Sgp3 zJ`Lu7IQa~z;=n8FZ-()iUU-(e!a8k_-4CnhY)dY~o&o3`X-Fx_r)MV9V=xi4mitH0 zNUW?87tN9Kn=jy#zL`VtH&5;!Un&OcX~0i}5JYk^2*Lp_p97J>iWSz~-s})2ch!u33CKn`qDNpc^B?L4Jec?Y!jUAigL5 zk;6d59rGQOBe`~HrWNcJQUQfw2nTX!_a&wpGfMg03`3nt&Klg2N0x~0E!k&zRp3_Nsf*S(oH z?=OCgJCGh9EFJnf)6cCD?vbsmpTABCt_*gl2Xb%CKSI!u&Sn-RwYfI2tFQ3bOlU<6 z5xm8A{5n*^dW3rQzWo35{gPK&?}stWk00=)KYnQcH`e6pPKFK+rY8RZx&I$L;Txj) zU(~yhy@}_4knfhJ&cgP#4z4c$r*}uw^BZ2k|N55@C+S8B8Q>6vtcDAU^&5@cgNzuN zZ4ZVFMl0)5ZXj-Kl7|%+s%2QqhF`0)SgqW)o_=|mpn!^O-Rfp=`*~|!&Guq$@O^nF zGyC$IEOW|^Dp&q%^ke(+{onNS_Khup-@!jf5W3PtK>bg%AJWL^)e~eIAZSE5f8Z&@ zvED#eBXmI?jNN~v9^el%-A@154&evU32=vWB;O|0@(yZ)xk0af26tqyL9VtAYD2ie ztVaCl$S**p#re~bQ~+&Az=tb5^ERHyZiHU&5-1MVhE51;L@U6cl?%21%^By)!>|jG zFTS|^z&tQuwgZ}jw*7Sfd8_Fo*L0n9`wG)?QuE{ZK;aL3ySC3Ya_->1bM4C}x}rjo~tHrxpdKmb2JHr+Xrb%7nODdH6To zfDy|vCS{qwSb#K5Y;C275EC?BR2Mw%Wrmbzqyw7mTz$ap8#CJ*=8Uw;E~S+v3VKo$&H4i4}r!SFI9bKj4jv~#4r76WN6%rpT(|OYN*#(Mh zR#07Phe#(O(o-OXfciUF%_sb4%;*Vvx=E)siw1u_D?$Q0M1Ikf;sAfO)FQtk*(T%O z1WJ$4DM2eq`?`L^lxv?^A&|)(CpgZ%>RV{CB!-QduRGQ8O6u(8{FbPPiY@v*e zIm7H>QHOk6y8tE!`$a7Q8*)Dt;175yKZ%q&p_<0jPqyP1)+%xS8mJK{Q*BkRn2l7` z(QHblv5!Cc0OEwGv?hWoWjEq)^P*TCN}|v`Bt}@W#L|)$i?$n*{PJUhYsX)3dKmU_ zS$ZPuC0|;iZt^q-+)aHDcT#V`1pUblfG-ijx#KU`ehhnb_i8PM!#b~hbk%mKeiuXp-`c7uW*92T^Xjbh?!!9ot}x@4Jui=u2C;V z=TVkkB8L+7Wl7zmbmr0xh%SNgQ@Tkh(U9J17ts=7X61G)b>1kp@(=BW5d`q0 zhvEkK6zlN>Gsbro+Ue4TEqfE##)1eF2bM&E&H>{L{M5Lx8bcAr4EqW30V|qXt!7kS zJ|<4C=g|wt8X0r+4130R*pU9_EM(P7q~M1*iHk{TX;yt2&?x{coc>XZ(wLxVMBjyz zp?NV1uRuFzybsBBr22-roe5cu5LEJHBHu=per;1O6c2^XAMW+2aO>+aEFGw%q3ul*!q(A%+9ih{GQgJyZF&6X8A-^ z*s9Fldfn}fMM#$7On?D-_H_0~{23qLHE2^ifahP$;WoLF{x3(pFOpY(mXx zQpdeYk1FV?oKgOqQBTCY-GaijSuJPAznFM}dqhQiE_6Cfe@JRQsq)3ZVP4*U0&dA7 z{b4BgE!C4NxKxCaJ-HAoHFc29jH2bsUq)Y{iy3z7F`7n_3pAq`qj4-}SS0FX%c#UXqO|0&}mwZqBPxu|~eOEJSms@7=J}nY+^_8)qQ-2`D1Dp4j zroaQ7xhr&wuNSh`n6b7O!`^^!d#D<(b_0tPdo>8!o?u9;O8Rit%g(k>j4`TP4~sTz zfC`k;USxOkBOjWoKuCs!n%p88nmO5Gkb+Z$oHS5vA9mf0z*;;EvnjGW5C5M(jF!bO zn(KZ^FfPv@_PDWN(?w>Zt}}lCoXF9&)Nda3<#%&{7N9XV(m*U+Y-$V7)E499vlYN!nkP}j5zJ~ zo@5TY!@*EmdLp1l6YE38e5ZLjb z3ohF@^Jwv(sn;A^^LX*yZQV9yS94;#9WgfXO548N@_@xW_9BAti>zByls71Lxf76s zibR~ac8nJqF*#R0Xxjy8E3g^dcX(8k`>lZ$_3o?f01Vb zB{MAD>90Te`#faMer8Ckro}MUeUL0aMt(dOxBeG8oDsm|O^)#62NUCe554{WXxsll zZ?&L3RF=^H$tR3SQy{X4wA7Vj86^A|M4$){MIuV80|yoSsb{8_5U`f!i5lKUTaeeb z*E84MoT&v()@1d(Jipb_vc9a=xhiX2xzy2g(&L#vnaPeS)LWZN_`KbIv+4Y=@jL0I z`)&=5oW|KODw4hy@&0V?;2=Ljo9`G=|f#ZSGLhQ7t67mRvJEyO4XIF2lMO$aXi zIkgb@&PralTPgajAMA!XZ>LZoZmZCD`l*?pbptNE3toHBQE$QKJ`@IGtEhmn)gB1H z>i0`uG?8<2qkt7@zG> z{{8yoA5(yp+m7H~?K_BnhQq(^%#gPSdWTN0NVs>6lsT&O@!Ns-U2}#*2`4v4kt6 zWEh?|S#B74d6PiA5XE4AfWo~~er`ZeZN~Cn2UojF&cmB8F)*~|kJe4aHRU|!`ydYP z8ggr(F+Van!I#+e8QZC6KmH70^?0bQU_4U9CPnWBKt5?Sr&S zvxg!Bb*+<$GKHmEN`f8B1yZ^FW#CHWt1=;QdrU1^TcFhZK?fA$srPbBX@CN(PVc_K z++$ni%(|oX6l*xg`gn#I;38$=3*=%E>}Fc^T{E6FqnrbaaCa#A2gSxg)bhEH!iI9F z@+t0uI!s03|1_Mj)o$kRpF`HFVzD$`p@S}XDqTzA+JU|kpsBT$jAfC8hCLt*)*%M{nUa8I5!+HI{a$!`{ zTx#!)m}N6-Syq#7;SH_K%vm)7o+kfO>XT?5S(CS*S5}gFs{>8KjJcJ2(Yi0YJV!;rUzjnAd>w4-I<*m=s?@n)covR8kesDjEm@{A7wFHQo;e~I>3?6v zKsJ~g0VWBSX)=T58YH+g(Q)O$WCU5Jh4I1B=43y> zhZI?&OPD!uCK{w{+2l&@*aW}Dx9oQ!pbLV0t~IG-$(T!yj44|P*wCd!M9DZ?^f-A% zTzP_-1e-DiKg+L=%`ldOOfD@mHik~@F5f~FLAjb3} z$CYOImT(lVqqrWS*5nPQ>C)K4?7$15x3Lw&PESp8} zuy`%HWn`NK3!)2lhK@IE3NZp)B1KY1o01uh+HE=38IIi?;){&`QuVlr^GhQ&*UG>& zvm`51U^X{E&rN4I2-7r6E;3{>r_>oZ0Ha0lS=z^hHJrSt)k$iZ{^%F{k?D-^4>OrB zQ!e3eQZHagXDIY#(UmhM>kulTJ)=Q}SD*NwuCF=Q;E$9|Oc|c@jOS9Hq)! z6aA2KmqF|e(fQy??`4(tcs66$JA_i|H0Q`{#Tcu~r_nu_5RwO+lNi;RtT_2#C2$ZU{Q zUiS=I0d9*yjJD8W(~hWfl0~)Qs7)>COxoyQoBhJtvA)!X0O1J*H`evxxqu!-ORXF^ zC|}Tr#@bycJ3D7XUMC?jnlhN{mQ3S>Dvi)B_X67wO_>1(Rd_%j$P(kGyRx0(1D~c` zU=4)Y7zFa%--6ZDBm|Jj{pbAr6s?e^EzOn z))5yu%hvvsyphlC#=*7v^#fD_zh-G=MoT#AV$K~qg%!Z%xzB|*B<*Z%vC@Y& zvOtH%tt;LI=ewG9*}L0NHfg6EW|!jdz{Zv-BKo zzjh(VzufNND*-Tj&vcY4(Nb$V0S%O#dg#onv4#z#_G6Afop=5p;H+?c{+Tv|LIl~3VvA&7gkW)&VAhj zH@>6`!d^S(cAsxxoI&}}t;vD}4{tze(Q_vXL&r&ymY7X^zMS6IE0yWd_PE+&k>k%+ zQYihZRrzu#T1&p-n}1zLWg-Cy#7*-3)MGa5Xd2rzXAo(7h;J^jYgOc)l>+C^+d~$u;^l0MHyP0coAMVYeYcKnWIco>mHab`b60F zl|Cb<;Wz5=XT?Fm&qxCp#R;K<+utl8(MA}=K#N5Qn+L{}bof%DlX0P;&2i#@VgSEIRxDjp?f~X?eyq$OY<{XKK~uz$BZH3Z6s?CE z$OCBAS4!smVz#fJ6fApWLX6WG1=DjO+FEkEo3h<$HZs|Lp8Ql3Akw?F%0I!sGBdpK z7AlIA%5k460u!n1shg89@We$`_n=i$FkE2USv449&7S(^N>{??2lOWA^Pde`V&XxP zFdmHL0=wGz(@GCGsg5ZNHHeb5Bs}PF&|?b%H(c@1FAR-iV@-3_>-;eq8P$y`ftg{2 zgA;o9{WD)zf%=Ixf!6M8b;VrV z3Op$z*b!kvTF}`QjB!aQJCLgGBhe2{HDQHWg2&=I(l+mMtcUWBP8kzk7a=`eD6V5f zV3SJ0js_vLaTnMe8a3I)H2e?7-XY4eXj|9K4BNJC+qP}nSYg|?Z5tW3ZDyD&tjv7T z+CA;Qw@-V8U7dwln{$lbe|$}?=skec7z~{G^FF*XAFcL;GrCwH_ZrE7@&^q<6M=C2 z$2#|WgjNDb`POi^o6A5HR{cR5GPF-I%8MBJwK+6$zmHMVDpPa4l-clLU!=dRI41^w zc|<>xd%u8oT@CUkL3$((M-3N6?5J#(j$PYf@0+g&Ak9hNoiAhCouPy@l?QNMGQGJo z@>M^Ryibq)1`M*e?-@AI)S86D6bykq(#DT9RN5LsCmar)(^3#>IR&AlYNwt-Kgi@l)CkF(>)Bip)9T-gpA2ZIJOla&O`@ zXlS3*ZjAZ#;+ykn4({DSDp!qTJuSv{N<$8ki@_k#ehAfGgDMw5k7z(RQ-^Gf5w){M z;=`HHhA7Dq@e~s|Sjf=I5lmnID}O|?KYfktJM{`z!gbbTU~i~&z@cP z9tY1Gf$r_P&%GOmo2|cdeXL9aaBxV|gqCy1pZ$+{cYbpxvk4!DKO05%s0Z2rYhfsS z72f+wvyTjT!>|lk0OjZSnmtZ^05l~G^7y0(o>+s;2ip@S(m^V$>ODQC!5A$=Z}d9a zQU|+l#gAoRw@rUd_FdOKM1Mg7q19VaFhJF~?_|jOON!mG=N{p&6njAJq2kI`fY;&N>OKe075~}Lr0*eL;g)h^k#s^ zA;XuQ2e2%0~c8Y z|D?LBphuMGgWeIEJo|e#T4xev7(*@kZkVlkv`w@c>neQ3kRHjh-ckBR7#A5UTh?R{ zIc-*1b_*3+mOM}jI*iD5qCPi|u|Vn9S!WS7%-yt?jaGGb*E@@%GLK;ji#!9G9A`+6 z-=Pwd5kyH6J9ELWWjI?Eh6NPRpglCW>_hKg$WfWd!d@+$XqC}=gsejrwG}oMP21ZrS=0Glce7J0(>q%d;?5G#JnCHEXY8eno|clx{)e9i&!b zrpBrZnGj}WZO$3k2paE0H?kRO;39eDzi3W=sEcw`>&q9a~XwYj3MA|34eE7kb zMohL~FDh{*NBerYXeeu4zKcp8%o*~Rr?C#F9>DmNAFNM2FnZtEh9gd=$=iy4 zLQ$Aly0*h&XlZuSQ|f--Q({744^}R-j7i;xx~+T=8{Wye3ZwplvZ0(~wU&=6t%q(# zad`i zl0SvD(1EcxHUd7w-3#UXqKBP@AO8TPo-qyaPAptX14Vg8gODS>(<_!_%DVi@taj5} z#U|5*9m*?UF1n|f@znZorD5Q~Q_N{uDE~YW$aw|+$vY`>5^VcxtlKmvwl~i<$I1`t z4=&^v8p(P^pVjX7FF#4l=f=aDzHrdEz&|gJC^+8tupJ9^_0xyXUF*%b zYO{V0(`47ls&qCkW?o7=cx8(9_@p}6%}b=Iaoz5z>Z6QI->+55elT{|MxyviKyM#e;Me zsveK=*{XTm%2l%l4x9DLiHmlHbP9v!L|XT^U)!ku2+%-(2B!VX`ctKHdHsZSxVv@A zTYpQH#lJ&0&32)tce5~3F|A;%jk!Qh#hW5j-XJYDo+m;+>b6PG&Nq^+L^Y*n`9$_`s8(@Jo!+O)zNty~>E0#muyV5e zfGzHdT~jg%My4-7%ZYx>^vb0~$9d%vgSYZqLtlWhLw+`8JLcrk<`$topa=^Q#w>`! zaOK<3Ae+HBxhrbs0I8~vAPswXH<{t%-i3&G>GG@9%0+AP^rt+RzZ8MSj37xSYh)iW zM(hWO#jrtxHTuT;1J&XQvw6GWqBG*{sxz%Xg(>ID$@FnIAF-m%gL+w9MWqxThFTn} z$mK(8?ea;b4c|j7gQ4onvpaYBbjt&tXhe4}9gQu6zPip@?KJ1_cV92z49t_x;E!?! z#z|;l<&EF;%v#w$*2ozs!LR04RwYsl2AiS7@Z~=;L0Wnat(F+Id?<#{Y7&H59iz7> zkHz`7R|c^7$vC0X6~xkKE>39Jf3ps7e#i-ue!iceW22;kCszJ>jGLPS8~Xl2wupQw zqA&Ic)hKXkO;g^>=}0w2>&d{)Xrq?+Jc{uVP1#W!rZa^+GZ%|kZy%ylulKHFDpl&N z&f!L{ahc+@MUj#zM9J#5BU`h5O41oR?nzKvAy}uDHA2LRX`RHjhAc+9!(o)!n%AeE z7&{C3M4?9~e=Js`VNK59qeglPs5}FP%aIF>_=HU}tTj<($G3(}-Ll*V=i~>WctKY! zp8?KVceDsx?eEw$Nk6+8hOgK!%42G@^W5d`2dPqswGj#uvs&zzzrEVt-CB>CU3x)2 z9BcM!2VQaVb?&plk7G`(m(D&cJa||)i(^NYrBv+}gKL>h#G|Ik!F3wJ?kebOqNAf( zt%5d5{>tgwDrc7$^OkRZpR1Mhv%40y<+v6e<5Ml6d}M)?hCNt;z9IQ()1;`mbu>*G zv5z}z_CwamMSkv$a!zCDP!_=RsY?rxhA=PDN@++G{ zZrl6$hWq-cks`%crf_tG^U{iZ_A(RCX1 zO_QIpy*ipyJ4S$>s_qA6;kuHhY%_EcE*~j)^ZDx9fdU=!aZT_+=}BjhEc*HL3*a59 z9_yrLODl@4oLlF-Ha5Z>AG*?OgzVCkbKrngux;8p82mA6E|2e)%XRO=qGIvWlYO-d z81FOjuYEO72=9b;))5w=w7_ZAyz>5SD4$G~*}`=>&*GmbQ$xKkfnk>KR*BX%*Jc;4 z&hBlp{iF@7t7LmdrNPxul{#E#PdLivT$7>r*dw~dGUd({j?;YMyZp%)KB;XV%&6`X zzkj~2{_Y8$rjQPk?xe)1d;H}5uJ&sx@)Zlrq?<;aCc(Z)-pdUy316CEW zO$GO;js0z8I{3l5%s7#l|4`kV{NLI1k)VQ#Ol|nzy4Q82hqC-xq!;-7*FCi76 zE$gMZ9@zIE4r2K<@s4oQPgswu{#9nMtK^q@nZS(&<_s7ug;uQX1Hb-WBH`s548b~( ziQxN&U%%oEhG_Fp?w#UqD|cB^TIv;Y^Z@P|;gO|2yJpEwGj!hkZ!?hG#mK32GC}K% zJwl|%q}E)af`(jpV68|$Q)0?)f-OE1+PQPz;+K^pH;=>U#H#o3-RoQNC5;w`$)d#? z12Im@1K{9T@YyPf^bwlPOV>$QqjzyiGGf?7F9rpwofy;Mxd`E)A&Oz{#z+uycXaep zmEe;h-eYi{V_?z$FV7oqiOXMTsT1knY7AUKJ5ynl2Y{rjiJ1G!H*t&juvzJmpkz2svU4Mzao=gn3&1CF)odbh$r0V zptk#%5MaCUS#}-D-%>F*T@rgh5bL&p`qC2m+_0b>A7Bvjx-*v;PVYjN4*IZHW^nF?jGWPVf zdYy%YF#|0cCqmF6!IcV?E=^@qIFeDMMKjCQme#J)@&+n-(K3V#7L)nw31!hs&3I3b zaFct{V)K5|j0`uT@(4g%+g$S2yfkRu1&A9X^{Dhk1ex4Fsc3lAV@}#Uw3)nC;5HeG z<(WYiS;Fp&mzB@#&MUNkc?Wdd*K zy!}c?iW*4zDf{i}e4eAG1I2CW>EZ2dM}eaYd=Fp%>)J9Ev%kaSIv zC|!gqdXnA|s87|eXepjXYk@TZWP2H#y#zDfbLr_sCeN z?2MwwXw&4bgXAI#LHd>H&=V7?eWIt-&9g)MWygCoHG!XMZKfz zVfHSi+izUFTGP>JP)a+?pTIrhSaqI~RWym}%~&N`tO^^eteTC6Vd1HF4ZY!WGbI>i zomc;@*PB*D^WAT53gMtWm(1sP5xP0Ek>9*lI-|z?3&g5Vu*ysr%}su*$+_LqJB^Rm zSDt(WuTa)0`O=p1P|beB;nmt5vxGepw?Ysx=Hk3;W^)3wh~h9o)qsKI&n~b1?0pK% z18d8l3diuaU-fE{lg|Y*9d6El`TyP?-Oaz@x?n_xTp4t$hYL!ZM{jJ>hA-6_CMoaIS>VX9{hjUp7*-63S}sV^%Zkc2!y|hnTa8%Add@V zML=UqGs_L7CMGu#u1|9XhOjsc#E|uN;-vwiVsV{QU>VcyS+FDSU4UL;v9wMtvARxL z3%x31bpUm4)P5ab2h`#9&U>B3{<*OA3{$j@m_gi;v$)`Qguzz|%so0&(!Hahyx`M1 zkfCk9-iRKsu~&f5Tj05$l9Hd4uK?X4DN8m`8BxZm1G4O`G?X;-GPIqsjC?lFSv5gC zr3Z1W%}5VcnoA~eOQjom4F#->7iSgaCOlitMmm@gDO&t%(vOquAgUuL<^uKy)+?{NFBoU5F<=q`Qtk=A@R17(|G3kg)Y%S%7uEslQ?B0Dsw#Cl=C}EDX=pXIlEEdK&Pc~3X00Z_4k-NWXWzm3-{6ye6?1GzZ$i0!mW2f&CJR)-@}DkfPO}>ZBzO zFuDV3RnD(=rq#@G`^lFis5-EJcty?x&6_@`TaEsKja-CUH&!{_5tidx(^Map`T7Kq` z;b}U76r?+;4EA*@3NzLxJIM_G=}b5fKn)3n1p8x2=BqJycJBpksB|yRH}R853UQ;g zotiCV8KU4ZUQ3H`tt~W|@sJqWP~)Dde<+P4na8B>o*#UF91-mcNl@k9G!*>{OzmwF4Oi)&m2Yg6q^QYJ z(sndCxZoHQ=G*28J^4%Hp6k1jy#o*_sz+G=ym`&vCd;`BWA+T=AF&)7wwI3%Oucx7 z$Y{~a|HBV~_9bk$xr-5#CCyqic4H;4k$wox`FCQrUFg8k%4;p`9}O7a1<6sm%$)FG>Lsl*bw=0GEfxwl zR0g`&JW(yTY+$HLL1!r-rmD|(^S5o0K8D7}<(VE9-|{2=V3qjMsqoxb|HoHYanT#j z^n2z{3s}YF+? zquvO?l=+Rpc`yDoSD;oY`8qzv7BJv#;v!WuY!lhgeBB94l0q6)4R{UGvZEXAf0epz zX92mkGuod`G00(=H-Kf%_o|@wU)11cb^Paofc+)dqF=ebo3zb3FhSId9<_3zHR zyi^kai9&z+>7l%_(O^+7%BrITKJYUEkn1{6x_72At>`vzgE8+(kWm!652zz*1yT)? zQg&dnvBihr#FvyBzjMjpW{(|ORXWEGdm%QY7v}w14Nlf5&ebp`u9HA-D-35C$1t!p znxzBB-+$-(l2Gx4R=uQ^JLbg?KYm~(Q{ruu{025Rza&VRDIveitTzxa zZ(cve#_*)~+w5gfg&7^sO-mjJ(^f&- zzKLf00(~v^YOEUb!lMmim!-G89T&I56%eu!XYY`$gm+(wH*W>^zZ7G&ALVi2t%CJi zfe&dX7T4#WK zQ5G{_J#lQGCG+#&-iR#l=!5qxj-PeFC6o|?#y&GSjICmsjpLpH*}u+4+R{PIFACU$)v&pW2~xz`C1dl9WDRzq<Nqmi z0nTSJ8W~&CS#GEjlO;apG&B}!j0Y*r8ReKo;m{4z1chScUJjB%JV1jj0e054n42-z zAki6FaUyf5HI}l-og`k2GWj4cQ&@(rg+=%haW8(_N}HX%7MqIGLcc2o&r}PQBQduI=c6Lan>*+##p&jgSj31Vor&!pt{Z;2 z6?VkEy@c|j?BFEZA|FF%@4rfLo@ZtSnu47Rk^U60}E7AU8h8)2`z-kTNb!m|*S| zJb0IV#=x6Bnpb;8V(X$yZynj{d>rkNB@w=qLp!k6T>WEPJ40JpIX){sjcV+;$A0!B zEH6|RW@$o-2`zJi<=VmK5L$Rc;QsYT#!`=@zAOp8o_xboMEb?)lvkuWebQ)r zuR7Q0cngje`nA=1>saR~IlXwNp0txja_i+XP2Xc;K_(w-4l-SrF+)#_;j*sDa|%j~ z1f{ZOW#;`-p04@M=7;}w-aHsjm|lcve7=HlQ$~wRxLE#%dc`>>m0T1v1-o20GO-s|W== zPHk_gUz&*xO{VEKd(=}?IYOqGXyI)qs)OK#?&xPvi#nK5i*jR4qv&>7HTg905M*B? zNPh|W7U|2Lx>Pc4o@#9&{JD|H-Og|OnA~R49vONbkariB;8fd&s2Z#umFYexUm*YW zus316R)Aa$2R(XDirFvW_*~Sj$j@_y&u#<}T;7#v!){3_xW|85;}K2LN$XVZBVA92 zoGc#M+V+LLcmY2ABc5peti>7I1eQR%r8;uP^tBWPLWb&%;smZib`~9;P=jSm!#;w| z5aV9D-#)Fx);VmzKlbkv0|ub~hR1sWwjG59*1b{lnq2KUi$)%_4t2Q`)a}i^2x|On zBa0Xl+WOtY20!>Xem5~E_>c@K66AcGHgPA=n?7#Pkim9#fcIcD#vK_BykO7`%-_ez zN`Y|(v#&rjCRylG*BZcB5`wb{tw2)eB2C6CNsUt_LV>%a_bVu4NyC^SK%Q6sBeF}5 z3Vnn9iH_Rw4MW_I1y5|Lxb^=icjB$-Eu_YruQWPLi^|K^)z{C;~nL9Ixpx%tH#Rku0J_EZ7h88{ly4y*C`-&~X^A!}4e__a?x5JMxL&2}^h|%<8cdhq&d8DDZor z@2wH^^^o-ItOUUq?iCggXzU>sKb37ZA*`sCR5JEcK6=zFu4oijiS$-jJEl89hLX&4 z;OlxX$>dH|eHi7!DD&cO>*Udacj@F2e{*ZOW46W9(@-#E*)}@7%xdC>lZ_mQWRE8S zXBD2><~n1@Ijg8#HHv1;BHXXunW6{6O*92$tWsW`R9aNP+AS5K&Pz}q|w7Fdq2WlEGA186>lU)ArSlJ|vx%3>)_F)^Utnl377g|)XoL5@?@kf*_L6opK3eb{90MEWe-aFq_u)(3p%i~ zD0J6A{4B)~o4jQE;0QaX7a4@f`V5iLM&K(p(zA?l5%UpR)DaU~I&A#eWF zsRl2lM3@@~3j@g2Pko?E@;$EK4|;<8Dvp@@8jc{|i`M^>giF)k;S|IGqVfs94?P#O z!f1q6OKiwbkl@`huvfy-G*cW^08~ci?@I#ILIK)-NsKtYckBZl ze^mrC^@G5?g+vM-DT4f^J7RpJjgr-o!US@D=?@5see=^$fR23P&AY8TZ@*1?%uJ== zFI8>t3330@9$E9HlzG1nD03S{z7dAOWMH9cgV+4-qp5DtK#8oy(VbwaLCzE^GHC;G zjU3??H&X?s4wO3|xdm}|?Z5@iqHWS~=o-0FIc~7$a%mbpLb2w|AI!x|Nf49|8K;NF z>etOiO_i(7X-jq)t>zi7x9Oy@4GUl}W8`SiNXsdxxhMqxG~TW{j(r zI-Xcq&8&&~YD+Y}T2&e~iitz163cqJkx_$TeM-CiRm`!>GZ~VXl4M!Q!J5>50F9Sb z6{zV&jnxW~S}h9hk?vcZGLz9B1^-+obH{XZ@Y(8QVdjyV!Cl3}~)OGA5$sZdvpXZnSJqAWmRcna1J`yas$z__0 zGIf@wJeK?Qv$NJYzx3ftl2aqNrBfEZ^tF@=RviwXu6eyO7$EAL8AU$k*b#KSRV!$y zS+``vWNyQITVdYJmA+&vqwkF{>gQleKPdzJ%J=m6Fm(qO%vEYG3N+aGRvgG>0=Hyr@agLi zgW6j8Bcma$w4&^vct^il14A)};>9-T4+)-^9FLk>VZ6G6wD1DB&V;M`J*5K0jt_{Pn3-lU0hKgb{{CkjP4v{ial#`GGzeuIAfbwInRi^|$gzTj-=(s)K?J z_Od4WAXk!&LB0n3!Et!E6f`30b*?qZ=bihxe4c0YS|Yz>t+(JCi;&&5B$RE2@Gj?v zUFgDNyl0;}@MxjOcv?+Rx2U{nC(LioBXA=wrk$f7plipdYX`0MVzwJGJdyq=By)v4 zb49=dpm3d&N*Rkl6O=x&%tw#W3a8OX2*%jcA0>x7(K}2LKd6K(Bj*$PLf`PTcOw3v z-A*Gp{g|(qX$IL;Yz?uvLn0{k2ppnM8huQ){q~e9uB?a@y)3U(e;2+;-8kF4zgg@U zJ>-!%-oG$dSaKBa%i80AL(m*j{0UoJ{nrMvwMgUk6+G-h@9>}g&HV%Y&%wXahxOGP z<;RadEdQk{^xyF9|Homf4eP6RlJ>7)QttNmDT=sZx7W^Yt5=8#dXH^Q*G_k)&mPxIauJ>(6O^RN0$ z0MTgxsrSF~gZrIqR}+iYB5*j-^L0pa60k`eu)Qv+1YN zZHRLl$&mMd-))w@UeSUa8c8Lfw5B_0C2)j+G-VQy0=Ddo#-2mr`0)(0nM8#7s~2Q~ zP2i!_>-dxW4eew}kXBJa`=>!ef`TFmUhB363O^yA@?~I~la#jTyKA1_%B7TwG(_YH z^iat#wP##ca z(bzia3M3HYcOYJ&%Z52DHzE!*X}_AK#k)7Axzt#s#~knQ`ut9q@6WNPEFn=boEqJe z(;}hH`E_jOV3Dz1jI!<~B$Cu89B-;lo&`ok0kJj01e`+w2&}UNNNebnD;e96!!6iZ+ZCn_x%$y6EOcV=4=Til zK!-%}pj@)HE4FSev>520P;IaCX>u49R~Q&F`KDGW0sL&j`h2S5?svH<8K_t){tFd1Rlk+9-)&>@=0P;odP&m zR?wW{L&BsEVnZe!ReyqRcD=_|k_$I=F{16%EA@#5C1dj|2_moj`3W#ljB#--a!=(* z9728VK`F?$xesrmO)-k1ya5Z55<`Eki&O;S6)hsh*Eelx{*>BfOqew7n6$v}1tU9D zd%c~;#Q;jehc3(vqlFlNxPFI1e8}eEw^VWprf0x6Y_uc7{fhCNl0_-EG=doLkIcnQ zj#!Ot?gNA#)VMew-R^#76k|+}Dz@qP`%@<~+srzOl$Q3}=}ngFnOZhu5~#LG1Qra1 zcqTilvY)sKL51hARm%VBJj&F#vnCD$!MBc@Zkj$O?z++;26+i(ujXYN-Vy$oVn} zkrH8(Lr2o|JA`hL5?bweH+20e>7)Q3y8737W5ltdVKgbR$S<4j@JAD3-MD_CbsIPQ zo0W5K7%R7s0fJISnkVum4^rNr2$sToD^Q^(FuSFT3?I!BoH?Jn#fzHfHF%G;$3B?e zv|SF=ahKOC!zxrbyE2B$=N#SoNWG#Z4a<3SWX|K(rBCAXEc3VWq0df;gxsAB&Dw~v z)pW<$@T_mN99As{E=6lm!yMC-R_f1qu3q{hq4iVcG(s5;30FWKizW2&kTcc-YnYxpUA{s8SrI_#JhSfaw!b z_2P1>@jUt(yX{jf(KFriNg6Pbo&KM%7@#|G!&OA@Gj!_K^79yse(beUS*0^MoBQ(J z+mQ(QXc7>Ly%08MUaGezJWW4iY<_6QOc3K5Y?WTw1RQ?CoNb78>pmmVhWtv&SjRUO{#{KnLEiVrL3%|q{;kzj=( zIL|Vt50orSO_yOQE(K7{gYk5_qhL&%hEH>i!#X8PmIJ1EZ>cG}!uz0D8DM9hy~MEmo( zaBx+=M__;)JtcWDwu9I7TI*WKOEbWU)pgOfku{Tj=+v5Nuf{};Xij4^$VB86JHdqR z2tN1EeX`po>Ged)AG|)lBWmKi_$;AQao@uB(sQTsSyNk zG|M49kBXhi7ddRP=RKrH%06RLfz8;=^%L~;-R+F#^1d?H$!-e|HE<=4uyh<3m2Hh@ zFIG2^a4gj=4U>_z%yLG8>fvxH$~b%xH`~7~&rPNSx5Dc?IN0x;VtGsSGQT(xgAQ?J1dFt6Qy5xrBRH{ ze(KmEK#Yb9t*xykGPFxZA_-AxQy{(NfL>I8F@@LxVTds-I!SD}P!w<7hDa4$7XE(=q&Ky}1}R)dQI&MA z!D1^@Jg28IGol;XSiRfee`>dDAK4@vg~f@bz^0{F?iJN zPKb@g3e24mnc@|aBWB;$8-&i)8ovoZglAdcWx>$MiSj)5)LHvQZFm@U8Xc zd(aCizrL6!00otwG8^<~)`)bEvW{xTNNL}F=7zMKKRP9)^4x%GGM9N@DU*7VRKDsT zeT8|pfQ)I@-F9W$yO1H%WS+Kb(h8SGYXF5La@Z}awKAe)#U-CZo2>HLFLTZ^?jI$xBW z(0$DYA}epix<^_0u1aRw*+a%+6;7?ipKu9MxHbJnnHQf#aQqN~XXYlM zDsHb_;e*Pi&Gj-feuvCw?uF7l z`_9}0^s;Pc$XTxM5#+slzAJEZ?MT5Fbkw(-yfelpy7jz6$pwwJENQQtU=*T7(;E)* zFg?6?J6GE8^hs^G6Qe2(OC**C#K~-Z+ZO{?`?tQcJLa7=$BzZ|q-1 znog+(6p)(K4s%zO3$|=2Epy)9A%9kkU!(+093LUoDk3(P!`sDf?BmRzGq58D%SQShiwT)~KIrP$`?Z z{DWM)5e+`bF%}vY#O_Q<{~-H4As;<4*B2^kbqJX6@(cm*sK$TIJ0;#7xO>n$@<0hX zbKTbuM5aH^ z+Hp29+zNoM{9|27Cb~=Zr}zpAqfxOy!y9bZ zXW}t6ei?SYiu7Zp79WfVB)tedA4->lHN9-dhxij5C5HehIfFbZtvq38YQh7GY2w== z_j(qgSmShwV8WiJOJ#oQc-F6AO<~k@rn)D?)KpKoJXF~+fw~*43N&hD4h^D*o z*Xu@3^l(2;gO*_qnBjixhHYa*1FRPX-+crh*Pk1;$>sIEL4;E;@_6a=#6vd_{Z&Y> z!+I(V$9q3sIfuSb%V0ZG>CQ$L$hWueeKuc~VZI7GL-ltEm`_LStMLLL@xK{J_?NF< zfAz|hAt2cUxx~@-!vY}wbHybmT}K}W`r`-mx4bF;Ur3w(KPWdcVRttxRZ}Z-d-MM> zKL20ZX4;L*wisIYzB(Rl`|6l;zlnIn@KjX0eon zPFPS)Fg6aB#Q}&n=FC9DLj_iWLO`MLw|J?WK1pp)xm~0zCjEG%c9skQRY+uY{pd|fyXRkw7AY&~$c};hR8TEutRO2>!A$PH9hN%^4 za<{u>`t>dQhFw3*AWnOm@7^T-JICjy;i2d7F8JcSe zHC-`s%{^NMA!;${=n_6yeg7uW+A$g;`I0W1uCnTB*I^7P(nmQKtAi2#yd1TXTl59{ zNrKkQ0D5@ClzCz!=VtFXZi8!C(JcpW$hKM>78P*O$$R4ytM}xWu}v`S^llAfVpPNb zH#Ughoa>Pega4)f<;$^;G-#zg-&L|4TqSZVSaQGZ?a&GZemD(P3V(cY*tr~3Wv%o$ zvnB?AK3!R;=o~&RUa_p(Yv+0PC92T*v%F1`{Xi$#1*)z(vDL6X>-;SKlur@$dJQjy5gc#IR%W`3c zM-*r^0Up8NJaH(P^MTuAb&t$U%+87W+cSC(TRqxsY- zr82pDP4G28+7YqDO8%FcGG$fFsKT^#%DCu=kEnG~u;fZQFbJPn`69;X96as84#Q2}z3smPPLhm?CG4 zth!>@<;{ZOCH{7P<)bt@Dg52tO7b4i@DH+y$s(sR#dsG3!h0m$*~;yhuQ7_K^zJX{Mmz~3 z{|N->8YyGHi{#-D4-{4+f-vRBE92I2FI;6BeT_% z%NIr#x)g^^5BFG`pX82z^8_5Py#8c*T&_&DXc)LYhD3okN9*tOO1F#j0O;p;@a3Sk zGiKYz0$ld^B3!F{|Fm3tduBsNaFR|y>T!l6O5HVs$;-q!?LbA2o-$!p_My(=B?TbL z+#y@?Q%?-#yD6te$=rpQd7@<5v)~(mc8ok{0-T;=VG(!6MpgbzJdU0+W4Lf%(lG!pANL^P^xJ z8}l9aBX8SB?}_G}9BHZ*E4`O>ne7%6JUl4sd@(sz0B5Q+xj(hH-6D6Tq%FI9nQ~9VV^|sbj7UFfw;&U33 z9$L^qI%xXfddYr$Ji``piu!B|^PcP)fj9&SPtQ+O>vLZm6J3TBb5+mo!b5@9(Fi3W zVA%7=yh^~pnA>b&wz&v$(z`5iPdtSd4>DiT`e^aDSi5xK-ZI`Aq5L2~=}^EFi)d$^ zdN#Eo06Ei)1WzWETX^lk3!5(iBaA+J)R2=5!~G<@I!b14Y0 zbN@ZpdK9}==&BlH!F;r%R%K$u`_Q=F0pkJgYq{EiLlDhT1wIdSB!4D`E!5Ecj;y1u zLZsDRF4!MK-eNIltC4C?ow&&ROUAVxhyu5UJw2;V+R^xh=O!lvTQq zv4&D|x57*z=llR3X7BVyCxn2Y)8>2{l~@}i+%=xexQK?7mgI`V@Qo8kV+Y#! z;2^*W5nl%n(4>J*JKCrS>P_wDY|+fXhfLOUK6X}u3Acm7BbYNnJGhgQ0}V#?S7@~4 zd!kfV<~kulZB>SfX&%Jzi*CudD{<1}+9>t3t;kJg;%g@V+6Z)*Y@);S1U3IW?=_f@ zvw9=I=L=(2J!7d{#MxUwc>~&0z)6s{XlRUQvyp~;K^(SHif|E1yD71#{yhZ5JQ>+^ z(oKifY&;ytRF>J_6{Co!{AuHWL`p{-oyq*n%LQfkOp!a!-cDvKdJK;R#w8|9cD_2* zWLQ|*(O?XGM9ZH6z}3b;kSR9z&y5sg!vUvx8*jOi^}^akeq27C3V}?i?@o2z*YTkU zWdT0UVMdkgfsRtnROl}weP*c|*M%m^X|c-UVkqt2@cPBmC)9KWnAPNd0|&=2D=yub zGsbZkrtYFit{1qWLA|I(RBKa;me_O}B?;=qj^q`J$FvEn$2JM-vs~1J$g0TTX<}{C z`1@)lDqw3C3DSD?+5-*Ks^>lW=uG`;vWCh7Kz}vTY6Y?Hb^)H$6*&$oZ0>tEtZOZa zjOgjw+xZQ!C+!e06*|EZYTQ}$iYLOYk_BNUItV99mVA1-v)@;XrwfEn$OGI1>iHAs z^Cr&AV(&DX;2ZU4SJ{Upuwt39*i}-bbu7xH-&nI}4;&$O&QtHpXMey`v6j!W<0zd- zuXO4)R+ZDWBRBF2e9@)tu9~I1P_!(9s%c0aD`pkfC_&3EQ(GmQU}Mdng+0+usLUf0 zmYA54&A}|mpJ^5rS{d7Fg}UMGv{C!xoj@*X5m%qKU8Xo0&iLRgI?NofA-wg@v}NlBnKDTy3BI1lYZrWLSwI(AR@?iTCJVHb~`?L{+Sxn zxg2K!tXi#TH~ z?pYbtq2!RWTs3;`wdgQ8oqE*GlU!&ccxvRZ;jtifj}}=qS5!^?gAv~dLtcvCehCDU z<1~W&vCnfOAe&nACBp@fK6~D(C>rT}Va&yvILDs|U}rd2`4^5Hqp|L5^2pkwc~>Y{ zW!M0FD9y^X)ht_b9Jm;DWu=`sr2tJMD@piJ;h(ov#olT(E;b=a^hd*yn?1kzd#|NJ za=smkW7Mg&Cz5e71abWURygzR_6B+l&^uw);Yg#k(YIz?Zfnl!8!ni6U!ElMks+qL z)LK1b;Ow+bN2XlKvFRVfQq|lIVOV#!FGw_e+i8CcH6&Y!k@(C@1nP{H*0O8XX5({F z(NKoW#+aekE|x-I28LtDOz`oHS2HAR^5v4bAqJVvsa?MMAQ*`aVP3CuL4pwUOr2Eg zbB5sb9@D)NiW_a^Ph&}*ZWGu^4e^x3jahij5F}UwR7j-wOt+6@hY!T~UT83XT#(^S z$$GZXj^3>5?N2V|oxbj3NAer-7+}8m&_~^on>Holux}3FF`XRmS}{Ph;A&JL!cctF zKD2jKsljwoydcpGgtH{iV<&^O;1QMB+IP|?wFx72sx~`rrd7RD=p>b!ovsLJkG?&_ zJB-keg*yP&!t|G6r+{Tdxy+db;YGYCT6A~4Q{kL+U2@AqirzMZb5xjNXtyv#cH zIbW>es5Rsh*?&x$w0r&P*z2JYXX!4eFIWaON}mTW(fR+TgGy##u0oIpGs? zh%Sfa6I}4p5Pxy|wPq&2GEG6C0BGjFP$vtVYhFL`BikWU!)d68D$LH^)Smk~E2X*t zVO~K4S5~O7;M=UNzcZ#wnRI%NStCv9qBfSK#-g$lgQ7Cv6+SmbZ?4&5-O&ILQ~Pmt z*_S7omB^g00nuQPHq9|0%wtSNu*}w<+Hz^Mw(mEA9T&ZeW@_X-qj!&DmLVHwEE8en z;q+Laok##%30l7a$n-4*HzsFRAjQdukWUV5{HJ z)JXK)dDmANSP4n(j3>G+2C$ajN#yNB+oXE!tG^u%*59!4mx_=7<6PC;*O3yWSk< z#F=Gs;Lw?6`rrwn3GwNt`yC^__d=b#9ujss3IooNj(+I5+1LDg4YUYW5945U1O$7p zaBD0?ZAQu+OIlv@7akCevpph4N)H~eKkN&@5fy0mW%w9lQ_nnHH2YytQuLfroVfox zfYjI-hXlFWI9xP7Vo)-EuK(yuX@CnNO`m1R+mES@z|T~Bqa{LPD_0FYSQ)b(CR#Gr ztZvv}w3Ar8p{4=7I`q9Bcok+%y{bJaTImU5X)iYF1EYc+4TGn{5w)D=#VlcuK{sZX z+?oC^$!g1PaAi;%2vK`jtx$-22-p?mywCb z69qelP6R?Ln76V91Tm5XdItSM1J^6|E%aF%NBNd5f|v7_!S&Mzq6Mb6HxCi3d0)R2 z2p)fLvzh4K4}OuB=+W1oFm99FsX>*2ut|7u!+ZZ#6A|F>EiVXe3GHPnH*5{eM{nY> z3pR|CvA(tp>wM|k{!GAxyh3%A2nYu9^il0Z%cP`tGwlHzr>ZxEU*IxjdzZv%`c%p#@h2DD@D zW+2#m=ri0MN4d&$p5Yz~=lGLB6i4#r7*lRfFv=K@gL=arr85Q>-I?=w^v;ut__svG zTckwB9GR4QQ(g?BhE$95?D}=2uh@AUwOFSZi&Aff_-j+kq_Pdm2zF{k2Z)=mTJnGo z`mZ0xsGEaZz8rgW?U&s;@K2wBKXroZI|LBO>6Wtl@X+Xn&}iD ziTC#l-`p*S+EAc0s5lxaDB}+=i|uClL6%RYH`sFT3(lx!DRDP0W}-+t{Ehr4NrD_#-{bu4(XsRFjXTS?0CXvcs0z|{W-dd2^PH}GFs zS`wy?pZqLwBY>l=z1u$?d&8%e@gE=p`NpJi-dboQCc*w+D<;v|v^_sUkbI#HiE}J; zUYPG|tvgKe{h4&IC3HvYRz9^e;-aVSVfK_nBXr&~_UwmepfB0K8C!40 z%W~X-@szITr`wUntn4+{ZN|w$udrTk##joOnu5+f+j!yyMpq9-NPG4~eC9Xca_nJ1 z8#v~`V76S7d1}eFFTfK5Q3oziEc3B92Euf5cbL<3UP<77!MqhA$`|#f_6VnxFn}CelD0N@l4jf2N%ga;8&F_*BTQ zn^OCaP)xBKc<8P8YdUBK=7=a5{al*m5!KjGX_=8Vcggh@1%=jTG)8WE%!B8e^M8yS%8@ju{ct&LmuxeD z4)A|;kBxSHOD#>y44xKe++RUa1^=>uxwDLnUo6-34OX8G1E-7~-1dhSa?6GIqjp-S z3aq7B(WQCCGfK3yYk*=5cm`6jgE+HE>K6s-tVDP7j)Cg%1?|#WO_`yLs)B1W+HrWu zoOzT62~!lcKee$gW+Vv)0s`7aP*uw?ODBDc6jHhQ{ijO;o>tWAz@3=~C;>z1|)(pLu`C zlTFjW#ip}C2=1M9$zQiLf3qoY6e96ccx)Jc2^9f-^(Sx@&;Ryxs(jz? z25fvI3IAHwn7&u}H4dkXdHqVoYVO*9Vs}UZKMl1ZPlO4kbV}1WNJG zN+coOGk-FF>m(zn7m?s#9cQQ2SFFf*#w!k_oe+Ogeyl>tQ|qhGk&P=?9@0kPX{6f2qhtzNM2CrU#G5$W1?ABgNh)=+ zGS`K&MX?f!pM)~>t+dQ)pjF>#s-8ZZp;e&1x~NQ;Ws2;WCB)kIhT-XIxxmmb*j~%T zd5|5ayxgH*o)%H!8BMB zSZYQ-0-croM3A)}d>!fwySeJx150w;ehyHHLsP38N*vFad7|IG8g0;|_tvq`8dlHE zf$eu-se}8QI$>kyV@3}sU|Vs#daG?4zhR~X{uFjduSZLxnxv?D6Vg;ovMlUlqMJE& zG|PHRti`3_-?HiwV8Y#uP39I;@OQM-kv~*Pn+S+w)Y&jCO%I^J$6$J?#LHV8CK1aq zz4w1Of#Wl$Kuyt#w4;hmD_{o1VcW8nOwHnKL4D_vS>~?1Gc(LQ6|`HV-DU058bJrd zk2j%YrU?|^KFXGzIm+S|g{Mp+J5BGRBi1w^GYRwbN-M%c(kg)mTDhO67jR^|uT-u< zrEQ^GY84xnp6V_7H>6fR0WizMp`uI~cCBlAC)45h{VR3p_`d?g7m`Kz2ht|f(mxCL zhGi`+wn5)q^WtE45owFBFU?MrnKG2q6;UNlk!EW70q43cbVn@wR_+&pKKM+ab!td&%hXJ}T zE`dygw;6XG zZv2dfIf48cJb;%P--}i#&O)x0G7Xiaw*^(2s196;lctEG>D!Bac!R?k^A<_}mSYkU zuao?K$|cn7F9W6uQH#I-z99QPQDk$S+w@oWhQB;Qifh^k(lf z2Avn?OgnDuwaef{vmDp^ZWuz??M@d=vDW%*dKgH74*tJ0kgHT2vkc%DR#|kED~RxO zT-&mivpY=8R{ze=I1gN19h|GKi>Q46S>4FcpVbDw<5Sg(y`K2og!6NKX|m!%_sBtS5d=0r-Aw2PFZUAT zBj9qdCreMG)O`@4yXlXz9WX&Nhg|%`9eBgZKO9a!h}sR?A;-IlE3!H@@)E!`nRmQk z3K;s^V*VXwbC4BUKX&_tL0ziY8&+m(R|$pTA(+$PqV(^21y=S+Q5^vQ9kA%*_QO0CgO(Xpm-ZHp~}p=57|4+ zH8NR^)Vb5m043{;j=!-EbHy`RJK$2ZgOul#A4`6|$V_6x?-%NW<%*JvQ4s3GtWEKq zC_8G7K59;7FqSaD@gojV|y(XggR|sPira18tgpF?Q<^(;_DQr#TnKkD=-JUaK zn>t6@Xkac%`qTqtv;J>e0L2pK-Jd@#oiJTPh>WO9w|@klU&Q6{KL#EqL{+;V^xI_< zbhkuUjyWr@_O$N>hTra*Hx=$qL@N~-Ew6wA|vx#`6;2TE0CkjS}Rf`(Q_YhVtlgwPY1_U zhufVvBJU^142*pTnh+=EHV^MRVS$^&FAhjI2gzVZ>%D|#`R)h)_#HKG zyn(U~*N9(Bf9>Ent`Efph&J~>x3}?&+&T!Gw&D4S+Y>l!_p@wociA_)R>GQ|viB-p z_kOm!@tAu<9(fdDUflvQR1v@O&#|zwI@*EeVka7cSReRNUzlJb zyolXTua@x8m>(}aLKO&Nt&EURewmAiTPi0rTp>l*snERv$L6M3r^;15HYn>aFC|B6s@DyjdODtAybSD(7;d!^7Tc8) zQ;!%fmgR|olT#4;Yi{H9GB0fL9SQml3m{EB-wiqtCgK`46H^N}3oPn`6{lJ}56e&c zc}>P_IsxVvmZzdCimrAk6@{o`A=xLD3N6~u9FG_67~r!OM-OxlM5nU^&|(nA4IPyG zxX@~rXc_Kj)_#?iX3{oghA?7C>luxnyh+JLWYx#OF47|OEwr32Oogy!2V_D{ zR97gzdG61-H7Mu>5mTVTS>JK4>K-Bs(bCu?0#~r+P!^T+l7ehg1Fam z(at1cP^C<+5~v*Lo${;kNSgn2;j}u9j-Q{Ayt>xs0@CJqn_9{sOa<^BjiU@yZz_F( z>@D1#IP30k%8WSxvwL`*T<}Z)N!lPFbtW^HN{ee#c))yJPrwPdkgJnAie{xFF(I+h zCywH{V?myqb=SRAe2TC)BIu0Jh4X6)TI6nsCo)tP#cd3+kPz=jZR+%h zEl%Dv9-l^cQtg&PF1qIW^5=6rIR(o}va7!?ft?&jP-{`)H72!6cTub(LrD@^9`*!& z`5EYmY|xu@va2#TvJZ!xhz{W?)~|8HhHNmzAx@0z;?Px{iwt1K)G>v74B!ap^1F8M(*md6?;Ya z!&0s+?rRj*LDB3i6K${hSZ-TGvWE6R% zRT6@x&{x+lNbL1X6mva8NKs1`0qTu}?wBIm&xZGUE6P3lmz-vst%HRNE8RRTtt3<- z9^7wkXx~-LzS(CFiS@@I)j%?!*WfONV)es{Ip!thSdWY%eDTSB<2@p{YuIU6QbV1d2C8coHt<;z z9Gi3w49kO>#Ev4rFJMj;OF&^BaxeOZ%_bJgN87*4(aM_q=*(OQiA;zq{Oy~uNTi!$n^`#H^X8GeSwLfY4F*lcFkb55Dt%fET}!J%$7@`rdl z_L>)v0J%SHAtW*(lcl(+!nS90vZrJ!Kb|9mFvN?H*p^pTL^euC5=Cv5R*2J@crIxL ziJ2jX_fdXoW4p4rNw_vQvp}#hSgos$%3`v3z!r?E>#>8U!U;VirvvP4v#*+4kRS1* z6d9POgu|Tp`O(gyOHDmwczR!cneQPv<1l|A;=9N{FICjr@(|T8XU{FUpvV zK!j`|X2BItuYOjt6^TIq7o}ljvp(5ju(i5XWHXT7p})Z)j$M^jo0|#6+&CQ`$_d+* z<=S-HB|~UM@x(5;Mnw}tQ{Vmj0k*11b#B|^H{A#9Z{LeT6pRkg-byvUmz^mX!oOvT z>6&8eA{9HLz9>>F+Ph8I9QzmH6}9b}f%L{U|AtUE z=wp}iT|(X)r)d{^eel;>Nta*3F7U7y`>@9^9J5oOcO-F-NX1`vpY5qdNvI#5l&pA#=4nJUb z6}a2~w!Yg8N%alCnSmy<4fiFzIZNXkM}XRFzH&~=+qcKG4*4&Lqj>r@y&10jrrC6y zz(*a+ihx>uk_VpRs+`WCb`aNPck|HahSq$38wAJQ`^Uc)MW1yL*r#&-pC78vE5PcC(MGy&OK0v#E?{u>LntAN7%;?qN#^{LP5 z{cmn0WbEK*|Ea%<{qxQm_LiTDEUAhU0AT9ipls>@vIRPr{_|I+f7V*+KUHwm(7b_y z7_(@M(gp>Csp>xx1S{%M@&&(H%2|>j75?p6u>tM~+h0v?;>P>zPE8}Orf}zNy`fG% zjWE1J3^}+YB?%XY;Kz<^rqvzs9&sIIIyn1$91T=~T^e^FO39MjAvEE8&WG_xIqvMS zZoH66xfEU$7&5RR@H;V{8Aj#|*+6GxI5JK#ssh~!mfRDp4WuSGz>QqHquqayA%;3> zSXW}ROJ`c`XWa-MHf`u}TrEH(k#~(qjj&NqyU|;BqL8LlS)n#(YK21}8#fkYfybmE zD<^9OR*6pz4_O4{v=v*W8)cJ{8d$QI@@hJiImPD7j5?g5b09tX(4IF!8@sx*``5;y zJwEH@1gv!3*xwTuueW5_BJH_*k6{UXDAKf4wPss+1kA|CW4rr(6=>qF!$YvF1pRcq zkjnNXNbYd+l6=vksORusS%o}d^_RI-Mfmg10Kpw#+xxV55UIK)9oQ11>^keD0X!ts zXlgO%CUdXE{#|kLY~+^F4QO7Om4O|YwKi#jSl10=TLjOoqGd0zPW>`)sA_YG1`qp@ zZV$jSzDg^dnn2OVyUcR&33&ux6mM7U(b?=gV3(7z>11CTT;%b%w5ZJ zZ@Ug{a&H1{R@0=}9&5}>1!rbEY|Cw(Ls;pzY=u3HK8iXy^>8?0fi5V+&dIE6hFRD= zRhh%f03zQsCkg92W;}CZ2_e(WSH7oq%rPq7?mo25z6Z2GJGy|eW?_~;;f07doZh+! zorYLf=fhZwQ~p2DwU*--Df%4S*j|)7)Z>elV%B}+eBty+9#5DY>y5_9v-gUMq*2It zbL*AdsHo8h6xsSGvR25=f(8@|N++;zpysd#K{Y#<*SWEo);3eK^0*o}Z(Dvu&T^p_ z2mL*vbQKKPwLw3GFH7+W0Aj3(l=kT7T$FQn&H3~4bLLO)lqt)U)N7_1i>JEgBon<- zzD3xpDa*odXBratB4``#9kNBrpz1+T9vu*FNxvcp?tBcjA{UNK$p-V8CoeE~4CrqH56J7gVk zi1D4*H-@uYa+`V+n#qC|@A@Q^_szGm=;ZRqb*~Aa>66iWq!+qqJd++$gJE3m9hTrB z^l0(>&mZLW_pj~V?NPL*KQpg^{jR8XmF|P~0)1QrfcT>LjX2VNqBEm)8`F)o%m-7? z>Cx6Icx!D5;R>ex-Ukf+{Dw4QTnYYoS;OeXvm6`nud3)$qFHE{fchfDsG3lUe&bM+ z4u9_???3Ml|9W6KhAk=l_&j6met?1L{Qo*<{&~u1Lp$OQV85G@d7Mv>JEtQVNA`as zle{GY%z{ZtN}l6=Uy~vk8kB+^o*mp2U4*ejhmxQQP)?nVn?=!fZ&H-j$rk-aIp3jk z>;-BpxbGa(0v-$0#kMzU)Zz);X1bW0zrUn@ERDTYZFmv>id(6*s^9CNKE39zaqn{V z6y)WnBp}>v7Ka!LQqv8K0(q(qIB{kR4?Ixw2S$}0_rg;r?xIo)`P9N>?LO6qPHori z-n3YG5*R4ju>tp+r3NtVScZ~R*L@kvmcy%5cgpaZU~rn$cAO)t)OHXe{iqY60=3ph z?1J~`(Z@iDLrZ0#Dj0#wy(e*W@c`1T{inoG3{RclYka#Wy_+Y3p+9Qr{)AA;gr&`d zh~vGVs(WNsF(-t8+6~KV`W_~=`c4wHx2epB^^L0{F9Awa(7+yYqy(3DA4rrFHRAN- zo}Dj)71gpsz*N&cROn2W^j_72H&*`4GSICrF=4!~d7fOB!-Ms{$?c!^EuIWDw@3y&pLw3QzALP8ogG{_anH19VM_K za7XGRyd>cw?Y2UIZccWH@HhYWs_5{X!ZFEXzLXdtz6D(D@Hu(CBa1&@e&ql_4KR5%*^O-5y}u{B{5QfppPW>QkY+vPHFJ>_s$QYN%h zmIy55+sj1OQF0+HKQo)H=3x4en#^oy8Mza6@`U4!B+@%pG`mvHi;!?A`no=K($*ln z=(=Owl5262N|)p#id{3(!RpTVdHHGO@6*l^c`Mv{v2F(Uqp!3luwRsCF`Xlm;h4(l0(5`Tkcm3Ehil)}2Q#ULOjqmSIZ8AfGt#}a%N2?6A)~ueL$Jl5 zP!XY6$&wojlPuqyLScdpN63F)*v_!n=w`*QPoy3pcs!kV1EmHbk`IX4$Jsmn zg&|yoH$ooCm1(HS9-sunUB&a7O*O6QrTN=H@G4n}I*CGTMp;v^3ISIHEg%I=4Dt#U znH;>&MirmUn#IRvWrc(X-zjo09FUtP5+q>B`=SPrZX z)PGg#BTvuywCY+fhjLgS_h7U-Y(~=zx#Su?Q$z|_Kf%6>KkIov96hxK`fO+6ya)I= zyh`->+~fxqUDpSiUzZ1ZHAll#c?q#Tx$Ai9(V;oibV~B(y_}HHmHiT!o{yfMq5$*B z-pQ2#M|(tl>%B=2{Md1W{|qLGOk!;huMgC?rZ%lXW*Gx_a-(77_kQWN6gmz%O4 zo!<-X2LD}@##&{R>gb^1oy}&oq{Uu&tnV+i896neo(ZQ%VXw_>g;YWDlHE^QYIwn& zvCGjuT0Si-?Md@$0KO`eY&Fj{7h@|UPPy5b>i@5)U}GJ`pR5oc%kS(bJq zHjZD<9wzE&BsQX{SRuTSramOZ#>aR2B*;xD?tJ9rG;dr~W4b|cCemBz z6yVC6Cj;d#e5d?7pvL$d2W=6h6O=`!yR9)%Tz4{feO$HSk0aetyf#&dQX4c76O&x+0R?M=;3y2z9!W zr#Vj0r{&n0ZbIaa)r}xn>8~5A3q8VXPiAsEnh;&XI=D zu2;*RUABX-1tGkuX)*jEsm~&LKluS3N&?%K2!y>#JG7CPUC1<~F@RChS=yTA3eq-- zRV$LiSpKNIM81IMb4%80b0otlV|Wh)zH_(q0sUW-`u$KI(3o?Z2j}RzefoXy=T7Ug zP1j7-UCBkUWA~f z;z-Mzu6-^jL?OBQa+wz6K}HVK<1SS?0p@hMGK(a=NL5I!v_@2^Koi!68=}T@Ie;jb z5X*wy{$NpY+gTTT-6~jz&Mr;Ie+_sZvu=Sm77&%x9D=m2uu~`MKXs$^BwkaW)|mtk zW#+Q`t>vH!)&v<(OeBh=_R|m`&4dg4Md=D1nP^v5dP6lKDOE95VkTBB*w{DwJ9U3v zEfP|@Tdq7^ve+0zv05r9d^TLX0D_3jUnN1^MrD<;n09DjbfnpLQG<#GAG)C{`_7xx zPFep1N|PuSp_dvb(SE$0ilc<0s&@n2m-~N z@TS_5SIB@E>;<>ZV&XHvSgZ;jJTaNBH2-iR(bsP5C%UK zKn{@Tq&`#)^bXzYs1katRrG&+|VISW>Z0yr~_1_)^GCgbuZD&H<9e3=WFS`M* z8m4TC$gdlsJ5|l2`AIgNBoo$xIaVEmHsz{xul~b=%2F|VOtY7DTjaB zwxodnFzFfD{G%MNP}Q?W6++{StC|?XSu0g5TNKZeQ=Z6$f3E+9OIwu;o#G;+8q zyE0zcmL~iW$M9FN2l8fxkZf~9J+DXk>qae*JzW#H(ooq~rYv(%pC(dDXb;3a`;6u z=y9cc7{$_i-jG17Ad+z`|3V_yTcNR4``EK3^}B%zDcNfY|Czl*bp}Rb3PU$)kyg>d zVFW`=2P2s?C^v+s+1hYH6v7((?q-ow`AQ47@+^9u{BozW`w)&p!4N20x3NaSg9b8_ zRODat{9Mh+Fk7>!>sWK!1hyj`PtAH2A=T2Aeq0d!z87Mh5Y+2_qI>?NLeYQhRy2}- zP{=TO41GV9HW$4aFqd1?&F{MKcob$zmvIiLiRUE&w<3=cYLp6DMj9e1!M zz%=}V$$1DuPLd}V*g3T**L?BsM~>Z!<`(|j_f7f)F`gL1E(L(1v0GZE8G42?e9M=7 zbVWumW=}rU0WJ||UFylV$lQ|kuWcdGIYY`A@+S(K5e$s)fBW{S+1m&^S=xL;oBr{p z9ca6G&M!24WSYcojqgMH8^Mnje*N_CiK7XH5c__~{Sxzy*m%Jp)*zNJWgM>VS9WnT zLq(gqU`0ctriLmCYI&Ppy}C|P*KJW+Sr9L|J31xy&^QLco$!-T_-SW*WA<< z@hWNOtLO0!zfYmIPo?-rE}Tz@LCebD2I}|G2!-n<`PYcRu7zutPiJ43#()6l4X)Zp z9`1*~k2=f8K!ndg7uU^I>5IT9(x6Z2qEEt3)01t(*hl=1%hMLKXXuvolOHN1AJUhR zkk1tex`Ewoe&yZ4xTgdaX|<@rzzkDYY28wgwesPh=M0r^_^gQ|HZs;;qCNJRc%G{& zlYHC_Fy#j-Tgra?2z^O36+LYt6#?3aYJ*{_OyL+@(|G(ITF+j_uG1*(0#^Xum`&06 zO|~ZWLXZLa7qPlgDu)c^3aROU276!fyLJ2A^!(6gd9D=QF>p0n)d8wfPBrwf(d*cG zO70@A1ILG&Wh(Px_Yjpy$5CZOywG_H`^4D1MY=K50CJj*>U{aQI*7bQtdK}H@$utQ z*e0=W?s}XygNXs*uIu5}_L1410V4z?MvaxSq`7CtM7^sqRsj+8D%&MnCN@mIL?r73 zHj@42AP@MW{_zPZmQ2l`3RIuFpX8Y3Y-{7m*g&JD@xO_Z8jPJ>mi^-lK-15l)MN#VG-%<$;!*>{K+}6qY*j2_rx3HDfAm zhd{05%wea@#Awq%)FW|Jby7S7U`oznj#fhuZmt;6 zkwYHz4H}D9M=~_apx0o&qC9!IA}9g*Kvu(Vfq)%l1dD7vUci0TFagbsWWtFQ12NU| z-q(_iK~6hIo#k+XB|3FLdU1UIH*e$><1Up{xT1S`*oOV@?0Z%k8#0VAv=^9b_2e}X zB5%!N1Zyi2wsPdv889{Yr*d5e5ap_LiTbi`#<>+cAVS<>m|r#qgQR{lSnHH$<3!R? zv;StEWFco(>%DU=_oSoX>LY`{bG+}SC@;U{pie%zADdWE55s1fREh^Dy_G3hHwPvWxf z$#Lb41jiB##U{FTwo+~N+}}?Hcl4N5c6%OHM&g|u3w;7oBq_5aaedd+%yLO$q3;1| z8v5I)<($$*+S}pOaPTzo^4_z1B$D3DEDPi*3E)?fATqR>FEQ(K36<Ho++(w%=kq=*)zY9WRJ?7)k24DKjny8$tqMT$z-Gy_+s}>VB%Q= zG!(We`%`un2eA^y%)YYNoSHlTKGxBq%%Wd0_Kzji!eQAPLAvMx46vB|B}>L&h)obIuV5O;l{6Vp(`fj3~yJ zN{HPtNL&U=GA|m_H>u8JCv~-JEA0&c*ckZAWD{lvoOEf9PJ)f=B9o~bjoKo|KrNA+ zDBQ8jxd0mag_^G#$IBr!tXgFt72Kb8W$wpqbvaqR)%*;E@iopq9f7@j?9IW` zV&t$i{>x2UJF4*%9Z~KDXg(^xSbBWp5@XaM>N02-ZID5MPLjOklD|VMY5Cq4-eM`y zq+qM5NJ(lQk~19dSg$%pf(%u+6!dcAJ5X{Ee_Nb=clDddD(JN4;xoc|; z@V5laLEf6sgyK*n2pYxIDvhlI8_jrg>8FP490lHl3buao78!0-$u#K>NBFhg58t)k zOJ~tTs-8hSXa4n6N=n){#qW?FAF+h)DDz7A+V3f*Uy!5_;-Iv~so-3CQ>{S6E!%3Cf1pDAv?_Z_Y7qe9IX=^Ra; z2WXL^?J{eJww|M%9x1yU%^e#%XEm{YHkp8dg}6Yh-S2cUpfDlKwo#7#zeJFMAeT^1EsZM2Lld7A$ti5aM*dZ8)lq_CBndQU> z$FHzhRfOv8jWnh6!VsX|d!uuInpBoVlxzISgo0#9h3Y~2z3RQp!i&x# zB`aoG8XeBJ4mUgN8fUGou_5yZ)LW*mLB!dyx@+H5iTP=(*;3o-mY>LOMe-VN18qRb za%FnwmMsodI3+cnMnG5x!TV6+pN;tzAxBfpFMg~T8on?mAhTkvZJZcdk8ijR+z#+sLb!L}R8jGUD# z+TGG|G0+@*OQn~_8dO1-_iUgneJ6<4b|YwIFH8n+vN-pghj(;itC|vhi5rTGMwx= z1ILuHi$akON^(0;LrUWPyw4^jl=prIFCg1!b2|>@isqkG0sxxH~x3 zmQ8Nf_eX^5sIoik^tuYANsgg|KchDw@)H>Pm{x()$LRx0qJqql91e+dyi#IAPyY(m z`+Pbpt1y`-?9yRr$EOs}>>Y&LAD#Ch!O|EWtl2}sr{h~kgLT+WP?K2OdSym`zbJ#F(KO+k~*%nbF@)@ghc3bq(4I^p|S zOG?mK8b*P9kcsXXcTnh(G->y#BXq9okNaXCB^mZ6pbW3U$eA!VL@CZku1P^slD~EX zg*d8f_hm22oiT*^E8e!CJak#@*Et}w6N7%QttKr8zk z&)Tq~muYg-*_o~i?tGun4FuuWsn8e=^2{uXZloFl!ZScV? zC5G%K`oMqH#Kq3*;7kqSr~5FLPYQ8T^Wa$>oHZlNH-j?&bQbd=b{6YVHfTcR8FUuo zIjm9xn}lyE*rlvf1DBb!A_d8G7WX>tp|p^exNh*nF&e7cQvqM9ia%MlF$0s@m{yZb zLp7j~zycBw|GL7i4Mac5Hpw3WMT&Xibd$T~!=z>8F5?F~Mp z!ge!;>^TiKsB=_{LFA$wvpRIC&gINH{EHwne`^y|?A3J!NInO9jda5?Q8Bi=1;S#n z&%DN?Qy{5FI-(*3B9x$GL5xD{lZzqXr%T|%)C3zK_bJJ5BmTV*#uDyOL`wRN?zfdKzBN=dzhuk zpC)@f5J2EVt97VAbA-eXD|6LXplvq(RpSm^O6`C+n1GX|vnNBV(N#vZ%T5ScXULnP zlyo(c4hmL&m7fCsd{CvcxQ=x-q}`r9;ksAgXDY1m(sYz;{>|uk-ga&^!%qAKvAKJS z%f*Mw95z~kQ)S~oMYaa1o6`7A9H_1UmsP3fq}s+vS0hgASeo|z84V7@k?MES1yzbD zku$nJoqgM|DII;CZ*e{1RxuH2JKMt}WbKGl`5>_=^UJJ3yLyiRv`Pdz=T)EJ_}7{g;QQU`n=m>m(cDCLTyiwxRLoMqqm z%m@N`*b-sn!U4G3c4ObAYzJfpj}&&!cPEPC{+@2UPKG2QQ}nb3gD(Bk>e#G$l7!SV zc_cX-{lb{ixk~v$-b)qRqXnn1mZn8Bb|D6vj6~RYju=Wve7rs#l-F|O`LmKuckTJk z&IhE{%vxiq$-=R(}t-ZtR2H;JGZ2Ve5xt`C1_O z2f1o17DU#NcKJ!~tEOqhmjLrgWTWO&I_JEVF8V2Yt&t@=jdw)jPBEaMT+$6zj`yyZ zTwB~f$@byx0x+ipC#wgt2EcnZWbp*Jla54A3bk`?Zaon40`Q}OsC0Gj3cJP!^}L5J zcF6P66SwhBKW64pek;=&-1NYmGpq#0dyYSfnC4(i>IN10gD~QYe(3u&&LEYN)D2HK zoaL~Edj(qA`!zy>ltzQg8MOqM3)M7MhdvfZloq~>ajelI={QFMhM7`UUT|f)SVne2 zC&^6%cJ@==40gk^)p&Fbv{k$svg}|Zx0{MIX1Cs+u^4TtNRK1h7Ue<$V~GGmn|jSQ zKMSQ$J}d;Y_>2U-w8h>FbjprYG2{Y0@jd$iTK&XJaJXyD^h~$IF8b|wPwGEqj^0i(ySE& zq238GB)mu}_MdDkR|2JT16fjns+$2)sR{}@(8SC4)&^mN%OC6u>ndJjZ{u>w?L^(t z53HYd>s{hkVD&HJsT;%2Cv=_>+#|FwEX!1$POWF(|Lzj4Kc8Aug8VKDBLM(t{7 z|4$+%Bg_AEF2x=HyII++_MwZUjP$duz8bHOM1WgvWRXc@MwMn95(~i0)H^}}#2vZ? z8Fe{b#n_nk+@!Fuy*9z%*;CyFrRedsS;|{3n>(G2t>?Gq93T5Ju-Sf+^YHJ)d4{{u z_s8`J7U1I66g|bDG{AV3*swJK?wKsiur|uu_>`|SfQBnC50iWUE-xz7h^vb4*YJ4! zE-iqLsc%6u1}I^_uM*6y4vV~KC_o-Kgul;~FTa}Vu5M^RK5i&3DiET=UaU`_D}Ps< z-(6yOfg#5@4O158dJnW=)1_sDlQG5yLnDHJ%LZ-JLfpJ%$~vTuF>fQ@Bc!AyC_U!M zej@B@C8SA>pxALB{K;{D8Ec`za8t}gD%(u@UyGqRxM`*6X@gU!W;9R>KdX}|;y}u2 z)SLwex`f6gk!hLP0`zvg^oxUK?Q$l8gmPy3tU`81ab&wF6?_Su)3notSlq#AN4sE0 zH7937%Rx0u=9nN9HIJrqrQ=nGT1J!15C|42B4#MUq$jMgo1t`OrHTaOyWvzx`hEug zF7gNI!Ll@L3c5Wg0-94Fd&eRxKr!b8ayrG&savl9}iRH^Ynn-*O%%mTE zoI5%7R^}qXH=YQ_=uL31t7*HlS*nS-`E?Gu!$TGzq8U{4(8S4HK!u<*KDEZ#+<0?Q zsXqf9ODP``>4+T4$_Mn+mLeD)Q0At6$0fj06@ z_?UUujGTA~hrx&xrz^;0kv9A=Xfm53{=tBRm9jkw?%1o^5b3MZkf~cJ3Qw(2Vg&7N zal})b=n%$cegO_sZ zy2I*WAi;rXNQgNuO2`zWQXD=Ka;xi0RHol$My{AGw?%U4u!g??2y-&_>vMuvhvopv3({a83bhV3EUqA zMnq^jv0>nlj~bI;+006}QdZR}j%KBlfV|n^b_ZE)jU^z;btg@*$#k*&NWRwA5=Izx z?2^x2jg0e0pgt^S6xUD@VBS5`j==z$ADlTBT_kM+)KS3|N_Ow@C*$ZKyb-d$;@tV{ z1(KR^qV64rO-dEojtGEI69vKgLRgif*@!o`FB7|{_v>+XuhTs7l-zyPN=>Udeg$G5 zZSa%W#Y=}jeEOj&SF1q`Vwl$1Z>fB-Y`1+7pqJ!^Y5JNuSTMV^S^e<_9jO7T*F_8y zbywQQbGGfyycoISD*p6L{gFC zw0g~{c-ndCK^h(*;h+gI%8xY>u4HP_8|Fp@CwFiyd4s}bTFe1*toTV#g^#pBGqU~S zooo+|T{tmrm7;*vjB^r4aBElsP;={R3DM1{eKZ0%!&Ul8*&>U)s^0={V2d{Vok42@ zX@Z?Fg$7z>_Y5|AZnzVbvWDTg8p1nNs&<5S=#Ioukdu%|X{;1mj|2!hTmiqUulbT~?r4$@ zcf73NcgDG@DADf5@ELOgI`Kkh5WU^SWS0l-b*+0m8nnWd6Fq=0oraj}TlIkO7_NMu zttRwIz4<8oVKGlD>#X*KRPOTXzgT1IScDxuwFq_|SYK zJ~vZB$Nx)+Y)rN>e8L3)FjEHr5dQxjBLAbL!vxh+I(qx~PCeA7p}hbjoCNsOh)4D3 zPdwaTAV465UO%|l2}uXL_DEK=7!LW$>VhSTW%*_cZDuvL6hPC;=4ux<4y)z?3vFlH zckdrh*B6@hPND#_?Vg^WkDjks&*O_gSioMW;$@hDxk7_bY#H%t1TC_(3jg29nS4g zUPGXp6Is;O>y`t+S4ZTRRehN2W-981F301uJoU&?QgPKAB+o^v@D;M*bsNfphbI?Fk&OB?E}28 z532Yv3 zZV@qkD)voX*naiKd#IC*wAQc5*rxj{EL;T;dCibT4R9>^t3nv53+-9@h!qr8Kw?Js zBQ}WY6|-!a)`;vCqsqcL*fmIRF015NEcCr35MhS~dD>72fp3h1BoNBax zYa}JBgG!lc!)jQzhzr&RA<~mg;fPiSDbkZFLs*=bg0X-NgIok{We$EM$Lx5SV~K<) z@w?$e6=hTX#s=akZ0d{g0O7?h^-@%=kskE{j+Bi;fo78km4g=Z2=yTsGJEKmZmSw4 zH;9AC^)ZX0S>s)uO2`-R!!%BwkILCNxsArfJ|1GQKo?)#GF!NtI+$wP=uRJ9GOz(E z7f&oGEaaNskD|=>dUK}t4g{HU2P>6{8JJ@qFW>4f*Q8QTyR65AM&0Glq{thLf3Nc+8LTTXWQ}qAzMz zaNBHQGMVA>rNIT_lOHEcB}XE-kn+K#HXGz?zQB=-NaFb~2+H)}oG1Blcze_-u&_Fv z(+u~bnf-l!3rFSm)}$i`Spx4w%=7PPuPXMa+gf4ZJ$!CD^-*pjC^Pw!PX#VAj3!dP zdN~1CIH=xjpLh*H8Zap1Jjn3Y{?d_mABk*wi?=E)3b{fesj1?=KH)ZXQGb>3Bu7f8Nd+gh-gV8oP-dU&HiP2e!VlxNHhZ zKD4F*O2%5TILEEWv8Pwf6jvy(K_k2szax==ylvfB0}D`g&D7um7&Ad(^{}s%c&%7X zaX6tyP+eY8(@j!igr3xddUS}$dzHPSGa1^QWe&>xo&IzRN~?eVVuRmW_&*$h9O2~i z%|FXcT{71s$oA1Qr^!9>31u<&O<)HJRm?S*{u5_TARC3rL{z|Aa151>YBMTt-13mF z0zYDinB$gV8WfG<$ks}oWt!Ce3AP;K_O5D7mNtGIlG@K8=|^Bp zeUXyKa#iyg2dspD2o(K5hwj#l92RGy&zA7v#5|)~!3Yr|rIGgY2Co+3Y$1NZF)EX% zB+`!WM1)pVk)BafdJD>PGLm3IgjD@ONMtN@1>r!pHvJ*&}TNOy-&dbgkXDVVd;|L5s3X4 zV^It8o~eeHREp$7>)mSZ5Q+hm2TCIXA@#)Gf9UgsZJk57=7ceQ4EQ=Xnb6`2_0uu) zRpV0Bs^aPz+qOk;*I)!i#UT?2P)mn^J*+;xO!-K`nyIV2!PO1UwA2&z@Gxom$qS~3 z6-G#JdyB(cuv(~(*#wQH49x(@$;8=+R{C)h>rybDe^nP1+THEkE%J;Np%c?{*_q{h zHr#qluxC6JAa+E|)WkI%V-O@*nX=gDo$ZvOSw9Ihsd(*P+tf@9-HwH^nc^v9-KkEj zC@NDWG(w?kW749q$q|`i8U4~oNkYHI;?+DsoSm}kxM5qjl6rnU^_5YAiWrpvLXU#C zr4fq<@YklhNl2Il2BusH#oojIE-g5wBf}`B_7?VJJb(5Ezp1GG=b@NQ&++qz7~zi} z<6639TR4y}(Tfo0Lp{VJsemKpy3Q##pF=R?j^ z=D)KJ1<{41^^XznH!#i1ejdT_g3&d*#dQ-5WZmn*=mNa4xJBuz?(@9mh2{y7WqL*8 zQ4E$v%-(lWer1M-<5v!1su#9W9%7NU8hOiL6U-7Xi6&h&ksElV!_oFgE$&8ft<)@? zGYxNKzQeYU0l66v1v~mzm-;s)WfVso@x*{<#y5wlvAjhQY0lL&iembt9@T7Lpq{X1 z3yg`$KE6#2F;$P`Eq{MFoIjVorl_rkspjLaZdg_ZN%sWzgW*#%(pGDI`Y26JWHimv zVDUbK0}8jH476pv0^$zh4(aQIcQ@Wc^TO?k|0a~Zdrn(GLbiJwKcZ?xrP3Xsv=()Z z{17a&eRZ1*V&~wK5xrqtr8f>Nb#PwgzGy}p|7O`9UKJ4@D}I(!5~qFpRoyiplYQfA zemJgSFo_L(D}%GG;*czpeP^2>qH9F1#XgOFE6Fu{YsJ2f^d_lKh+O*qVquON*$n3I zv<3W6u5TyFHL7;TDm9MW&!H)n;ar+A7zD`8e;6O6|^Zn`}zPzPLy+%cB}Lj(Rb9WTM~nO z)~Q@3_&uufr!rz~nCgL2P|#)}=f4a$>CFsMm&1yET=(BI{XzPfAM6>rXsY;;JHkYY zdg;5g+?OVRH2JkVMojlA*q%e*)DfW2kE*;Gh6<=9FgP&N%t>@Y*9+gPN zBx|q>EN!{VOl2;OaR!GFv~5)>8R3o>LA&Br4KcT__+7~>B(FV-UzKyNxL%A@0V)pC z@q@xLb;Zi@OhHLpZa;3%N6@gMf#DDu;h}JA%>=79VutxH_!T3+C6}~q2s)@cwADF< zd3o|!P3K{xd_W5)_p0%lPFyjwQ+buMP*W0O zC8N5yDf(WD`QMrt=-{S6^3KiXboZ~&;;2HxB*$PSiAs1O$%;6X!oiU-sf$Z1yRx6r zy)B_1m{?a4YaBp;%;rJlSOUF_B9PfQj6q2;gnU5RIH)8_Nu*pNz9dRz*e(xMDY-sF zp(;u>`9SP82|=2i7%)F6{-qBYNSB<1w<;+zuSBU1-VVDO;^nNN<;=`f+@skON{{p( zs)(8+l^$uA(zabwoM)%U@}%Ge_;9&%PGjT3fy)@OiVZ{^GNwWGeS3h1odBNz5#Wjy zNYq^7M?$xbGyxTl%E%2^p$B_l;g$!k>=~Rz%-G)F{&QQx`+ev`c}PtG+wshOTX2TG zs-#tiv78n$_uS=AoNt;Wf$eCels{YBp~_@IJ_j)DFnE}>6b06W1%91~X~5B^c_ z$`2P7m4v7_Ppm9*+Bq559}WSO?Qm7mu5=&E>7ROQV%b7-1hzi~>y z=w*znA&SwqFA@7#RD@nwj5HgE-EqeKZB_DBW327h0Jj6^>%$H|zFv?0E-$30#YLU) zEM%vBscuP}7NL4oMCz%o?Sr_mW&Reb@oF5%*q}A=hb(}*;*w6iya+F3>n|{U;XXiX zNY}kvfkS>eJ{AaRdaBA|ALucoq{3gZ7}n|v(L{HFeZ#v6u=l8|=TV`^*k>ZPiV3nf zh?Ju9bh$;UKWcy*$xsRb6tL~Z0+dy&bI{`83w8+AxgHqHHvX|UC=7*}eC7-*EN&`1 z@Tn~-ZKBj}vH$TdNfNL_UjH*m3y-o9CKT|OngW}Q-V=6;Cdi%}JY+ir{vX+94lH9wy5V-_Tw z;w$e*{xkfb!%Jqp_?hrutbN|UQSL-$Kb(x#Y7`QFSOi*W9J$4pi{ZS78!*TETTZk( zJkU`*X2coevk^J(1%4>>He1%?QFbw64#&6-3%aP%;AIazHl?rZBHUTdU1CMpB^58mPN<{m4r9t)rTS+{hMyb8n$qLa_jbm7+(Uegku2 z@=v2C0+&KKhY!?%UfAMH_7u1g>M=5ke3gb7D10R3xm?81Z|BEr!89B^-TZ*9duxm+ zGtOZKaRX)iy77&CPrj$mNSXZVA72f z{sMMimU3jt(ZiZtYB_CKw<;u(vtNV4a~Q|(Sh+#?Zx$TaogLRG>h_XuP)$0Wc`{@?8HNkVF z71VINDV7uq_XN|@0{0(24upG8lr#PW(uZ#x{GOtdftrZZD&b}G$U|j?ITh19vcs** zC+jDaDGGt045In$^I{)@TxPmCcG$H)nC+i=3sc_`Ooj=JkxN#kXfHlpiW*ZJTBy3( z_)a*0$XD-N)Rc(Y9`#5^0mE&6L5!jAxgS@Ts zp>%$&3*757Un)9)Bz?4hK!#yU4^?;(riCx{?O`QeE}1vF>`no{Lzd$GW8mpji6Vcg zR$xlQTS!k_;1WUh-ETtmbEux&%}qwuJEr0$Yt+06=C3GeesOE)<;0d$m?#}b&1!kP zBY>iTDpm>_hY5zD(D^MryZ{n+G0C~gv@e|-XbpWkR1=Lh2WgZJR~BFG+4f#0T4Z+W z$};mw?h?%*95%Cc!MrlR37dHvzcR{gwg+_op^xYr2Fn2l^a^8Fa~q7l!A}7uL|9C4 z7#$XXLmu2WL@hx7P8reejgrrjf=~4L zPhHZF_>r&r_)p3GMan&r-EE-GIOnT$t<+9HtMNNb7v;jst}lZ(E>FVQ$Zfb3Z}5!K zJG&SEZFkabcYu7-4@L|CaM2bhaGq3@_e{yx1 zrpby^1nU46Pb=V$PCi9HrW!(hb+k;=<3;^cD80&j;ve$bFGO zt^*FnVF!A->BQIp0)eqY@MHSF=$N1eT>Mo^xPS&;2EuCYgOXu;#nhQc=_#_$Gmu2( z1r;^a1J~F(G!N3u3Jt9?su(1KA_?Rv0Xe;A@GG(*4R^T;7T@RqY5d&n@TvT<>u_iS zSlZIep0&lx`G+~=h}r+9H|mpAC*&LPX}I^@?&+O`rW}vU7Jp}oF@p$VpFg1 z;UNd?LGyt2@RI&w`7!+Y$o~XTqH8C`@(cgFoc2XA<&&uJsi|_o^)? z6dYhS^f(}w)`Dw7SK3eK2yG}gvYYDAdQX?t8wg1;2?d=Y9H1943N>&!Kt~Ei%25L6 z_xVM~3Pl>Mzn#IE-{zTHaqSJ$_eqjbp7D)>6@=kOM>R-CMG$3{CE?35vJVybp|lOy zOogn38A1##ea3Wo$SpVG&=)qR>w)guU&jPBF%D&vs_25dNSn#`Pc=yYhzdkbF3kl1 zBktIeX{9NG%#r&LJ$NZW3M8;pG7SOM5rGp{M{w`g=Wx6V3Y8yBwa!440 zu=Q_oKy=YKT=iXm2EZ7&>8P79>rBmu8zx{9k_&}D4p6hT%aBbPjnIiGCS&Hv;`~I| z<@NeQC^!32V1ZW!-)C7C9@L_lY9c{)Yx^N7OdL>i?k=-|PgD~wkY(vW#25|#f8K|v;&LPI~jYJ)A zbfe~qbsd0g%bcg{3JTquc}4mJ&J9$(HGbvnhOXWJxW&Nn_YISJEky(QK`7kaF`(+A z8QKeBKBD#Qhw z8-cpZc!%LdqZ3N_8KCYJUUpb02a;b9HN;emu#jwSrh2TO(g4J4jBG-QNw0dR*S$aV zXIxz^?{biT-1}6n!!E1=HB`LPlkyP$vPYk$-ACFBEY<+$Sg?fwrA7es$RUZi4jokQ z4?8SFXURjCRC+jIIkJ8!12U+*%&x~=M4&yG`YVe)1ig0v(!5|AbZhv`G%S&%i|USVDSYKV)opMu(566E7bwj?v>AguuH;4zUz`Dlui zyB|AHaC{{bSp_|Wgo*tCvmUq<$<Enua6h{wlq7)&3DA7nl@i)WPF^!`o*;lVIdk{1BS(O-l zqwa?;<7<0ygl1;rbX>D9i!a#?f8SXcGN;OkcT2UZS5TpnYA-tvdUo!lLfkC98ER2{iB?{yo5HttqL% z+YerLJ@+Z=zy3iV$buMI8Wx~c6ZARy9h=8k-Y9;NC0UXsN!l*OX zHKL2_gc!OB0u>pi`j;Jeh^OJE7h_6c1nr4jyBJcHbwWgh!y=X|fn&%7IAr}vW&=J> z{Ng~a}#`k99iBaJg!Gj1a74saFoQqD3D{rmkV8C?peJP5A_a4l-bP27;0n$r;4z{)#M6t)WS$iLs#3IdxhqV}G76ZM^( zHk{zCl;EwnMg7%&T5<-vys>|G7LH!sU3XUyZZE)IpUVAdCH{KZBDu9q)VFfpW`ey= z0ez+{_M(y&oNogu{p0?l4EzI-+|Bjrr3gui9pK$mxT9-ogEB7W1Z&6TF6Y;7zFQ$^ zk}O<+-Q_;qIoi1+?Xd)mNN*K?E`FTFGT%y!B`!ug^NPkyOwTLiOPctP;db3>pSfUj zbB-GfYo7?X6vBA)v?< zPxMWeACt9cN?DDNj6A>NjL;xhuHUcjLe59g;^TG){C&+}(azPZ!@(T#sPcC{q%(Qs z(&;t#)&Q^$^q}dTUI9Gb#c-s%DT2;&G{gfLJ7^JH+~YU67tHG)D54If!fPZ;aTbrG z_8vIt2zovB#`Kb&=__ijZcxQ+k&L=(n)&4Zgx3Lr6-M+8ptMI6M(inU8PNl4mJT@y z@9HUigjISGmC((*k4)+oDi57cCI3P!_APmokoXZG`2Hh&jhmp2CSku-7bTS?-l;@G zTX=sTCDo=Lg;cn}u!kZMxxip<@)m1=PPk=N@?kc>cQCkf3w`$zC3W}bGU+Up>AJE> z%D#a?j6BZ)usArWroc%{q(q^ZO6hpPYXu=r5-$}iE1+|9=xcOx3x0|_DmJYhwd~qf zXt`(N#M0Nx1y?>uJzPtcgSwY9U8zJZmooW7HpoW6s;wYZImEzy51Z2nW-aK#+L z{$;QJOK2F3x9tN5`U4YhoDm#^&|BWeVqc}?f;GYBOa^UePG#G*uIwU8;@|SeqsLBG zGhy4^9QS>;3EX^)olo~n@b^7OP(hl#If@YB!wi-A+V2d+F8)s}rwfmo4XRDdUQ2X<~KWw z7+(zWW~&Qt;v6tDx=bdyYnw5p;EKKHon;H{6^?vK~QZ6j0IHm?8K} zQ_6yrKh;!h&HvBhm4w(i5K5Th2|tWv^eDDX1#EK%K$yuR?HQexv?y1NG>nea-N!v4 zbzpH#V`@q6GUPL1lvb9V;qs+K=5@?QZIcFr{Vc=9UaZ(G6CI3BAbRzXB01}V2)*UQ zk8$5=$VpgVX#Q0|xT2}cc+Or@t0p%CDQ6@SXjS^!>@WI>Gug)9@Q7b9s-;K5u_tEa zp_O~H-22KXj#exWSJ9qkQ@K>_`;aTGyY$(^BWe1lG?QG*$3OdpW0b&`aFSZt3Z+qY zWLDZ?>7)7VDb-75A*ivc0~BaS(hWLB8-#%|w+(G2H=N$Ro82Csc2T!!8^W~6Vj6K$}Jy7n_tu^*e zpDX&a72P-o)aH<#TjDbaHaeC`n>Qf+Qa$d=Y1;5VC|DmMkE6(wGAzsHxOyu2LzJT| zq|o0KQT;7hpKX!xjOtg~n^2PaSmtwoKW)^^vV_-~^e{uhjgKp4;ifYJ=_Y^oujl~H zq-@#(n0>$Fv#LS@oAv;i;!=JjK4^R*QGkXWxV8}cr0_K-=H>u&{9#}moRCOO@$-NG$-Z?*)B+)0h;I_EH9op0BjVzk<(E?1Vl zr2}zpFKfI8dR8ux(D)x*u>HZu)i6tcdx#Zy+1Y)u3zW?BW_(At!4hIwX*!;N>%D;f zl$F_JZ#WyxE&;INwiz(a zEoJS6a9`Ba+X>94hJCwi3TM^dSzm*%bA7$ssKJA8aAh&}O#Du*=2!apK zjm+)=qZaTt`$~QXc=d6LGb||K*5np-N~G zAa`&+j#w~_P|;9fIRZ>nlW*JYII?@O>W<9%&$&DT1MM5t;YIgib0e6F#QViXA3_w| zu3xv0!`!1Iqi{svpJ(!R{R8T3zS-y;D{BJK+B?nAz3pk=&V|%zHKYHoCs>XR9R6qI zqT)K*N}c65h0R#S<3F%$hnE+zmfbc9vYs9IN6?+#YQG4JBAU=|f3ojz%sbkOm6!7< zCV^`*WyhGVpK=F+js)+Ghp_TcT%*-&~f zK-kt1Gr^0#ld>(rD{u=}#Sdi*-=JIsU)=7~&hS0SN3Xa4MF==eZ;2!g^b6U8{{Iu` z$?zY6psKYhrZAEZh(Jowo-mSy?qIXDrJsa`Ml*F91bh*5aWY?=N_FNG8047L^fb@} z@15x>=oR}D*4K6Hy_;#H926vxo1Ux*DXVMF$7Hr=uJ-r$$x|)>53p<=>`TJw$QMxw zz2RP?&S65>9zQ~^p-EU*w^+hV7dp!1Z816uHCNN^sDM9y4J&tYxA7kRz%R_PL#y1l z=3IfS``9z%1FAe!z>ZhfIcYyazj}9E<5~1N@-n6Iz-X&tBzW4!&cUJSQ8^`2LfgYA zlbZ61vnB@?T6)mQD9fCH@c>-*1TDvSnrv7t96u!$d74h{7D(4(aePzPeq6Z$3c2V) zNiyap{U)E@1Yxkwhb3rUvFU0srj+YTOq_p=yUuZjb}M~+In0{5v)q~6QY&KpM25O& z4Q^w>aIV{(Ng%+8yycMTDRdb! za<=>#o5`WQg~8T%Z)|Jq^y~}4ZZkzo@Mrja_5@NuKskp2;YU%|koFdOsADuqQhg={ zchImMH-ku!VNIcsFaXzS6$pngo7OHoSa?AzKGxPPIkw6ek!FHe`9RIc6*Jg=c=SIP zsZc(~D_rTAHloOey-u$_Mg@EFjt5d``uR-vJ(c2uwAl9Tq-3O&+n{l`aLRvV$t|}` z!Teo`{dC$kmc4( zWh=$C?#A^$Ja+?8n+LeMF=Kxj zq4!P{Ee~^YvG%Pp#!s&}`L?n(gUFaNrFIEc?o!xBE{lBjP_UPi5nJw{QO+fc_zL6o zzuB+NEp7BsI5(mdv!b+FM5cOyfg-i1#Eks8`cZLDTvHCG1(0GfvY#L<-w@h8^Q|;p zl7?Acv&;dIOt|JAdjvFp`X=+}JH(s>syv-ob+~^^l8;oBG)PcAk7s=kx`-D*G=w^D ziLEI;U%VEc#RrJH9*sJY*gPj-RX{3*K`;pw%Hm2h373#d9Uh$}=Cv+l>CJT^~@~1@4g6TktPUBP!QBmaST#mQJ*SO4zBMKVHF_cR)IM zQMh29DOUf2ctmqQd;Yud05GHDs`)htZ2g53%luCS&Hp=>=>HNp@`nUHBoaK_Zys3B1nh|*-0y|m z^}S_cz?$w(xS2@lLvC7}YgL2H33JqF0i+9$S* zc;aQnBoMO^v_FWT?|NEU&d?K~8fxy=| z9=VNbspb-8YHh0O75u+%MtX41csn9pxX`ahDo|KFFS|Hp;+r>g0QB#iXUv1Y_F zfiRg6h86_(*NP>cUr4we5eOv_4jhP3C(Vju4Zo3bV$uq)AYfM;x9VQ_+pqi9PZ^_2 zN&WRaw&AnGwW0lzps&d5^y2ZYd*LLDXX{~Qr|0X>F0og3uSgV2UvFkb2iiyr(02a@ z$Tt10O@LzR{;Ex{!d5*HM!Y0meuYR><+fV{oBPuei=8`k&al#7a<&RpIc`u30G0Mb=ni~VkX+E@7^)UKn!$n5LLMMMr=lJD*UyWFxBGbc|@}bPpMLn zXdZap&zJYA{@34Gs&u49HyJIw4X&~3x5LGT#{+d{FzWg`w2AqTFOW>gC!;_umhHO| zWB118W;!h;)K5!QRk$?cSjHHzt2Nj-2yWc}tV)deU1Pxp-@)+fYIa^dwxnPS>&~P#}usz*Qe7 zIuLPOmlA!jILTL7 zS17(hjtlW}b#iJ|_&Y_!5kkK$C0{JzMjS||7!6a6X*PGhNDS8<{?XMIa4P@f%X_dI zgT4yDst42@5QV^TCN~LgIYH>umegUa9xq~7bHFNw#fPfyXP4b|^BCe(pcr{jiK88{ z^X}lJ#Ji`mI>=|mdT-$*pB>*#-;r@wNhdr(Hl3E5C63es?skV-lA({A{*XyR=|~}K zlVID7z5>ZVI&PavtOT)$nj&s|I71#$RaI^w5;Rz)d}DX-SBc-z(X>n5M_g@VYeN}Y zygpB>0MfNvObyJrU>J^>!b(L{8I!N?sMaW=rFB#^HCDUV_GW3X;3k;rSYS5eeCPI^ zZ#rp$k@D`CN;J+Kwf{Rv;uRa}wqPK6qk$kNjm$VtgiINyZ`z!~J~Nf`eq>x!LjU?r*8c2coz+qTUe+euZlW2a)K`AlQ-1{ zdeu)a*q_#yU4Z%fveDF6m>=KC%6TiT@jJ*&)hJm_-|)|CE4O6M&*3mujc_s*3#);D8(A6a8T<`a3Ohk`oO zhkl0b5_LWEp~!SU%}F$)#wjS3>5A+R*n1X-8a0ehGb1xeu2UJeS?iwchTg$%w!V9# zfJ5`}x}lp0wk@MYB;TYxxb@r(`)!(`_c|BUmAA{&n)FX4T%xB-)nP(%ee$C)Gr zbDSxr-dk%9iF~}pdcEXU#JJ;UY}eGSY^6_<;*;1}W2U9dissxf!O5WG9a#x2xK0m@ z89p%*7X{?S+UYmE*%X__X5fTENxKG!{X#+~4x^Sn5(v!iIcun82J|f*k(OWx4|)`O zW#__U^}&r>KB0^I0^{zS9S|HyzYwOia>YxMs$ZvU4)qwE1Ko4|mVzmrE7wTuT z>$Zd1ywm#l=t?)lLJyc%#_$g>To2@vSuUHN@oCPeLu%}f+% zuW0MsO*+is+-}W>3Rv#3V|Tp2m?GHR4F~)LD?aRk+t1E!BeRezhQV#j%b&7o`&FNs zx6L|)%R1NK@5OPeKios*MC0C&^rQR?& zydC{fGSSJnO9$%XP~b~WIrB!IVZtnjp>n~s*KiOTnun{+zARY_Wt>Trt5x#bWdii- zvJ8L5yG<|WM9jgevtV50~x^=(KQV_U0xf*xiInwwkZ6#i| z88(6g!XX&M4ER)6uEx-eJR6VYng!>UNP$~fdugo{O?R*@R8{tp$Pte3rqf=CG5W@>Hcd}!+)Q9gW9kjXp8rs zndzn$b=W_&Pz>WFetq+lAP682Nd}^|rn$OYzffl9(IX^smz-S9bBya!D6YX(8&E9>PiKjqQ$*C8@^sL1GdlAbgTL@q>3sDSd^0vLW28!}PPk^^MlR*Y z9D!LitGa}DE-opP<&$!m=Ao&HL#Z}bHV=tx&mBbqx=pl9eDyeHN}^Dpy@Mb>S2})i z{U-g}z)8f#;si|N7#c`filKL9;wJcw-;marl~cS4m)`r^hoq%!F@ry*yRm{E@9sq> zb%|;E^bvT7YD;KYdNQ$XZl9pVw1R$KXqCgVF$>UXP>aHyC~}C>ZOswGU0XPYPRqm( z?;nCDIi&}&@hYiJ58AdBjNf7?7HA>zN{d)&G0pboex^XE; zK9+SU{t3>=##-4L#T;%GM6>PfpK8tH1EPS(JFNC_p@U|*)iwdABN9n1FkPNBu|JG15}w}i;W6HL z9125`8N6!opqHw|mv3z?!P@tiT(_ocO4B-9q;jgJt)>`2(%!UNFl*EYkXri5cs5iY zT#i-HNs#THj;*8`Fi32W10dO%e4B>l7jXX-15m2%G89CSpT!jh>7JZ}4Xn&$-iI>j z@FUzaH{kfuQXb!7{8N*k)m>&R%#5e>OE?nj(2$yCzRGz&55zYzMGUQAG7C4fus(tI zUVF~`n2H@eN;RttyAuL5Hwqazi8fZ>gd!cn{U&%f!bbeAO~^o9pw46!MX-&H>FVVx z-3nrxf=P6s1!qr5&}mcH1rb?0DG!(LoB(R^^JTJn=7=IFY-mHiH*^)uy61pz^7reacQ0xo0J=-Ac>Bx6f)0R^wp zk;OYjKG5iy~Y})nc%8K6{Dwv)^6{{ z>XeW!`RRS|$6qh|8QsHc*D+?A`KkW0!}|5kb7~{8gyhA{c{_G*KHt|(H-ye+2*<0s zR(-R8so?A-r`r3OBcUh);|C)QC3yq0+f=Gir`0qlM==nSI0Ag>5&Y0B8l3p7H)Oj5V(CE*d*3m)=!~C4G*mPsDjIN4mf#L!Onia4v5b3g` z@s8cyC*7)bOb)pCOjr0m%RK~dJw1H9AcPw6_`PsO4urGz;F*tWve0GL} z54d;V`ATP1Al_kY=HndIFd+i7DwPdJpOzu`qWU4;fmuvPS}%0DCoEv!0{tk8r*zSv zf<%l6G)#c&pp&`C2wwCFS%>Sesdsro-NngpUa9&_N0jgW8lqF){${e{pheS(gQ8k; zIjiftY=JoMvpE{aY*8PkGpBbzp`S(FBUv2q+z|99Nr+M*i{uGuA4Nf8V^Z%O2aWm7 ztX}Im-Npjtw;Y)tb~6G;_+a)sw!#M%2}N*k*cDstb9Fz51y=lT%4BfK-2P%--3;md z0hJE?7)`YK_zAeP58TTCw7fG2{E)cBy#sj<_9e2H1E|cHBH!Geggd`y@)O=-W3N#1 z`KoKh41jOVNQ1J&#)N-!v(tCIIBxZGma*$#=4Ij%1YXdB1k{P_^k%AI?C~Y<5i&$BXNW3y=!a;73s&jo+^&3rHluOmH zfHzvhf-?LJp89MCurOYfZ5zaMM<#t4{x0WAlfzRyE%FhvgRgm^Rke9c?TI_%X#*%# zRXM_C*rlK{70iqY_@jrmHzPu3%v{V(fBB+?)vWzILTGPqB!>?#;` z(KH9FCn&=4_--Uw@p0}{=!~ha~m{-3ROqKC&T2x{h`dxQmeQ*|e z9sHZzeoX>RFErK856FEinL*9(3R!qDhK(0A-n3js=G7n@#=7NW=D=A>l#O(#q6mrUmNl7NvzDc-&QRVY96cuzGGt?9ZrSa*^AaH^nqBJ@k(NWKId({F<1LDs2t<2HKERHQJW{mK+Z zH>oplXZ4N8mTxzy1l>e1N7x9G)_TtQj;qLUtZ7Ypok8;8K7~7il@uFAc`G*_-5iSK zr}Au679nq(`v>yedOLy_*x|(#Sn-iCPUFs%cbVw78Zir%}dz)2DunzagtG zSBqwNmz6)q{_wV=gPMnI#l9f2Q{#jQ3l984j9LV5M<|jq^NA5va`pMXJ|EkK;X6fG z_VQfvqdCYk@R>D--vX#X@rJ<3)@``G2f4K>j}sgEo@SvnLHEa4A(YSpaiDE#p19Ys zQeYrzh2UjBH+n~Q5_KFiEq%b~Dds-u@t9b!=mb1hbl1-mwAI)snRNg9VLGy6Hjwx`*>dFF(Hot$KbR3nw z^(8}Y1+%Dd{!f9luiJ;BMLT!nqBdx6VO9~lu$^Cb!O6GEMfJwf`php%z7lbk(bx|J zPR-~c%4j|I?Jy;SY0hG=p2?qL%v#=1#yrymlqM^qt!wHxEcz6B30V}}XUrKR@gBWi z$KOP_ycJm1c}N)#$?(lGb481$@I%EfwzM>hQ>e_D+^NZ0Pq8;IRw)x$mKW}~9MWB) zYC>`&9jyEU>JRz(phdiN@s_*@R&@B;fdoK>zO8yM(WxgHV#} z!P+FLT}2d|$f$ZsnwQ`wPJ9Nh^RhO!_fPr)NF7Lqu;JlTgI8?2;K@Qf{h#%qEhnbe zSOz`0SBw4rl=~E1hG7T#vhs8t01@)2!pzDBl%p71w5n9-auQ_VFZN;gUnVG$d%`7R@VMAFkNivQ;!v ztsl>j{_f5oCPJxGX~j586pq%Oqk)aXM=U35|GrI*C-9{^dxX9Te(%ZS;6y~chG7^C+N^8fvuRK!R`*#8?)!)S;mOA}qtq07=CF{g zLQP>X?{R3_;Pm4pa39CgnE#R$k_?wb;?pI?e=`O82R!|=f4mO;v#0Xr<2K|;7iM$W zEC1P{Hw0AkPKeJtvH%|I?Qt$w=eV$-Gm|+vP^2qOEz*W`l$2tW0Ax?$J?=6( zCvZ=FeVl>%9)xoUeV!V!Rv{;kl%sGF_fRzAVs}0_kRIHsT=1am z-9lKCHd_096Yqb=Qn$Uv-HJliOTqRY@xjv4OTqieA5f9DE8^e?&OS%!p>;8YZmM0RH?_9y$Gj#h z6r-2ngw^uE63}1=L>}d{EHYflEFI2$Y(9GpTD=+q$I*?bZM)fG)~FxV$@kq&KGGON7>`* zt}SrH!h%NOPlzY4piBNX!Bs>ay{rRzF%`Fll%7ag`GR=b0ksK@e1uyI+wv$vgbR=~ zQ*AkRsM2oYVu-4WD?V}kqQP#$H513P%)Pk$ciLc}Ld1y4!VE;WR|W>z+^+C~a2-HkGlts(M*FQ=CCKyFCW0;0!GK=%{>| zTI0=)-~W0hS-YBoTZp}!hW3)G$ajzvA84;b>A%=jL^xJkU|6{4`wv#{YQ^7b3rOnU zzw)Q{Mo!hH{?>TX9W_q!Vo2WZ(A>6)Ir#|Y@yjnfdq#;@ z@^TmXg^&Q%j+c&nm&2GT3%Sulopq;qSGePc+wP+=hdzq;RozMq=HU5LW(#U{P4&AF zZ}{?nwTE6u6vqJ1Q@sb`Pn1jNPv{OR{@&U|WDgoMxIe=?w!w-#j2ZW?yUQ7i85IEb ztRa?-7xa+#`bcg0tal{8h(C@)CIeyScy@flT*0cRo>Nr9jr!Y*l1g-`-pXpHVsH9i z?>d8$vG?YchxX9l;#lPUpT1Q)Wk)L~-Lk!fvB;w#R%R`?O6=~yMRNKBaH8pRVphml z&$tgbG0+fr5dIA8X>uNa7q{}*`(8Dp_)e7MH?j-$Y>f)b2*9KvP1ve6UdALwaOQtq z#eBYqi(`w@tC+pXp_&U!ON2zn2enU9y{n)N8<_ft*E}j{Q`yUPc5}QOk&2RtJ`U|$ zO&m#2>6STx0-#y%#W`7B7h{e2*Q#TnQBfOJiXa&L*)hFWkQe_nZvF{L=7Gregh-L` z>4f7=DD;N7?ueJX_noIlBI8ED(Bdg2GdY0-npc*}BT4z1TA*79p=0#)XNWYgbm9=A zV|0orBEqEBX&>v8FCXQJ$;>J@G9_vOl~ZoDRAm*=WLDg~f=+X{qzRJCx<21`l#0kz`8ZZ1BUuInH~s zst4IhOeGO*C5|_^Vjoyam&Nc?9Mj(Txu|H8m4zrnJ&~e*^k^Iz`Qqde^|11JXjEuH)z)Q=BmD#Hi=QKrvRBaZ9)0JEDCfuH1_Bcz;3V(L^${IsNUs6;8$v=Wnk0ZNB(;h154 z2W9*qhoO)g$@e8f43QmSVsc?-EAc5tYFJ$HqK0bM7QN+ugq2Azx^rR{(!TUu1AkRs zcz?;Xy1ZL)(DMY0kF%xLcNH~(Yb2i9y)zzCJKV?nrJyEFY)1#S#H+9)wugu4RRYhC zhB(?C0FDdg=yBS?*0g61rOJh_Xie+f7^M~l99QBIwL*{5_ zMgzbMDaeHb-ZdM`!N|NZ|NdP?br=W*D?j%q0uOE~=-> zT(MB3!4HMeP*Kw&S6;;~LX{N~!~EW|;pQ5XgQPT0OovIP3_D?r&50U6SaD|qpEjnk zA0sYfsFfpl&DR4?JnbbV_AVCfZiU(hV{~=OtB{+nuryi&vq*m`me4SCUKd;Db%vpZ zraFkW%797(X6LdteN-zGJ2l|2jzTu+V=U!#RH`y#60!;MfQ;+Pw@M*dy*$So1)@=P zMQ(zfS1WdDjHsb$ykk7I{A=7U!h^OKL|qr%foa04TTUD~mZz@FOFf_Npvz{?xzbP= z(#(_~RO31ly$ST&fl>z*`rFK3s#A_stf@tc1eu_DTqiGJuATRv|CTW=e^bM&{YB+C z{)(A0`cJ4F{{z_nJBfo-%FYI0_h0PtfAGow@lbIwvM~E^P@_^wP63n&DRXxWG!N8| zocyFWQ2%HajDkprT}X~Ji}$zLk3qW#+hoGSUc&7d=BcXi*`S0wMwZOfuE(O=hmRYW zZ^;fw!X!a@5IV{`V!NB zP^djs9F%p{zJq2my=`9DZZz{DpdSYk2x=Mv4!889fbtj0DrjP^aF;kfu1h)hN)R37 zdg5rAD`mXBBAQ}{KCOxYzFYVK;=kfjC0J%|8DHW6Nz`xO4E~eCD%jb0{?mc?UqLC- z|7W6@9l!-(WCQT}zw@0MHICg;m(f4@q?SgEzo{7p`Um`gk*vG^=05{0Y($Tg3pyt@ zp|+G6p6e&@<|Q!~$D**ECzDDpkZUWT+ni(DT%TE!PGhGcbdsM22;7-`27Z9>@f8=7 z-Q9IjXkj$8A9r^3`8J&Y`E;txCLy=p0cw37~zU1-J|)XV7C?gJ=rl~83vb%OJ3 zH3>wFJe=$sEBuq5GpQO*}lp8aeJz zCba=|a>a8KZxLUlqC6dBM-KQ<#??Y2#xNW}R(J8%GGYMe_rXjFq2LYY0zsV)RKhr`p z{r>I^ZLsKMpoTTyeF+uwIJdo&0Z?X)Q@X*d4g$alOl+kr%x)~A^&T<~r8qI9(OQt4 zOH&RO;xyPFVkQ7?()?J2irGpSWqbH&#=F8%wO+z%cB$Tvl^ZL$ijb4?@#8wyBQ=Lr zaRm+jxvN%?FSF^PYbvos&*iyg5h}alH!L$lr&;5-n9?Ln2*Tp{%CUi)K$16KwCA@jkOtD(Gf1>H$!Ew&O2Z`5c$ z)cPkltrR2|9gO3tMB3?;zpneX%;wGBbP1|VA)er7=wBKG@NSiBYQO4jL~4ChqVes9 za6h<`BOwNni%<0?^bYyocluQ^0RqftfE!=aBi~bUMHGsG^p^J4$Aqj%$BRXP0-{Nt zwuN+-krnLpFORmQOXcU%O;D=TEEoY0W*b@73iTLP+nxAVzU?e$Q42+^8jN7~>byt- zMO8HcTGRct8xx%{#niGVrwWMR) zFkb8M%{8&BS*-4MYSuCq#;93c>Ij14-Vjxz1G_E!eQ~hnBDPJHj#~SVf&EWD2wVB} zq;jg3i%1f8rWskHY zYhwHu)fB^tf0bD39SLwzw_$QAgMo<>=e6cGf)cuNA|l@-YjZVNe;?wS3ol)edQO&tiKMYcso_REG1|3Bd8O3!_{c& zOh1E#aKbmKBFtLiY&{9Ztj!xjnaSM3NJH!~Hk%4MVUC#>n7-WwLcRGLoP`X5HuiMb z83-B^y{5?f+0g8VagX6v+vOQLs(kb@@I2jL9^Vgug5X9b>aj9&O`&xe?90OAg4pM) zx;4z}tRa)D8NwN@u|G0JB(Qbt46U)(>slol+w`C)O+plnqXaRWsfg6k+f<;UF3PGd zbaE^h;=tbK1{3y486gO7jlNvlz+eq=qnI!Th>8?RkcA0h_t10#Z)FF~nlQ+k2o!25 zvn+70L9P4o)`K`SzyCDGe}Y{P=&q}L!u6*3m}=U~wt@T@G;SGn8><a z?35dQF>#1$BoU3^G?*S{t8!q9xW^^wdwT^)qp1&jVGtZ2_k5#TR3;rCw`EB#rpQ~4 z3CzeAwIau^@wOO-@gBz8|Aqh=Q0yQVfp}XYu7(U*gOWA(|0Y6^`=Eu3{}LhGe2EZr z|C7PsKQQbkW%?(TSHo5XR}IaNKFCJ1siUzW$x2KP;86=Asw7g1Bve90nVYLI{ELUWtG6Qn9Np2UoH$4fT;{#NT|*4BOGAo{h~aVHOszL9 zfDo;M<@;dt4v+$!6q}x`{@L}TVL-2Tw+cPjNT+Qyr&1HceYfbMZNp5GjMU+4h4e3rCiz^MLUX5+SDF$}S zk7#3sY=|_Wdk^|E*i_Kwn7zZ%CrUX^*Mf0Qy8c+)7(UR)$__JudMrEfve@OhcHa33 zO^wnD5);~(R{1ESCwxQn-c=PYeI*0_+g9})?ga6vIk8cq?8HR4sB=c%GEBaqT_a`b zKxTd;LO_!c>7gkG>3Mv@jtr1C+B(YlJxR3?MyG+f=p0A=f&i1pO}!uDf+a|ObffMZ z2Am2$`6>%ozM^_1*pJbK%|5LSkdQ8Ii_!z!5W*u~CzxJK_D2?;Mf;&g%;w+NaZ(Xo; z(p{J_#fph!b(3|o;_xDsGqI<*``-ViRgC0Mm*v?o)MUo`m5(Plxy7Rg4h}3Nr&trb zw4GzS@awO1HNwGl`Lg|}*#$WBeWqI$5Ae6H*2o7~OQxVphM@VG*nLIUOV< zAQUGgu1YtLXHL)$eZ;bB7>L?=xprFk{dy#qzC)~OU!9?HM_)PfNDTpa#Hsu{BTguY zkN*m5bN9{m=bQ@eR5O_0WJ8y3QlG02lm|`N(2+>ypJ8pW5DGTV2hj6sq!k=r zga#{~p_*|3k4-spk0lgrVN{nN*hR+#IoXEUd$9Hv5E@7PV)0-N zNytYc&zHo01EMtv1r`qJ4?lCWt#6*GzT=IRUUr1e!xH;yeEb`EZ|!y9PwSV6p$zWJ zo&7)Qh5zpX%cTGI7j=L$z{UQbX}FEaw$Ah7NW-7WkTh;+P(a|^Tzmku+b_z3+{7WN zFuggfNH9-EvU6F9CI%r@uGaVr`7X88DZ%0i7mrQE#pA72HC+j}eKh?idG7O1ckgCz zn&;~7&nMI#{I}R1P7KtUn#7*vmSQ6=e5t6{OjCz0a`O46LvNhkbh1FdtC6_T&tk zX9Il**7*->S<_&!{h1Rpv(z@W?!rm5mD4}GD z9aeaoXREN4}Z}}!Ut}QEDI;89GP6<;u zmEj)H{Y=-8*yq)w+IyGXj%?Gn5ULTK-w7$GN!mB;z2_?EIObBXCLWG!E#4?b zSRJ{`=+I@=-dKI6YvvASfJYyj3s-^ZVI6kBRlni^x|btt$OD>p{&+6oKg!&C^IG{2 zB5f=s77K_9-4NbVm|!h}wzBX=k_%|DApGi1#eAu6OApFje6lktR=X1!C zG_rT&(-IIQVe12g%zk%#zy#Ve-kq@l4Tv5vv?=B-O~}E_QIZ|Sn2z_w9BsQItW{dR zLTbYE4KLh!W%t_p6vaXVv`zw2<9e|T$R})IS!CGfsM+Os*yct7G3phgM6PM^KSc3k zisX&xWivyIvIY)~PG&7nBG8JF8VQ7=kT(#N-@@lW^X(bMOI=SmGW<$Wo{^Zuev)-5 zt}sxk*L}jkmQC;C-6tPEW9em+O=2fHP+%0t(K<(QBDTpKreg|qgvFZ@F zuT)hp;$cXp>u#bh1BOGLR|dvD$S^<2WRwX=vDyT97Xv;O=pe)CfsZ3QH%`W1B~8T3 z@oa)O+pLMr*Dr8yMAB$r*~#lPX;!UOX=x!LUA1+uvXGLrb4Yz{V!Nz3EzctSndb0gB{3xQBAxg*_5_ zxiR<{iKdIdP`ijR15rNPfo9!19j<=(c$$+v*l#-De2~OuPUdy{QGVE*^Ocy_U5*L`bv@{(pb<~v{o*x{+V5yeDWjYV|p1j2Gl}6k7 zXk~>r|MmEI3({(hU(prR?sgYb- z)7@gD2w^z9wSD3`RV-z-&blTD$bqYntRvM~uCXayk~G)9&n`*6taCgZK;UyPemvUC z4brWjq~evs%}a>V3V%GMT+KX-#{D zrEQ8>Kxlw+D1y!a{9;wFMUc+=#kuN%!(%PZ+j5uC1Sg8z3YEkC6UPdc^;}hyAC(yYj0E zd|j@FKRKXnpw{Dy!s*r^S?7=lFygdrW2KcTDG`4wBE9sjp6MHn*R^kU_Vy|ivS3(b z)H1yEVY-R`dBT6gh(5fiO2twRMPuG*=i)kapXz+faDHs={^^IXjX?1DBO>PDN(w@+ zC0$&qw;@1bK1FIzA0qi$3!d|1Wa^H$w=dlcr)#$u=x-3v6?0`6S8K$)J}x zP&vAbu_Pk8|2@1C5(E(om<;D`0GqYsn!U_-9_E+hO^>NP$mY4~7S-uvqh)-A(XJkw zZP-GH$=okqJ&UL2 zi!4d#%)eYQF|P{wF1E;ekqAXC1w79>X%!(`=d7CgnFUxlhq%b9I(ocbxPE z{Mz7ZL8}EWm2u=IH`deXv0z&`Gi8qcODO&QI7P_%iTmzjWYu}Y9v|qF3*D~m-51rA z<#ih8zoG4!G;D(flqX_CE1quH2R`>%6Iy^Rsx-Rc=`HwbC)5!=4i-vp@mF~T441Vo z?<-y?@RQ3m+wDd2zLn`b!t>jY-gSSB*$^Zbsfs&C8@2l%oY6Yho~FU5t5)n1iFgIu zU~CAMc))6??$1>3Qg@lQ@K&Y&1zj#BhJ8Lcn)Gqy?2on8L+$U3j<9ROfHL6FHZI80 zaKsl9H&N0yb)BxK6TwW9ndosQE2L-C_ zUw4J4V-)~B2z-TlF&0m>TxEIy%&&_!->qGkvEhY@#jt*>4@(=DM?(o};8pHxKRZV3OFR&`D6L z8V~N7OG=fFO~B5PTy|ATEFH6cpFU;3nLCw+)Gx*z$2ptNd&w}cSwKTz#8ugKlX4>L7rd%RicSqmv03Bwd&i?I}`3c0`SpLkX8r)2^{k#e|G%4VM zCYl$FCYoO)?+G0NGoq`$Q(Q6ogS0CAj* z>w7>|rKxLa`x`GU_Enwb6s2LJJGYtWl0`-K1RX~VZtHjhXFry$v? zM<}cEbUbC&u7YQG;SSO#Lb(eF+zSY%Ae~&E6Sms+7|SH>Fmn9{vY+fsDDdK-Vv)bh zEW(&@SjZ)*8`~n#c7xUB8yc;iHt-!sxMOPFmN0qhyTY#BmVEIwRkkd1mmpK%4iTBe zoMD;)3>QK1>mDq;8Kj-K3_I{+MYMU{GEaD@n|%L1zNAUgo#}mHe-mHW-&Zu%HxqkX z26HnfI|eHwHzNiU8-SUe3xkE3otcx-*UiP5;eVt{|AYPgtACWDy_w5D+@$_b%x_Zu z3-inRFU;>|Z(0bEfcGevfX{)^D!?!lg@a#E3xf8z$$I@@hxh3lf1;xsJQk|miiidG z?WB)^1%LOJz_)FfXc5a`hn}1?oI4UDF_b={z%^U)#R7^(MYt2N%GoWd9XxJ`3uCPG zp!Q~2%?V|GOxQS$+dMqJHOj#jZ>^jnOIQExe?Wdj_b6MM!%7OuBvkB@@e>iXeQ{US zV#)qlX}1ROddg_26GJNrFxVLt)kpiHiM~?}$;gFK<_sCEhH*e_4mplM4qR~JM1$$t&YtcQ zh+pD00<}_Pm{R+Z@7-O7^X2?)KglnQ2e1V&8zwZ!)bJ1xH>|Q`<#AO`t}||qP6ZR7 zw1UbhF~*Yg_>2J8xdizRNvah;GD~m1rqub<(|xfNU9uM^Tez1!>3N1hQIy#Y3-Bg$ zbWYMul@=SpTPmK5DfEE3E|rD}Z^L}8RP^CaR!gkKxiSh>9$RiH`js5t`F_giS#}_G zAC^A;R=iXSE1DnI+Aot^H&TQEvq`eRg|6}x=M?meS@+!o{ZI5#O8OBcon+HnZOIgu zN$&8QIb$5M)CH5vr}Zn`d3U>o<@;RBbdRE-U&?Szz%OP*vNl*Kr6NtT0cth$2(}6x z8%2trmA%E9#S{JP;eL`WIPC9N;Qv~*)>hOsCzx;FR)2iqwf{-c{?{4dzbkdF<>`Z` zhX2`RT3??E*Ps{Qr%Xw;nIxBXF{dmfN!3KeXXqV!Zlv94=SDHgnviPd#%>D}fJxx- z3&x5M=@KjmBTY`)wlo}FiB~DM9ZgK>x(npJlOti0e09=J`g)JBA$!`}e(P=P^6@?M zk|X_9zvJ}BuUpOEk{4uO%l*GABUamYOqzAI!q zCMf*$35g0Lk~;}LEu$d{*U#pJ{OA1^ralfLXQsv|*6&ESknAYL6b;2-v^@fJV`5nddc5kp9QGL5{_y*$O` z*2gDIKdD9P8(XT*Rp}tiejAmjM-V6!FS5>(xyZ4dp;Oxq+0I)r!Ru@qu}s8}Pi#pR zTVco9UUzv6NYUWS(B^r^@S1B+)^GF2xOj( zinMnL6fy@n;w!y z>ZwUTrdZtrpc`9tQKN*6&CgWH5l7deZLRwBCwDYW02B{tKjaOv!gQ?2$q));7o%yH zRr#=GO2ddZoZ|7DtW}!KagLP-D#f$SQ^gr;P}8n|CXlIAnc;!8`8o>$LbvdOt;%aJ;%{>{lexX(!1~ zSr%MkI8$~im`VI|tIA_}u+zx*eC8PAE>U(Qfm&qmvaUJhIVurL{=`f@4ptgUAuO~h zE|DGa^24$62WS;H^8l|BB5F=^8@aEL&Ry=-Htr%Q8S*LpPzBc(RUiXB=h5pT%a9b_a4ZH$c&1ia2#n+-{!YS^Nny$3sLiXFcjP2gqUN6_DooxJ%(IFV&rSRG+yI}1H>%pbq6DJ$;)imIneRjR1afs^}D?^wVP z42Zz^MTZ>Q`5bGQIDlvzAVbGcd%!6$PtcPfAF(5Yf^RfM8d-N*okj;y`%Kk11?FD- zV1{WgdO?`KsA8C#TpW%veSe~_&oW)c#nwBViI(&TKlMw@edjFEX?gz}kYx__eR&x& z{~mJ*_vGPa`=th#Di`I;=$&{S6e6@`)@<>52xSg*v154(ZP` zn@I3B3OR{e`luq~l4u@|DfBe;6TBbIjyp`&-tf=qJtOfJov4H(mr%o$%v?iOyvVtg znV#1D@6|4$q;EpKgx3^6XPHz>RmaiI#6-a=USPyn)6HCTgY6)yiL9&!@L+{R11wr1 zgMOd?h2_9TbKkclS4;g06Yt>pN(1`m9@7mX^rz|-!<$auEsTE8Ptuo<-oQwziU2j` zL74f@-IWPP!AKpIuP?=?xJkAUYOzr?!z9K==JuEV!`!vXw3fM^amDrTsj`l#aCf1P z>rMEBv{k9>w%ntY3|sm+rp2hUrj$1MMEPy?@=mJuY!0Y}YlWhy{E|F=p&VTi*Mu>v zlA}RZSy9e_g9fwR(-k*DC)ZVEmM>@O!R>rtndZw2)rnVW2Wy)LB8`ZT;TS5zylp z9yVfLyM5D>$}+1B>UXg8f)th1$JC~p8a+umFyNZc=C@Yj$_M9u4Vu8{yN84wo@U<6 zQp<$Ca+-zKL`hE4rQ-0F^LVwx>(GMiZ3GuJLxu*SUCo>H&JqP;4StbW<}_ zF>PH0PmhAgS(B9Y(m`u#h}<47ef=0z-IIgLTJ#3Umkl*dl}0vC)vS6TIm1o3b> zPXOK#?0$;RCffRvPq|yLEJ3v%+*pWS9Iz}9RaSQRoI0j$++W2^ zihRGy#M!@H66942eyOixEp@}G25O@{vZQ%Wk0*62hIlJ-k&j%S=I6BqE0%Vcg_^V}udgY4nMvFS^ahS{%+lAO7Qo$zI|Hax{Ma9`> zTiYZM+$r4M1BJW0ySuvtcQ4$7ySuvvErPpCaCZq7lAm{X_diCzd+&q(#y+eu>ZqQ2 z*1GR&%{kYQLBkL71X|?S=ySK=!-wWaXgjy(PdPqLA*pc6!2zP8ix37D2u| z1vaFw?g>BIk?m`dr3)0r2jw*JQ?}fbn8dr)D5RjZbM(1GRX-;X6#Ebs2mJ&G0K(*|W!fHQn(n=rZ z?h3EBf~{K%ccHIGIRf6!R{bHqPX2zEv-cYzV&Df~_d6b+x`MWt@uc^<;fNYq2O{`5 zkzVHewkLPDq_J29c4rMg;0z&g1?qD}=w74N5P?bgL{|UMT$VkU-v5CmdXN7M_PU{{ z>PORvE?co9Fh9Fy(~Y-W<=~^B|@RZN5A25W8pb&)?3qQ%{7kxbJ-Y2=1Mc|0n0# zzs=61UH%!CA?@%l4o;!wsF1R< zQs_q!RAn*LViICg7(jiT=T4}5|FElSG9Wylg!9;Q2jyClJ6GN|C@FP-YwLXVJp1vT zkmpYRetFxY4uq=~LmLjE0pBo3Nv21T1&`RIs|{kX%T*Zb45}ir;^hKE%fbL#h@$p( zB%?~4j%D1Usv=Uond5dYmh&5}RweAlWpeb^JR*MBSZCcR1LntDeBW=~dIt$VtNIT6 z?WM0WDAs*%siwBG)HGn&w0JIofZyPns64nDjX>Grl&E9sK`1*f7sBcntF2GtU@Q8p(etD zf-iu5=BRGKLq^WmFg;xYJ|&c*X;|`gjEkK`*z%=s7B|BichWMf&U2IT=YKse8%E0Rdfd zs@h^}#qf_@_Zq;_P|i7{QYj>|g~VnA67Ny*Q=yVz%I_w}Ul9Y$3w253jThc{hpxv~ z3#iM$_)kdFZVV>UBZT*-$Nlz%`t21(7|X8BMIrq!d4eRM!?|5+Eejle#}Bv$zXrQ; zO%~nZa}u56UGKH*fX&%F@;2#y^J6zHgrK+;jcf60!2M9|tbDvWz}4-<%T_3s$K<6` z%n({zf`jb|>6~8PW=70(#W1EQLxTS*5UV-S{B#9j*SeA2>?|Bv`Hrx~Q088?x0n1% zb*5?+Q}1C=1shW;`IAaH2ShR#2o4iSsyBi}EJ~=2bf}Iy!AKWBpyZK;MG2dX$N;|? zZ}Y`dlPbLH7}7SETrS`PtBk-HJ)hKY4gCRuV1`q!=qb^V0^u2{NXk$_VLJk(aKYeW z*yWH>f=-pfW?TV@n;)jl!cOiLyGWLXJK)ie7c_3BYmHUlMgI^0X#pgN`}N`9FQ8sh zLC=4Ypo4d6p!uJ?sQ(KIlK%2Pa-bGv*}t^k?;NNxVr+2a9~_7ZJOl|-L^Vbwrd;^= zaZqK>UV8oD{OWf5{YAtLXE%x2h~alNF#PuXPxZHDJ-!HkC?j-1v%ax7-T+64#B%=h z;J93+@pLp4u9`{BtigY=plQjRAn9k=n!`DPoZRaLMCF@?N7XG%|7?tW$#tIJ5(-0d z*FoLvH(* z{Cffg0jF9>$^hb>D4+^w*rlM_0@Mkr2SFk7V-r>EG)Xnd*a_csVqi5xB!Dk})AgJ8 zMx>&?Kh2r<(SyW)@_D`E%(_~)-u)$6T_>U%f zy6)aamK`B-`)Uhf4(Mdsiw2{RtJtfJdtx+j@e$=ohw=S$Z^Z~D=n}}hCKn^mJ;*Ov zo7Z~zT$1k=qP_4s%C>l!lJq*T*}D*(#pI~{YWu+tGVru#ghD7#^**ey;8YuVdT;vwNC}S zCO)Lr8eRQDo^-JlM`ak%KWlr}1mG4sSz`Tuv&_uv=CZ^PPPQ5u&x?FgM_?zkP-5Jx z4P)Fe_54`}X_?MCF@pj5Sno0BH=NM+z@+r2hqtqx@3PpK>*c(4lZg6CA)A0`)|PIb zcf6=px1hSV3wRczjbOBJ!XCA3jZG#A>oot2c*uuCcC)Le@@I80&Jwg6b1{- zToc)hrwXq`x0spJ>M>JFWgh{F0kpp;GfJ6+N^KTJMc(|DFShf_jsJ_$;wqi6JoIp{ zw0+F7N@Dk33TiC(`zFx;a+YXL7bh=xl(gKe9r6qS*RA{IegOr>4?h!^~fij2cod*GI;+1_3Ia;iePrz#TvylE8NV3?MwZdmpZ zaL)$`&7Dq+#k>-jPzV8U=7K7m=o`kmGVgkH*YqVfVwIU6{8J@ zfhFE*1*;us$4r5ym(Qvy&6DA(*y)2_Naj%9?ijJ%d-V}MIV5|ppEEvQ;Ce{#dRQ=j zM0YdCn1xl^!iZ}GCYe=zbFr=0=WMIaVe{oJFE8LjJ=(1A*TVT|7FX%xsS$$>rp&iO zZjwwGvAcXLBJ{~Y1A-w^CcwQEtY>0$zEyju0n^J2lkh_!4y1_tOf*@j7%PQA%g1Bb z=;y)RQB=iJY+fU{_J~llAXlw{bZq+T2&?wAY9BSW_{hVE&=E?4lxvERkyFjdBs|bz zYM{XW*#YPfUr7RBNK*V|^7g?w7C)*4zck*qzrJ=(tI0eJew>z+$H5cAaG5ry`EjF(9T1WU~gQC6u zAMc+-LYxO)!2`as!?9~-NsPl5=*)we6NtuIg|-Di4^I)rwgR0Eqm{(oj0@F*1o%~V zowkC|!H;fS{FWWJt2ZfZJOw>G zXYL20`bLaz!4X9Rq+ZUASfIJD?>g`$^RaILoORZ%Yg(b(H=DdtEwqqS3O6`OcpXAT zEP2_qZ-#Jp=-3u#vAjL04EHY&5op`7l~Q$8rSkE%p+qu^NIE3NS(QsiQc|8eU{)?L zb60GP-IBbl#3wp)wH@u-y;y1--02-J+>x8$80?#*n6#Uy7|ol^nB^N#4ChU1C9y6-FbAWk^4K?62UR zC#XDlUV-Er?%sqO%HE{wmKewDnwYEWo)}^$39$B!D>AkDuLxE|Ue-}kO0w>porGGb zJ*)L0#xI|9^2SSF8RT9g3rOj?B?5EOW&c>f3#*AKyz(h{oNU0%tX^(Pcc$*=vFeWvT7sMs3lPF-^2rXFb#PH3J%Y&T#+}(X zjvpuWPMS(a zw-C1!+ft!?Sa*9#qWFXXWlL2Vr=A%vM2((N^hjP!G*g{ei>bN1UZJ-U=*3^VNYv2+ z0^yZ+l~^@{-NjY-XoWihlWaH;!)k!9az(hqY^I8#_@;zW!pL82GQ1>AK8dQg+qmOw z6c4}U)zy+4mWakR-z^4^Kya>>&4;;2plt3lNAf8px&vb{X~c2M&mrmQ&^>q{(BCTS zGbO4{DzLckQ9S9ZJ_oADkslHC92gW z{FME^Y3N0C&Uc&bkUH;`t?;FDRUz%lb&F1uEh?C1e>|NvuA`=^h=vcJ)v6Zh8~%Dd zO4p1ve(QiTE^9U6d-ev46}E*j`DH* zDvO*Mv0Ysr$L!vT!+x21t)_B+B{k&S8e%8tLqL$(6Zw>C;x6sow2V=vI?>A-yE=4; zrCS-B&h&zOULb(tvs0!|Ch^mR@j;e0w8ZK67%iYC*O!6%D%Sh<@3iD3W@wuJ-Ld(M z1_7b;e{+2LuLIM+ESf!lUNdSp!bTjC zo(5k_oi#Pch5rw-zhl*E3k`TNw1@kJiCqV{J(LjG1-EXVk2m~`!}kP?5uvNd40^!1 z?7RIuvBxS(@l%`q7x%-X7o;Jx(`+9$l5gbBPd!r301nxB?@{yHj*z}Yxv06AuZya={8+)sw+^SNz1;0hF|VSMN7)a^wflhT*_V{vDZ$s$X9k}z-|9vSG7A*Y!U?GC8Fm23qO?o=wBG}Ks$actn3atA0# z_3X$3dR>yRmo2>5H|BPhAmGd$>1(5Qb^23`11MUG2Pc|4R5^}{Ex8ZiFa`NFNcv!T zcCVx2vN@#3XpuZsvg@>SY0N2NnU;&AGP*SM>ITeT7pkxQ45<2`yviWWVmJ#Bq0rf_ zS1q<~DJSEbC9WmhSffT-zZ2O@3UU~4kJFXtW*7bW9w1XuwpFsSp#XURv6)qB4NrQt zIe|G@!Ith~YoIKrJ67Z2&~+S9XexE6UuUP2rPA9`n>1K0i(zCo>_QK~r~&#H^P9e$ z>Lg>inZSpNUL4dP^9*Mm(dyC`9%=IT%ewfAcQEUq_GUZ#;f}oC7!h2F(#1*h5shG^ z1FuuKdZX$R1=^hK2_%hJ2!3?v07jbUOb9FpnmiLoU;miW<9|~Cvla4Nt`|<&!_&}~ zeg=rMb0x79pi6sDc3@IiKTGE&71N+lpTU(wchvmqOuP^CrLf+{clO2jq4M=dTu~r~ znl+ww+6`ZCfeKUH)wcH7R`r>T$ibpEspe+Vj~~%Tg`NU&SGzuA9g->ZaY;s^j~L@e zVu^Iq8HCb}hu*8%hehj(7l=3R59aQYE{lDXpo|ShF>+-7I@X6J9lW+){gNlr3#Vy;yu5;qs~Q|jqlgS0@PmmGDQhPoR*~J1FZ@Vu#cC8BywZ|FV$x%}r&G1~$YqrhE3LT~=R_ z8BYBIy+Q(5wz)Ip9=g@B+V6X7Gqr;%U7I^BKrm=vy zDYWQU63NdUd?|*~y2RmSW+y@)JUd|Qi*Ax%)o5B|LW!(Cu}Jp`s$&8(Swpm6T5VrM zcc|3k^x{Yz^x5LaZ?+%t5Q9pONiFXM!LTl!aoiXt$Ym|`5)Q#HuT%>=8VkZAu@$@u z5j=|JW0gC8X+TfNqG(Ycl%6QR<%U18Rc;G?*MbRMe^&OljQ5@Nx;$`*g>xaw?%&fQ z=bIjI-n7aeBj&oU=FIQu@xI*q=tu`!y%H&52=xsuvE_|5-hmETkYqVwSxVROo9IgP$Tb^F zkDuBMI+ysx2OC9IUWp6Uh2B8o9hOo383&V<{G-vo>*U}X{{Z=5As{&L{=+DR|3&8i z-=-V?8fyF#vT0kp;%j35-unJ?rKqB&J=VNTHc0}h^;}{#lY>Uqp1NXlWy)lP^s^Fp zZY9@~uPE-_kcwb#tGy;Np4*6Rr43)4z$5>W@?2@G_lh@caB2rdkY#^(A=aEqGd193sLN8j7W1FrVeaS>*fTA>b<~^r3RYiE?WAt=MR)0d$OoTRE z+irTq9(r)Q{J@20Vg$BqJEZC)D%a%r^_NHp!+v6q+Y$X=H!{CHQzA5FVfP&19=8pU zAJ?EMZg}7xcl_b%M(~3@$+swWC($)_8OgTjjM>ZlAsmyh-MdAHc*VPAhkS5O&uJM6 zwWnwJ6PPVcFe=T5;^>-W7z%7FjYp`|MOy&t&F|xLsZzPv!_JZU))I>I&8;D0*(P;* z1*3H~(IyY(bDKK68q==@rOR@ai1Lt`1<2+WV0BwD+-2)huRb}NmvR&9U+Y=bJEhFc z53BB{`QEbcA|HN>Th9P*!?7hf(OKMm{}90OVv4H{zjjPX{2IB}<)S`(3h zw8VFLC}Tt$MDX_0s?(dMBugf#pzLe#T_}+O+GH^t@$RDRM+ytcvfMom#i5Im1!pT6 zTNU2R-LFWZ!0uJ$?F68GdK(_%w9O;w6~164RTLb8gHZE4dJt!8rS+I=(65TC{-`%S)QzU@a4CaAlyIPH=>rXrlGw z@V5|0y+I4GOgSGA=QE@4=i0q$#0SyPRm)O)G?Xzb$?zDOE&5$QmaX`3F+PSp$S0Dp z>}&hDWIVMCTGkAQ%E54vC#U2HNs)GGu;jHe8ga5Sdi>ZE7g1rDVyKhUy91lbL;-Bg zH|5m6HlIx`(mM3!C))lUzU?R`qKRc{M-}m1xga-$QG8Y=%0;r<9W%Y%#Nr^77h`aq z)PS)(9$}glBfm0{P_FT(aQL*%Tpm|#qgDYeZ_nLN7>wPqW;l>0?kf&XeyWTpGxJ3< z#J)ko{V`+!vU)zC+|zyH7)<;lS?^o#kFg$A8~KFXcH%?U%d`i>XI;5eB-VvH#w3a+ zXtq+nuVS{MU6P6z?bH3g~PH$@KZ71Zy6A9kH?SxK%u4EDI z5=HLd#m9FCwTBY#j4YU7odUp5j7QYnMVj1O_Ub>VWbRM=k*HZDf)z)8&U+P702@Cj%2yCUFM_yAd)BF*i0xp}t&5Gp z_?gt^>2(@!3Qm}p>Zi%C5r)hJ<>g)U_Pu zVt`v7vD>H**RnNYxUbHEqz2*~s(j=3_=72T{_`=~E;_MDT${WPNn=nKGNs}~a8nZj zk)D~z6(8oar<9)ZZu5kQ0@p$B76KK`d9*Z^OY$NNAy%rrVVoSq3aeR6?aVgQ9UG<` zvBBmeu=uZ_oyx{@^+Rs?9@nKVHqi( zjN!-HQcJ>FAy2%saJ4+~$`OZi=Y(VEJyQFJ1RKat zMij(y_E@D@Z|#XJm03nVy_wJWlg|o^m0fzzHVBfQc_+EJhBl*vL^iO~MtU$p!rGZ= z<9Xu>L^j69_qIa)!rFDmcCendPMv>9MNV|+@=TMS7yqzso+^lKbVQ~n8jXhbowXX3 zDEb5gl$%9;GPv5ALU#zX9U)cRnd8=zIMw%u)`aDXPYKa?(Q-qs;*ZpvGM4WZ;{^Ue zR(^sR7!V{Jt82bLK`7Wa! zbhPW$Y!H3Kd(RZO8?z_HWr~hZpm-awMIlW+1J;`c3qW`M011YTsz&A&-* z-_-uYcj*ki+Wlbp3&}tJM-tq~oBx~gy3di12y`)A62`5C z5JY7o=9uC)pK0sW^pt_60~*X*@G!N(jZszbe3+P+y-}4>wsf@!s+>cnBK`6pt@r~i zeN(1I-(mFU*mzo(bpS-{MhT+vNU-1ZhL&K}ptHC3xODz#u zJ?Qmc*>xv1JhXtcb(;>)woN_a*=yE1X^WL9$q+#u5n652E1S!~wTQS^okO(e9^Wae z+$-9^XOXbik>1yvuMbC>M!$0c?xt14i~iVfh)RA|cO_a<5Io4;(X8s;Rn)l4wtQBj z1`U^lD>2(;Qd=PESi^H5PWIIneVoU(L`d4|L4sB$-lC6noxh0^-vl)$raf@v1n zToQy6EOuv9D6D|8rfK&{ zAV_fTPpiHh%$eYse-nAN<*Xm+yjrO7bF+(cQgrQ5{ZO{TqO6X^^pMX|6FzZn z#nL+6LiRqX>#u@H7UcweBPEHdRQ>JTU~KC-Y`OAP0v8%ZFFCGfJ3K$S1qwmg+g{^1 zW#fS@-03d$>HTm@G=|0h&{;6rkpk9Y-9Q4 z`YflS!0wnOCz7>UHpXs{_Vfeu*E(J*q0NGDWcKbjUc9Y7eI!SCpIN)brg@VCMv!<$ zdvF_jcZdgOciE1gZ~l&`uUN}_ZiK7@Y0j7{z)3N0jVG`owd=$tgaWHRkK)8;GmI8ur%-!-yl{lrM20N=tLRbO!ZyTpVo_Tu4E zb{q5?=jZe*7B8314gX;F2doDoCaDI6u>)-zMB!@ToLe#k#$sK~zBYFrhE{Vt5y@{V z&V*!=8n;Y2C#7`$aqD=!eQAg=zc2V@vCsH$UjtqoY!+aTybPnRN{7yQqZQDJnO=t; z;=;4uYVB21Kk(`t^tNN+EV1{88OwT;URZq6Cx*PO4;AAQe?(wZ+>&af-uIjS5=F5o z!e)*mH@(%Bp0z5{iH$BX@daMbH|+pVUlYaWM&#TfoA{_4tQMZ!I62d1tknzc#=!v#|#GQ z3%G+i8)E$nYd}xYD$xo%aNZ8ZtAyqED9w&rjV<)J(h|usEI%<;9-CWXvyO4gIHkTJ z`6QIiW(X1C+NJ(nYxtx)nu+5^N?)>GuqWO8eU`&cQY_Bhh}sLgsH`3V$h{U@R*>+M z=$uj>O*z$KKxbb7%TF_&jB5GkC~UKlU`)R5*!|3!!2ML~EX%xvp(y^V^+jK|9f7sg z9!bqZfnfRPF4@~c9h6J*qzJITxLq-2!M-F}maWnqxia4JjE*Q@Lwgv9b#~0syJtSM zsYgZ=Nj5-87wO`$9#}z<`blEw3ld!8SFO+I)u`@Me$f<>u41K;5lA}v6;NBmq&bX& zyUGPEbb{!z)rshY4L&Mf_H3v=a_I(~6&tu<)xj4$BJ4%0#KmJu4Oj^VQ6gKQ7y$#A&vast9(VC6kgr%L=D;Ko|$w)H?!3tqwXJ|R{(a>_dUD=#87%>Y4Cz~B0l zNgd}Y)F%iCFbV{O++pFgWlK z4(g}<(m?PhM6e!c6-y#5!_6W!N{|%A>$_~_ZPE{+%0?~BN)>^lANwf9w{BOB8>!=T zUQ+6$K^9bnm>Fub*I;s77f>66Mx5n$~)g~IUcNn)f8F9vQJqu*%@ zSrpC2${?yxL<5SxmYhv5-SwCGSpzKJIMQLQUTf-G_IF*C5xgI2=j1V8V?8^9ue=jM zQ;=8=R$mTA#f2fyrS>mB^PwrQnPbC~%{W_+yO==uZc0OYpSsT{^@+1>Qr3)$hMsjI2Jr0xZy zp|y$GTqM(Z$TkGRh13?Rr7n#gM<7dYz`p%jOzk%^HN6@{|AT%&t9hR#Z?DC}V8e;C zS&Z`Q`YsP;A*Er4fDNyj&u3ZhSB~nQTa7i8KhzKENiTH-4%#%%)Tr6>PE}23Zu3k& ztF+T~1c$NDFhTgE2&Tu^*Yhnv*Z>Cn)hSizVwDa{Z1HAER%79^llfXK_Ga1l++@0x zhv*=334Lp^*WR)MNt4^d+`~0m(s&cAd~5*W4>nU~*z=<~EJ*%(#O|;*r1vI))E({u zy>`^b$0=c+6p;^H7)05Q$MaKwXLVyf3LiRmn|AuwEWvY} z!HKHDNaF{TX-~9n2gXIn2FV_&WGNA5<08pDY9{^`0Y{%`jgB@etMjkaC%<;^ux!)W zyE0&Yj@f_GzNB$C_$|81cpwPD*^M2cV?iu@sG*lvB46fnol#hT1o8 zOzBk5yX>y~5)wDJR@AYkz7DIn&;!{t2ixV-wb3KL`Um*b|eq)*L) zOVwyMCCBeSH{a|xZ;n1pTsOf<-HL|u$Li^{va>ffRU}Tz$DTXdm_@6S<7eZoUi4id z-69u98=uv59JHy-3ll0DY=II4tFgbs5 zBecI$vre+{brpaUpcR15+egUG>~06mS1n!_r|g(=ft)jM_yt`8)JU!N4j+$Y1Y^IJ zPH6-K^EGVJXuA84Q&g#vX;b!l8`KYChT`aV6yfX6om4-SoL`e9f&iQoeIcp!#=F&x zl|hQnM|bO;sEWV;R&6;M;fM#{<$&hM|2Ny`|E9qHcZk{YUVhgl0KYZBSXjH6LYbf> zHquBS#TV7JuR>BClm$CU&?fLb#RCi^36z?t(sS#M$GT(!S@vRn<5}^LElCW#A1Mk%f6h5UrwAxQ`I!f ztKyZSpHjb)@X>t)9f#uB1A!l<#3Z69XUYQZbx+Hg3-EMCd zX!FN@Rz%GO;FxOZz5i72*XMfw-S@%qVlVhH0oB(sjZzs4%ep4bE(JPQXf~A&Hzk{ zd9h7rFd&UPPNz{{Inb9G<(AGe_a3*#!a^qyL{45cFw9Ojc{-gHMZiJx`%mFI<}8-S zQnLA@m@A4opUMqR9+2&7JTHpVSzVlIODVC>maY?3)0qex=kRyg?}?e_Hh`J$R05YB zx6(K6LNSn%T=$8|q6Xh$rZNCldtO&>Yi5!l&%nYenh}aKzO}nqmv;<`Hef%sd3zUC z;^U6kf*&l`U<2mmWd)M=9mkbxUbbyIUdtW&R>&(fp>v*xue9q-?RJP@yqGUFRsCYKoZXAU_|Vvf%f3#9+HZ-7q(0fLy*OIk@6ix9w_osFBW8J z&elyikqL@8%v4M!i4hWi&($sM;WNaJjM(@3-iiI@LmuH+)RE-eZj^mpX_j}EdaCEK zx)dz= z7Uueg>EBsOAmfl+);mjad*5vSf0X0$&ydU-%~wr;8{iKj3FKZxM1DnuZEa__9@`i| zFP~BN8yo|m4W_zz@#xe zOlP`O5(E_njPWu=@9`oX)EvtI7Tj-9XP(xM;*%M0(}t} z9!kEj&uFA@n_LtHFyVJMY~GXv!g-;V*VPe66a>R}WB|A~*ysoV+EhX)dO5l<;a-}t z|E!pp_%WHu$1fM8i?^C^D?ji!3j04;oc5cJm7^oR>y(&h3RJXUXN#P(3ARl-P|L-35kgP8hk@s{&JK$orIH!r;DS z_;Kny^aR2s5F8@yaXdwaXiq3bK!1#?VpW2@)zN1N{>VO<9?emWOF~4IBOz=?|HFHCI;5fE|#HI>xbH^ z5;%5@=*bk&2^J%tMiFw3QZuq(xywB!5F`lef^Q(_t6_pShia^Bps^fLxS~^^Bhl^jY3_@v+GF2OL#x=#k zb`}96cq$LcvKW9vV>F#qhG=o?cAFzuS*CWgBbLp&<2a%0c0EmN$@QW$z=hom&A4c8 zLgu9roaWtOcVt_M&L6I#JQcy>dg#vD;MXUiAxvD&8`6@Pz4`VUoBp`;8oW*s@t>J7 z@z=l%z5s{lr%(icI-?6Yv(DYl8VT)rt#s}eC;$fz$bPjH-Q~@MaeCO&>q!rc{glMJ zM~{nAr1O`=5=u#i{mmc1FOr+XOx9b<;>sjVp1QpV`9Kw;TN-rOBo+}pQ&;-;KGC!S~Nmt2UNMRDu6B;FH;-y`gZz#RR+=G6CENOB& zl0jRU8czFo`_Xvn%eTNNvpzHPZfM>9E_?wX|TUcC4+%lcJ z*=l!`^oi1HL9BGDu48$T*@26!{xTGaw%}CPslv(f0$t(wtiN`9=9-1D{bo$Lq}{*OEN#3Zv=+l>bCAXzr3(3yjNtI#$}!N zY1(2-xycBp7{@`a=k&^EUJaBmf8Ru+1G7;QhC-1ckIP1*Oh(XLx}Kzp8V|dYjyDV( zKFE+i@*J1~vJnmrts)K-<{Bm9ro|M?mg1)PA(X5Ke~<@NCtf4e`IjNp*>WqLh!^kJh`frQ7DKV1%I5m_}dO!Dun{Zdl@X&u6HxCQRMfOLG` z4Sh9E&3siJmNSt*GCTWLnju51wu@YW%n|)LIic~&=mfAY&Crz?xE|%(sesy_oZt*^ z>y-IDk2JmMejTbmyQsl|EK2ju^f4azpP&NWp=?)*hw7xsG9AF^sJR3y| zIN0bP+d7Y$0Yt6S9a5)VB+!#b3!A<-7UjS@vD1&jhQ)8PP@cGp_kP&1gFeTX9(?CQ z)UZoNyuo5}6r*(KBrm+yoG1f=D>NpQZz85ulHL7xrv1b;Cyd|Z!Mj)*f7t0iFDDTw zC-l+wk$ZkE)K`3Q_j;-9#yLt&L?CJpQoBjXajUHgSJ2#UP%B$DbLR=%tWc<%+-BQ+ zWFJo0h}YW-RZeUJh|L5U$*FG%GnVGVs%%gumzz|^o!L`xmbIXSCxAZ4IFQs z6b0*b=FlGcfmV65x@!5_ zW&2;`E0X4}s;*zmjqR-+ELF^1oE#lo%+<`lynp;FCh8ybtwqCL6JH$Q4{e3jx+C7K zCTv?t3ti99YE@IvoFHN?FDwnK(QGa)p|vtGvhfrczB8!Ik-pnkL714sQU$g3f@bch-Fiio} z)M(Z9Y2D>sfbV>^mRYZJL|wsa<1?>`N6srIt#9rTk$sCf=*dr*fu;81HG98pT84df zm1MZ&YUYOUp)W0XcLNn~gnq)HX>7mP_JUTup;-!vu1OOU<|NWisG^c!S*MCd5`LYs zJNFI3<`f_$Ms{?LUQj7nu*O9n*|C;k8?7I0HhOdKyE)4jP^sXg7A@wi_DLy+z+Qr< zzk>#}&b5rsm3Bw#@4=Hn5(!)D_KIi4!h@$9eI^7~kTWiyF zbY%|4Q5Ad1uO=C#l#zR!L$bmaQqC=dxAL6ld6*-bzKb@gELD=`ipnBb3E>~14l3V> z{%nkXJN%i97<5=Dp);~JF<*+7|fRg3{GB6TZ6W{~Vsw4s=RP4uoiJW?lS(#RpV_NP?+5z?S(Z!`t`uIC< z>fJ(V^OO4#ijtHT6wqUKOjZT9acQGk*IXBfYJANR4)QjzM3U~8ouk&7uagzZs1Zjw zrQ*20!tg;=J8PF7%U)%CpbOQ~7z?op+j*3bC{STk*R)gq(vep!T^iqHS61F-gK$$b zRU3|qyYA-l71tV)7g3YUxoAYylAGfAnG3=@DF_Maq_d3Lg1EC>?nlY|qZOxY*XPX1 z(TZ<xSjX~cnq!^-Lq;2 z80vZB874|9;7U)e6JN2<;LN@+-kIKAhtR^Y()r1Fq7KxWTglj5PphhaRTE$2slEf9 z)8UuAq%G8RCiQdx>Pmyz76z&=WX0tfhZ8osbZBOXR>sWlWtOv2 z^lN|h9jup?5-&qTY5dTjIu2H0oi%7W4FhtN=hxf-FP&^HB%qdFmtsqP3wv@adx_uH z=lV2pxi{BK3cO4GO*Uek>q0)cLK)>{iC{nvYv_0GgTT z#$Xy78VjMcjw z?jIRXccjoSK|4NG$vM zQ85ctd9Yxgg6|CNSYdMstPV5JqN%guu4rU%IHKucpoeC{zTgwzO|p4k*pU25LpZWK zceCXSPPY4KOSS$?2LO?%NoEA~m#zq?wYkE~BadddlAyQQfTPh@xg|y@S!INQ3T^Y) zID%cFp%MpR`bBi}NS7TR?GX)|nQ`~Sar?{f|BtnIY!(IRmNd6*+qP}nwr$(CZQHhO z+qQl7>2v$`eCRh~BJM;?ME!=URVy=}?BNcZ`+5T5X)-bwnIU@2_BVA7HU0Veszm3e9@k=9?IEcqW!Bq%hZL&KJ7#$cNk;6{1JT;sFNuGWs#HmI zd$RG~@_4?h7DaS~CU@^MG3Co=e`@hO(*kGac(DyT1@j+o28;RoAlz}1x`K3T<7Y}s zNT0wosRDM~A;2E<%5hOD1}aRii8LEy=Kg}b!M*L9IEIGZ6C}+Nl?vJ+!xnKu1(a%V zM!q7rVR*xh1C9}kJNyVJcW&N+!x6T4JXimKH~7xBhTs#ghJE!KZ8yZ0 z^V{|kMx9m1wSAp~Yo43yI#-8WzJK3T7$u7Bx-}}RAUVM5QUD)(QI5?fq5c41HsKXR z$RiHH31f^;>>;cEh%I76=tVuMWRhQdLO2R083p)-b`a+Z4wS|e+!iI={~z!GF6uJ~ z@qfE6^?ymE|4%%^|JNY*e_y%1>e~ODLnyy;$!<#s+7Prss9uE5la&GxBIo znA2xHneV3vm=EM8{kCW4?pB4SJwdVFC^LY8#FeU}>bnZeg$Sy`fM$o&h{d6ulb5j7 zU4SMH*{!#b%giesIWS?J(&!yDgyp5@7aKBbY$eGjW+b|1VRYu_CCsVrwQ{htvZ+D- zB_korZRH-LmQ#tL;T%WzIicS9XSfX2a%_ORmNA0$EbZ-8G ziuGSq6@{5{lU8QSnzxpPvG&_?F=r+xr<<~EY&+)_8gkhsC>JKy=nyQpb{&AM<>WN@ zL|2r{%;zKrzQA#!Eb9@tWvBI|F-j+AE(Y0BvqBhJppNMV8dqv@2wUP#XZqD)Fej?a zCj?A1HpGJ7X&h+I#Rx#ZyG|Az(X3idbbW>^@0F;6~{fEKdz+BieIQAJ?K} z{1VE?b;S*TT0f^0rY5dwI8oy&KY>cNsZ(XS=GqKCpE!*tThCU!1S3`^mF5qq zbwIilFbC4PU`>!afR5Pdlk!8p{C(F|zuAS1knJBA4E1S3S}($vgXTU9*`YN^`j4gH7+8{N6vph3Y(2a4ExR>xQnb2AQW08ApF&ntF;}#gjxu2qv?Q*9_FTKENAjTVIM@-{Y?r zp8KP{0T4!hm7r3Y(~lsTI=fkSh~rGtZ+CowBaYZMds&Wfxi?-R{mv_Pf-bju$V-c6 zx;xng9gAX9bm2DVf-;&Q1Yh7CC3cZVRArp6$x<@ept^sx++TF32-zbj|7JBH;wT6~ zp>kA9ghPq`TM_lZCG-|L-DLJTjhBRZS6&QG>6kH1WNgX$Mn zGy}<>d$%uI1+y0xvG}!MVEhK#s+ez)djy;3B@oqWvD7`_6mpG6p!y9W8ZVVv$z{kB zNx#7JJe_h;RjDXi>Lo;KrMT|6fau(ruq2lx1WjXItG~XM){VBd5;>iYHje114ZDIIoHtFZ4GjJNU_AmL7V&452=e(TzgnQ8-0K z>t2;+w$|$fMwZ@F$bVQXkX&P2PRVtRUvOG!$L6pOuw7%H>=*ZLU-zG~%2W3~>1mE> z5A_FQ;aqB5CJ5>Q6qRbBP!`mPe!=ICQVaibxWi=N-6r0uIL|Nlwn{MRrjVrpz-_>X%1k2&(6)f=tq z>;5SJ-mtq8n9LXw5dt8zkb-QGjQ|u^OGc0gGD0i}B6y9S^MAVbdtTfAAKwRtfYgsd7-xsfpw0!9 z7a}U+vH}cWs4qqWVRZuI@E}2q(}>|3BGPgkNtozX>Z*YQiV%lV4;@lG_2_ZdBga|~ z9rZ9go%#c?or(jp9i2FBhw7MZl$oJhraJ^CcdCup?vT=M)SX~&(;f0-zc3|p0r?dc z29`FlT91zSZ8MK>wwlo5usK=soq1V1>o`;Lp`935O|DwjH!>XUXs+4cAvSII4qU

VLwHNl*H=c8gxHT9sC9g_(P0R!-YRONwDHA$KfTU1DYIB{`Ay z?lfB1@kw^#8w3HO8>ra9sFk*^5}4T=_`4w`XFVYy zGJ<@(yCYT^l(@p3(&kQg@OUm5>}RB>k|0H@R-cJdWO0*>LQJu6TUf{KMNh4p20QzD z&vIeKM2nWs#@=HtTw1P;GT6_;3*A3z$!*ZOz0@cV70Gx8d)4z%;+ludQJ0Ywwd1bJ z&K@)59jyR^k6eQva`I-Z?RHIT7d_rS?qIUlP(eJrDPjZN8#p;r$$4=DD6S?sSi_c} z14=>Kzst_jgJ<(I2OOWrbq+$M0c-MADj+Y_29Pp`GVCoL_A=Fy)p)GZ6#%E9?+TtW z8W!tEJWA4+I+)naQwE+ZX$YtVPsrT9VvT>=#9HbCY{&=+LTRl(#&G zHcd!zG2kjQ!#=329tvZ^RCr^=Fx$V;cfNq+Aa-J&UpWf7#^MMbDr3e}ZwHWJmd83O zk0g0Xjq0Pz9%5t7RC&YCC>AZZ5KzLlJD3edkx@!L3X$m4COs;VbpO>CidkRf0b5_~ z0X)AjmYsT`uoweNh2e-$UKj=M7-0DQmklm5SexLufTKg0if?F~39kA>M927a1Ebgrk6{91O)iN^SWzM- z>ku-H4C=)14%R*Uo8nTqH57>$RnA!Ius4D} zgE>j(gP(aNw|AdSrUg{dxjdMcEkH3D?sGv>oPDU)ODH2Rt5ZlAKNo4;0wFh<@UAwD zdskg#u>2!ttiuMkPy0vqOXnx{0O-C-QeQETAN&&LJIPFiCY-yX`9d)Zb)xqQ2Twt< z1hGZdxd<4hJnU&WqK%+vC0`@dUw=W>GtLI*wRn;Vw{LmU!uJx6-4vBP?iCrqoFgwH zh7+M{+Y&Qf6xapK?hsBUc6!`4GLn%&9Bs)c=O&a_kWs)4qm)R1!lmuy24`W!grna< z2ziDQR0Kl}eWvw?vh2;Pa)p#>mR8NBvNe#K8!$n>u4$ZHpU-U82UEZ518To&g9>Za z%!OfwTTF#LyjBp;&NUpv%1#UaG|)8p@adzG9&=wgtW9gpAPMf?CB$F|i z+=^#XA`2t5-|kJ^iL&ecv7U`L`P0>U{GLq_%S|aw+yuu|17QL`EctobkgoJXN5L#u zRV^wKTmY10k;n3tU&r~t)tj(adLK!S+`Lj!pbG}!S8de3f5m0iW}snHLpb&IhU(@GUcA%*TNFqP9dT zif;s^v0Hc#EPujIkx@8q~kh6Fk23d{!p@k3(kh6Il2JFVj zpxQ(OEuRc9{t>C`iw5ekqmpp-%5dSWSPu4VH&ce&Rg@IXmU7T#y|^`-E!Dx6^a9%K zx5vR2^g`b3w-(M%ps7@|u}3HXVs?(v7<*{gCM0chZg(-}i#O*#RUfH{O@Dik(|A zcT3D%L3j>d{y4w)Z)=}$`-tjOZA>D6y71VLzt-e#fBs{?SJj?ZuZj-<;I0h-!1F)Y z?+O3!Qi}h!nmPX;TG;=iIgDyU`lzg~@}KvS*fV(sGSmPD1|X6_LxzY#M1Vn%B)}pG z2#gS7CIwE)iRDRpFcC6}NtF=Z&F_Bf&wytSiY1MkSMz^)LMsKZYwcq>idow?q zO$Qx}$M1aa>CW+fbH4AfgZJ(HB_`t1%CtL|(yMx6O0Blhu_YgzzI6#uH%S^|W&7Hg zYt7iMh47@gN6htH6P_#)IjcnQ=*_KO^ zr_;1atDkkVGi=Xocc{+Y-XPX*pW3t4Y{~A`+?nG8M+9%~i0-!aiOOw%hWl(%K2^SL z3FC=e&ii@RJ z{8ak<(8a!2`((n_w>zfBF&JNUnqqb9ORG;t(YG&`{{Yk6p@_~t$;m!le!tBbYo9n$ zOSNx)yhZBdCK2{GIOaZW=r(a|kM*ax_O|h`6<3}IOKXIgs-EV%(zx5&S^ptP=(--@<=t*DocVN!{xPMypFQGc< zGb$VxMeJWv(g*w0zsChGzbdDHIVpnqQaX@`hluf2px*ei`K2n^*jLrq zR9ERYRn!%=Cr>Iiudduuy>$E5mc|SQj;(X&Q+hYr{EZ^GG-ST!$ zp*p&`q)wl3{oET|D#veaEpHsyfdduCa%5wxv9TIlT%I1jP*r7RVY6jIX4Z0Mb@A+@ zxf?dFuWo9bTf3F(kuZZ)op$={k7I}Ik8S9B0ZYdfi29^`2obhcDI9NmX8cDjsxVH4gpdc z2acaX(3x}*`n~pQaqSvF<2^Pv@i+?HI(=vT}qjt#$|5{59IcHCyO-7~5xWgMQuU zU_Z9iM=c1J6Vv*x(A>Sl`6DtPi^VY9c2HkDq+`X>)vG*E_8+u_yJQ(JsrD&HF>|%9 zuLf!g4++O`VlbBvT|wJFfNxd7m|%4UhqVLp%qsK>sxgVQ|IM*f1?^RzKxOLRK4rFD zfK?6pWT)B6fs+wt)c`~f@vzvYL>XncxOW@`#m2E)N2E_*07hJqHyAKqc}7wjSL!n8 zNmgmAt|MCr1DS3t?2#7eFZGttfX>D>7U&|ayT}^M)io`+Z#T5C(%sE0JzlQUKYqO} zA^t~%;rQYLZpI6%J+K9?dKE_;Wj@Om-;B+Q7-=gcOxV1&eCiF<0BdRFxGVx^aaL)H zN>+WAC}RA|j{poU73OZv1F-tYjp>+k9KkZ6vqetjobc5p-~odZYVHe1PQ)uG1-l3G zC6+QJm5tTKz-OqpSYdUnj=z=~F$pm6t(1MY3Ds{7&}3v@1ExwvHbwWWd2*Ot^!z(b z5xR~6TUQMW$d1>ZzKO;TUyb&0S;I$yVF7l!eumdMoC?oTj^tVxp-}?V817?#<9kPo zOg>^Abn0bL5sL%BLD-z7J$Rmw80rbxp45ppyiIWK9mvWzktt%cjV2k1HT5gKySq1Y z0QtK{m$j^BO&{|_(8I?}31vWm#{iqPjnNIVoE;(vI~~J28MyV}k=m3aX_aW}zrs4% z4MxgHPDUQJftd9%Z(UpM?Ho_Xx72@e9!vnk;Uv*TlEuy>_S(-~Jwlf05j%KiUnBpVfC%BX_hUl8HkM5kR=RTxO6 z$Jv4N$mC?5Uf)ilYFxT`0dMVQ=i=_H$rK)0W)M@LX(O0u5 z5?f(1)pX;NNIQwzhQ-6&I)CdjRky6|9}Q+eUJ%KxSQi0?@>8f$8KshCi6V>TN3Uk} z3e{V=Q1y~6UcZEmC4Uf!-8*-Q{T;%@>J8Du8-t4#f5wolL9|wN>>*o=e689jh(sO{ zQ_ZP}lszJm?HDnOC4V%LWr;>p?O<&b9r$}r^Yk4oaj5%`^y~&Vi(tz+6l`S;N53+{ zcBm@aP3AK+FH&`}Ffs|G;SQCMj$99zbz#&^QlO1ozVMf&F*i?f6i#wWPBn+B@+*zZ zEz;ilC5Yr!onplD$VD|L5Osd$&`CCjbWW@eEmQ~AG*zuC(s`sa;`2$Sl%${RKBMO+ z3j^hf-QJZQoYgUp1AqJMf+7DqrRS#%6gn4lqNF%V^YqFl*vW|2*#gqXCv^RKrhagM z(lM4S;iv5AhfH9K`*r0fOSc=!X#`Z@X9&kJk&F&)e{qELNJ-U49l3kdG^;}=s!dU+ zFp_#yHR~g<0}ChMV}$icOIC-xZhZvyNQ|WLPbX}K%91g<><)?D+Q@t98EoY4u{7I$ zQKa^$ZNzsTt*6{1G(++9HSNO4ZIXCKplkvCJc%l@dqeJJ;l>)0f*lvFxgg}*xt_DF zxt}g1j{QfiKpzKm)U#2RX)6}mJ(kW!<~QkzS)X>boRvpFS%5#8_{YheF@I^60PwSdlvFH|t}BhYTwJl1HkC4l4iR zh|i<4Do^F(?GdHw500PEj}R(2%cJxoOu&LSmbsL%ry5UrooI)Ts2vC6W}H?0bz+$YTX%IxpTI+xT9WqXEDu0b{j*yWf7zHm7`5RA$@?s z#W1cC{*cu_IS5%GUXG2Xn54<^cIDhGdxm+;@`&`2smE*Oh~?4xF=|Y>;Dtv8jk5`3 zkeC&3`uKp3b}DRSdv(c3Ks*4TNhw@kl;DaD?l4^22B|{;kpz596tur|dYvYeVCOl4<08AFXva0zsOH4OHJWCPP!Jzm|$g3DtjP zB!48IP|zFiH#LBLmG5K7%pJTa`7$Ag8G7LOz4VVc_OMKFg4GxLCG=k?+^AKDVCO^r zntDyf5bke+@aRIcQIDT&*&kixzX*Rt4vs~uJ`|Ag9mA;j)<*hA@X9`er)RLc*t~gj zZN-A>BK@QPRvaP!BS!mFL5W1qkKoDr(Df~hq(5C!qd-lXE~Tm0R4!cTdd-(LR6)op zrm#>7z;7(eQM4j>O;Jb=z)o3gDC~pRIIUo8=xNV5BE$^hr9!4i zPMT6h%9_w%%8Z&}4rd25B{q>T%mtPeN4NuXOT&quWh@J6m?indS6U#fvu(&u=DIC` z)R7npqm{95eteEaZX5Xz*m9od-TtedQ9hkm!*0q_sdRHufZ9Q#D>E6&-oz253_a3H zn0q43o2JJ2(?#ximi^Tx-hTtBHGrG>q_QT}xYbbQB`c~-I=23j-Dl+UwRF`Lh4n|E zBELFB1kwg$0P4@(1P%D4GB^iHO&~WcJ)qnwH#{psU`Zb5I4c|Eod&9E=lHXG=CR@~L`qeMduYo-3+ znC6|ZkK%?RJ~Rm)m}G*q(fsh))*y_X$PC%Mh+7L6@Zq0W~{y?x*yO zL9yxDI}0vmKAh@G<$jDf@*i^@*|_y(n#=$mTY zyO=YsZ;%A6`;3~I8?Br7sh4Sb(o(xuZ=bK-OB`y;=xv=qvCim6*6w7%_<#hvs!b2W zth*a)6C^&tx5Q{_|Ch7UL+j6g5_D}#!4EzazTv-c2NGeIIrbazV>I@Iy%q?=hn~t^ z-5<#0m!8D7GSte6*xdFCHuDT^#4^T4G6O15!tdfF*6C<0c+bIpnM=g((q`Fev@>l; z!JzTYRn8wLMh+9wzbr$cU9rR^sgg+Pu#-E31ZfzVGx;@%Bk~FD)4*KWGY+iNxe&^) z1aiE|TqK{Bs_NZw8CG_t$9Jbl;ZiVP5;d^WOD`tWMMczK@~2$2S!&joLtI?;G z_v?*)Bnh?(0M9@Cq*H(JU&sJ+Fu`C%bvYKL z$Dabl)WWMhv#VEooTFCDCSb*&>YH{Qj zj}tnuGJ0+h0)wviu@svVAM=qig?%b5q9y(iNJ@9%RcQNN6bxPzf#}+kmen8Ce(p=E;j}Rn^xuloo z{o*vAHgu+0R23L))JF#C33oJ3e(2n;I?4C*<#iF)dM-V~O?<`(XP#^itSWDA>Lu<7 zmi%aE;8e!99r16=x??*t1^bgopt16oGMlu`Y%(66hpyhdym9}p7I(D?^i4}p%O1Ng za;1SkwwuB((w`GE-I>AY-|GO_%7lA&YkN@Jp9z8|LAaNJSJu7}%nk5Rr|T^A@5y-8 z?C-y&qWYXD^STHbkjO36qud>;khy z_5GgO`eoRdD}N{bh7@j48;3u(#&TgoiC=c*7#fD1V7VK%QyCZlDrGSRiGsllUy?S( zw^DshDI9w0wfBtZ46t_Zw$8@D>NZQqUmoOlxQ^j6h_%m1x{EczojKwNsN%0vY5+Bg7|CV=hzvwl)$p%zPcC_+kx7()!Vnp|I8 z+lE)AXE7)1)@y=iql|ey(Ym=FxvTgWV(Vz`q4lP%^~msu=8V1#&M>h_xL{bA9@>X{ zh8yXh(mPecCmW}N)(iN0?rKJCED7CD$>00%HXIwuohp;7arPABGBft7rcq@ws!*(X z^U$n$vF1*dW28+KM@FiYOC$U#MrD(VT0DJrf7#qEV}A>o zf(opqKZX-(-Y&AMQUnaGetvCrCzkUXnI=IDM&_x~>p|s6_AxR;%qz*pnmrD3$C7;K zX(euSZ=Srcc?Bt-e?sJdHHkCC`BFN+9+Y>}M@!2DRHY6Jz(TN>L;A)SVU#Wa5H~5) z{UqlRmYY40Q3@Jga!z?+@8`Amt{;DadLzyopN5Tl{UqygpRnzE{YHKKQ}vdw{|(_Q z#sJ5%UeKrZ4{s!u0kSI!8Yo15IU&TfBA24@%3_9x!X;cbgi|}>Z$n22rkpJ=;}qVx zP3d7Qb<*3?!r0yv;)2Q%VWAU^@nPt4+v3Df(Qk_r;4U=#Vwz%DQ)E50WrP*si&|L% zgE2zD^k1}p;w1c&KAL}DyuW}CCdnnUgVx+H zd4r2$+!RfRI#wL*vqsgkJqL`KC}Wu3~x zrG!+liY~n^!Mt9W`if=lDWq>ER=J&yxt*51Ez3k~(?o3BBDLUW84@bp9nM=wS+I{_7Ad zrDESrv35_{k_mRU{c*`DDHBRq>BZARS!*9H>kGArEFl(29T1_Peqll{g(MY`b}nq0 z7E%F?tqa;yOEs5+R(xf35w7#m_~ob-IMx!EgkSuAss zm0}SgKeggLfm%Fsx^Ql`xh_Q$?A+`&z=n9%GNqK-FXPnKG4;gl(bcm!OIfYJ~Z7rFl}2zdQ!q|9Y+6T ztOh=vbYbhc^<0reFX{^na$$B|tgR4Ui9MAo6j$Vz-##>VA857x!#hW?=IO7NFJe;jsU-azgGc+7Ya$ zdS9}h3V!Ko%HLD)6SAiQzo0!8{fd2p>aFdGj3DNHUu8k@*u02;As=D&Fj@}ZPD#I< zw-^?a@x;UVLH6kYM)(!-4~56C<`Kj%ppAV>5x=xQu;b!P4Zpzmm@1eZxXF+3r`jhq zTMB=%Z;GVxOZ*l7TPpJiAse8j~gUgNk9TE~#i4`ZI6&HEj3CKTrz4@+A`QhoInYw;~wDec+fHEfj{GiZj}4vF$I=5w#7w` zU`y_#Q;`AoFVm)-(qFa_67c+ch!Jmk;x9@0#Y{w4lF>r}BS@A(7Hfz^yIN?Jl<7LV z<3p73H;nf7;it0hp4_t#iu_oVlYJJHD<&|dZ0J%=xKPWGsT=^(O(@n)I8;tlDJQm+ z6P}n@B!52*u%~vGFc^cYs=R=k#5>49D&jeIsVt&HDn8PQMlx6?XQ=UJW!!zH$V5O- z^^S5HQF%p<1Hqg9G&pvVa?I7sCZP{*;6Cj&^CMh64yv!$1zyUz#~d-!g?-~f-DrYU zDW3WOopndDT!2Ztq2}!73gi@bXSUmcXF5Eg^Ctz47M!l2@Wt1gf^83u-C5!by#XKb zb(>u7#1q?iyM-F;g27eZuFb|u$;}UJq{d=xS=lX%CR)jYG(+;lc7>Nd=KN-v-3Z3v zNd|!gAt5qE}NK&;RT4H_6!L8dk${Ux;UV5POz}^ zqsN|y<4;US&s9z)uKaYYb;=Y-9r9%bz9cb6KG~zn-Vg*g4T=pBX1v& z{TzrsZy6tLu#kID3E{cI zl||LEjJ;Wf(ZdhyLE_m}H-j{l(@Mu`RJ7ajX(Xll>0-3Agl%*^7@>55O0{Ja9&uV@ zs}ZI$GL5knjOhW7&u9(gTsi^SusA^;hc2Q(uTh~tTm?;d6*b%xDo&5=Xl;eXK`^4L zhH8Vbx|1%jx>p@kkxYb_+MB}r&N{XkrN>y6l@cT`>(%RdM&(m*;;(*Las`4{x_?({8nI4Tai0_;LeX!+TJdIAZP2 zmoM@7g1tUuzBuzm=N~s;i1LN+pE_R{^(FG3L|;Jj$1!~vg+AOhj-5M#=nqMKNa=@j z+-GDUr$FRCVpdQz;sW*1rdIPVe%z9l>8tRZ>|70_8+S@Ft`TR9ZnAy%hKd zSg|k5sPTbeH^D7VH_tRH**r7(R*CJ~l3o!9#6lM(2)7SMX#(*{VkP8(W^A&gy$_}OseaV6k z5v(Qh>4StyfHz#1C7(Tbd3M4@%RnOACB+=mLNv#)xAMs2=n_H+h^|G5T%s^CK^xO) zoF##cSq3XvQp=sjQc>!wh$?GI<1--}4X!P|H2bAadRmrQ$c74zMkG&K2NI4(v_dy5 zKpk|qI&4pM5k^nW*%S1sm#ZVm%jy7YYlgbfS3?xgu7oZo(y5qxDE1D5y^DCqg1M6s z4RVR517b3ElV=>oh28Yxu#`bYDN#^KF$8px27{83X^R5%YYfDYEB1UClCA)UFD!24 z8-)*zDaRaAFBB05+O-Gc%8MnaJ5V?^ayUY0JRas3HPBx)$=JFWJSFT(-zJbtXy0JU zpV&p5sBrGs3E8SNGXRF3B}snzQb(sP5O!4I3r#6dnO2Q)=Rp>LGao&RKwT<7(yQor z-0W>jI-YrQVNsfYP#B&Uu_%8m*uLEH1h{>R_JI7U(I@8x$l*L%=AnLaM0)9BBNtEZ z6k#pKhc4kn0e#6M!HmQ0eIfbcPi9VlI43z7`pCX=Tz+|${#nP^ql?iw{mY!rr2m>F zW%_vQhS8aUz8i`aIc))w#iI*X+?g`y>Oe8uLgR^;Ha0Ej==23nRavwG^+Z)kytdF^ zp;vW5ae00J`gs*&o-QX|DmG~k* zsMmN!{@5?b6>x>WFt5xN`EwH}Gx`&sQOcQRC;)Nz*ZC0X>wr0OX8`V5^5_qtU(2aJ zsQ&Xd-{k%le7+<2+4A`h{V_HKE8wT z@E?zbczEa!2y&m5`1sF9N4`HG?l**h`6e3)8B#cToz7PxMpVAjhuQKZ#*vg^20n^f zNkyKL)1t~{g;t%4Vbf%;wI)(ooaCppp@r@;t18Yph7>sIuR<<@j4c(k=+h}O!b!8i zQDqoOmDnVfROT~_gPdV^lDyJO*2h(4B(*|fj7v&n^$x{dG^ghz!l%~h8@72W(lFih zjRfbaqRhpd^8%DvO;MsmSfy2pPM*4VNbne2Z>fgMPT_NCyyaorD~xE7G0Ay-DOt-T z%S;k1TXnwLX~(2pj1~?BQmSTpACgu!#Od)RD+g-pTtRz(>hTJwTP9JXGQ9*-<0(MOiY84wyro@s4S*?k znM~Npv(@qX5b0vRL{ zB>AdNQ1e18gyyTDN$8Foc?gfFJ%k3-MgI%n{7@26?jShA&hcm|_frHe88Rak2g@?{5n6%gYn&*Jm`qfqIc2 ztbW6eEwE9hRUenZB@^Y<)~nTHntsy`GuIE$pE%~Bm{Kuk*{)2iLzaWiCMK#eMSby^l9|Byhqfy!x{u0V^Vc^Tg z#|MJla4lAz98DDy<$v91NU9>jh1#{DL&1f($ApM~Pex+nkdzFou_h_YYK3(nLT$M& z+nzj$W>=dvM`<{bmYcvM^BWGZJ`bA0;S$)1!jC5u9N-*K^n3w?EhQ0nUe zuRpYr9_e)ol&`sD$S?;Y=_5HNoOzmXcDXcqfkxxKaGSQbsf}GYCptB`0Fpf`RgS<7 zvNl|fX*P8nH+g7dKQ5O7S%WmD?e%I1B6`3<}6J1*Gd{7S0)VA~&yRx=UJ z;%8hTG8nDH{kv2?!G{MevJmi5tHlYxCH&#fL-Tot#~?fI=9Z7Yb( zuq84>Fop-sU}t0s4KjP|wF<2Y0*e#@|C(j^fU+!-KDAv(cDhL`lAoz#5ebm%_5H(n zqg8i++kCZDJ+i-eG&59T-tt6c`91mV|E2G>s;s>)!t{AjV~TNo;94XqQ-2oS4#JjoAl}>98q(tr*yoZ5j{U;60Uay6vpvh0H| zX2~a(;`w0#Ruc=8IvAvD`Vp2V_^vGSWXSIe{PyOm5zH`V**0l74!8rd(TqVRaZ2)$ z4{)YrSGJjA>yTykQXkN_vlD$m+ABcz#NtJDaq9^;)N>E?Q~7xZ{W9McBLMnmmrk|h z)zq|xGTGa-rnoTX)saq1%%LI(*3?Eu#euV2XQYe{Mt|gtPG5WJbJ4f|yz~d+pMrLH zbBiCy*mH{?Py7Ap+UBO*2ienBrpNg2^>j?1L;Uef?y-F)jUsFgfC-bU0d5*v)1<3(7L8) zRohB-1y(d>vF)MiZK3VG|899NeSJTR2h)J<7WfwLdH&w_{k`{oR+%oJ3)Y}_LnA_3 z=XfOR;S5;kdPM6{jU4Ndt>f3N;}?#+ewgdz)r-u2pbKS3BZ9a`oBhsFc-$+u6Y@TJ z_6Lfu;2>CTW?)vX{=l$+(Ce@OuP4crA7z*bI-m6)#pdYrW( zpsBa9xM1&h4^W-G;XYzM`2qBs*Ou%syqj9Y3?+Q1Fj@VDn-@@`tO1oEJR2*!7d9N5 zT5C&`jO}yowbD(>N0InFY6j{sdZR1A`8q#kcu-$JBO04^?_fS=BZO^HN&&0hUxoZ~ zapoYr-3uM%+e>IyYruFmkwNAxtywf9y@lG>41Dz9A#sNVoO(@R+di0x6Sq*9G#Z}A6$1jcqC=dfm%8venx zDHz9{Cg$Lg-TOTBckj0P^!qP9KjuJ_kro(2H?VKCPM^465r)4&= zs!34u5KV_5+CZbm40O2reoSW~mvXl!0zwlpt9D;M>8&4M$9{SO(JYr*0be})cR|JT z+5nDC%^m|&*kU4D#D+0RE#cvq&Yu+Q@S-!n5wgyXe7Su6`o&vR)YPDFu`zWp&B9!1 zG{7xiUnGS&#i_z8RaCagR^KMAtd{ViF#bG7=jBA5QcDOFR;xoVPMP0BRR2INR3C{^ z_{ZcsO}NSr%BcLq^QtY!=u~dT@lpCm>QH{QN9-T9Q1n_TKXRk@kKlpNBzMJ)*c5n6 zfU{8NX$tLo#nxd_{70gw{zkLaNOs*mhHx}*FL@?{y0C7^-0$*8|nzoep8F#IrzSn4IP%+2&?$^MsnjBr{s9)vj7o{9 zR2ro`R9Xr(QB#Yg5La^|R(YbOF)N9w!2?;37pny5g5^=IABu?9r1I7%je1Ft6i2{R zZBVjN6or?gwN!1;dOB1+JL{+((d_By9^s5l)YlDX?W>N28dZt@p~8LZ&F)e!u1DBZ zSE9kxK*PqQNHlQ9g)%hg)I^DOV;E$Cn2#6)Z=;Tq;M^nIRYnCVU#kv@woIgVVwvJ> zhG^$$)SJbg$dA$m69psa=WndcTE$RX9$lUse#QzJil5Ygq^UfXXr^(tsth%vF}40A z=veO-U(d=cWwP(4vV)|^(x!{gWmP`8x_#bW3bXUfg0O$J*yR>>iC@R7Ch%#>CFNh; z$Tzx>sCv&dLlFE)d3{Q9=7tp>a7rt=*I{Y%TdL#~T};?-bI)$?%yTbypE;3v=qWo} z;|fc>y1tX6QSMNC|AmP&A561usls6WQgF?`rZe@;mu7tylCM}xLys_KW5*Wj#Q-5X z?ulkTQ0_u<dvbwvD&S(OXi|!!-9l{d5DL^GdB(6n}tYMm7)n320AYe9rjtQ?{ zQL!9bn;fM`ZnO=4ZE0OE(f+(#_^UETD3xNpJ<`aasnJKiko0Gox3@dF)6`O5scn3J ziII-6kNN9!u6W6~`B0MY^DouxZKel36pn;qSj?y{*Bi2ittXM}Bs^-g8YVh^G38oJ=5~|Nc=f+-w#2hrtheAr zI8;e;v!xc~1SVX~sV?uO#HUdb{GvC|`tKx22YwuE&pkfL3J{#GSK{k0mQ$TJ|0Xhm zlZKTWnAa9DpumlJ%64xT$ka1j1%AjA(6?^owESd}?4`Ey&gQyeM%ypBG)JKEn<8v2 z`G6*E$~H3>p}dJ}Ldm7HRCN;wDg~ak*x8vg{4dQ6o_40-{!q5Coy?&r8-7IFk`g+7 zYg@kH%e54gx*vW`GFo~V1LbJmF}L!Ly!Y~`Od1K9OKhs`k{<1*59CCoLZolu5vN|l z+N&m^jQu^ubwd4JOMP0TbI$!I%Evm~b#8fsKOEDNfw0H2G!;UmSb!&nd~OApK-`?u zg0yG{MB6=3bf4&%&uZ3v(fZi$rylHY4fIEP+*};{)0?Lgrw|%iYIve?)a+2=pOPo3 zr+fiEoh2fQ4**c{$Ry~wHo6WCuEtb!12QQ_kW&tf>SrSh2dW$38pYBL`6X};HBIrg zJzSF;)*M_B(wj-Jk3gW)$6wE;@4_$xnePlyZ>MBz5Tk2|hh@&&f8Lg9pgEyaX6lXbuJ89evoitINwKiw=PASdW2%|!7(M1|E z6Qf8@kE6gEN{kVuoEi5RB93rij(FETQvEfmPspR6sK6AFM?tc2fHdjS!5WCcZs!5d zKY}S|2B!p5HI|xGc)M%;Eq+B;&x`-0*f;dG8kb`K1= zhct|Q((E2_-b-@e3KCw?2g2x`Rl_L%i?MeK?=0-LJ!9KW#dgKEZQHhO+qP{d|JX*w zthi#UvwL@6obNoRdta_~`#x*FbB#I2_`NL1#&JyqhY{4_{|fKLljP&I&M>MDwM6d&U4KOa2@q8ByEi>g45C(#IW+M_ z8q&Qz;Tpq;N|^XC{~(-TE^vi4%QAYkMGK9Jp;!!*KK~R{$nnbuY^s`?Eh~ zo}QT$jyfwe$fGz34fFwDXx{Aa;p^$m{6l&Gen}ST7jp}}r~3bhftU)^XZ`aN9Jc$@ zvGe{9x^-cDCsSEd6HCMYve5o-lHdQ62u2Rfrin4wB2d{HP?`~vZd)rwlZvCXSSAaS zgce=VVN=#%+m!v!PD|lCUSB)@XGf&b?=G0X>T#Bo6fG#n2r=BV)A`yt|Gg>s_2l^4 zA0z`HPt7-24pXKA=Ab&FsiSJ#lDO`oZ zZr_b!v4iB{AN6=e#INdK%VS~c}A@W=qw8i_*6>d))rL)fI znUy0SdVPr_36dmF3m&G2B*Xd(&)wF`N6WCf5@YW^!*^-1%1Pmlv3bYsCOZGHeWl;V zT&ADE?zXyFS!B_heR(NMbau{bH~8sDK7D8MV`*3$NpguSF6Ok^CsoI+|1e@&Q7~um zmniA5>&Tv54YT_VJ>k~0x;1y5_s%58jy3gKVgPEP-tcq7{c|>wVTK2>9V`~E?mVW@ zR_aBKpg?jf^(wx-c9YT3Th3K=6TRFn)G<(`CNMmkkXbmH=xCNi2QVwn$E z{y+I8c1uU-yG}NWi9Pli@l9f)s(=UUfY#Y(bYvPIO39Gc|DM~bCq8I zt~v1L;##l9fvcfnWJMbcy@teDy;T?@NkLmTs-yI%AwrN3tS^kp2&3?rbf}6{U3bVW zC$7g~YixCY@PfyhWrN44ZnIB)?HjtM3U<=QyUQi2GIKl?fC}0`#3_nklF4nT$0pZr z-!f0qxc5n)`~}m)p9;zU{n^OseXUR%e`OWc$o`Um^|t0Yl~C zn71GjK`KS6S(}eypv}U@G|f=s=c=-`!>SXHIg@IL4%3!deJa`Tt54ACm8#9+EYVRX zei=NSyj(aTrZla!N{!0FIaMK{X%-S8Sfg6f+9*>QClPemuh6E{rC0a8)y3bIAfdxU z8f*Adb8*uMu6#p+{$#6EkY8rgKOsBC6qhXQIE~lS z$Y0i?DAxy;ae1x@*^*5JVt^cA9o%JJ*3 zu8F@OwQp8$Sc9Shbz-+fg-o~2io&L-7RCH~KdjxwMtHJ&NTI2tUmvi`_%3Gt!5H7@ zy4@ZW0k^s?kPXoUVO#6F3KCb_k>;9OPZ7s+P$#1lZH`tS;DrzL;%{#A-$C=j^Nz7Q zsVo_#;^rcJI?WuiO*J{eNuQ)#mUu*0(Wew;Cy^HsCO9PT9DibxMxZo@6NfTl80Ahs zP4LTmz{j29jt;`PhFaV`8Ksle0GLeO;lL}7rzK}ms>kvv7wf?9d6 zN-A_u=Zys5%DquUPK&(+T{5K#c>7{m=5SO`69COg`D)4)EKqwG~xtU<%=F|l!s zy?`kP3%R9Bw~+sYc9_w;`e(x_ryX=7v|RR;!wI zt(Go`nzXI;g`zd$rd2I(&&9&fs$SbuZ|0xvKPL4O+Htx5JndM);FHArj zqB4P9%BK(j{-UPA1H%wZLf#cC9DGP;1iBn8H;G?4z z2boafj%PWrr5Z}G>HxQLKshQg$&ESwW#c#8In?`1G3>E|@yCg0C~EUf9Kn@yDf_ZK za-&i?Wc#Js+hb*K!hL#j}BqWIbpOuak}8KyGp+G=@A%(y(K2-&gf2Oyz~2~H(5J{_aX`D zHyH@2k(xf`0j{SRqQ1X^&=V%9b1`s{F;I^0(F@8?vTv>_&Cd80%e)i9KIH-HCpS8G zSUci@>sN?nKgJz(EB8Sx?UWv(@3gngj5pxj@ofryZF>C@1$uq>*hjtp$*dEODDhGN zw|2N@;sZr!HZ_X(1Fa4-@xVuv^uQ9dga=zzNZv(7s5T5)ENff+i||~wdYrALmA#o} ze{Nx6FXqr@du#K&{KgyjrKL_<0{)i%E5;HA0)Q<4t7-Kxz6vT?R!7}g*}a(?++Rsp zS-E+tbz<97%vpR=Msf(}c~X|Vj7g;}r~!Wb-`^GMEZy74$Qg6DRyX!;Hr5iQ{GE=n z($Y?EW$UrBr`0%CyC946ONUNe6jJkHCg_m$i%X4v8_O&6vd(q@7Ec>XH}=}!m}QZv zxsGp#8HFi{R6Iue z#v<+xRrrpg;Nai*Qa94X)Z`@_MNBK4sw+cK5XFgu7A330ioVqr35L+_J|UHEp+Uh` zlugw`ECOJY4~>5V>=`S-iMOedl|c2fG!pcvesc(H7P^5!EHLcgMZ$G0&%4D!Ps_;% z7+R^514GNJ$r{!2g`9t^+CDZiXK46<6;h8yIZEg;<6YrDc(i-HMJ`P~cxY9urUnq_ zKLp@L;$m%-kM&^JhVF8QU-S@#fc9Xc5BNt`Gi1lgBjKjt zY|V`zc}k`Y7!>H)#d^3B%18(IUSYIITb=YK#eu=9k$=`mH8CiG(M4fnS2WK@om~XA{$R@_xFAp#I0u^N9X2EX0M;obb30P#7V<<0GSe6bX5-j{Z zjxao3UUT=@(YdJYiFMp4V_bS(n1^i2>={AUmQp&(Lu@tLJNjEnD{JIsXr;#lyWBuM zq|LC~T!DgmzZiv&e4m|^hj^cz%tr@cPlVUKeYoa>cF$o4A&mA;+4pSusTdX9Li@w1 z&|yRGP7GLsDL2pq&6++rEz+-Fr;R!j67W~Ye;3*K|4MJWaF2yCGy( z?S}gWOvpB^WmnWoM&uX+@fvqycs5a*>P7b>59IkU8D?1LVe>7j>r6-7gB%kWV*+&q7iGDe(|7&`3>K{yBNWaRB=|^f% z|LCs5mK7WXNlPzp@aSK}c$(qev^|;!k5({!`?zCQW~?iYR`r@CabF08c|32Wk&6XYK> z>sU>-7k<)@@*u(kakSEAFPuYGFrN#`zH`-1;?ouq=t8LM2I(RJHjI z;;5V4oXN;=0@3joIp{w2It8?JpvWyMG^Kj1sOkKi7b>R!Cnh!h5Mui$B z5vaqFDZ9#;b!x+s2PTsNssCVRNgbEemQndtTe@;;bkQ86I8tqf%mZ=A6N40maaa_Z zJm$ukP0W&T49iJ0YV&c4XB>&p8#R^{^AOKURYXgxjpz%hjiBw50Ai^=VbhIh{({^E zJ49(z2frP=Kp2>kNc7yPiv)k87+McX0?4CHAS{T1XuM6dq}P5Y5~mHhlP=UmU^EIL z(}-3Rt6}#!gb{BH+eo%FFL0ACOt76Q4O=bDkkJ3@LT?nSFiZV`u8@%Q>VTTdmdy$F`46*i|#B9*)`xCH@?5k z(wPzqs;-cwo|td&_8-`Oq6mZaC=E2>v#R8Sqkl7LTS8u_J_=|QRD__UO|d7Il1M}? zADOeDfT>%%;)2>RqSbzs0HYFe+?pm@m#79ZGWl;d?5vFzMkb771*P-5q;3Rp)J^PS z=H}*ZA8pwsN~7>~$?~#dD9KdV%sJhpby+I0OVzz!a6~yBAFEB!~)Y2GwI9{BA-XuCp8X(51eWHDtc1~-TYUFoZ zHA`nab3$=3`G-E%GpNP<6U5W_BbKyz*h+G!nVO`0IG=*oYR-u~^}$HwiaHYdbgMBH zy@z6QkaObt#494N<3;pbVKE)1(<)Ee_Q)H|`1?r$*dDl!`y=I9;KjVK*np1OXHk(- z>Y-5CBn23V2`2mBH=~1`v7ii-Ee>tCRY_mSZ3KSG8H(ns2Mjc%Lcon%Qr&k)GCWGU z+fogMz$@houT|RkB@x0_PZ^L6qQzrHNnvWN@u()%x3|K1ed?#DHaY~OL>}gI6Quw! zTEao)h+C=_TMyON60aj9BCX4@>e-n!hf(x=@az(&GKmrBuzKGKgevoZ$%7P4;}mx+ z-n8)pp2qmNwzG9T2H{|id`;Y$#ub7E>9Exg#1XZBD6Za^SBx{#Po$FMrh9oNmrEbW zaSzeeO{fz!z|_v~EdlkSuuPk#R9#Iv`sk3tGhYqoWgAA2SAA72V)#>eDIC~gu}ajO z18#0kN4S34UBtmnO4nNVkzsfkizdlSPGiM*nAIcDeVS3PnWvc}9+RGF4b}G$Y-&g_9w`+i_4^6}Z?!bQ}3;JeOd}>-m;WT-LLwGD3P+&)!_Du0@p{dx4i>ljYz6h4HSw@IV{ zmU+N4Vd~8vK~K6VRyckAKFLj#(@gaoX4v7+seBBiZTG^6QM4c;>CBnUcPlsVAzrjz zd|46u7z+9Lb$AWsQrZsw>R{^r>~f14N-_xzb4KqToE=?Y^wlPR|5E7$i|+~{XWnCU z|2DYiXeOpS+S*5Id=u@D8SJ2j!{(eg(_)uX6?zPJ4H+hEmQ0Soedourlpf+DATw;` z3tWZr_Sl^Zw_DnR04GB7u|Er?lxhh@mpDuYCHoC71vUH9;@ZH!3->$gSe#x2#+Jv6 z8jZ1?^nw23kS^7`Xlm;x~>%s@%2u@Ur@qR z5tbbh?hZL6K6wH&pakll{nL%E$dh&_X%a#oso`Dx`yboBUAx*DuW$AkI?2m9AHpmI zqIcKqui3ymNg_j!4?{_vs)(s!VDO!Aev+JzTe~N;7m|-3_vbw%kb2BZ7j?P#FIv1- z7qsf6Ma#e|lf(_SPv_rK3VD4m(H#eYCh{oiiCeaVd#k6v04!=0EYMh;wxtw%_tpDS zpvplfUrQ7_wF5Ner<{I0{1R|2bEqIe_f^daX(%+JgA=UTAp1Od|}dk zBAoAI;8*(|(Gb`~O+gN0j?YO4yM5%1FpVnb}4}oWBlUh7E}Q z0>NW3w}ZQZf-0wjc6kT#@V z9uoeoY&ahjP6ScV?jgIZJsn!`B#6bl>IN2>&J6U<>P!#>Aab}Nfe>X%*sRdR10{nn zj;L)6H^>PfQCO7Ay~V#b+T#I3rNkf%Qwk7fRGgQ`Ud&348#v~@X8!I?K&RB3pG8^6NAW^^$)@0(~gJ{0MKiaIFs^E{gGpb;0~QIgoAa{jh&0sLXQQ08bR|6{;pF%|dzu}gvY^~N ztFKve&wM4$ z44--bge3#&*-Bj1@+Sidg=Z=Nv z*2M9iQ4K4BccO=J5=83Xm1yK(=xGT@j}sJa>>#;4Otd~X6uzefe2j`XXo@GvH*uQ? zKoRF@ghEj04kT73K@&z5T{u>NpHTp%L%Ua-Kb3m34VBXXr{@4&6~Z0aa$6Tl1?>v-=dgeu2T2l_$5@0%@ec{T1-wlYp;jjt1 zP8#AD*ZiBl7pkx5<{8X9-aQZLAK>?bYZHbjC=9Hv5LU~9@xeg=(SQcR0Ug8v4&jJn zGXw**?}#)?9kGWOalpJD7ux{3X-Ls!i0Ng>ZWqSO0p#t7G&@3>6P`ZA_cPNRz1T5bV?-YDvfro=TYHdsA(tV>mmzcSLML~KV{tA@Ed$ zfXRcv_OtZH$_uvJE6e8P(7+a~_J{8)HP+w4J#@ z^&pU%x7CK=56vI+@X_Oe;SbjjP~M8X21qYw3242uc^=dkq#V(Q>kru*5PzhVC;`dh z)C)lONRg}w4T>M}$U)5O zQyHr3)m|pZrOo62u8~s)ry&3*la@H>v}@;6x|qT8{2*)3)0yr_e5k>51c9Z`6q5}? zxkvA5N!D6LM_FauNau9hy;3+8M{mKM3Us`lbpc0Rh8%-Zu>If=gD9DEhU9lLzEnV( z>VvT*AY}m z&9lzbJoiNw4Gq$#J>eJ%KB_vjd}5Ary`~KZkWYq@NR6^~IY9C)8eCE{;uqxq>W1jb zz?ww=iOC;90|MgzA87r`u0IvZ*xJzC^uJ>a|3m4&Qa}5zbo}q$d9$oDl|q}aQYZ}C zB~u_8ZS4XTEzoTXDP%#zB$=U<34jU2ApF*|ul^Sl?-*K@czpg(=jX9IMQYoeP@>B3 z>9phR{%`BK`(o?)ZcLy58)6TsFa4HO2t{t{WL3{P)Uq+^x;B1vnCA@GwI`Q7!7>&Tr=t`tLl9$*s}+}y zF3yXpsXjlis?kDKaR;%2(9`SlHpjvVqpay^nkixWM@}5ZTPyBCt|hLlxSh3No6PS$ z4RKN>Nv1Ri@ZjUhB;%xp!6Wmt?Kx6rsN0T;EP2zn!}Jx+vmLQ5M-l6YXK=ts3i*Y@rbg1Kz)VEIUr&x>k7PP2-zT?&Aa=}$qwpQf5lX-O zS7NTtAm)n_Kpm!Ul>K8SAjl7n5l_>R-S||q&wZlIr+%+eqp8pyJ#=7RQ+(H89glso zEPk54vb?AB_~_LV|HP)Q>?X;uq>LbIDW&t@dE0(jXxne91sDM^{tZRdidB*z_HY50 zh4I{#m1b$z>hEhVH~5p$&#tFC693S0VR$FeS47#r&2!$a!>n|3)>dI-G>_+5n}*(W zx26dpdSCe_zC?)>oHUma+2@r~VIe5cYx`?a#N$uQjJ_y+rdT?x2)@Rz4fLisE7Hw+ z6jCb+67DJsfcZ<``Ob29H15Kg#bigi%XKqmIYzorK4hs9I;p`4ADHDhsn`I05P&7g z#=i+Ak^W+mdN#u_u|(4_T~+i1U)y7{J0imZHH8B;)^#bb`wH+eYA;n7qRN=6gkFbVSgQ!=u#d^`QS!j}Zk*AY$i(twiv~Z1eU2JGK{Hf!17S9AbQN>jp$filL7l{v;_Jjg3kmTI6o(uD(5wgc9t zL&znsRN7-A{^#ik5HJ3ak&PTbK{+oHT6;S5InvcLbkuvFn8MaOgrMU$F8B!V z6KvEwEp(LkCMo3)^iLDGY3yX5;IU%cM13Gym(a2lmuLnJ`y+({+46`dWjJ)~V*0V$}$C#9RqBG0@+^ozsC-oInVEni3-dqGkakKjsQ>3gltY ztx@SOpyL}hy~0PBok8v4cp_r8 zE~ZY#rVc-FzW=y!YSpZND1BIdeCf!eJuzr@qDTNtT@8UQSZtp^p`s?C z+qTf|Cc_P+`*k7ShDRn3L=4HEf&kyJ+3YaOj(fN@RL zSbwz`l({qp6xBPduW1*U+h(gtEo*qk=Ih%_h7!DJp5UVTf6d_pZN-Y*fd!~KSF@@= z>Uuhca;wE+ak@*=&p0NtW_D@QPRkKMjWnGlK2=rSBkX|Z7Xc~%E7`y(7~%Uj1|5~ zf~PRtSxjdfVYEWcS#x{b(Rc>Bf&_hL7`^`%DamH1@HK|Ru-(85KbTmd+Z<>^?^3-G z#DfJBqFGQdqAi&XUCBf*o`zP+cFG!Zk^QH zSGyVCNQQfp*2;}ZIX~I*bWrPQ0nSycZepFC_=P5N#>KlAN@}AD`8m3Q5P#J%d)2npNE<`soVIz7fbV<}}EKySzU=v zex#iOaN>S}9bxq^cFM#4B5%TLFviaKJfJ6JQ%ac+_{ixU+1}|TYn7g_5D7!(*65uH z^^nDOXLK=crYi}1QXFIF(nt7kuwRu!9MMX9&naW$jL&; zN_G+i1%x8N3{Z^hBZM0G$}=fopmDvRBgaBdK@zj?V2ive!GsRGJ6@U;L*?W-PH&aZ zA^3uUIwMY8PxC|*{tb}XxQdE6^z>0#bN!0jneHjy2Tl?Q0v;QuZA$qcv)0!m@ehYlkS@`ZaW+k?bBFDc*=#pRZL{nwvsciZW_|6| zc!?5j`H#yzpSK=;%sWr=yg9wUs`Wt~Shml`)IN9!!C%y0KZN+c$@Bfw=lsV{_>b@P z?_NuNzBc2(2fuM5-fw9>w8rd9K5FB3Upw!g7hm%NbGc@*PZw_e{bEKu@iE~pSD_)E zu-2zYBH{2-nCIdbN?sL-^BqgzhY&;F&^=3rXz=yUZluE1De?uo2$d%oDfOlLeZsI! zaDMBIBSXagt{5l~3XX!qF`c&vj)JF7oMi$y*2n>;WsSZnN*{)HNmU?1yS6HzhESuQ z;}nv^uu4`;2+1O!YZca^R>@RU3Z=rT66H&M?VW&lWaXDBrz)_7Ej<2q#`2S3KXo}| z{JkK1muWgb1Cf_x*zB71Atc#EaCd z7dbEzv>$NM{fbfEmeUq)7*cv{jWozET@nI>ltzl26giAXk*T8DQ3qF! zRfX5xcSsn!o&NYs3It%K$tuQIz2)u-VydogmMU`c=B&coC_`m&t?7 zkuTJ3(4sWpb@8=pHHt0Ndw4hS;3!(JetV%@5w)Gxv?QWUnH@u@KH}r+LT^6wd@{_`%1dyX5go*K^kujy))4Wq^8Ku1XyKLVVQBK zcDpS8Q_g3E!N{DE4?s=s!8Avg)dgEz6RYx{ z^v7R>?pH~3n2&_N&Qo7w761Ge4knk0c{1qPo-J-^s(kE;-gs4Kkn~uN)1(!+3z_KS zJJn8pjuq&)6W1X)wvKaqs<9%oApklS*rT`peF!gl5NS}737+YesjQv?Khu`1TW8p# z?e^aN^Bc zjMk3+&TXq5diCE=6(2883gyDq_=~)Qwv`)EqsOf1v9ea6mNHZAk^RO_Pblu3#UP#C zw5>sM?dL5jm}{NAZl13G@wQHu*=zD-*ff93SS``MS{LdxnoS9@lOY=yT{J@(i@!tJ zQZ+^~hik$tNC7z7>&@#{@NS`|;j-uarim7wu_J5!5tB+kObrU{+7rs%Zvx#eVjSyg z7&4;KYL&d?CsDnDC7ftC2cZju{MtWe?joM$ugU795 zG@Zl)@_(hKydV-yz8b1a$BZG?Elyr#reFCn-Sk-@kH9?rew7QX0!Jgt+=HZPXUHc{o7TH55C45;jjZx~Fj zCv(n}>kDPHHRJJiaMgH254I+&v&Y#|Ot`NYlnw2igV_@6mdycJlgk~-3SA`}6c(d7 z)`hy0fF6h6VUs#o~Flt^k*Qp$~2 z;~lA5(6DAN2dTRnDYs7suvx89nJltx*ePXrP{cY#x{`}l43$(oSZ~tRxi8{Nc2^bB zs4(hIjuFYDT#U#>DFaIAHw+i$&e0TJri^u{bcsv6xKOP&>=mK zNtgTQOj*{n*h*S;^p!YE@fVFgclDs9>s7K6(1oss66`%R{iZDSyY%uU@_=$mSxsGQ zrF4xy7gmpO>Gbuso1~t-?F_}LamM|)iAT>&CGex0$PL@3yzHL+(`6pJqUC2KJbf3| zlN@pu^tl<|a%eSj%aioe##a`uTGv_o>*g%w56rjUf^u`!NH*=eg0(R{G`|l_9B_wtlt6i!kaX#zXfh*uw-2#)6F)v@I{gK zLKH?@^U=FIXp;VEqvqUKBRkpp9Cd)Ho8*=2T%+Q|JYjlf%nb+C;jdWjin7k(5gzi@ zd1qbw(3z#@hoG)M71i@JWoWsx?7jJ6Q}^DaLH6|Cq(b`i&QF1QF~r;jEJT0Y3HUL5 zFx=|E6P{eVz$JfAg#FaUEKaOIs~918kctto=@GPPVer3)Udy)?;2rtm?HfI};vPT> zDYc-5B6mEZk(XITB3|)DB4+hPB3AiDB6hlp#GQqdiJXM_1{*G`+hbjfc(ptc;T?GS z*A+@%rIjYRsLBM?lUWn2n!}X-*q&odmlaw^hjB~+rBamHiThBdEM6g-9JR;wHOj{| zhsUlhTcT>_vx@Ri+jmTzIUd$cFnYz@{8C+=+c_Y?;iK1k48IS)!ChL7qGogA{fC_`k-0p%+JEorO0@lC0~I7JGy(cPQFeLBDN6mLP|ojQZ- zkFbEW7g?kz-Jhm{=tw$cX7NsFd4m_!|)0qA>$L_FF>afCEbDrL+_PMQ-(WhNxQVYZ##~eezHz;HHiu=5LzKp)s z4Pw|?nZxW)IE*&N*Z&|E_9tNI(AY|E@et7T*_zbZld2kIl_uFMPsEZ12i5xcmojoa z+xC*KlXxa+a>x)QLt23c_J>rAEi+NJ)5nCNiVXY8R?QDQ*Zjfp$L-kRu!r;dBi$SDRM9DQx zWglo}f~~kuX1AAaa1npya8}EN6&i>wXaVog=pLjv-xo`#2W6HZBZ#iroiKr zy0Q23Vt7cSfDQdy{6o2wYSQz?9VGegWtdJ4V?X~Ok;bO;XtV{F%!QqNiD0^< zx1!kBqTq8~=Gg!je}JAVBAAD~HpE+5sv|x1CZHG$-}8E3AUEP0hR~#K?|VFEIR#*3 zfAw-J)}Ff}x6?$XX}n)vVom$edX~j*O$zI;+f`=15>tZ%t1l+8_K6UGk|6n5%p0TR1-5jixV&hrAr@~8${VQWg~ENB%pnl26Y_i$_lonSb8K0DlSRki%6a$o zLRw}=d+;td0+aXx2SXD@{mv*$ty5EfI`k04lyAO-rdsK>0N0(q;`sTdawyZiKoVON z&w`bG-aYv5-b}V*!S2D7b;pGLTr;-$QjDbf)~uU}zuK{F`?MYR#Gw{()G3}0D%_R#o&;il`*ss09!Q*14@ zy4Eh`UXI@jkF{JudndfpH)Cw%gKycfu>cXaQ)4-NM2Gflh)!o~BfL~+`PmQ~bLzbz zC_2^G;&iC0Wqk#&RG{3m-yfg6cee2WZgc^+BW%ay#5-Em0i*d8wihBU| z#y6#95_LL)1$KhANp98X83;RbXKg^G8_) zP0qm8uwbPkWwv!I`(EqoTL{u97Yh~C%dCzEcR_!kqd0wzs)P>$%C;CY-5%^I#f>8T zMZAv36V%62##$PW40oKt8=j450D3oWDGnruErXf$yF&TZn9>zN%{)SZB6q~h##n=F zHzM+t-{m}CAm~Q0hk!Q}gB9Xo#}ky^62ZvDhOvjXH{P{{{GRwm@=K;0RR1!CW}h;Z03Xz>(EsBC4pS~ zb9J-)VaYpZBaX6twTfEBb(!25tBqCm+OtwmU;e?PT-4gLa?g(B?VDcIS~o)d^+A2^ zy)$1}y48tea~wIo|B(Ms>#h)gxDh@-2c+^C;+(NtmGd$<+zFD@)`b716(0rni?-RV zd(>N^m-rpa7|(}t4(ej#d7nQEIcE+C=-at(0s zWZJ`$r5J#r&-aW`5If~YFRWvC=)|3FNYC97OY(M{trEv z6g(qE92f|w<%fK)`hS{0{{JW?q(ZKiHYTP{!ZwD^&T@vfrvLY|vdhny^1nrtQpG_z z5GEww71wl86@d{E1_F-L5j`0m2S%x&BqWI=*hwWevTi!NZl4@T{(*Sr*}5o#81i*t z^Rny5Udxl?$205!^f-{;pm>bS6rECK%opTG0`*c<*jy_7asas*CSD%9^@l{Lgqv8$tzNdN~fM$PG!@}y(w#G|Bo zw29?xQ*u*_&r1N(=ykwE#h|J@m`d1Um$$KQ0LGBT=ZSx|h-Q3l#2ILuKj=lNG_lLH zcyeb9-q0gI_l@(gI2J1#~3h<2p`9{f1 z@z*p$l=?tlexLt1xv@0xpKl%r2wn{ch~WQpazBdJe;>gW52S~R>gtJ3QqROxa7ZBn zy?e?yj ztKQBPS32)m-{gr08IbSi&-ZVd-RHl3@Bet8bDZV-+57Hp3(bKH5?``l5D%5W(<^^D zSkhk(9e;3$hAwmvV^%wu5~v+g!>%6fTh+AgW%1MuwZi0C4ZiW%42<&Vgv(;^%miJ~ zt=kM@z}hwJiNV@U24i<*64t`lO$1Bdy3hcfQ~$Ur(2=@3R%#2BL#aAs2d_LEFm-tv z#6{V?I*yN55&T|MG9vv_6JRT_hI6U^0k&cODHh_*?T>Y;5$}WOT?@hL4fp38fzY?@ zmD71df-|)4nZoGR0Z@8^2;Z?*Q(^qXLQS`t;p&xctkBhNreJ!+2IuaQ)|lPaDivba z?v3-KJUu{#`xE(n;@<6)Zp_fnZ!!F~s`hNDYlb#o9m9j%s~Yl%>P{HkD;om!*>0w` zscrtI&veKSdaH2c0_V&!?~J;3t!G3GS}gC}SoQ83*% z)gK;uBP1^%{CX`yb-( zcB8vDhwao~2>L2F&(vSQKkSwK8(x~D%!3DY@b5Cf)r-3y62-US;InE6;&7F z6(afvlwr!$Qm8@g^GnyIpZZCV?UR?hdis8~$oM_vW)I&STQTpRIAz6d+4b_(V8D`T zz55&J?_ceI{v5A@3g!nYU_E>Oq;f58>puMrm^=Gdr6Z@@f-q#=!42o$z4WWV8pW*D z+v_qnY|b{FkY_M}9jn3p^#LK>u-@t((#OlYK&`J1C!j@KXjb#wg&TA#vZ&}F7D{s^ z4?&2gf9H%1Cz#hZtX|aK89Qm&ZM#+Rne&x*D--?H4TVejAkE&L6W)D5@5*TrMA=8s zJ=Z(cJbm+cfm@ARH>^K!Rpap1M%<&A((atPSQ)Vkq%~~w<_tK#-mHB=k8V&EA?_0A z#fts3xi@^E^YV(oy}WsfAXAfWx7du+7Z-CH7SZkP()C}!{sj|Pj@N*Oy@zjD{!em` zTzoe(C#QAg_EsZrSkid`|K1ri!^j8jT51HRkmO$#lLB=gFE8n+SoV$k@cQ-#usHV$EvlPsPt@8aZnVanSdXJ&86zC zj+{N57@+B3KjJU+EJE?v1@!!;m$7()h-q$m;Y+cI%|rrmni2I-Jf(teR4CGcCQ2ME zG1R?X^Mu*|McF&XcNQ*Pq8;1($F^lXPrb9ou#~H}5^~J-<0;=G>Y2 zw7>4(u6mwbRcqB+z7NfggYyI}3|J!`Fu0+coyE$l?jj(<6xhJA797=LVcum6$Bxe; z*V-`{GJVyVB=@U8q8w)F$f>C2#&PO*QCg=!Itz4&*B+HyaV$kv0SuPwvTs^^F+S$CQZf|f=xVqEMu=-dy zMG4xec4Q-xs7qL0@~HJ5D@eAt#v@WINDp368<>VOy{;saQHJUV%vETb-(R-+_SMME z`)`7^%8xCId2hg~gN9mTCw*Vc`95J~R$ zhh!o{4A<%ci*+l#Ef=Bj3I8bG8A+*`r8?jo>tF0REmDz?i#RfYZkq+|os)_0DVx$z zM}u`?Z*#}y71?_!ZyrZA{3A+SCWe?;q|LJd_uR|pECXnGQw*WQ(JDbHQ-wc5n41nc zpk{j|it2}2Z6v{@m%Und5&DBCT08kStt>BZ%aS2rZVIT|mpj8QG9f6B0vI(g3UU4l zTn#*@Hm-e8xwL+{aBpzZ!&c~6(WI4xKk&#vTbTrnpAqVzcs zEDN;t7^f#08o*em~c|Fk0$ z!2RwQsMW$sIa$X;ZYz8@16wdvw!D=ls(rHOM>+h!1XwQ#R+ebqM-*l%@(Isi4YBNG z*fd%gT8!D*a##*x4C42ESV~Hepzertq0T*nsN#+IT1R2p0R8poN}zYc=EaR`BQ|8m z^u)&mQOyXFS>ZR%4nOBs%u@wZ3F4IKsy9vJdk7-MR(9D~d}uNxC#7&ZC1pl1gDnAc zVrDbn3A{p_a#PklSJRD^rc`qV>+8hcP4pl)l9%rE3nXQc&~*JC0(|768DKN3A|N!a z#sCqE2VOp54U+{+l`pR+oHiUhz8`~iRURRc)Csk~qMyhKEwKzrHm1NJE1}}%8uE;f z_@w5>#yl{)F2Y9^6_Q%?%`Bd1*wUygJ%WK=mteK{{X@(ryCXcGraYay&M1zE%+jba zy)dF8lS2+?M$}S^7gLs{1BU+dz$?NUjDol(HzV);K3APES}_mIyJ~YLt$Y3~wJ@w2h!*^M?m6knHi; z)a%1t_e{Y#i>LmmA+*8t+lFme_n!;0zjXPku^9K)iz62Xy}n%pS)tx}Ol)J1TM1|| zB}rqB?F2Mf`jd*t*rH@JS822|qG&TYa!8M19ZShtGkwhoX#kFd(LmW#6laj+@zr)i z1nZb0-oOzu6H<_(8EFYjNXsN>r5yuwe@*I5DbF|$>X~3U(_L|kMfzt&%1)F-+Q_nv zv;$XbA%Bv2iKquUSoaf4gu6lJ5q)Gr-u#6alAG_)1v6?RdaBpu4A+~XMLf3L^KpzL zdy3LDF{PtG#Av+jkU+^pe#~swa5<#jTL9ZbUS5<&I*QNN>gUiO-tg@ps+}F=b1Wg_ z8&KP!f+LTvLTP1cFQk_#Y9V_t_i zp1xri1^5AKr*@?3N5pUOf_-$538P9MAan8x*@uz1LK4>gA|i4}w8HY+RiWYsaRhgz!S=*1 z?o+de<0oS|wSFQI)d5B@iL+k|7exV@Zgp;*t{DA*k?eHA6Oo}aV~|KtSuOmi_b>+5 zF+oSa>r;_cWZ4=^Ico9c!nxoL?OY zdf68WQfS?K1bG(4I-H%<2xbv{A^pYP83E>OoQN2Q(+kFFSFoL=X-`YLVx}?pn7uKu zw()Y%{J$wKH@~&Bl2lVby;X6LKSA3jAd5w;2$pv?Qt|X-C+rvRPC6tTB4FhjF)91U zf%sc#1k?KEScuXkjmG+KT=)XkNv~PvO1WJ!>-66?hjRfw8&rxSySTCs81+l$+Pq4q#mtm{hOerNpK#w|SVh%#G~X2E}2I?TLC``!52I{&O#3m=ehR0CI^P*AVe%|VrD~2(R^F{%JWs>C*53?X zI#yWI9B!+m+(g;TUHgFCr1s;CO^VLFa(I;ZKbm;T2KY)=`}PB=rd=@F9)X@vFeVOl zV?w}$zZKn(QD_odZ$op^;hD_2UDXpHD0)Gzwg?z*xbRPtha$rK}*`t@Y3_YgY2Lw{-FNKNKBuJW^M>QfL6^tJ& z-UF;A(3W}VGXylUyDG9bb0aB|MTe482*i6A5;-%!Y_So~(UPd%hgn`V8xy#fJf)KwP#waehjz!E3yWZi z@Y)g?*$DWv^}>zue#<;B6xCCjg%vw`_0QkBzf~XM_lxT5n-<;RWWo6l+6;0-_edgo zM?@#IwR-CAYr=h-VY8kStDh=wAH~2VNry9LFDLnR4=wC5zvMd13(X<^D6&hoN=dw8 z@d=EDMKx4>X-HWh3fkKE2MjRRxUnYp@p*2eC;78@QGXp#w&XM zRJ?{T;Az1RCqH>5`C%7`V+HiB5{OY>j4xtMAL9kx2%fb@DlhaTIO>U$!dDMjfAkb6 z#qa5xKR1)kH;OR}L2@@2Je(O^eU$Gw1`*2+ApQ->ST>zgZh|+Bvq-;Q49pF|TWTydT z_l6as>VUV{J5-NF7p~O~z1;iAvahBA^W0l;gSd#Ij~($7rT`y{P=wl=jK1J!0`buu zDPi)=4g9TU!S<0~`n=V|S#X8Kb{t5i+Xvw=7w7`QK#U$oU*aDGX6=ay_1Z2I8{8G-bS?B#Jxv5FIbO;u5w#npM~#2QHOffXGXR$flamhm8h8 zr-*B8q#UNI-6P5#g|_?vGiajrOur#AtsO6fK4I&05a*4m2VNtT8XZm`M)6A*Bz@@6 zDWlg+(XDv;i;Xx{LR{tnB&8Nbam9kBmUb(};x|6U0J*P-C z;`tFY!Q4dS^m*`W^8^y3j=}hlkTRVd+o921zD_Z25694rpN5ddL(o7$+Ug>rN|?bZ z!MC~<6K@-mCvyQCdGe3^JW>atNt7hLrC?Dh?qPM(twX$Vx6AKq__^7ADx! zW?7iGAT5+45`lfzSGP1{q_HDAm2osm*=ROLe%1$ZSK+L+ULaPdSP}oK(w3GMu0Lat zffAIZuXdwgBL!`NmyVng0*Uxw^;HNjz7}l=Ub!pN<5)snS+DO!9Q4vF?@QF~|BP+4 z*0rvn4G;Y_R&ZCofa6Kp%JXW;8*k@kLCQu8O511+;%@5_L)Q=s-$%CAlJQFm*Vx8b zsD3C>-)Q3JpEBoXKpe2PAmp@53~fVf>L2Zncbf1eGq}FBI7iY}$3|^?THGZV+qm1- zTS5zWnR;1BL2>*WpasGc6Ww#<-kd)mInxg0NZquc8^Swh!Fa72c7Jz}7Vn&_A*hkS zwBjOLBTK?1Kvr`($=1j+0)!C>%)n&JOGx-VTYZkgZTku55u79aRz+pTsc=8UJXXmb z`|Ut$xbb~ah!Jyx3Q!(Rya<@P!F6Kp2(g7%{NPoxn~wylDMGh~ zA4fmW4A3b+Y~?4YnZSVL4{?vwUby9bLHbB`v{>J3q*TC|A--=R*0q_n1N~p zqZ^sn#ki5yx}@v>P#39zM%ZC{f%`~nW)v|Ty54y{fY%?^dI9-Jba>~Z3*hhbW&rn# zI=nFtN<#4O+m96Y4+SnXC;Ete8!n9Eym5bl(1_H|>wUkG#}xl~1G&A`XUJ`Tl72~u zNEh(w#6tp;A(7LKDk^7<^k~LuV!$RtDMLrfUg-;qYL+A7*+K^7N$*DrqhjrlH+OVE zUnm=t26;l$C@Ux%ga#F%m8&_x{&Jce0p0^-Npd?T*8GHxc@me&k14X4>*FBcp7a5D zB5_767Yj7*1s;@uGQ|bNj6fL%`vNX;Hzt|p1EPg)DzpvO_Z=Eu?@keQ<^}9cm!*Xr z)(qQSz69HOK-DjP_7T;whN^)GNsulM=cl$yr=_W-%ief?0$A*rVumA0nrwcLLj@S?C=YCtni&>L@b|7vJ-8dmH<=V+Gim*7o>~QlR+Oz^Nmj0=#I&}o2(G? z0b}t2o{1?`xal)y;HB{%Wo4&_#rbHh8w|oUETyl+-jW9#7PD5lrJx!Qbh^S!E`~jLFs3qHm#eb#pIB2T&+ILE|3C{)iH#e=CQqoe93tDZQ zv`{%*p8ILdL>$fqM0(>l3O^PJN|{Y19(29@;$=<{45$DLnkMT~qbbvb#+^a1rv^M4 zXnk!~y%EaMaIFcnY@J0W(Nk7wHVvoKX|!ysoQ*?a$y0`CX^Bv+vr!B6z?UI{P=EnW zj-SnR)w~^GRO*ENI42|uU5m|r?cJ%Sk8y~bo)Mb_gr3ia?PVBz_(9$fhw4;}V40k# zMn_5NIMReis8NS;Wj%sZnPic>U!}XiIue;BP9;QLM>3Mg0qY3QEn3&tp%9pSVo(e0 z651FDB#jP17a*f8SKN>Yd_V}e5!iO*)9GR^P+SN0q+^hyB1gnhQG8_PinJ<;Imyvg zr|vAD%X8NnZ?^f{P!GT2{A?f2(W3`_u)c5|vA?1)2C?@mAeL@qFhjL(X?V0- zxn_Ii*0>O6M!FN12NIWyb^-DGD7$Kq-UBtltN3`&G7uRdoPSi0dg z#o0r?ePenRXa8M>gwq%XMdeW}b21Z)-wvSvWx<%q%5n}& zuTaQR0Cs56?`DVU_*v@ z1JJ;YJSwNP1R}9pWR%M%>TMb$VWPo2qRn7=TWp$mYgK*{o#UUv+v7&zcpEXS+~vS4|Icx zU z9z+J$_^Q7@WQ&^QLku;&BYweFi9(3;poHV$YVZ-}l$WWjW#@N#k*`ymdTAb2=j{bi zvSKhKd)emaNQUGA4Xg)s>C*SsJ6@!uW}H-HOp;3CP?XTNDOK@^Bp)$hm|HxyWDMSs zCyX%Xav>pf+fMIuA*m@qIr0mEtYEH}@j8V4Y09A+Nd97~L!=Emvh*_c@Guh%d;F~o zp{-GRJ*f|rj*qjJpvLGa=4X0Lyb9r^(a+iV%>xrpwRs@^!J1uW8oP#uQn}HraJuzwB>q1paZ3=-Yh)tXN(bGcNnB zt_(h2ejebHg3F>q5|NsRYQyTV!4#|wlkrb5>_rWE^hTr&M>dymilM`1rJ{r zo)}pyxzMHEm>Ew@YRQuuCBztWqr1p{+Ho%FHFhIEux%N;)I+&p#W!PtV@D=Kk*&pRUhO*WaFdN}$$^ zI>A^mA}97NF|n1toI#8+)*hl$G8XC8ZzErSRGY|IyRZal^%ictFw2NMKzM?3GF#Ui*5Mu|8%6AvA%vjU0Xu>p{C^)?;f93|7RDLZ+?(UPng^QD8t}=$L^KCeh zwjE%y!xTdQjb{vjn@H#ma{&}Cgi*?Ixan~?%ps;4m^9t(mjof?Z$mmpBT1jELk z;uyme@EsWzOJJp8(VUd~0jgoJv6S3XQ;b)bXS|rOV}M}H=B*$@vk+k<5?W~vUov-H zL6jK`Vg3JU%tl&S^v{6yz9w6gqt#*AeMC>bqhQ>FG9;hA-} zWzRmMZ1bMw6Kae)U=8{^o?UDiMZ*4`Y z+s=ziAC1bs*)ClvJyH8oShz&Mu6lK}Uz_m0k9Ab&fnttEAL@t63o9!Mc;1L~EER2<&yx&$V5Xn~XKT(X);64VGpq3kB zYuoMZ?B~G4T{AxL`3ah6xccMf18d^kC<|ffAHJkojy3j--c&mlIVL@y4gv(R%Qf}qd&aZlznC}9O{z!I7(FRod+V+@c#Om7> zbOwy4=g~9)NfW-cTgG83&9=BC8s10w7<-)Ux~)p$ms=|ax@yErz4;?!3sjx_Y67l# zPzZc_Q?an@ihWyJv@2zkDN-3Yt;yMfpS2RRC29DP7O^QZxLR9=WTo7NsWK0I4jF6B~L`X+C|jwC0uDIm&BbR0=^yFesP zTmX`X^w)IohI7|<_jb^yIzasKL&6O-@j^v^bv4vHh~wKrV-dys0p5xnnH^EDw~|PC zQ1~P2rH3xEn9rbGp-nS@Re;T^Hjsge=-8T0KNS59y}COpSa{}4+)g)NvUnnigzxs zDIP@VhQvZRy8B(px9;;@=g}S7A|;lT_`)a2-&(z*n6Ciz4-I6YY7)>OdqR)SYTy^= zhte*~?%<?)wtYXzv8nc_D6dT@3rU@JI}{^ooPUy&Q3 zonZcX{18m=cWi4G*v04BD||SYR$_-@E`x+%qgL#}*EuOD-$tMZXC7laT76=4boVNH~zMUwR55WXG!|MSm3Nt z*|7VrN_jU*86`n1mB&kHf6gN&sko4;M24%RN|8t@tVUdUMoTzxt$B*jal!4(%S(g;7r$O;jQZxjd()F&38>wWt4xNpTU z{rMxlNi3%02aa>c46hYDe0{!E<|5rK(E(zaSqnK}ysNle1LK{`rI?=#&Q;D(EhC>h zxEzNj3{2JBESE^?x*_N2pCLMNPsB}VwyZGD+-p3|?Pv0KR}mH7&ByIRE+m?VS{5SWLeh+8yRP9SL9QM~&Qi|cF(ZeL!(J6I2J_LTvDP=x&IGu`7BPILe?xydqQz*!@U3=^g!4@bUJbesVeBo9U-Q7G^Ci+#ri{3 zm(I88^Cs9($ejLzo7_nkzjR!w9C#!Dn5?E(k4D~edgJjIJd__v@4JK{#$RP z#FF!B{Vke6PxRvl_kT*ne-=*vmXZHfGHF2gY%T)6_}^`EW~5?ff@Ac*?|lcnvC!sf zl48f09FAKFpW(j1nin}HF5L(~$weBxn5FcIL5r-m1&nPrP|BQ;CE!nT+EuqZ zWoYqsvP8;vgy)kH#>+{b&Ndn|a`?UE1fny<}iMwB9mDeEXj5cs-!J-N!syPNPrUBe?gE zRWgGp_KO*ou1Re87bLiRJP6N)f|w{Gpl^HP{DAOrM-V>sxbRyEPP&1jE{~Y__pShX z(Ak&~&)bjy`nOw?A4ENjJ-9YnLrt%F9}Q0#PQWF&6@aX90~J zuKBLzMNQFSG$((omU8~At!yoCZ?JPTx72kP-Rp#n%P9MMH*a5EsjCdF=3`QV3ue_{ zQ|(33jljz0ZB|YYkJ}ZVty5km5kX1f#)`n{DvGZ#&|FAYg(amxq@*xqCupmxGLr}s zw!lVD0sSIQQU;t#k|QHO7A2ZCgrrD4N=RlD)KZs{5?8=1B+-?T6Zx!$kYOjb%3z#b zAGhF21$Bm-o%F0-^?74Ejn{jrcevQkHiytuEEen$>1L)U?EBt@TAoQc#W%f`z>y-I zDk*`lV5*9#j!B$@Hu05t)=(OWEUPLDkfbS?EJfI)sA~R%WXa#OTZK+FjK^H9PIl#884d-Q#(ga|9uKP^f zhNkH`ZucKvL(X_vKtteXLv3;zg&NnvUsL!nZ1l}?L_0EvXV(qh*ibY6>2OdKq|9~R zv@DAcJ3bC(<*m?;d5seMUUchx&A6w-bQ_7YUFvu$woFZ?9DRZR||K211X8hB#l}XEYEr$ zwm;>#30h3HWu-8(+uT>QJC7tQFD2%u+?FjRS;W%HwRw^{3rd0^C9F63?63>$CqhTC zk11O%54ZOrlYwcjc0vbXMa5vLCB^ug*V1Zd5v3;njxU1l8B zWJ)kc!{lS$_l{F-{Rsps($b8VTw~%rCS$DTV36Bs{bnID<{~BPc6(vB{t|MGJ=a1~ zGQ{~KB{p7*6^ryYPW? z_2$XL!H5@DKjNJ>BERtM=ob+3zr=q@_Pi8qH2BExBVL&Q_OG1QnV|gKmLxe)q!j!+ zld$1FVsdXVN1bUqnZSlT4g^hEp%Ar9W!4;mgD^u~0=kWrT##Z@4IlY}{dfBGFX7&$ z2Sg1EU?kshUZl+?#`0E0l=AQC$ZwGkZ2B9~)v+mVIwNF^==6ZTXqb*zQ$3QG;RH{{ z>=tXUaCfB}6N{V;J;$_dT$4&3>y_W@^+I)4p>Lp3VGCtrut-OVIeEC!%-*w3v8941 z6f-L|5r2v*KD2=<9DY$(ZD7$uq^(d&iw-}|bGMhakt?xuC-VgG8iFo}KE|b6N){cD zgcyyBQW8H3Z6?koqA|RRV~jAg7(Qdm4jW{9%1Awq{+jX`=`uN{iR)j-yfhT%6PLAe zG#&J@Z=uo28!Ia1w_-U`W03I@3DHFPxt0Wrz?xZ`p63R30O`Ux7@kB7$>xXRFitOJfx`DMJM2!7O^7P8M5Uo?-JWw~%-Ajz5cp zRgSQ(@9fkO(F|+!x3Px{|MiJ^ZkHt{OqS&)29wiX%aGIC1<=;?IaD86ghG>>A5vumoA&Tr z+ab3=HefzBfN@P2D@{=QVy`)@ICjB8YtncCOOP-^QOH#QO4ic=J`Hz-fHL#%6nx0zK9ZK$c$*kSgx6z1cE&h zs*EU78D}JV*NC6UlJmhFO(^qhj-Mqkp^&lSb)FyB(m;R!ivayu!P3BO0H9 z>lAak^AAT0NhVq$_}y`;N-gn2jtqi3;3wdBi-~O9H3@sU8>|(FYMr6V9YGfb%DQuT z-?Kb~%onC68#{g-?z#?@y;}K5UkUk2$J#HQA>n4G{xZS{WFkn_2FB9(68N$df*~)EK<#b#fzDYy5>%5UpSeO?!kB zH>*nWkW{_2&-!zHenRm985HPecSL=6w*7SGkAXvv=u5Hp9d@9XU83hT9to%8xw=fh z=o5@P$4`hkrymo}>d$z070;bMmPZO`x9S|&zk|s}HmI`Nk2||A(s&VlymzU4Rx~N- zU@rJD6iVO*&4t7Bjd+PCt8gY|+00avUB5-}I%h()Qe(9&3-vB57DrOI*g%f@)>8EL zD;CWubD$mzim2gk*p0AT@)TYzE47*-QW1=X3>fCS@Tn1YQpB&^6>3PmPz9gT&wr@x z)*QGPY;{k;ieO|AYb0dWxd)xIX}i;|Ox0-jSz1I_kCSE0u#4P91|SJKuwN;3jyR66TY*lu^%~ggKg!^EI9l(a*+@ zn~AL+)>_Jt^LX^dEzTl^_x@R&d!J^shaE3JKKau7!yUY#-FM_FyC*K@Vqi|zMTn_R z{2*Z{XY7Y#OH5NP+4s#lYm3gEU3{U$ZRDV=`feV6#FfM#^st5mBcttwahDmVRV zSIbMz=kCcjN%I|W}`o)`fOL$KUxyX|Pt>xsed&^!H~U=~9l zGQ7Qu!7{uSfDxv&F$6ttuQ)lHjP^xd5>K4-v+{MX!Lg>KRuo% zcST` z-r6|=ZTd1gleNP$e%hAl9-7*i>={`6wfPag_T_YsM@iBfTOWmU#c7Aup=O9wPZtXo z#A~I|J6COK)y`NhLS!{abq7jAO-v};yIc)cc_rsONk`Y;{N3;Qb_zRlLk%*b1lSlGN<(F?Fh`1^^r%Oi--Ofm zX}$I3qtvtm^%apq2BjDQ@=k={Dsmm&zkGY8DvUJ`v}j{$Wpf)py0MbFqN&?lyJ#`( z=^D-^gYQ7RKU06A@C@{>?kq9NqKr&04>f8-E(=B0Y^Nx)(p(q#oB(9l3$j_#r6yVV&ln^*-@7-M!bAI=&WYTg&FGn-&!w^9Ve21Z3E{#<1(qCpj|(Z&SfiJ=U_Kl9O27 zxSmg~I~@+`mzZJ8L+(ujE+gxmG|>c-U8jes9E2p7ENP@}yH)u%)`NY5u1w+lcuRXU znJqBj^V7)>Rh5${4->QH`6t` zs>wlLY1h;qVW{8F)ic04PgzWhCATeG@R)wb4KL=2|R#2gBFTlbtM0}b`FJW}_ai}o(;GNAf^$Yub z6vRR7GL8r%i_ROKc;BAK3AlP0~{+sCWMxJN)0&QfK=E0RQ2 zl#Z2C;=F+OP%_vrmP66BE)>!5q9h6^?je>G#^4oJ05$`w9AiON_PDGDMFJZQ=P^n7 zl5wBweaBHqixjD8-6A9lgR;heIa%of$B0wfqru4FwAbc$LYm7i_dJ%;e5jS{+E)Xy z9g0AZaE!=h4Zl)vcr-;$vYO-gN;Zl-0%3Reh zOO>igOfO62c_+MEY7jCzgM;T=X|u3b!CB)Ei38xz`z)DTx?=UEht*&7*oIJi^AS9& z{+pnuAjxj*sO7}4x4VgOK9$t0s%bXQ=r)n;ua8s?xXNU&gSHZL7GT7ns|E%jfjQh= zg3P*i-(E8HxJb@r-$zcDU4u2oU(p;Gpv-Y9C=HVtGJl9Xk20pdY?1iE-1(?x)MgbDjGc{B6=pEv75mi<&NN8v>QS3EKELYxk!U>e;EreGYM52kR2SwD9JPKZWqamAFsqycV0 zMp2M8Fi$?+T-@*T@o*$NG5}=U<4h7W(-9~ zD$cWrxez*S6AN;xwO3n^_9$o>bKA-<_sU!B`@Bt0G=p0!46Js?bZ+*SQj&wL&9kIS z(wXtPz@_DbJ|0AYs~A$6-sdD?n$0T*D+|)w4)Yjc73}l*<>Kc6{64h)+=vv+J~jS6oNR4rvyFz zPFp`8CEX@7*NHbOL?Ki%f}AO8h?i(!>~Ng^m2My^SA>>&HyB%x7(ahaisTc+cP=ib zR834NDc+d3t_?X>)4X9Da*&1)cCi0&iUp9Yh%2VS9W%6wM@-_jY%2;m7=;kNgL+fw zHpMA;4YRgwcK&OqQtbWgk>qYWZ05D-$E15xcCuhgwQ5H6l4uC#&!u}~PJ!Tqp2r;I zNMC*DGxf+pjz64YTyAqHQ3()P;)|LE5#K$lG>mVg)uaY@fGi`K5v2ize&F9C!}KF7aOLU%g>F3a7M3lWVXLZ+G1&6Oe$etPnq$F+a!KH` zSdd5LuGo2}g;6JLxO}gqT}D#AQWEW!RVnr!_*ZBs&(Y3pCV~~r&^=$4;H|IQ>}=u{wGQ5p`NnN$cAfVf7w@<}R>)^Q z4O;erq+k4a335G~qA=BksRFG9Nj;I1I%p7DqQmXuH_m)cHKdP1dM|27zYpq$S%*10 zrUmBu!3!&^CGgfrZK(F7NZ8|J#dIzL3wQi%FYjPtE_%3`!Ja3A7#9mf%+=ejS5v zTIBmI2y{GCbm>lWhVNM4avZ};2_vt+p7TtD4bB~_bT^Td+_Q8y#c%^2ebX`VwaeoV znMb%t;&W=_*S^ZNP`QJ`!Ihm+i}a3>JSqJUH)VRq3Bv#E$Qs0uC68LQDZ=4jo7 z(0(DJ{%X+HNhyBR6Sn47jYQfs;iwF-|FWa*LPNb}-{&3<_34kOzDL-niK`WT-?^D> zb3=>*bpB!# z+Z6UZ=AatvMsmmQs!FS5KBal1EQL}#v zvHcTiyabpZn#01bz_YEg9haW~`vcJ(bL)3d80Yr#ufxdJ4gdw9&o^Weem*zCiR>&g zeNcoL>6oD*I|7|7Q}TC+Q;L*ihxrL8KTNm>Jj&ob$u5`-8hw%zeWDY+a!gMUDN9

DinIUa8;w zh1*7Z{xZMaMNd>+Xo7y70zrMKn04!TakVV0V(pbC$!c4+IV;Nf(z%R6l)_k3=KLYM zbIkAg@c&oD&wH5%M)I3YH1m!6DgAGow0{CE{{x%I`5$zm|0qXNqd4)+8brhqmdsSj zN5DhY;c%e9@BytLFZV#LB$}glSg=i{YLLEo*yp$b@WtggPS3h}vsV!2w<`6I%pYpTeD#lcD#Xr*o~#m$*m-CMl`BTIDY zT&gr~<}^;pEG*}Su5`H|3=Q4YHw(VYB;WGowN*hQMA94EH+kw+?44zoq{ZR{C* z9XK^`Y(C+xUEmyn$=p*ju&7Mt7exWxKHFZ5bWN->9aAR1(0AtA}=uSvSUq(KGh{c<^;=pw>sRzsToMpl$W>>e?hDg5j7X+V&yq6t>8*zYrTMKOo z91xqMzS(sL^YJF9v$@~b>nqF;z1~i+cp48Gf=j2VO0iQl#U`vT5rR~hb_e&4;-Fp? zJ*iTCsI&J;@|$5goCPvh&{Wql8= zZJBIXle7)-K=)Hl`ewnsia$9RbU4D{22`=*L%1}LTqR}m0YHpWX7}H#<%NlIm?3T* z0*AQox+E!En%tw5q?oCSwuG{}?s5O5N?;bd8FRsDshaNIk}bY&mfNQ z!VDFwz!yrqJbxjq`Dk zJWV6Bv4(vm6^+m?sjgdvsZAz%t&&hQX~354BX^BszHtj}B`RU9x_t|}R1~`IFZ@*7 zmP$zVesJYjRhEZH8koev_Re+o4TE~B61g0`A3b-mVDgY%UDckTOrO$=9Z2ZaNUNQj zeaIeu1>=y_dEy*$0llEjzfUm(sSzO{#bIti3sDjVIl$C~c~}GF4SC?0Bm9RLagUf8 zHYUs&bI*^CJ72AZUp?EA_U=Kt*cp4kqF?ZXHwc{|uJ+RV0M86sce{K%H@k#1;cIB= zgN)JstA2>lNavOr3q#xJ?dq6~zu!xgDl8~S+rzY-6G#6JPYnmi#C0ZL^Y7JIk zEz4DlYTA}?Wsg?2RW-aVs@mQj4|cp>npHdA&ZcheX$dwTfxkb^dd|Q6uf4Cmx8KS5 zoL_c|emG!puYpwUChE+79Ucsryr3h*dl6vZ6^t9J@LcunL9x3m+)E<(VD}6RC@jbo!Ir8*N7G(bAIyqK_iob(RZ;G6E)UBBP9Xx7Z* zvxH9ABT^jsZy8+c139mXlBSjy&k)eHlp8m8w!QWE97Vv@!g8pZe*Fmh`g})C_?4UC z`b+q;v7QRh4IJ$092n>fz+dnZs2GbI zmBz8%FFtuj*-n+H?ApQWYAIh^pXi@^p)+eLNP4WuYHl`-Buh4yMTLvBC<`q4AXh^t&L$!VM48ikBoqCUm&P*yY zGL1sXtGCor2sl-lEw7P85Z~b7ur`fqFi)x8Z}xU>Xh;)k!io3f@$i%A%k(}j{A@GV z=Xj}b+3k2Q`?TzcM6feJ-+c+Kc1Jhun7p`bOee`fyFIdnAzaSK9Iy?0jq0 zay^1vjNHnjlJhEOKK1&9A0g5>!^R(VhAGWWfstH1zUK0JW`)K(st^_JCk1;N2Rwbx z+)&!buf}zF+K}5Ef9{?s{XTKQ8IH~eAJaJoiCLD%=SN?yB;P8n<)#!%F)w5dO$yoQ zoL3rG!}nFUI3XsT@}J~cr_z*`N5p0vvC8GCtuyDs8+QqX!h?9(RK1fLWV#OEMkRcE z$*f2^5sP1c&NVVeW1_uSA zB;#KEC-F>?A~@D!fK*r3F)FL+YfSx^Yntxyu%)!eLRwFG92DYe_xd#%m1x-9675wr zcxBqfBfe|s5r6Izttyh^-x;b89zJ*UO7RVyB{JyfHCB=bX?^YYT?F;C1{0H%`NJjl zaa|-VvrxZ7;^C2QLVfSf{R4Me+WDm_$h|tQJA%XdlG{~9Rs8wL=5x_KA7NgJWOnD#5Jq~ZInAC8_l;j=fbS+v*he*5dJS5M9n z&c8lKt*QS&xT{t@`}V2$S3QFK-y^DJr1y_&-YlT3QnfbAXHyqF0fV#>*TMGCw9ag)ovhs9A5~?0}ClVPz#*?|^7a#U`w3+t4={;|gQ+tl!nUlK*-D7!F<$s2a%-|R` z>z)Izs~MeB`#)zwZtF8<49f40A4)h4eOw38+r9RQG(X)?c>mNGh50V( zAW7)4mt9y()^}8@vudOoCQH_q5 zxb>8kw8sceWS!9?@**`6zVc?ym=>P1=R)eRtwv1N^ZU0}=*71sLG zn-b@0`6tt{480okLu3+yV>DbZ(^lc#k{Qd5c3!qC zq?)O%+WYCB-_vy9NIE{?4GD;zsiS`~cICe$U*?7N%-Y%XXr+tPvuZ|3#q4>_tCqw@ z3pc}4MfN6U60`@EU)Sk{)~Wm0!lBZh0&9$4BJ0(S;Wh$%ajjvG0|lP4*7l7AJzsk} zF@le;Czlg{=|$0{xdgJ_tezaxLCJ`=9K~cZX#<@le1a?2d_Et%5@EAHfGRs8@B{w4 z`H%1mMcOs4dBQ^KoJ1b6RdH&{^!OsGA1HD0MObXRuN>*?oG;A ztc;o^BiBA&cU#S>MVkj-*QzJ;jbFa{sC!Y2z)BR}W=Z1u^3p0vzF7IEUFAY}9`x3u zajZ8(S)P;PD1LY|dC9KFJVQkY61vNJ-h$`Ypps1Je!fQuBJp97N%&T*NrU#XwBB^0 zE3*Q+4v&ey*bbiLDXA=sTa?z`7u)(~A+E67_mK#ViK3%ua7&DK)nSEDS_@komQWi9 z-iIk9bRokJCG1``j7~RG)Uhwrx7fg+IfWLEr^t4xeaAPvLkOD}%xsywVPIxClCDup z${QyzS31YmyN5-Ol4zO4K}k7Q--PG}mXndxau>+I*n9BhbeoLFJDazQopZd6 zQ}ddTFe+$lPt6RWiSBdBqti|Yf@#lt*A}K`JFw@&QU;Za9FG=c=$SWrS)4J?RNMFV zex!D^iRpKdMTyBrSN^qYRVt9Q@iML$Im-)f- znc5qdVUw47eduoYSaVO3*1kw@pv$|cHA35PZ^Ep8e1To~ieLv7&s;_%OFnTuEQ>>7 zUbtf;K7ZZE*7cq-aef59K}Pvv7?oFCOMlyFViQiSktxowYnw*kEH(U?UH`5{F_(*h zkQWEXPe<-QbsV3^hM!PQ(PHeWy6pp8|3|p)k?@J*nS;5+b=I|kXmLq`s5qitduB``&VGlu(y&-kat7oxZQ(S!VxhHQzC& zC>d38XW=ZPBfha*JvmZI_j4A$+`A@w(MZjgtVrf&flNC2lbj$tzxed!#^n`rnWNMJ zEh4yyB?fQluL*UQcoTN^Xo;G73{vo~sK};2<#oI`AJXl^ag%YCkK@ihl`#qWYnA;J z*YF=Gk3l9JV=A)K+U>oFPfT_*Nh&o&=MDnKaYa5;%IQ5=AIQn$}Q<(h0AhQCe5i@I@E32#DvIBO% ze@t4LLm)5*wVqzMwu_eWuw#gIf6*L?XrM)AIZ0pY@k8q@cqgxwR^f6}e@Vg_%A8w?=U>M$)5)X*eJAQ&M$D@ykGiH+s)z;wx|;F>iL{!km&ZW~>n;Wu=Y zq_WR1-s6a&VXVigXC#~T2x`Bq+@OOOEv)i6blMhY9ls()d>1>h$7OBzy?Zh*Gt@Bo za$mJAeCSHnN_A?aWQD%Iq05f%6K?D{x4R}jiHB4U$tQU5?FQnN3}J@jFO4d)dfFC> z?)hhqKJ`5EpQXyJ#^ctb|FJ*Otfda^x$Kyy zct_B=)#3v>Q^fpTNh9wBhRc>%!`cW-;fWgb-gip-gUnq!%H>F&d3rLfwyaAtor)R{ z(O|6EL++{>{^8iJZ}_dj9~GYq?Z)FPV8}n(8A7aZCvwntDOg%K-{cyfB=y=xQ4BYJ zc*oR~0t9ubMj`QNDHY7(Mu2_%9Xw3>cZ+EA;M$+7wSKUz&)7k`uAU-jF*#myf+FYe z`F7k6!V-F-^FycH=Z~~xM7fg$81`9O-ec6dJ#ai-w&|4Z#7BswvetXL5Cfio-B1}# z&!kB~_4gT<0(bTZ>xfhn%DG%>CI%o9Bs(n98bEos21@%WcQrsb*T7I^+%Xpe#S56{}Pbtfn#b*%7 z=`qdu7QIN0ReF|_IZ}$x`UiuTi6_6MO5K_5uL@pfocxv{b!T~okR|Wq44mcU`!<#n zpV?L1#p&L$cwD-(S~=F-JY((}NPzRCwYuKM*ahs z!Bn7*AoRwndZ>L^n^maXS6Tb-xQ=?N4!MUoG^x}+Rk(PnhlcCDXT9()F>g@cL1!iK z<4Sh7&W#{-=eG?u-`kjLB3wN6Dzfj!Jvm)^C%yJFOm*yu7W(&K;#a~KFqQ3fq#%4eR$H#O(RO{-QqBliC!|Mzg48&Y) zMTh85&pm*rJa>Vq$_qNxii)y}R?MF%zo-%5tUFRX5fm-VXvTTy0XW;RF+Vw=2Tny! zOF3n)=>@mxc@zBFGH%knEGy$k4DLQ^L&LuRR>)u%DoQog4E=gtNlYB^n+YC=n9kz3 z#kcVDL(>Zf8Y18Bm57ZgDbmOiWxYQsM@pNPdYS%>>MZ=?bM|ZwDk^{88OXhT30V`z zpo1TV8v-Q{3J_H>vvNKj#eG+LOUty_Tu6)!{(T~ELhiV=HhFwj-`a};GnVuQvnM`2 zvIpQK?hD6N#V+OyT<9yzKdr<^8cnR%`q&U6EJkj0-jOJIxD;Pi)5HkQ%LdOXJ4=1; zxwP#gjoT$hjLwunn^Nye6-+^9~vM%&IFXK!V33qJ5U0U^-z~iP1r=8X~p2nY|iQW6@wf%_-D<&!75qtgz z*@paQ2m*|XdIscQ+_mSg%l!WM;>;A&)#;@vOG=jXSqIV4EZ05c4edwHJcRk!-Yus; zy|Bl@rs}$wx}5g)HyqNb!@;fQDaLh)C3|)KwH{Su7S;LB)Oj#Sv&!mcNDo+F$Qgw< z!^h6K4lT~;omZ~Va{ips*Jsg1?#jXAIB~Z;hv7xw@ie)dr6PL4Qsa)QSfi9mGgt%6<-gAPp=Uv?^C6HHQV;ZDytE{!K1pBJyGtnN-K*Ob2kKaovS z_*Gp3s{Qda^pZf5LG?t1lm9LTp53w4CU2gBCz5?O_&eVPlMmvTr~5Xj zyqGJm_(_MYSxM+j^w-9p3V){Pr{7&5t90hs(^Q2ru4|)nLHCm{;C|an(C}=s)5eEV zYO!O2?ftY`{f%mJ&a*#HoT#h35)gVg-y7WDTcFs*II8mec`aHPbxA>&!}>?FKbo&{+dtvQkbnUg97@QMEt6Fg!BR5;7P z;UI!9PpgbLKYGx?8Su{HJ(q??Li-W>v5L9WLWr%?u~+U=2Ti*_>u0h%T_uN&CbmDz z3O-LYT$r%?0#}SQ5nd(5r4O>~NziwlLIY_l2IULf1QIdMW}QNeA4Jt65`v*8LUc_7 zN*z*pQ@a*u&L&f{@N-}CFMVU~ku!t;(xYGXOF_MbG1d9<><_6z3g8WO8*bBV&F%|n z9?I7fUi;-&XkF)LX%nr|kkYL7?VZ8h6JJCE_SS9* z)Hsz}%pc$-YvMkG!o$X_~na7R22{xsB zWlF$%vWr_+?`5S2aA~pQPD$%{sKf};iEfXJ_sVR|SXwveg zQK^hHO5mb0>BAnYxM@|#<=tuW${~j|xq?Z`$DffkWw|wF^{I%Z<-XawclFk>u)L

*F*DPn-A0JSV#pltJ|+#qqq_!JcbuYEU|QPMIz|=%YBt+ofYZhORn`=FiS) zA8^~>U+1Ad>`U^x7T+Y#;r=T^xsMheZ)+#wPu8AQnrlqpAH#e2(xzt8tHaw!deSku z{@P87wbRefq;=C)3C^B5(dU0ntdaWtLG}d*9|>d3>F?1vE(~sY#SjVT%&}CVIS%Ig z&=1`l{d%*X!=$|}qae;7+@c@)#WcTCAfxQAJy^86w)YP%t^j*qOQFm6CU;A@L3ssSLdQJ`Vuo5756Nhx|` z=Pp;(m8bY>H!;>ve&aCq-FJ)UN&IFTL}&{7Y`;0ic8-(ytslJ&Ri)q^T{aL zb=Viei2rHkqfp)j&*;O@FG7uzQOiM>#lNlugrB{yIJQtF_Vw-ZcmK80Q@igJ+NxBk z9psaLwip^)GOq^(lHuLxKX!7Z(r0$C>4K3n&oQ=YErR1Sy<>eQy z8{XJB$8guyVc}Ba#rg0~zf&UeJsv)pmnMpRaM_jjwdigTr|RH7~L6Pg6Ubml^~V$oJoFcG0+gEHTgB&n~Ggu)3{xW>- zK~y8L{Xe9RS`DVA*S`3k7&3SRiy6`{w`mV-`}gAF)^E5zd-9=hX= z{o3(H3-JpM!QRIbNpCG4aPz;)Sn@gT#i%(qLph;Iq89nU<><5dxqC)iZoA})%f8l$ z?%`bXate#D)~x@$d`uy3ZN(vLit{a=%zdYV%7xeo^62dF4YJntqZeVj?TEeeqoai6{l;?a0)){aVPqD--)*UyX+*9fp&%9QvxYoPY^_CGb-xdNH zg_zO{WUUFQt#@Y8Tn#5XmfkXNz-2OV&XNazS?B8g{rodbviQPsdsCpFaV-097jXv> z@Cr88B#~P#QM)#(;#;10PW=Ep7*DPv_EX}S>Eiew-Pz&x2$g8d33P(A*E@kcg26jLj&b& zC!YryoqicfQ&0VFMY@_=8t!M#&@e)8%koA|m(TN@(g~`bFR}B-7ufjeCzE|GWSWY) zPD{Vc+4D5k*zw!-uabnS5~b@B4(F$33-QiJfpJ)Vf-eJvT1W3*d81+RxM?mf&-1Zz za8q0RkX*=rla(E%GjZ`&lz83;A}9x*P%Y%brFP%fEEo`25Gl@wJCoB-GQA(7Bj*#% z*N|#XOt-c88WkX*v!H%ZPD)+wX4yz-|C2*Cu}At8@+rP6TBUldQbw75Kl?a{GNg7$ zB*p!73$#*OBy8w{qxtyR>uJp;Z}UhvVO7W7nUam@>7>rS3;CeITRc{xk;un7Y}~ak z-|l21v5o6frMu>QUgp$zK2QAKHi{JX&Vu8I!rhou;C{E~#Xr5)OX)Zi`$$wh!tRUb z1pS#i@i2P&%R}Klys={4kflsc1@(EF57ETZjLR_&-^6Fw20BhqzKlC@aZx~sWQl1e z*t$5F=z{%=gOx+(MTvOIW-8WgD-=@I^y;2$It~||5?_>R?-wg6IDc;g_qRC;Ca0Qv zsI1S#05iM={*r^gIxt7LopG=i%vb0*i1fXEg5AP=2Hk@LJiNRjW6L@^_q0h$1vKhj z%<}Q*^xV@n)#&Zh>NC(7fC>nip3>UOZ|v*M3)y9C;0?7Wv=+2Zk90VED)~ySL;RIH zM;pzm@8m}cDjQa@)|5z_sPNVlKwNg~hn~zkY3hA4FZHs-$g85hYwfAV99k0M5o3|X z#~bR8|8WQpf@03=VpXlcfvUlz3@xD85a#C-4E6AX`G8{1&(r4z-RUOxJf4V9G_CRD z%NUd>NyCY+d(qP9p6EW{o$}mv=z+Ao%4t4m2N~5yD6au=9cxMOxp|AJY=)$uEG^hH zd8plat&my^7Pdap3y*v{59QAAK6tBKQ&T2lJ)|?&)*k&P4_2dX6>~y2@t)#vc3%OX zFI3{e(@O)e%ic2Ca~-COd)Qj8$A*f(8TG||%PrE;=d#%0S<5h<#=qW55-CX+fGg** zOIc;NWZ>H=^0(#vPbH$Sp6_{zqjoSsLWVq}iDw`zth(Dxd7%A_>Y&ffsH>rR7IF&( z6a3L6pXw6FUk!jKjt$x6#m-$*;eAF%D03)aGjL5~O~R=OVJut~=Zp znvyrvS)exQbD+Lb_SqWq0eddZQ^rxHXC{tKPttWdxqbKUu14QmeyYpd{2^yj$qY(EHz_^w{8*Bf*DTLNMo<3#4rfFR z)=cpKcWcNjqj<2IY=ZXy$xQDoW8ubx^-2d#&AmZR#C@T1;= zoMiQ}oAux58y-Hy$L|oAs=Bl*cV&1yl_ogpIA?;u4Yyu4Jg;7DW#0zwy}m3jUrDY~ z_b|U!xFIeWJ<~8vUp0TWTp@O}zlJ~3k2k8|X7|%&=`{jk+G1D+MjpW3JlH>*}M?I0pQ<=BSp6R1}dppo8S0x2+4L|0|#tvUI?JJ zKfi_uOWQ&sg2K-W@!cixPqgQrY=y6}v7q=23av+gNxffp06&W(xWK1qZ-LCtTjrR4 zS74iidCH!S!RjzS5Tks5w#&DIM@bHl+5(sbpkgZ&@B|zT;K<`L3}HZ=Fb@ah7~pR- zj=%7?)_z+Fq3i1RGXsQt1cX?k5MqyqjS!?bP>U4}KR>UZpP0e@T#VuFFi(F!Y;=fQ zhGwY%I<5jbG*Rdf1%(q@Z6F1Lq~rG?ix>~V+{!=BQBo^qfO{6;s-xgefPC|hxIek& zz&Jy@74*nyy|a`+yeVLUP96m`3Iu@dK@sb*Ee~39AXWkB?QBvv=Is-}-Yh^a8eUnM~Q5EBG)7zK-y3LDnWJ*cs7ybSR!#{YogbWzaS z0scR7_J_gz;BND^jM$8I(de9a3^*4sm;wUPM!^mQFBjY%dsBZ$JOe!tOEv`KzJES7 zi+cLaRv9Ojd$VW*uI~V@kDwqsabiP8K>b=0ZaJTD8?BxR=Ww$Ch+_cJ7zL4r8yh0# z(<^^+tON6N@pQx{?a1qF6s`#SCE03MQ#{xxK<6z`54fL^3)~&O$Mjj?w5o2}l@8;9rRcy>xLGFOKN~v`%16s7z)`Vn9TOc?`V{Y+=bxz1v$3 zKwbloW+-xnN@IgWa{G5*OwY>??&;yH?*sD%r>bGI;e%IdCba+&uK^LL>FtXQHX^pm z_t=;}u|5O44sh2%Re>5ME95ZXB6mG6`?s!t zW;x7Ja(gGP-B>tt2n6VFAV32wF=49f}PK zlc*6<3lXicSyfeVrNkS6%>$w%;=I3KS8)U!gf6sf{>cYn0lXlu;)o)kPqerHcLiduS>7>8&DsFvou!08Ko~+^#S!7)5ht{;Ke^KPgn=`* zH(#r)X6FE!1HtGy3ySt$umpm01#W?An!*+sAds9PmG*Z`fOiLe@mu^Nm!hj0dyA7E68Wat2m;`8Us9<9Ex75ud4VH zN5Q?@K*fF#dFLN1s-qb0jT9zout9%+i#EttL=bHP7^o{YEqe_2M~V&u(7)I0pGWO^ zz5wtNAUITT97hb`NX)-21*0a>b1qT5aDg6x?*g2orVqH&&cXj6=ZCu>%oaWFqTzzA zC2&Q0uvkz=(dcVu47f;%Z=@`I}{QS%c=fQ?u_TxbFhEFKTYfx`6GzsIltD>ihTl_16ju zJ*;Ri9g{V%H$?9pwcSvE5d-YM$Zq>G|3c__`CO30$yv9S`N0L)K(Q@X(X%P`Dyu!vV{nnnzy65yg!dQ2#e| zE)S-u8vvkLAYVNs41&Ec%@}}?>>-8x(;GLJO&q_QgxCrua_4MWIIyKF)LX;N&AZsZ z(UdORTTz2ZkQHKm+739?N8vQA8ygq~PX912Y^=^rYqk^uGb#dE0xS!WS8;?)4>okP z-5vDa`9blak2+}7Pt$E(9f=NMgV~{DsJsos8v~(diG6GTarhB7D5O09kl=PsxKezm zbs2P2$2cJnF{JDeR*LuHpRu;f87>;$BZybGGy>y5T{S>I?hxRY8z2nyUsig0Nw0k> zfMtk)ydjIi+t(Fr(C7;>^rmt2GL2R}xIZgkQxyegeGLN+QcYXZ;_tY&eM%H(b*@J= z+-?G?>Y_k0e8&KZEw~^Tf!G}GTfeavqCIjSQ~{`QyJsB(_IB+4Vieh3MK5H760w;Q zfEo+pHfrth9I^|`5)cXhms9)qWIHK|Bn|NEKrYINJwu{foY5o&q=z;jOvx05LX53|ynD8j1e0U+L+Dp=cm{V*h?{(TN0f}kNboO*OxjaZ6 zetWm3jvE5l@OEf42yTE(e_X7aKYwn3>qugNa)yC7F4=*$kMCa_#?uplQDdNrhy^(h zahmC`t2pB9Kio~p3$E(pxKO?ICfF%O+oAeH z@JKHH#De<%OnARuR<>1e_roR3jsgxN0f(S-iM)y_SCg=hnfBq zD|(F$Ph5Fm2l(^=#icD079m<&(A32S{JYbDGz<d+9m078$lV)6N>nw=f#Mq*EkB(YNr#Ca+|3t^1Nef440_L6LHkGj^yS@-y~yg?SkHdwGGE*!*@w4p9t% zs|(RXz|#?HY}7*9)Ezq@8nvQ_k<+q;I1oV~r0iR#IKrZ_!=UC=qzM0<;n=ifIM^cg zbocTH^CajA5k4au$_W+?A|TtL>e3?le+4nJy`;HkupjlpC&G+=g)FrRIKb13NBtAPPe0mf067OM5w zfsMgYT}W=xb7nXHm9hwMMhWHzz^)|nDvnTV#tvX)=kDbOQ}Xh{f>IJH_9+C+VtfbH z0;>EJy0N36af`pB9eVb(p;raZg7{7dSVUbp9RSlQ*h1Ss0b>dUT#-UNZooAbLH7`K z<-{i-A|)RcuP>S2LkEdx3xh;02)+S_51TQyREt8UyTdFGy1BF32!%6 zaF~aqmnR&&7j0`za_2v8=Xbzn^MPz_P~-~R$!(SFef@mEUZm&Um;mx`=&-4@SfWw`Tg5K5=In8XzfvjagEHproi4*M( z2thReHZ2=5s{-}iv_h!I_GRLMdEtw_pvB5AvNg>;-@8M2(A(X1q4Rk4)$wxBsMi8R zw3aBG67lT-3X{kkT{rp1RvFi(dpNAHKp-v_TZ?f)(f>Cc=#{KPZ@5c4G`V>3a+95+8lk9{%bPERs0zLP)$swl=se{2WX=rw>I z((|M9f+;-&LUnj+`XX}P0VHZVL5+FnfptGr%OmC?5R*}MD7@Ya-vKa^*R2xf_|bN- zv)`Pi!PZbIp@#+J0OQvHDDPU~&gEK?qY7^?0p)ssVUH8Q7e6LDGRJGP;s>KneE1 z|6^n5kKC~B>Rq40*)JDRi}|K|Y8E#?R*}H|hD+SHKpt&x%Fhi2=3Q z0J1bu$l|-O1F|sN5QdPIr6D+P16-*OxDrSg$g4P_BYOw9NLNA)+=%I_A7LDu3yo5Y zc^?5}OaL;BkVGJCmdgz{<(Mx)`<9mu#P#P7SuV|LGaK8wi+E-CS$M; zsLwyy2CO+gg8~pR1l&UnMM#BJJ0Jofq+fCM=iHl-7t8^}vo?2iPQ}>)#;JjF>`*Xi z!A$VZ8UM>3k#XD(F%pc;J*Zikzbu2~F2b<2uvn?x0XgVJu(?XZ6vkgCwh!`y?Dho| z(fTN&FuuJ5Y@`kRC5j)+V@hX)*EU4u!75P_tP)Xk>$}z+pkoNve>u+fYY98L@lko8 zh8c>jmUy{$2gK-lqD}MYLxg>m)Eiu|bm|0cB-9-^wFf)E+*bAIk);F)S=xZl!9XVj zwXnYaa0kd3M872D9l`t&7}$seTb>~AV5>^YZst{)fKEc7)z*g&HP*2cgR)1w$vq~^ z;wbA6cmvq3rQO=h{=|%f)z*J)^7vvwsk3RkY6>cBSB|ZXT`4Z?D1YoZV8Q8)I4Xg7 zMtBNfq3*5BiDJi5@$`ZHK4Sq3l&!gJ%voS735U1t05V8nhuUVJ483{Y%B1h11y0cc zdR&Sq5dcpQJDicfy_cPXtDQ4!OOqTu*pR_w-)SJmV?d0kV1Xvs!L}ayfJKlLs}_|H zKw_s5-D(>)mKebPc5M`sN6!=oUgmkkL#Wq5I5Rta~1Z`Bug7d3C_Rk|sT^V>< zKA@l?1-*Z;d4#-*Bb3}RkN_A%&kmEg2%i#Q#~ZMN8kyh6VYnA2cK-PRY!A4};9G#n z18hSGNj+kXj7%uVHk=N&yg!2>^V@cbQmeg;j|tq}uzF9AQOQNI^FX1~39u#6#Z zv;1_ka;-N2ZdDCxEhQ9=0>K{G_NadjO(3Vpe%Suvt1owFi za7Y3EgNYl8=YDYoJ}b<&b&#q$1H4afgkKRhAT)En=!LcQeObRj z7^<;>Af@(4?!fl;tgV|$TVMP18~;JgKjWh|S$|r`HukvnT|K`sQ?CENFfkQdTTh(+ z4JhCG&wzgmd0Xq*dfwe{%!32}56pj^&)s@z+i&={gV^BF&*x$}!)>c!Z9Qh}HvzZ7 zaO?I#2Wi+S;b2?4LU)wZZ%EA%oUI2-{YfvnQ=NW)`5XB1)^z{lj3<39aF{H(^1&ZA Nbud%@5UgAv{|Cmbv*!Q+ literal 0 HcmV?d00001 diff --git a/seed/csharp-model/alias/src/SeedAlias/Core/CollectionItemSerializer.cs b/seed/csharp-model/alias/src/SeedAlias/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..be3d0833d35 --- /dev/null +++ b/seed/csharp-model/alias/src/SeedAlias/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedAlias; + +///

+/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-model/api-wide-base-path/src/SeedApiWideBasePath/Core/CollectionItemSerializer.cs b/seed/csharp-model/api-wide-base-path/src/SeedApiWideBasePath/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..abec34e7745 --- /dev/null +++ b/seed/csharp-model/api-wide-base-path/src/SeedApiWideBasePath/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedApiWideBasePath; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-model/audiences/src/SeedAudiences/Core/CollectionItemSerializer.cs b/seed/csharp-model/audiences/src/SeedAudiences/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..2493e39bacc --- /dev/null +++ b/seed/csharp-model/audiences/src/SeedAudiences/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedAudiences; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-model/auth-environment-variables/src/SeedAuthEnvironmentVariables/Core/CollectionItemSerializer.cs b/seed/csharp-model/auth-environment-variables/src/SeedAuthEnvironmentVariables/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..d7827223005 --- /dev/null +++ b/seed/csharp-model/auth-environment-variables/src/SeedAuthEnvironmentVariables/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedAuthEnvironmentVariables; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-model/basic-auth-environment-variables/src/SeedBasicAuthEnvironmentVariables/Core/CollectionItemSerializer.cs b/seed/csharp-model/basic-auth-environment-variables/src/SeedBasicAuthEnvironmentVariables/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..456869554aa --- /dev/null +++ b/seed/csharp-model/basic-auth-environment-variables/src/SeedBasicAuthEnvironmentVariables/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedBasicAuthEnvironmentVariables; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-model/basic-auth/src/SeedBasicAuth/Core/CollectionItemSerializer.cs b/seed/csharp-model/basic-auth/src/SeedBasicAuth/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..1867a98c6bb --- /dev/null +++ b/seed/csharp-model/basic-auth/src/SeedBasicAuth/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedBasicAuth; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-model/bearer-token-environment-variable/src/SeedBearerTokenEnvironmentVariable/Core/CollectionItemSerializer.cs b/seed/csharp-model/bearer-token-environment-variable/src/SeedBearerTokenEnvironmentVariable/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..234d0ef14a2 --- /dev/null +++ b/seed/csharp-model/bearer-token-environment-variable/src/SeedBearerTokenEnvironmentVariable/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedBearerTokenEnvironmentVariable; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-model/bytes/src/SeedBytes/Core/CollectionItemSerializer.cs b/seed/csharp-model/bytes/src/SeedBytes/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..ad8473f0730 --- /dev/null +++ b/seed/csharp-model/bytes/src/SeedBytes/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedBytes; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-model/circular-references-advanced/src/SeedApi/Core/CollectionItemSerializer.cs b/seed/csharp-model/circular-references-advanced/src/SeedApi/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..10121ac93ae --- /dev/null +++ b/seed/csharp-model/circular-references-advanced/src/SeedApi/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedApi; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-model/circular-references/src/SeedApi/Core/CollectionItemSerializer.cs b/seed/csharp-model/circular-references/src/SeedApi/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..10121ac93ae --- /dev/null +++ b/seed/csharp-model/circular-references/src/SeedApi/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedApi; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-model/code-samples/src/SeedCodeSamples/Core/CollectionItemSerializer.cs b/seed/csharp-model/code-samples/src/SeedCodeSamples/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..c36bb49e4e4 --- /dev/null +++ b/seed/csharp-model/code-samples/src/SeedCodeSamples/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedCodeSamples; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-model/custom-auth/src/SeedCustomAuth/Core/CollectionItemSerializer.cs b/seed/csharp-model/custom-auth/src/SeedCustomAuth/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..23803eb3013 --- /dev/null +++ b/seed/csharp-model/custom-auth/src/SeedCustomAuth/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedCustomAuth; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-model/enum/src/SeedEnum/Core/CollectionItemSerializer.cs b/seed/csharp-model/enum/src/SeedEnum/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..3c618883a3c --- /dev/null +++ b/seed/csharp-model/enum/src/SeedEnum/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedEnum; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-model/error-property/src/SeedErrorProperty/Core/CollectionItemSerializer.cs b/seed/csharp-model/error-property/src/SeedErrorProperty/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..4b0ecaaacdc --- /dev/null +++ b/seed/csharp-model/error-property/src/SeedErrorProperty/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedErrorProperty; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-model/examples/src/SeedExamples/Core/CollectionItemSerializer.cs b/seed/csharp-model/examples/src/SeedExamples/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..d4f303e049c --- /dev/null +++ b/seed/csharp-model/examples/src/SeedExamples/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedExamples; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-model/examples/src/SeedExamples/Types/Directory.cs b/seed/csharp-model/examples/src/SeedExamples/Types/Directory.cs index 005e35889ec..d1151baa44c 100644 --- a/seed/csharp-model/examples/src/SeedExamples/Types/Directory.cs +++ b/seed/csharp-model/examples/src/SeedExamples/Types/Directory.cs @@ -11,8 +11,8 @@ public class Directory public string Name { get; init; } [JsonPropertyName("files")] - public List? Files { get; init; } + public IEnumerable? Files { get; init; } [JsonPropertyName("directories")] - public List? Directories { get; init; } + public IEnumerable? Directories { get; init; } } diff --git a/seed/csharp-model/examples/src/SeedExamples/Types/ExtendedMovie.cs b/seed/csharp-model/examples/src/SeedExamples/Types/ExtendedMovie.cs index 88922bd0aa9..868b65315b7 100644 --- a/seed/csharp-model/examples/src/SeedExamples/Types/ExtendedMovie.cs +++ b/seed/csharp-model/examples/src/SeedExamples/Types/ExtendedMovie.cs @@ -7,7 +7,7 @@ namespace SeedExamples; public class ExtendedMovie { [JsonPropertyName("cast")] - public List Cast { get; init; } + public IEnumerable Cast { get; init; } [JsonPropertyName("id")] public string Id { get; init; } diff --git a/seed/csharp-model/examples/src/SeedExamples/Types/Node.cs b/seed/csharp-model/examples/src/SeedExamples/Types/Node.cs index b413f086f90..c5f79feba8d 100644 --- a/seed/csharp-model/examples/src/SeedExamples/Types/Node.cs +++ b/seed/csharp-model/examples/src/SeedExamples/Types/Node.cs @@ -11,8 +11,8 @@ public class Node public string Name { get; init; } [JsonPropertyName("nodes")] - public List? Nodes { get; init; } + public IEnumerable? Nodes { get; init; } [JsonPropertyName("trees")] - public List? Trees { get; init; } + public IEnumerable? Trees { get; init; } } diff --git a/seed/csharp-model/examples/src/SeedExamples/Types/Response.cs b/seed/csharp-model/examples/src/SeedExamples/Types/Response.cs index 1a19970c48f..0ad26d87ed4 100644 --- a/seed/csharp-model/examples/src/SeedExamples/Types/Response.cs +++ b/seed/csharp-model/examples/src/SeedExamples/Types/Response.cs @@ -11,5 +11,5 @@ public class Response public object Response_ { get; init; } [JsonPropertyName("identifiers")] - public List Identifiers { get; init; } + public IEnumerable Identifiers { get; init; } } diff --git a/seed/csharp-model/examples/src/SeedExamples/Types/Tree.cs b/seed/csharp-model/examples/src/SeedExamples/Types/Tree.cs index 9d5ce810980..fdc78f4af6e 100644 --- a/seed/csharp-model/examples/src/SeedExamples/Types/Tree.cs +++ b/seed/csharp-model/examples/src/SeedExamples/Types/Tree.cs @@ -8,5 +8,5 @@ namespace SeedExamples; public class Tree { [JsonPropertyName("nodes")] - public List? Nodes { get; init; } + public IEnumerable? Nodes { get; init; } } diff --git a/seed/csharp-model/exhaustive/src/SeedExhaustive/Core/CollectionItemSerializer.cs b/seed/csharp-model/exhaustive/src/SeedExhaustive/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..448f56cec35 --- /dev/null +++ b/seed/csharp-model/exhaustive/src/SeedExhaustive/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedExhaustive; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-model/exhaustive/src/SeedExhaustive/Types/Object/ObjectWithOptionalField.cs b/seed/csharp-model/exhaustive/src/SeedExhaustive/Types/Object/ObjectWithOptionalField.cs index d5ce19c9090..552ceefb341 100644 --- a/seed/csharp-model/exhaustive/src/SeedExhaustive/Types/Object/ObjectWithOptionalField.cs +++ b/seed/csharp-model/exhaustive/src/SeedExhaustive/Types/Object/ObjectWithOptionalField.cs @@ -34,7 +34,7 @@ public class ObjectWithOptionalField public string? Base64 { get; init; } [JsonPropertyName("list")] - public List? List { get; init; } + public IEnumerable? List { get; init; } [JsonPropertyName("set")] public HashSet? Set { get; init; } diff --git a/seed/csharp-model/extends/src/SeedExtends/Core/CollectionItemSerializer.cs b/seed/csharp-model/extends/src/SeedExtends/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..2e3dbdb9646 --- /dev/null +++ b/seed/csharp-model/extends/src/SeedExtends/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedExtends; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-model/extra-properties/src/SeedExtraProperties/Core/CollectionItemSerializer.cs b/seed/csharp-model/extra-properties/src/SeedExtraProperties/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..6810a82ffda --- /dev/null +++ b/seed/csharp-model/extra-properties/src/SeedExtraProperties/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedExtraProperties; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-model/file-download/src/SeedFileDownload/Core/CollectionItemSerializer.cs b/seed/csharp-model/file-download/src/SeedFileDownload/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..0979d57cd8f --- /dev/null +++ b/seed/csharp-model/file-download/src/SeedFileDownload/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedFileDownload; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-model/file-upload/src/SeedFileUpload/Core/CollectionItemSerializer.cs b/seed/csharp-model/file-upload/src/SeedFileUpload/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..4b4596783d6 --- /dev/null +++ b/seed/csharp-model/file-upload/src/SeedFileUpload/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedFileUpload; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-model/folders/src/SeedApi/Core/CollectionItemSerializer.cs b/seed/csharp-model/folders/src/SeedApi/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..10121ac93ae --- /dev/null +++ b/seed/csharp-model/folders/src/SeedApi/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedApi; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-model/idempotency-headers/src/SeedIdempotencyHeaders/Core/CollectionItemSerializer.cs b/seed/csharp-model/idempotency-headers/src/SeedIdempotencyHeaders/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..7a87593fb5c --- /dev/null +++ b/seed/csharp-model/idempotency-headers/src/SeedIdempotencyHeaders/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedIdempotencyHeaders; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-model/imdb/src/SeedApi/Core/CollectionItemSerializer.cs b/seed/csharp-model/imdb/src/SeedApi/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..10121ac93ae --- /dev/null +++ b/seed/csharp-model/imdb/src/SeedApi/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedApi; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-model/literal/src/SeedLiteral/Core/CollectionItemSerializer.cs b/seed/csharp-model/literal/src/SeedLiteral/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..a922b77b7e8 --- /dev/null +++ b/seed/csharp-model/literal/src/SeedLiteral/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedLiteral; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-model/mixed-case/src/SeedMixedCase/Core/CollectionItemSerializer.cs b/seed/csharp-model/mixed-case/src/SeedMixedCase/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..16b397e85e1 --- /dev/null +++ b/seed/csharp-model/mixed-case/src/SeedMixedCase/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedMixedCase; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-model/mixed-case/src/SeedMixedCase/Service/User.cs b/seed/csharp-model/mixed-case/src/SeedMixedCase/Service/User.cs index f1d52c7ec9c..04a0194614d 100644 --- a/seed/csharp-model/mixed-case/src/SeedMixedCase/Service/User.cs +++ b/seed/csharp-model/mixed-case/src/SeedMixedCase/Service/User.cs @@ -10,7 +10,7 @@ public class User public string UserName { get; init; } [JsonPropertyName("metadata_tags")] - public List MetadataTags { get; init; } + public IEnumerable MetadataTags { get; init; } [JsonPropertyName("EXTRA_PROPERTIES")] public Dictionary ExtraProperties { get; init; } diff --git a/seed/csharp-model/multi-line-docs/src/SeedMultiLineDocs/Core/CollectionItemSerializer.cs b/seed/csharp-model/multi-line-docs/src/SeedMultiLineDocs/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..4d3191b39ca --- /dev/null +++ b/seed/csharp-model/multi-line-docs/src/SeedMultiLineDocs/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedMultiLineDocs; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-model/multi-url-environment/src/SeedMultiUrlEnvironment/Core/CollectionItemSerializer.cs b/seed/csharp-model/multi-url-environment/src/SeedMultiUrlEnvironment/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..dfd8eff2120 --- /dev/null +++ b/seed/csharp-model/multi-url-environment/src/SeedMultiUrlEnvironment/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedMultiUrlEnvironment; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-model/no-environment/src/SeedNoEnvironment/Core/CollectionItemSerializer.cs b/seed/csharp-model/no-environment/src/SeedNoEnvironment/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..2a7edef8c7a --- /dev/null +++ b/seed/csharp-model/no-environment/src/SeedNoEnvironment/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedNoEnvironment; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-model/oauth-client-credentials-default/src/SeedOauthClientCredentialsDefault/Core/CollectionItemSerializer.cs b/seed/csharp-model/oauth-client-credentials-default/src/SeedOauthClientCredentialsDefault/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..e24e60bed91 --- /dev/null +++ b/seed/csharp-model/oauth-client-credentials-default/src/SeedOauthClientCredentialsDefault/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedOauthClientCredentialsDefault; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-model/oauth-client-credentials-environment-variables/src/SeedOauthClientCredentialsEnvironmentVariables/Core/CollectionItemSerializer.cs b/seed/csharp-model/oauth-client-credentials-environment-variables/src/SeedOauthClientCredentialsEnvironmentVariables/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..45506a13645 --- /dev/null +++ b/seed/csharp-model/oauth-client-credentials-environment-variables/src/SeedOauthClientCredentialsEnvironmentVariables/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedOauthClientCredentialsEnvironmentVariables; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-model/oauth-client-credentials-nested-root/src/SeedOauthClientCredentials/Core/CollectionItemSerializer.cs b/seed/csharp-model/oauth-client-credentials-nested-root/src/SeedOauthClientCredentials/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..5bfe4e0f26c --- /dev/null +++ b/seed/csharp-model/oauth-client-credentials-nested-root/src/SeedOauthClientCredentials/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedOauthClientCredentials; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-model/oauth-client-credentials/src/SeedOauthClientCredentials/Core/CollectionItemSerializer.cs b/seed/csharp-model/oauth-client-credentials/src/SeedOauthClientCredentials/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..5bfe4e0f26c --- /dev/null +++ b/seed/csharp-model/oauth-client-credentials/src/SeedOauthClientCredentials/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedOauthClientCredentials; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-model/object/src/SeedObject/Core/CollectionItemSerializer.cs b/seed/csharp-model/object/src/SeedObject/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..473599cbfcd --- /dev/null +++ b/seed/csharp-model/object/src/SeedObject/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedObject; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-model/object/src/SeedObject/Type.cs b/seed/csharp-model/object/src/SeedObject/Type.cs index bbe86f26ebc..075f8d7a1c4 100644 --- a/seed/csharp-model/object/src/SeedObject/Type.cs +++ b/seed/csharp-model/object/src/SeedObject/Type.cs @@ -35,7 +35,7 @@ public class Type public string Nine { get; init; } [JsonPropertyName("ten")] - public List Ten { get; init; } + public IEnumerable Ten { get; init; } [JsonPropertyName("eleven")] public HashSet Eleven { get; init; } @@ -50,13 +50,13 @@ public class Type public object Fourteen { get; init; } [JsonPropertyName("fifteen")] - public List> Fifteen { get; init; } + public IEnumerable> Fifteen { get; init; } [JsonPropertyName("sixteen")] - public List> Sixteen { get; init; } + public IEnumerable> Sixteen { get; init; } [JsonPropertyName("seventeen")] - public List Seventeen { get; init; } + public IEnumerable Seventeen { get; init; } [JsonPropertyName("eighteen")] public string Eighteen { get; init; } diff --git a/seed/csharp-model/objects-with-imports/src/SeedObjectsWithImports/Core/CollectionItemSerializer.cs b/seed/csharp-model/objects-with-imports/src/SeedObjectsWithImports/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..ed7bdcf2ce6 --- /dev/null +++ b/seed/csharp-model/objects-with-imports/src/SeedObjectsWithImports/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedObjectsWithImports; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-model/objects-with-imports/src/SeedObjectsWithImports/File/Directory/Directory.cs b/seed/csharp-model/objects-with-imports/src/SeedObjectsWithImports/File/Directory/Directory.cs index bb3cb79f273..9f3d79d7054 100644 --- a/seed/csharp-model/objects-with-imports/src/SeedObjectsWithImports/File/Directory/Directory.cs +++ b/seed/csharp-model/objects-with-imports/src/SeedObjectsWithImports/File/Directory/Directory.cs @@ -12,8 +12,8 @@ public class Directory public string Name { get; init; } [JsonPropertyName("files")] - public List? Files { get; init; } + public IEnumerable? Files { get; init; } [JsonPropertyName("directories")] - public List? Directories { get; init; } + public IEnumerable? Directories { get; init; } } diff --git a/seed/csharp-model/objects-with-imports/src/SeedObjectsWithImports/Tree.cs b/seed/csharp-model/objects-with-imports/src/SeedObjectsWithImports/Tree.cs index 78e593b1ac8..1431b1a2706 100644 --- a/seed/csharp-model/objects-with-imports/src/SeedObjectsWithImports/Tree.cs +++ b/seed/csharp-model/objects-with-imports/src/SeedObjectsWithImports/Tree.cs @@ -8,5 +8,5 @@ namespace SeedObjectsWithImports; public class Tree { [JsonPropertyName("nodes")] - public List? Nodes { get; init; } + public IEnumerable? Nodes { get; init; } } diff --git a/seed/csharp-model/optional/src/SeedObjectsWithImports/Core/CollectionItemSerializer.cs b/seed/csharp-model/optional/src/SeedObjectsWithImports/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..ed7bdcf2ce6 --- /dev/null +++ b/seed/csharp-model/optional/src/SeedObjectsWithImports/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedObjectsWithImports; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-model/package-yml/src/SeedPackageYml/Core/CollectionItemSerializer.cs b/seed/csharp-model/package-yml/src/SeedPackageYml/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..a452937b61a --- /dev/null +++ b/seed/csharp-model/package-yml/src/SeedPackageYml/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedPackageYml; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-model/pagination/src/SeedPagination/Core/CollectionItemSerializer.cs b/seed/csharp-model/pagination/src/SeedPagination/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..cbbbc91d9f1 --- /dev/null +++ b/seed/csharp-model/pagination/src/SeedPagination/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedPagination; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-model/pagination/src/SeedPagination/UsernamePage.cs b/seed/csharp-model/pagination/src/SeedPagination/UsernamePage.cs index 8c7a4e83840..cb779360096 100644 --- a/seed/csharp-model/pagination/src/SeedPagination/UsernamePage.cs +++ b/seed/csharp-model/pagination/src/SeedPagination/UsernamePage.cs @@ -10,5 +10,5 @@ public class UsernamePage public string? After { get; init; } [JsonPropertyName("data")] - public List Data { get; init; } + public IEnumerable Data { get; init; } } diff --git a/seed/csharp-model/pagination/src/SeedPagination/Users/ListUsersPaginationResponse.cs b/seed/csharp-model/pagination/src/SeedPagination/Users/ListUsersPaginationResponse.cs index c1dd2313e38..19bdcd9ebc2 100644 --- a/seed/csharp-model/pagination/src/SeedPagination/Users/ListUsersPaginationResponse.cs +++ b/seed/csharp-model/pagination/src/SeedPagination/Users/ListUsersPaginationResponse.cs @@ -17,5 +17,5 @@ public class ListUsersPaginationResponse public int TotalCount { get; init; } [JsonPropertyName("data")] - public List Data { get; init; } + public IEnumerable Data { get; init; } } diff --git a/seed/csharp-model/pagination/src/SeedPagination/Users/UserListContainer.cs b/seed/csharp-model/pagination/src/SeedPagination/Users/UserListContainer.cs index bb01ad47072..1f674f6576d 100644 --- a/seed/csharp-model/pagination/src/SeedPagination/Users/UserListContainer.cs +++ b/seed/csharp-model/pagination/src/SeedPagination/Users/UserListContainer.cs @@ -8,5 +8,5 @@ namespace SeedPagination; public class UserListContainer { [JsonPropertyName("users")] - public List Users { get; init; } + public IEnumerable Users { get; init; } } diff --git a/seed/csharp-model/pagination/src/SeedPagination/Users/UsernameContainer.cs b/seed/csharp-model/pagination/src/SeedPagination/Users/UsernameContainer.cs index 837fa6040eb..3068ecf7fd5 100644 --- a/seed/csharp-model/pagination/src/SeedPagination/Users/UsernameContainer.cs +++ b/seed/csharp-model/pagination/src/SeedPagination/Users/UsernameContainer.cs @@ -7,5 +7,5 @@ namespace SeedPagination; public class UsernameContainer { [JsonPropertyName("results")] - public List Results { get; init; } + public IEnumerable Results { get; init; } } diff --git a/seed/csharp-model/plain-text/src/SeedPlainText/Core/CollectionItemSerializer.cs b/seed/csharp-model/plain-text/src/SeedPlainText/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..bdf8a5d3176 --- /dev/null +++ b/seed/csharp-model/plain-text/src/SeedPlainText/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedPlainText; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-model/query-parameters/src/SeedQueryParameters/Core/CollectionItemSerializer.cs b/seed/csharp-model/query-parameters/src/SeedQueryParameters/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..af181865547 --- /dev/null +++ b/seed/csharp-model/query-parameters/src/SeedQueryParameters/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedQueryParameters; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-model/query-parameters/src/SeedQueryParameters/User/User.cs b/seed/csharp-model/query-parameters/src/SeedQueryParameters/User/User.cs index 89d780b1758..b69cdd17275 100644 --- a/seed/csharp-model/query-parameters/src/SeedQueryParameters/User/User.cs +++ b/seed/csharp-model/query-parameters/src/SeedQueryParameters/User/User.cs @@ -10,5 +10,5 @@ public class User public string Name { get; init; } [JsonPropertyName("tags")] - public List Tags { get; init; } + public IEnumerable Tags { get; init; } } diff --git a/seed/csharp-model/reserved-keywords/src/SeedNurseryApi/Core/CollectionItemSerializer.cs b/seed/csharp-model/reserved-keywords/src/SeedNurseryApi/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..6822acff5f9 --- /dev/null +++ b/seed/csharp-model/reserved-keywords/src/SeedNurseryApi/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedNurseryApi; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-model/response-property/src/SeedResponseProperty/Core/CollectionItemSerializer.cs b/seed/csharp-model/response-property/src/SeedResponseProperty/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..96e36eb6465 --- /dev/null +++ b/seed/csharp-model/response-property/src/SeedResponseProperty/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedResponseProperty; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-model/server-sent-events/src/SeedServerSentEvents/Core/CollectionItemSerializer.cs b/seed/csharp-model/server-sent-events/src/SeedServerSentEvents/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..7f0d4c20352 --- /dev/null +++ b/seed/csharp-model/server-sent-events/src/SeedServerSentEvents/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedServerSentEvents; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-model/single-url-environment-default/src/SeedSingleUrlEnvironmentDefault/Core/CollectionItemSerializer.cs b/seed/csharp-model/single-url-environment-default/src/SeedSingleUrlEnvironmentDefault/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..09dde63fa38 --- /dev/null +++ b/seed/csharp-model/single-url-environment-default/src/SeedSingleUrlEnvironmentDefault/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedSingleUrlEnvironmentDefault; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-model/single-url-environment-no-default/src/SeedSingleUrlEnvironmentNoDefault/Core/CollectionItemSerializer.cs b/seed/csharp-model/single-url-environment-no-default/src/SeedSingleUrlEnvironmentNoDefault/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..20bb0c76012 --- /dev/null +++ b/seed/csharp-model/single-url-environment-no-default/src/SeedSingleUrlEnvironmentNoDefault/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedSingleUrlEnvironmentNoDefault; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-model/streaming/src/SeedStreaming/Core/CollectionItemSerializer.cs b/seed/csharp-model/streaming/src/SeedStreaming/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..76ad9ed09e4 --- /dev/null +++ b/seed/csharp-model/streaming/src/SeedStreaming/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedStreaming; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-model/trace/src/SeedTrace/Commons/DebugMapValue.cs b/seed/csharp-model/trace/src/SeedTrace/Commons/DebugMapValue.cs index faf76f95d77..b8fc04a9e15 100644 --- a/seed/csharp-model/trace/src/SeedTrace/Commons/DebugMapValue.cs +++ b/seed/csharp-model/trace/src/SeedTrace/Commons/DebugMapValue.cs @@ -8,5 +8,5 @@ namespace SeedTrace; public class DebugMapValue { [JsonPropertyName("keyValuePairs")] - public List KeyValuePairs { get; init; } + public IEnumerable KeyValuePairs { get; init; } } diff --git a/seed/csharp-model/trace/src/SeedTrace/Commons/MapValue.cs b/seed/csharp-model/trace/src/SeedTrace/Commons/MapValue.cs index 232bf264188..dc3f6dfd10c 100644 --- a/seed/csharp-model/trace/src/SeedTrace/Commons/MapValue.cs +++ b/seed/csharp-model/trace/src/SeedTrace/Commons/MapValue.cs @@ -8,5 +8,5 @@ namespace SeedTrace; public class MapValue { [JsonPropertyName("keyValuePairs")] - public List KeyValuePairs { get; init; } + public IEnumerable KeyValuePairs { get; init; } } diff --git a/seed/csharp-model/trace/src/SeedTrace/Commons/TestCase.cs b/seed/csharp-model/trace/src/SeedTrace/Commons/TestCase.cs index 5f7b15e4e9e..bc9db263350 100644 --- a/seed/csharp-model/trace/src/SeedTrace/Commons/TestCase.cs +++ b/seed/csharp-model/trace/src/SeedTrace/Commons/TestCase.cs @@ -11,5 +11,5 @@ public class TestCase public string Id { get; init; } [JsonPropertyName("params")] - public List Params { get; init; } + public IEnumerable Params { get; init; } } diff --git a/seed/csharp-model/trace/src/SeedTrace/Core/CollectionItemSerializer.cs b/seed/csharp-model/trace/src/SeedTrace/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..68b213e0f1e --- /dev/null +++ b/seed/csharp-model/trace/src/SeedTrace/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedTrace; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-model/trace/src/SeedTrace/Playlist/Playlist.cs b/seed/csharp-model/trace/src/SeedTrace/Playlist/Playlist.cs index 4cc6371f074..726c983284e 100644 --- a/seed/csharp-model/trace/src/SeedTrace/Playlist/Playlist.cs +++ b/seed/csharp-model/trace/src/SeedTrace/Playlist/Playlist.cs @@ -16,5 +16,5 @@ public class Playlist public string Name { get; init; } [JsonPropertyName("problems")] - public List Problems { get; init; } + public IEnumerable Problems { get; init; } } diff --git a/seed/csharp-model/trace/src/SeedTrace/Playlist/PlaylistCreateRequest.cs b/seed/csharp-model/trace/src/SeedTrace/Playlist/PlaylistCreateRequest.cs index efb787fd285..62530ba031f 100644 --- a/seed/csharp-model/trace/src/SeedTrace/Playlist/PlaylistCreateRequest.cs +++ b/seed/csharp-model/trace/src/SeedTrace/Playlist/PlaylistCreateRequest.cs @@ -10,5 +10,5 @@ public class PlaylistCreateRequest public string Name { get; init; } [JsonPropertyName("problems")] - public List Problems { get; init; } + public IEnumerable Problems { get; init; } } diff --git a/seed/csharp-model/trace/src/SeedTrace/Playlist/UpdatePlaylistRequest.cs b/seed/csharp-model/trace/src/SeedTrace/Playlist/UpdatePlaylistRequest.cs index 7d1de490adc..f89e1bb15c0 100644 --- a/seed/csharp-model/trace/src/SeedTrace/Playlist/UpdatePlaylistRequest.cs +++ b/seed/csharp-model/trace/src/SeedTrace/Playlist/UpdatePlaylistRequest.cs @@ -13,5 +13,5 @@ public class UpdatePlaylistRequest /// The problems that make up the playlist. /// [JsonPropertyName("problems")] - public List Problems { get; init; } + public IEnumerable Problems { get; init; } } diff --git a/seed/csharp-model/trace/src/SeedTrace/Problem/CreateProblemRequest.cs b/seed/csharp-model/trace/src/SeedTrace/Problem/CreateProblemRequest.cs index 64f5fa42fe1..373a8497437 100644 --- a/seed/csharp-model/trace/src/SeedTrace/Problem/CreateProblemRequest.cs +++ b/seed/csharp-model/trace/src/SeedTrace/Problem/CreateProblemRequest.cs @@ -17,13 +17,13 @@ public class CreateProblemRequest public Dictionary Files { get; init; } [JsonPropertyName("inputParams")] - public List InputParams { get; init; } + public IEnumerable InputParams { get; init; } [JsonPropertyName("outputType")] public VariableType OutputType { get; init; } [JsonPropertyName("testcases")] - public List Testcases { get; init; } + public IEnumerable Testcases { get; init; } [JsonPropertyName("methodName")] public string MethodName { get; init; } diff --git a/seed/csharp-model/trace/src/SeedTrace/Problem/ProblemDescription.cs b/seed/csharp-model/trace/src/SeedTrace/Problem/ProblemDescription.cs index cf5dab71129..893aa8191b6 100644 --- a/seed/csharp-model/trace/src/SeedTrace/Problem/ProblemDescription.cs +++ b/seed/csharp-model/trace/src/SeedTrace/Problem/ProblemDescription.cs @@ -8,5 +8,5 @@ namespace SeedTrace; public class ProblemDescription { [JsonPropertyName("boards")] - public List Boards { get; init; } + public IEnumerable Boards { get; init; } } diff --git a/seed/csharp-model/trace/src/SeedTrace/Problem/ProblemFiles.cs b/seed/csharp-model/trace/src/SeedTrace/Problem/ProblemFiles.cs index ae2c565062b..ea32573099d 100644 --- a/seed/csharp-model/trace/src/SeedTrace/Problem/ProblemFiles.cs +++ b/seed/csharp-model/trace/src/SeedTrace/Problem/ProblemFiles.cs @@ -11,5 +11,5 @@ public class ProblemFiles public FileInfo SolutionFile { get; init; } [JsonPropertyName("readOnlyFiles")] - public List ReadOnlyFiles { get; init; } + public IEnumerable ReadOnlyFiles { get; init; } } diff --git a/seed/csharp-model/trace/src/SeedTrace/Problem/ProblemInfo.cs b/seed/csharp-model/trace/src/SeedTrace/Problem/ProblemInfo.cs index 778c72fe952..0b264a0a2b7 100644 --- a/seed/csharp-model/trace/src/SeedTrace/Problem/ProblemInfo.cs +++ b/seed/csharp-model/trace/src/SeedTrace/Problem/ProblemInfo.cs @@ -23,13 +23,13 @@ public class ProblemInfo public Dictionary Files { get; init; } [JsonPropertyName("inputParams")] - public List InputParams { get; init; } + public IEnumerable InputParams { get; init; } [JsonPropertyName("outputType")] public VariableType OutputType { get; init; } [JsonPropertyName("testcases")] - public List Testcases { get; init; } + public IEnumerable Testcases { get; init; } [JsonPropertyName("methodName")] public string MethodName { get; init; } diff --git a/seed/csharp-model/trace/src/SeedTrace/Submission/GetExecutionSessionStateResponse.cs b/seed/csharp-model/trace/src/SeedTrace/Submission/GetExecutionSessionStateResponse.cs index 1141b0c2e67..38b404ca227 100644 --- a/seed/csharp-model/trace/src/SeedTrace/Submission/GetExecutionSessionStateResponse.cs +++ b/seed/csharp-model/trace/src/SeedTrace/Submission/GetExecutionSessionStateResponse.cs @@ -14,5 +14,5 @@ public class GetExecutionSessionStateResponse public int? NumWarmingInstances { get; init; } [JsonPropertyName("warmingSessionIds")] - public List WarmingSessionIds { get; init; } + public IEnumerable WarmingSessionIds { get; init; } } diff --git a/seed/csharp-model/trace/src/SeedTrace/Submission/StackFrame.cs b/seed/csharp-model/trace/src/SeedTrace/Submission/StackFrame.cs index 58358e85d27..863ab77beb6 100644 --- a/seed/csharp-model/trace/src/SeedTrace/Submission/StackFrame.cs +++ b/seed/csharp-model/trace/src/SeedTrace/Submission/StackFrame.cs @@ -14,5 +14,5 @@ public class StackFrame public int LineNumber { get; init; } [JsonPropertyName("scopes")] - public List Scopes { get; init; } + public IEnumerable Scopes { get; init; } } diff --git a/seed/csharp-model/trace/src/SeedTrace/Submission/SubmitRequestV2.cs b/seed/csharp-model/trace/src/SeedTrace/Submission/SubmitRequestV2.cs index 6c2e45d830b..bcbaf54ad24 100644 --- a/seed/csharp-model/trace/src/SeedTrace/Submission/SubmitRequestV2.cs +++ b/seed/csharp-model/trace/src/SeedTrace/Submission/SubmitRequestV2.cs @@ -14,7 +14,7 @@ public class SubmitRequestV2 public Language Language { get; init; } [JsonPropertyName("submissionFiles")] - public List SubmissionFiles { get; init; } + public IEnumerable SubmissionFiles { get; init; } [JsonPropertyName("problemId")] public string ProblemId { get; init; } diff --git a/seed/csharp-model/trace/src/SeedTrace/Submission/TestSubmissionState.cs b/seed/csharp-model/trace/src/SeedTrace/Submission/TestSubmissionState.cs index 4881e236ccb..20a6adfc8b3 100644 --- a/seed/csharp-model/trace/src/SeedTrace/Submission/TestSubmissionState.cs +++ b/seed/csharp-model/trace/src/SeedTrace/Submission/TestSubmissionState.cs @@ -11,10 +11,10 @@ public class TestSubmissionState public string ProblemId { get; init; } [JsonPropertyName("defaultTestCases")] - public List DefaultTestCases { get; init; } + public IEnumerable DefaultTestCases { get; init; } [JsonPropertyName("customTestCases")] - public List CustomTestCases { get; init; } + public IEnumerable CustomTestCases { get; init; } [JsonPropertyName("status")] public TestSubmissionStatus Status { get; init; } diff --git a/seed/csharp-model/trace/src/SeedTrace/Submission/TestSubmissionStatusV2.cs b/seed/csharp-model/trace/src/SeedTrace/Submission/TestSubmissionStatusV2.cs index 47d27dffc44..6f3acbdd886 100644 --- a/seed/csharp-model/trace/src/SeedTrace/Submission/TestSubmissionStatusV2.cs +++ b/seed/csharp-model/trace/src/SeedTrace/Submission/TestSubmissionStatusV2.cs @@ -9,7 +9,7 @@ namespace SeedTrace; public class TestSubmissionStatusV2 { [JsonPropertyName("updates")] - public List Updates { get; init; } + public IEnumerable Updates { get; init; } [JsonPropertyName("problemId")] public string ProblemId { get; init; } diff --git a/seed/csharp-model/trace/src/SeedTrace/Submission/TraceResponsesPage.cs b/seed/csharp-model/trace/src/SeedTrace/Submission/TraceResponsesPage.cs index 76c2da3894c..b806e45ef75 100644 --- a/seed/csharp-model/trace/src/SeedTrace/Submission/TraceResponsesPage.cs +++ b/seed/csharp-model/trace/src/SeedTrace/Submission/TraceResponsesPage.cs @@ -15,5 +15,5 @@ public class TraceResponsesPage public int? Offset { get; init; } [JsonPropertyName("traceResponses")] - public List TraceResponses { get; init; } + public IEnumerable TraceResponses { get; init; } } diff --git a/seed/csharp-model/trace/src/SeedTrace/Submission/TraceResponsesPageV2.cs b/seed/csharp-model/trace/src/SeedTrace/Submission/TraceResponsesPageV2.cs index a6ce2877895..67078091cc3 100644 --- a/seed/csharp-model/trace/src/SeedTrace/Submission/TraceResponsesPageV2.cs +++ b/seed/csharp-model/trace/src/SeedTrace/Submission/TraceResponsesPageV2.cs @@ -15,5 +15,5 @@ public class TraceResponsesPageV2 public int? Offset { get; init; } [JsonPropertyName("traceResponses")] - public List TraceResponses { get; init; } + public IEnumerable TraceResponses { get; init; } } diff --git a/seed/csharp-model/trace/src/SeedTrace/Submission/WorkspaceFiles.cs b/seed/csharp-model/trace/src/SeedTrace/Submission/WorkspaceFiles.cs index 3c9a0f3c732..e8349edcda4 100644 --- a/seed/csharp-model/trace/src/SeedTrace/Submission/WorkspaceFiles.cs +++ b/seed/csharp-model/trace/src/SeedTrace/Submission/WorkspaceFiles.cs @@ -11,5 +11,5 @@ public class WorkspaceFiles public FileInfo MainFile { get; init; } [JsonPropertyName("readOnlyFiles")] - public List ReadOnlyFiles { get; init; } + public IEnumerable ReadOnlyFiles { get; init; } } diff --git a/seed/csharp-model/trace/src/SeedTrace/Submission/WorkspaceSubmissionStatusV2.cs b/seed/csharp-model/trace/src/SeedTrace/Submission/WorkspaceSubmissionStatusV2.cs index e14a38d94de..26f9b5e3b04 100644 --- a/seed/csharp-model/trace/src/SeedTrace/Submission/WorkspaceSubmissionStatusV2.cs +++ b/seed/csharp-model/trace/src/SeedTrace/Submission/WorkspaceSubmissionStatusV2.cs @@ -8,5 +8,5 @@ namespace SeedTrace; public class WorkspaceSubmissionStatusV2 { [JsonPropertyName("updates")] - public List Updates { get; init; } + public IEnumerable Updates { get; init; } } diff --git a/seed/csharp-model/trace/src/SeedTrace/Submission/WorkspaceSubmitRequest.cs b/seed/csharp-model/trace/src/SeedTrace/Submission/WorkspaceSubmitRequest.cs index ae58a9b6c44..fe4fe672231 100644 --- a/seed/csharp-model/trace/src/SeedTrace/Submission/WorkspaceSubmitRequest.cs +++ b/seed/csharp-model/trace/src/SeedTrace/Submission/WorkspaceSubmitRequest.cs @@ -14,7 +14,7 @@ public class WorkspaceSubmitRequest public Language Language { get; init; } [JsonPropertyName("submissionFiles")] - public List SubmissionFiles { get; init; } + public IEnumerable SubmissionFiles { get; init; } [JsonPropertyName("userId")] public string? UserId { get; init; } diff --git a/seed/csharp-model/trace/src/SeedTrace/V2/Problem/CreateProblemRequestV2.cs b/seed/csharp-model/trace/src/SeedTrace/V2/Problem/CreateProblemRequestV2.cs index cbec1f98782..5b2472ca139 100644 --- a/seed/csharp-model/trace/src/SeedTrace/V2/Problem/CreateProblemRequestV2.cs +++ b/seed/csharp-model/trace/src/SeedTrace/V2/Problem/CreateProblemRequestV2.cs @@ -18,10 +18,10 @@ public class CreateProblemRequestV2 public CustomFiles CustomFiles { get; init; } [JsonPropertyName("customTestCaseTemplates")] - public List CustomTestCaseTemplates { get; init; } + public IEnumerable CustomTestCaseTemplates { get; init; } [JsonPropertyName("testcases")] - public List Testcases { get; init; } + public IEnumerable Testcases { get; init; } [JsonPropertyName("supportedLanguages")] public HashSet SupportedLanguages { get; init; } diff --git a/seed/csharp-model/trace/src/SeedTrace/V2/Problem/DefaultProvidedFile.cs b/seed/csharp-model/trace/src/SeedTrace/V2/Problem/DefaultProvidedFile.cs index b6a1a22e8a7..d02efc608b1 100644 --- a/seed/csharp-model/trace/src/SeedTrace/V2/Problem/DefaultProvidedFile.cs +++ b/seed/csharp-model/trace/src/SeedTrace/V2/Problem/DefaultProvidedFile.cs @@ -12,5 +12,5 @@ public class DefaultProvidedFile public FileInfoV2 File { get; init; } [JsonPropertyName("relatedTypes")] - public List RelatedTypes { get; init; } + public IEnumerable RelatedTypes { get; init; } } diff --git a/seed/csharp-model/trace/src/SeedTrace/V2/Problem/Files.cs b/seed/csharp-model/trace/src/SeedTrace/V2/Problem/Files.cs index 986a24d2e8b..d07a0a83b90 100644 --- a/seed/csharp-model/trace/src/SeedTrace/V2/Problem/Files.cs +++ b/seed/csharp-model/trace/src/SeedTrace/V2/Problem/Files.cs @@ -8,5 +8,5 @@ namespace SeedTrace.V2; public class Files { [JsonPropertyName("files")] - public List Files_ { get; init; } + public IEnumerable Files_ { get; init; } } diff --git a/seed/csharp-model/trace/src/SeedTrace/V2/Problem/NonVoidFunctionSignature.cs b/seed/csharp-model/trace/src/SeedTrace/V2/Problem/NonVoidFunctionSignature.cs index 5d19c98285a..923791760a5 100644 --- a/seed/csharp-model/trace/src/SeedTrace/V2/Problem/NonVoidFunctionSignature.cs +++ b/seed/csharp-model/trace/src/SeedTrace/V2/Problem/NonVoidFunctionSignature.cs @@ -9,7 +9,7 @@ namespace SeedTrace.V2; public class NonVoidFunctionSignature { [JsonPropertyName("parameters")] - public List Parameters { get; init; } + public IEnumerable Parameters { get; init; } [JsonPropertyName("returnType")] public VariableType ReturnType { get; init; } diff --git a/seed/csharp-model/trace/src/SeedTrace/V2/Problem/ProblemInfoV2.cs b/seed/csharp-model/trace/src/SeedTrace/V2/Problem/ProblemInfoV2.cs index 4c0cc644866..7a5577bd1f5 100644 --- a/seed/csharp-model/trace/src/SeedTrace/V2/Problem/ProblemInfoV2.cs +++ b/seed/csharp-model/trace/src/SeedTrace/V2/Problem/ProblemInfoV2.cs @@ -30,10 +30,10 @@ public class ProblemInfoV2 public GeneratedFiles GeneratedFiles { get; init; } [JsonPropertyName("customTestCaseTemplates")] - public List CustomTestCaseTemplates { get; init; } + public IEnumerable CustomTestCaseTemplates { get; init; } [JsonPropertyName("testcases")] - public List Testcases { get; init; } + public IEnumerable Testcases { get; init; } [JsonPropertyName("isPublic")] public bool IsPublic { get; init; } diff --git a/seed/csharp-model/trace/src/SeedTrace/V2/Problem/TestCaseImplementationDescription.cs b/seed/csharp-model/trace/src/SeedTrace/V2/Problem/TestCaseImplementationDescription.cs index b127c5be335..fb7ca3771f0 100644 --- a/seed/csharp-model/trace/src/SeedTrace/V2/Problem/TestCaseImplementationDescription.cs +++ b/seed/csharp-model/trace/src/SeedTrace/V2/Problem/TestCaseImplementationDescription.cs @@ -8,5 +8,5 @@ namespace SeedTrace.V2; public class TestCaseImplementationDescription { [JsonPropertyName("boards")] - public List Boards { get; init; } + public IEnumerable Boards { get; init; } } diff --git a/seed/csharp-model/trace/src/SeedTrace/V2/Problem/VoidFunctionDefinition.cs b/seed/csharp-model/trace/src/SeedTrace/V2/Problem/VoidFunctionDefinition.cs index 29c7b3f99fd..06c18cd0645 100644 --- a/seed/csharp-model/trace/src/SeedTrace/V2/Problem/VoidFunctionDefinition.cs +++ b/seed/csharp-model/trace/src/SeedTrace/V2/Problem/VoidFunctionDefinition.cs @@ -8,7 +8,7 @@ namespace SeedTrace.V2; public class VoidFunctionDefinition { [JsonPropertyName("parameters")] - public List Parameters { get; init; } + public IEnumerable Parameters { get; init; } [JsonPropertyName("code")] public FunctionImplementationForMultipleLanguages Code { get; init; } diff --git a/seed/csharp-model/trace/src/SeedTrace/V2/Problem/VoidFunctionDefinitionThatTakesActualResult.cs b/seed/csharp-model/trace/src/SeedTrace/V2/Problem/VoidFunctionDefinitionThatTakesActualResult.cs index 9f52c077452..5c3a9cf76fb 100644 --- a/seed/csharp-model/trace/src/SeedTrace/V2/Problem/VoidFunctionDefinitionThatTakesActualResult.cs +++ b/seed/csharp-model/trace/src/SeedTrace/V2/Problem/VoidFunctionDefinitionThatTakesActualResult.cs @@ -8,7 +8,7 @@ namespace SeedTrace.V2; public class VoidFunctionDefinitionThatTakesActualResult { [JsonPropertyName("additionalParameters")] - public List AdditionalParameters { get; init; } + public IEnumerable AdditionalParameters { get; init; } [JsonPropertyName("code")] public FunctionImplementationForMultipleLanguages Code { get; init; } diff --git a/seed/csharp-model/trace/src/SeedTrace/V2/Problem/VoidFunctionSignature.cs b/seed/csharp-model/trace/src/SeedTrace/V2/Problem/VoidFunctionSignature.cs index aac2f97652f..b4e42777fd1 100644 --- a/seed/csharp-model/trace/src/SeedTrace/V2/Problem/VoidFunctionSignature.cs +++ b/seed/csharp-model/trace/src/SeedTrace/V2/Problem/VoidFunctionSignature.cs @@ -8,5 +8,5 @@ namespace SeedTrace.V2; public class VoidFunctionSignature { [JsonPropertyName("parameters")] - public List Parameters { get; init; } + public IEnumerable Parameters { get; init; } } diff --git a/seed/csharp-model/trace/src/SeedTrace/V2/Problem/VoidFunctionSignatureThatTakesActualResult.cs b/seed/csharp-model/trace/src/SeedTrace/V2/Problem/VoidFunctionSignatureThatTakesActualResult.cs index 19462b0fe52..23afc7b6188 100644 --- a/seed/csharp-model/trace/src/SeedTrace/V2/Problem/VoidFunctionSignatureThatTakesActualResult.cs +++ b/seed/csharp-model/trace/src/SeedTrace/V2/Problem/VoidFunctionSignatureThatTakesActualResult.cs @@ -9,7 +9,7 @@ namespace SeedTrace.V2; public class VoidFunctionSignatureThatTakesActualResult { [JsonPropertyName("parameters")] - public List Parameters { get; init; } + public IEnumerable Parameters { get; init; } [JsonPropertyName("actualResultType")] public VariableType ActualResultType { get; init; } diff --git a/seed/csharp-model/trace/src/SeedTrace/V2/V3/Problem/CreateProblemRequestV2.cs b/seed/csharp-model/trace/src/SeedTrace/V2/V3/Problem/CreateProblemRequestV2.cs index 39906264b61..9145e590055 100644 --- a/seed/csharp-model/trace/src/SeedTrace/V2/V3/Problem/CreateProblemRequestV2.cs +++ b/seed/csharp-model/trace/src/SeedTrace/V2/V3/Problem/CreateProblemRequestV2.cs @@ -18,10 +18,10 @@ public class CreateProblemRequestV2 public CustomFiles CustomFiles { get; init; } [JsonPropertyName("customTestCaseTemplates")] - public List CustomTestCaseTemplates { get; init; } + public IEnumerable CustomTestCaseTemplates { get; init; } [JsonPropertyName("testcases")] - public List Testcases { get; init; } + public IEnumerable Testcases { get; init; } [JsonPropertyName("supportedLanguages")] public HashSet SupportedLanguages { get; init; } diff --git a/seed/csharp-model/trace/src/SeedTrace/V2/V3/Problem/DefaultProvidedFile.cs b/seed/csharp-model/trace/src/SeedTrace/V2/V3/Problem/DefaultProvidedFile.cs index 38dda0ad1d2..209adbc3596 100644 --- a/seed/csharp-model/trace/src/SeedTrace/V2/V3/Problem/DefaultProvidedFile.cs +++ b/seed/csharp-model/trace/src/SeedTrace/V2/V3/Problem/DefaultProvidedFile.cs @@ -12,5 +12,5 @@ public class DefaultProvidedFile public FileInfoV2 File { get; init; } [JsonPropertyName("relatedTypes")] - public List RelatedTypes { get; init; } + public IEnumerable RelatedTypes { get; init; } } diff --git a/seed/csharp-model/trace/src/SeedTrace/V2/V3/Problem/Files.cs b/seed/csharp-model/trace/src/SeedTrace/V2/V3/Problem/Files.cs index d2358441ed3..e259d8b6ba1 100644 --- a/seed/csharp-model/trace/src/SeedTrace/V2/V3/Problem/Files.cs +++ b/seed/csharp-model/trace/src/SeedTrace/V2/V3/Problem/Files.cs @@ -8,5 +8,5 @@ namespace SeedTrace.V2.V3; public class Files { [JsonPropertyName("files")] - public List Files_ { get; init; } + public IEnumerable Files_ { get; init; } } diff --git a/seed/csharp-model/trace/src/SeedTrace/V2/V3/Problem/NonVoidFunctionSignature.cs b/seed/csharp-model/trace/src/SeedTrace/V2/V3/Problem/NonVoidFunctionSignature.cs index 560d564cf43..fbfb0de7007 100644 --- a/seed/csharp-model/trace/src/SeedTrace/V2/V3/Problem/NonVoidFunctionSignature.cs +++ b/seed/csharp-model/trace/src/SeedTrace/V2/V3/Problem/NonVoidFunctionSignature.cs @@ -9,7 +9,7 @@ namespace SeedTrace.V2.V3; public class NonVoidFunctionSignature { [JsonPropertyName("parameters")] - public List Parameters { get; init; } + public IEnumerable Parameters { get; init; } [JsonPropertyName("returnType")] public VariableType ReturnType { get; init; } diff --git a/seed/csharp-model/trace/src/SeedTrace/V2/V3/Problem/ProblemInfoV2.cs b/seed/csharp-model/trace/src/SeedTrace/V2/V3/Problem/ProblemInfoV2.cs index a7b8de187fc..a02e026e758 100644 --- a/seed/csharp-model/trace/src/SeedTrace/V2/V3/Problem/ProblemInfoV2.cs +++ b/seed/csharp-model/trace/src/SeedTrace/V2/V3/Problem/ProblemInfoV2.cs @@ -30,10 +30,10 @@ public class ProblemInfoV2 public GeneratedFiles GeneratedFiles { get; init; } [JsonPropertyName("customTestCaseTemplates")] - public List CustomTestCaseTemplates { get; init; } + public IEnumerable CustomTestCaseTemplates { get; init; } [JsonPropertyName("testcases")] - public List Testcases { get; init; } + public IEnumerable Testcases { get; init; } [JsonPropertyName("isPublic")] public bool IsPublic { get; init; } diff --git a/seed/csharp-model/trace/src/SeedTrace/V2/V3/Problem/TestCaseImplementationDescription.cs b/seed/csharp-model/trace/src/SeedTrace/V2/V3/Problem/TestCaseImplementationDescription.cs index 1c2ed877ea0..3cf482f48e0 100644 --- a/seed/csharp-model/trace/src/SeedTrace/V2/V3/Problem/TestCaseImplementationDescription.cs +++ b/seed/csharp-model/trace/src/SeedTrace/V2/V3/Problem/TestCaseImplementationDescription.cs @@ -8,5 +8,5 @@ namespace SeedTrace.V2.V3; public class TestCaseImplementationDescription { [JsonPropertyName("boards")] - public List Boards { get; init; } + public IEnumerable Boards { get; init; } } diff --git a/seed/csharp-model/trace/src/SeedTrace/V2/V3/Problem/VoidFunctionDefinition.cs b/seed/csharp-model/trace/src/SeedTrace/V2/V3/Problem/VoidFunctionDefinition.cs index 869a8addd55..c570b2a78bf 100644 --- a/seed/csharp-model/trace/src/SeedTrace/V2/V3/Problem/VoidFunctionDefinition.cs +++ b/seed/csharp-model/trace/src/SeedTrace/V2/V3/Problem/VoidFunctionDefinition.cs @@ -8,7 +8,7 @@ namespace SeedTrace.V2.V3; public class VoidFunctionDefinition { [JsonPropertyName("parameters")] - public List Parameters { get; init; } + public IEnumerable Parameters { get; init; } [JsonPropertyName("code")] public FunctionImplementationForMultipleLanguages Code { get; init; } diff --git a/seed/csharp-model/trace/src/SeedTrace/V2/V3/Problem/VoidFunctionDefinitionThatTakesActualResult.cs b/seed/csharp-model/trace/src/SeedTrace/V2/V3/Problem/VoidFunctionDefinitionThatTakesActualResult.cs index dd0c0430617..145cdc2df2d 100644 --- a/seed/csharp-model/trace/src/SeedTrace/V2/V3/Problem/VoidFunctionDefinitionThatTakesActualResult.cs +++ b/seed/csharp-model/trace/src/SeedTrace/V2/V3/Problem/VoidFunctionDefinitionThatTakesActualResult.cs @@ -8,7 +8,7 @@ namespace SeedTrace.V2.V3; public class VoidFunctionDefinitionThatTakesActualResult { [JsonPropertyName("additionalParameters")] - public List AdditionalParameters { get; init; } + public IEnumerable AdditionalParameters { get; init; } [JsonPropertyName("code")] public FunctionImplementationForMultipleLanguages Code { get; init; } diff --git a/seed/csharp-model/trace/src/SeedTrace/V2/V3/Problem/VoidFunctionSignature.cs b/seed/csharp-model/trace/src/SeedTrace/V2/V3/Problem/VoidFunctionSignature.cs index dd8c8a0d5a9..c03ba728de7 100644 --- a/seed/csharp-model/trace/src/SeedTrace/V2/V3/Problem/VoidFunctionSignature.cs +++ b/seed/csharp-model/trace/src/SeedTrace/V2/V3/Problem/VoidFunctionSignature.cs @@ -8,5 +8,5 @@ namespace SeedTrace.V2.V3; public class VoidFunctionSignature { [JsonPropertyName("parameters")] - public List Parameters { get; init; } + public IEnumerable Parameters { get; init; } } diff --git a/seed/csharp-model/trace/src/SeedTrace/V2/V3/Problem/VoidFunctionSignatureThatTakesActualResult.cs b/seed/csharp-model/trace/src/SeedTrace/V2/V3/Problem/VoidFunctionSignatureThatTakesActualResult.cs index 73c2ef67861..594085a9a11 100644 --- a/seed/csharp-model/trace/src/SeedTrace/V2/V3/Problem/VoidFunctionSignatureThatTakesActualResult.cs +++ b/seed/csharp-model/trace/src/SeedTrace/V2/V3/Problem/VoidFunctionSignatureThatTakesActualResult.cs @@ -9,7 +9,7 @@ namespace SeedTrace.V2.V3; public class VoidFunctionSignatureThatTakesActualResult { [JsonPropertyName("parameters")] - public List Parameters { get; init; } + public IEnumerable Parameters { get; init; } [JsonPropertyName("actualResultType")] public VariableType ActualResultType { get; init; } diff --git a/seed/csharp-model/undiscriminated-unions/src/SeedUndiscriminatedUnions/Core/CollectionItemSerializer.cs b/seed/csharp-model/undiscriminated-unions/src/SeedUndiscriminatedUnions/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..ef3378fe044 --- /dev/null +++ b/seed/csharp-model/undiscriminated-unions/src/SeedUndiscriminatedUnions/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedUndiscriminatedUnions; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-model/unions/src/SeedUnions/Core/CollectionItemSerializer.cs b/seed/csharp-model/unions/src/SeedUnions/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..b329843d776 --- /dev/null +++ b/seed/csharp-model/unions/src/SeedUnions/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedUnions; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-model/unknown/src/SeedUnknownAsAny/Core/CollectionItemSerializer.cs b/seed/csharp-model/unknown/src/SeedUnknownAsAny/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..df1f27aa4bf --- /dev/null +++ b/seed/csharp-model/unknown/src/SeedUnknownAsAny/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedUnknownAsAny; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-model/validation/src/SeedValidation/Core/CollectionItemSerializer.cs b/seed/csharp-model/validation/src/SeedValidation/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..643c3d3387e --- /dev/null +++ b/seed/csharp-model/validation/src/SeedValidation/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedValidation; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-model/variables/src/SeedVariables/Core/CollectionItemSerializer.cs b/seed/csharp-model/variables/src/SeedVariables/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..2e2b98b80cc --- /dev/null +++ b/seed/csharp-model/variables/src/SeedVariables/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedVariables; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-model/websocket/src/SeedWebsocket/Core/CollectionItemSerializer.cs b/seed/csharp-model/websocket/src/SeedWebsocket/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..3259f23e4eb --- /dev/null +++ b/seed/csharp-model/websocket/src/SeedWebsocket/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedWebsocket; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-sdk/alias/src/SeedAlias/Core/CollectionItemSerializer.cs b/seed/csharp-sdk/alias/src/SeedAlias/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..be3d0833d35 --- /dev/null +++ b/seed/csharp-sdk/alias/src/SeedAlias/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedAlias; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-sdk/api-wide-base-path/src/SeedApiWideBasePath/Core/CollectionItemSerializer.cs b/seed/csharp-sdk/api-wide-base-path/src/SeedApiWideBasePath/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..abec34e7745 --- /dev/null +++ b/seed/csharp-sdk/api-wide-base-path/src/SeedApiWideBasePath/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedApiWideBasePath; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-sdk/audiences/src/SeedAudiences/Core/CollectionItemSerializer.cs b/seed/csharp-sdk/audiences/src/SeedAudiences/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..2493e39bacc --- /dev/null +++ b/seed/csharp-sdk/audiences/src/SeedAudiences/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedAudiences; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-sdk/auth-environment-variables/src/SeedAuthEnvironmentVariables/Core/CollectionItemSerializer.cs b/seed/csharp-sdk/auth-environment-variables/src/SeedAuthEnvironmentVariables/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..d7827223005 --- /dev/null +++ b/seed/csharp-sdk/auth-environment-variables/src/SeedAuthEnvironmentVariables/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedAuthEnvironmentVariables; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-sdk/basic-auth-environment-variables/src/SeedBasicAuthEnvironmentVariables/Core/CollectionItemSerializer.cs b/seed/csharp-sdk/basic-auth-environment-variables/src/SeedBasicAuthEnvironmentVariables/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..456869554aa --- /dev/null +++ b/seed/csharp-sdk/basic-auth-environment-variables/src/SeedBasicAuthEnvironmentVariables/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedBasicAuthEnvironmentVariables; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-sdk/basic-auth/src/SeedBasicAuth/Core/CollectionItemSerializer.cs b/seed/csharp-sdk/basic-auth/src/SeedBasicAuth/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..1867a98c6bb --- /dev/null +++ b/seed/csharp-sdk/basic-auth/src/SeedBasicAuth/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedBasicAuth; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-sdk/bearer-token-environment-variable/src/SeedBearerTokenEnvironmentVariable/Core/CollectionItemSerializer.cs b/seed/csharp-sdk/bearer-token-environment-variable/src/SeedBearerTokenEnvironmentVariable/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..234d0ef14a2 --- /dev/null +++ b/seed/csharp-sdk/bearer-token-environment-variable/src/SeedBearerTokenEnvironmentVariable/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedBearerTokenEnvironmentVariable; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-sdk/bytes/src/SeedBytes/Core/CollectionItemSerializer.cs b/seed/csharp-sdk/bytes/src/SeedBytes/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..ad8473f0730 --- /dev/null +++ b/seed/csharp-sdk/bytes/src/SeedBytes/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedBytes; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-sdk/circular-references-advanced/src/SeedApi/Core/CollectionItemSerializer.cs b/seed/csharp-sdk/circular-references-advanced/src/SeedApi/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..10121ac93ae --- /dev/null +++ b/seed/csharp-sdk/circular-references-advanced/src/SeedApi/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedApi; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-sdk/circular-references/src/SeedApi/Core/CollectionItemSerializer.cs b/seed/csharp-sdk/circular-references/src/SeedApi/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..10121ac93ae --- /dev/null +++ b/seed/csharp-sdk/circular-references/src/SeedApi/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedApi; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-sdk/code-samples/src/SeedCodeSamples/Core/CollectionItemSerializer.cs b/seed/csharp-sdk/code-samples/src/SeedCodeSamples/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..c36bb49e4e4 --- /dev/null +++ b/seed/csharp-sdk/code-samples/src/SeedCodeSamples/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedCodeSamples; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-sdk/custom-auth/src/SeedCustomAuth/Core/CollectionItemSerializer.cs b/seed/csharp-sdk/custom-auth/src/SeedCustomAuth/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..23803eb3013 --- /dev/null +++ b/seed/csharp-sdk/custom-auth/src/SeedCustomAuth/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedCustomAuth; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-sdk/enum/src/SeedEnum/Core/CollectionItemSerializer.cs b/seed/csharp-sdk/enum/src/SeedEnum/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..3c618883a3c --- /dev/null +++ b/seed/csharp-sdk/enum/src/SeedEnum/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedEnum; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-sdk/error-property/src/SeedErrorProperty/Core/CollectionItemSerializer.cs b/seed/csharp-sdk/error-property/src/SeedErrorProperty/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..4b0ecaaacdc --- /dev/null +++ b/seed/csharp-sdk/error-property/src/SeedErrorProperty/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedErrorProperty; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-sdk/examples/src/SeedExamples/Core/CollectionItemSerializer.cs b/seed/csharp-sdk/examples/src/SeedExamples/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..d4f303e049c --- /dev/null +++ b/seed/csharp-sdk/examples/src/SeedExamples/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedExamples; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-sdk/examples/src/SeedExamples/Types/Types/Directory.cs b/seed/csharp-sdk/examples/src/SeedExamples/Types/Types/Directory.cs index 005e35889ec..d1151baa44c 100644 --- a/seed/csharp-sdk/examples/src/SeedExamples/Types/Types/Directory.cs +++ b/seed/csharp-sdk/examples/src/SeedExamples/Types/Types/Directory.cs @@ -11,8 +11,8 @@ public class Directory public string Name { get; init; } [JsonPropertyName("files")] - public List? Files { get; init; } + public IEnumerable? Files { get; init; } [JsonPropertyName("directories")] - public List? Directories { get; init; } + public IEnumerable? Directories { get; init; } } diff --git a/seed/csharp-sdk/examples/src/SeedExamples/Types/Types/ExtendedMovie.cs b/seed/csharp-sdk/examples/src/SeedExamples/Types/Types/ExtendedMovie.cs index 88922bd0aa9..868b65315b7 100644 --- a/seed/csharp-sdk/examples/src/SeedExamples/Types/Types/ExtendedMovie.cs +++ b/seed/csharp-sdk/examples/src/SeedExamples/Types/Types/ExtendedMovie.cs @@ -7,7 +7,7 @@ namespace SeedExamples; public class ExtendedMovie { [JsonPropertyName("cast")] - public List Cast { get; init; } + public IEnumerable Cast { get; init; } [JsonPropertyName("id")] public string Id { get; init; } diff --git a/seed/csharp-sdk/examples/src/SeedExamples/Types/Types/Node.cs b/seed/csharp-sdk/examples/src/SeedExamples/Types/Types/Node.cs index b413f086f90..c5f79feba8d 100644 --- a/seed/csharp-sdk/examples/src/SeedExamples/Types/Types/Node.cs +++ b/seed/csharp-sdk/examples/src/SeedExamples/Types/Types/Node.cs @@ -11,8 +11,8 @@ public class Node public string Name { get; init; } [JsonPropertyName("nodes")] - public List? Nodes { get; init; } + public IEnumerable? Nodes { get; init; } [JsonPropertyName("trees")] - public List? Trees { get; init; } + public IEnumerable? Trees { get; init; } } diff --git a/seed/csharp-sdk/examples/src/SeedExamples/Types/Types/Response.cs b/seed/csharp-sdk/examples/src/SeedExamples/Types/Types/Response.cs index 1a19970c48f..0ad26d87ed4 100644 --- a/seed/csharp-sdk/examples/src/SeedExamples/Types/Types/Response.cs +++ b/seed/csharp-sdk/examples/src/SeedExamples/Types/Types/Response.cs @@ -11,5 +11,5 @@ public class Response public object Response_ { get; init; } [JsonPropertyName("identifiers")] - public List Identifiers { get; init; } + public IEnumerable Identifiers { get; init; } } diff --git a/seed/csharp-sdk/examples/src/SeedExamples/Types/Types/Tree.cs b/seed/csharp-sdk/examples/src/SeedExamples/Types/Types/Tree.cs index 9d5ce810980..fdc78f4af6e 100644 --- a/seed/csharp-sdk/examples/src/SeedExamples/Types/Types/Tree.cs +++ b/seed/csharp-sdk/examples/src/SeedExamples/Types/Types/Tree.cs @@ -8,5 +8,5 @@ namespace SeedExamples; public class Tree { [JsonPropertyName("nodes")] - public List? Nodes { get; init; } + public IEnumerable? Nodes { get; init; } } diff --git a/seed/csharp-sdk/exhaustive/src/SeedExhaustive/Core/CollectionItemSerializer.cs b/seed/csharp-sdk/exhaustive/src/SeedExhaustive/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..448f56cec35 --- /dev/null +++ b/seed/csharp-sdk/exhaustive/src/SeedExhaustive/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedExhaustive; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-sdk/exhaustive/src/SeedExhaustive/Endpoints/Container/ContainerClient.cs b/seed/csharp-sdk/exhaustive/src/SeedExhaustive/Endpoints/Container/ContainerClient.cs index c7071326f3c..028c1b2e07f 100644 --- a/seed/csharp-sdk/exhaustive/src/SeedExhaustive/Endpoints/Container/ContainerClient.cs +++ b/seed/csharp-sdk/exhaustive/src/SeedExhaustive/Endpoints/Container/ContainerClient.cs @@ -15,7 +15,9 @@ public ContainerClient(RawClient client) _client = client; } - public async Task> GetAndReturnListOfPrimitivesAsync(List request) + public async Task> GetAndReturnListOfPrimitivesAsync( + IEnumerable request + ) { var response = await _client.MakeRequestAsync( new RawClient.ApiRequest @@ -28,13 +30,13 @@ public async Task> GetAndReturnListOfPrimitivesAsync(List r string responseBody = await response.Raw.Content.ReadAsStringAsync(); if (response.StatusCode >= 200 && response.StatusCode < 400) { - return JsonSerializer.Deserialize>(responseBody); + return JsonSerializer.Deserialize>(responseBody); } throw new Exception(responseBody); } - public async Task> GetAndReturnListOfObjectsAsync( - List request + public async Task> GetAndReturnListOfObjectsAsync( + IEnumerable request ) { var response = await _client.MakeRequestAsync( @@ -48,7 +50,7 @@ List request string responseBody = await response.Raw.Content.ReadAsStringAsync(); if (response.StatusCode >= 200 && response.StatusCode < 400) { - return JsonSerializer.Deserialize>(responseBody); + return JsonSerializer.Deserialize>(responseBody); } throw new Exception(responseBody); } diff --git a/seed/csharp-sdk/exhaustive/src/SeedExhaustive/Endpoints/Object/ObjectClient.cs b/seed/csharp-sdk/exhaustive/src/SeedExhaustive/Endpoints/Object/ObjectClient.cs index 40caf4ac072..491844a6d24 100644 --- a/seed/csharp-sdk/exhaustive/src/SeedExhaustive/Endpoints/Object/ObjectClient.cs +++ b/seed/csharp-sdk/exhaustive/src/SeedExhaustive/Endpoints/Object/ObjectClient.cs @@ -63,7 +63,7 @@ public async Task GetAndReturnNestedWithRequiredF throw new Exception(responseBody); } - public async Task GetAndReturnNestedWithRequiredFieldAsListAsync(List request) { + public async Task GetAndReturnNestedWithRequiredFieldAsListAsync(IEnumerable request) { var response = await _client.MakeRequestAsync(new RawClient.ApiRequest{ Method = HttpMethod.Post, Path = "/get-and-return-nested-with-required-field-list", Body = request}); string responseBody = await response.Raw.Content.ReadAsStringAsync(); diff --git a/seed/csharp-sdk/exhaustive/src/SeedExhaustive/Types/Object/Types/ObjectWithOptionalField.cs b/seed/csharp-sdk/exhaustive/src/SeedExhaustive/Types/Object/Types/ObjectWithOptionalField.cs index d5ce19c9090..552ceefb341 100644 --- a/seed/csharp-sdk/exhaustive/src/SeedExhaustive/Types/Object/Types/ObjectWithOptionalField.cs +++ b/seed/csharp-sdk/exhaustive/src/SeedExhaustive/Types/Object/Types/ObjectWithOptionalField.cs @@ -34,7 +34,7 @@ public class ObjectWithOptionalField public string? Base64 { get; init; } [JsonPropertyName("list")] - public List? List { get; init; } + public IEnumerable? List { get; init; } [JsonPropertyName("set")] public HashSet? Set { get; init; } diff --git a/seed/csharp-sdk/extends/src/SeedExtends/Core/CollectionItemSerializer.cs b/seed/csharp-sdk/extends/src/SeedExtends/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..2e3dbdb9646 --- /dev/null +++ b/seed/csharp-sdk/extends/src/SeedExtends/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedExtends; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-sdk/extra-properties/src/SeedExtraProperties/Core/CollectionItemSerializer.cs b/seed/csharp-sdk/extra-properties/src/SeedExtraProperties/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..6810a82ffda --- /dev/null +++ b/seed/csharp-sdk/extra-properties/src/SeedExtraProperties/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedExtraProperties; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-sdk/file-download/src/SeedFileDownload/Core/CollectionItemSerializer.cs b/seed/csharp-sdk/file-download/src/SeedFileDownload/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..0979d57cd8f --- /dev/null +++ b/seed/csharp-sdk/file-download/src/SeedFileDownload/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedFileDownload; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-sdk/file-upload/src/SeedFileUpload/Core/CollectionItemSerializer.cs b/seed/csharp-sdk/file-upload/src/SeedFileUpload/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..4b4596783d6 --- /dev/null +++ b/seed/csharp-sdk/file-upload/src/SeedFileUpload/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedFileUpload; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-sdk/folders/src/SeedApi/Core/CollectionItemSerializer.cs b/seed/csharp-sdk/folders/src/SeedApi/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..10121ac93ae --- /dev/null +++ b/seed/csharp-sdk/folders/src/SeedApi/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedApi; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-sdk/idempotency-headers/src/SeedIdempotencyHeaders/Core/CollectionItemSerializer.cs b/seed/csharp-sdk/idempotency-headers/src/SeedIdempotencyHeaders/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..7a87593fb5c --- /dev/null +++ b/seed/csharp-sdk/idempotency-headers/src/SeedIdempotencyHeaders/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedIdempotencyHeaders; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-sdk/imdb/src/SeedApi/Core/CollectionItemSerializer.cs b/seed/csharp-sdk/imdb/src/SeedApi/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..10121ac93ae --- /dev/null +++ b/seed/csharp-sdk/imdb/src/SeedApi/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedApi; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-sdk/literal/src/SeedLiteral/Core/CollectionItemSerializer.cs b/seed/csharp-sdk/literal/src/SeedLiteral/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..a922b77b7e8 --- /dev/null +++ b/seed/csharp-sdk/literal/src/SeedLiteral/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedLiteral; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-sdk/mixed-case/src/SeedMixedCase/Core/CollectionItemSerializer.cs b/seed/csharp-sdk/mixed-case/src/SeedMixedCase/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..16b397e85e1 --- /dev/null +++ b/seed/csharp-sdk/mixed-case/src/SeedMixedCase/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedMixedCase; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-sdk/mixed-case/src/SeedMixedCase/Service/ServiceClient.cs b/seed/csharp-sdk/mixed-case/src/SeedMixedCase/Service/ServiceClient.cs index f58ca1ac4ca..6cac3e6f961 100644 --- a/seed/csharp-sdk/mixed-case/src/SeedMixedCase/Service/ServiceClient.cs +++ b/seed/csharp-sdk/mixed-case/src/SeedMixedCase/Service/ServiceClient.cs @@ -27,7 +27,7 @@ public async Task GetResourceAsync(string resourceId) throw new Exception(responseBody); } - public async Task> ListResourcesAsync(ListResourcesRequest request) + public async Task> ListResourcesAsync(ListResourcesRequest request) { var _query = new Dictionary() { @@ -45,7 +45,7 @@ public async Task> ListResourcesAsync(ListResourcesRequest reques string responseBody = await response.Raw.Content.ReadAsStringAsync(); if (response.StatusCode >= 200 && response.StatusCode < 400) { - return JsonSerializer.Deserialize>(responseBody); + return JsonSerializer.Deserialize>(responseBody); } throw new Exception(responseBody); } diff --git a/seed/csharp-sdk/mixed-case/src/SeedMixedCase/Service/Types/User.cs b/seed/csharp-sdk/mixed-case/src/SeedMixedCase/Service/Types/User.cs index f1d52c7ec9c..04a0194614d 100644 --- a/seed/csharp-sdk/mixed-case/src/SeedMixedCase/Service/Types/User.cs +++ b/seed/csharp-sdk/mixed-case/src/SeedMixedCase/Service/Types/User.cs @@ -10,7 +10,7 @@ public class User public string UserName { get; init; } [JsonPropertyName("metadata_tags")] - public List MetadataTags { get; init; } + public IEnumerable MetadataTags { get; init; } [JsonPropertyName("EXTRA_PROPERTIES")] public Dictionary ExtraProperties { get; init; } diff --git a/seed/csharp-sdk/multi-line-docs/src/SeedMultiLineDocs/Core/CollectionItemSerializer.cs b/seed/csharp-sdk/multi-line-docs/src/SeedMultiLineDocs/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..4d3191b39ca --- /dev/null +++ b/seed/csharp-sdk/multi-line-docs/src/SeedMultiLineDocs/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedMultiLineDocs; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-sdk/multi-url-environment/src/SeedMultiUrlEnvironment/Core/CollectionItemSerializer.cs b/seed/csharp-sdk/multi-url-environment/src/SeedMultiUrlEnvironment/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..dfd8eff2120 --- /dev/null +++ b/seed/csharp-sdk/multi-url-environment/src/SeedMultiUrlEnvironment/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedMultiUrlEnvironment; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-sdk/no-environment/src/SeedNoEnvironment/Core/CollectionItemSerializer.cs b/seed/csharp-sdk/no-environment/src/SeedNoEnvironment/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..2a7edef8c7a --- /dev/null +++ b/seed/csharp-sdk/no-environment/src/SeedNoEnvironment/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedNoEnvironment; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-sdk/oauth-client-credentials-default/src/SeedOauthClientCredentialsDefault/Core/CollectionItemSerializer.cs b/seed/csharp-sdk/oauth-client-credentials-default/src/SeedOauthClientCredentialsDefault/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..e24e60bed91 --- /dev/null +++ b/seed/csharp-sdk/oauth-client-credentials-default/src/SeedOauthClientCredentialsDefault/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedOauthClientCredentialsDefault; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-sdk/oauth-client-credentials-environment-variables/src/SeedOauthClientCredentialsEnvironmentVariables/Core/CollectionItemSerializer.cs b/seed/csharp-sdk/oauth-client-credentials-environment-variables/src/SeedOauthClientCredentialsEnvironmentVariables/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..45506a13645 --- /dev/null +++ b/seed/csharp-sdk/oauth-client-credentials-environment-variables/src/SeedOauthClientCredentialsEnvironmentVariables/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedOauthClientCredentialsEnvironmentVariables; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-sdk/oauth-client-credentials-nested-root/src/SeedOauthClientCredentials/Core/CollectionItemSerializer.cs b/seed/csharp-sdk/oauth-client-credentials-nested-root/src/SeedOauthClientCredentials/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..5bfe4e0f26c --- /dev/null +++ b/seed/csharp-sdk/oauth-client-credentials-nested-root/src/SeedOauthClientCredentials/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedOauthClientCredentials; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-sdk/oauth-client-credentials/src/SeedOauthClientCredentials/Core/CollectionItemSerializer.cs b/seed/csharp-sdk/oauth-client-credentials/src/SeedOauthClientCredentials/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..5bfe4e0f26c --- /dev/null +++ b/seed/csharp-sdk/oauth-client-credentials/src/SeedOauthClientCredentials/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedOauthClientCredentials; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-sdk/object/src/SeedObject/Core/CollectionItemSerializer.cs b/seed/csharp-sdk/object/src/SeedObject/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..473599cbfcd --- /dev/null +++ b/seed/csharp-sdk/object/src/SeedObject/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedObject; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-sdk/object/src/SeedObject/Types/Type.cs b/seed/csharp-sdk/object/src/SeedObject/Types/Type.cs index bbe86f26ebc..075f8d7a1c4 100644 --- a/seed/csharp-sdk/object/src/SeedObject/Types/Type.cs +++ b/seed/csharp-sdk/object/src/SeedObject/Types/Type.cs @@ -35,7 +35,7 @@ public class Type public string Nine { get; init; } [JsonPropertyName("ten")] - public List Ten { get; init; } + public IEnumerable Ten { get; init; } [JsonPropertyName("eleven")] public HashSet Eleven { get; init; } @@ -50,13 +50,13 @@ public class Type public object Fourteen { get; init; } [JsonPropertyName("fifteen")] - public List> Fifteen { get; init; } + public IEnumerable> Fifteen { get; init; } [JsonPropertyName("sixteen")] - public List> Sixteen { get; init; } + public IEnumerable> Sixteen { get; init; } [JsonPropertyName("seventeen")] - public List Seventeen { get; init; } + public IEnumerable Seventeen { get; init; } [JsonPropertyName("eighteen")] public string Eighteen { get; init; } diff --git a/seed/csharp-sdk/objects-with-imports/src/SeedObjectsWithImports/Core/CollectionItemSerializer.cs b/seed/csharp-sdk/objects-with-imports/src/SeedObjectsWithImports/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..ed7bdcf2ce6 --- /dev/null +++ b/seed/csharp-sdk/objects-with-imports/src/SeedObjectsWithImports/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedObjectsWithImports; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-sdk/objects-with-imports/src/SeedObjectsWithImports/File/Directory/Types/Directory.cs b/seed/csharp-sdk/objects-with-imports/src/SeedObjectsWithImports/File/Directory/Types/Directory.cs index bb3cb79f273..9f3d79d7054 100644 --- a/seed/csharp-sdk/objects-with-imports/src/SeedObjectsWithImports/File/Directory/Types/Directory.cs +++ b/seed/csharp-sdk/objects-with-imports/src/SeedObjectsWithImports/File/Directory/Types/Directory.cs @@ -12,8 +12,8 @@ public class Directory public string Name { get; init; } [JsonPropertyName("files")] - public List? Files { get; init; } + public IEnumerable? Files { get; init; } [JsonPropertyName("directories")] - public List? Directories { get; init; } + public IEnumerable? Directories { get; init; } } diff --git a/seed/csharp-sdk/objects-with-imports/src/SeedObjectsWithImports/Types/Tree.cs b/seed/csharp-sdk/objects-with-imports/src/SeedObjectsWithImports/Types/Tree.cs index 78e593b1ac8..1431b1a2706 100644 --- a/seed/csharp-sdk/objects-with-imports/src/SeedObjectsWithImports/Types/Tree.cs +++ b/seed/csharp-sdk/objects-with-imports/src/SeedObjectsWithImports/Types/Tree.cs @@ -8,5 +8,5 @@ namespace SeedObjectsWithImports; public class Tree { [JsonPropertyName("nodes")] - public List? Nodes { get; init; } + public IEnumerable? Nodes { get; init; } } diff --git a/seed/csharp-sdk/optional/src/SeedObjectsWithImports/Core/CollectionItemSerializer.cs b/seed/csharp-sdk/optional/src/SeedObjectsWithImports/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..ed7bdcf2ce6 --- /dev/null +++ b/seed/csharp-sdk/optional/src/SeedObjectsWithImports/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedObjectsWithImports; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-sdk/package-yml/src/SeedPackageYml/Core/CollectionItemSerializer.cs b/seed/csharp-sdk/package-yml/src/SeedPackageYml/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..a452937b61a --- /dev/null +++ b/seed/csharp-sdk/package-yml/src/SeedPackageYml/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedPackageYml; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-sdk/pagination/src/SeedPagination/Core/CollectionItemSerializer.cs b/seed/csharp-sdk/pagination/src/SeedPagination/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..cbbbc91d9f1 --- /dev/null +++ b/seed/csharp-sdk/pagination/src/SeedPagination/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedPagination; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-sdk/pagination/src/SeedPagination/Types/UsernamePage.cs b/seed/csharp-sdk/pagination/src/SeedPagination/Types/UsernamePage.cs index 8c7a4e83840..cb779360096 100644 --- a/seed/csharp-sdk/pagination/src/SeedPagination/Types/UsernamePage.cs +++ b/seed/csharp-sdk/pagination/src/SeedPagination/Types/UsernamePage.cs @@ -10,5 +10,5 @@ public class UsernamePage public string? After { get; init; } [JsonPropertyName("data")] - public List Data { get; init; } + public IEnumerable Data { get; init; } } diff --git a/seed/csharp-sdk/pagination/src/SeedPagination/Users/Types/ListUsersPaginationResponse.cs b/seed/csharp-sdk/pagination/src/SeedPagination/Users/Types/ListUsersPaginationResponse.cs index c1dd2313e38..19bdcd9ebc2 100644 --- a/seed/csharp-sdk/pagination/src/SeedPagination/Users/Types/ListUsersPaginationResponse.cs +++ b/seed/csharp-sdk/pagination/src/SeedPagination/Users/Types/ListUsersPaginationResponse.cs @@ -17,5 +17,5 @@ public class ListUsersPaginationResponse public int TotalCount { get; init; } [JsonPropertyName("data")] - public List Data { get; init; } + public IEnumerable Data { get; init; } } diff --git a/seed/csharp-sdk/pagination/src/SeedPagination/Users/Types/UserListContainer.cs b/seed/csharp-sdk/pagination/src/SeedPagination/Users/Types/UserListContainer.cs index bb01ad47072..1f674f6576d 100644 --- a/seed/csharp-sdk/pagination/src/SeedPagination/Users/Types/UserListContainer.cs +++ b/seed/csharp-sdk/pagination/src/SeedPagination/Users/Types/UserListContainer.cs @@ -8,5 +8,5 @@ namespace SeedPagination; public class UserListContainer { [JsonPropertyName("users")] - public List Users { get; init; } + public IEnumerable Users { get; init; } } diff --git a/seed/csharp-sdk/pagination/src/SeedPagination/Users/Types/UsernameContainer.cs b/seed/csharp-sdk/pagination/src/SeedPagination/Users/Types/UsernameContainer.cs index 837fa6040eb..3068ecf7fd5 100644 --- a/seed/csharp-sdk/pagination/src/SeedPagination/Users/Types/UsernameContainer.cs +++ b/seed/csharp-sdk/pagination/src/SeedPagination/Users/Types/UsernameContainer.cs @@ -7,5 +7,5 @@ namespace SeedPagination; public class UsernameContainer { [JsonPropertyName("results")] - public List Results { get; init; } + public IEnumerable Results { get; init; } } diff --git a/seed/csharp-sdk/plain-text/src/SeedPlainText/Core/CollectionItemSerializer.cs b/seed/csharp-sdk/plain-text/src/SeedPlainText/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..bdf8a5d3176 --- /dev/null +++ b/seed/csharp-sdk/plain-text/src/SeedPlainText/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedPlainText; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-sdk/query-parameters/src/SeedQueryParameters/Core/CollectionItemSerializer.cs b/seed/csharp-sdk/query-parameters/src/SeedQueryParameters/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..af181865547 --- /dev/null +++ b/seed/csharp-sdk/query-parameters/src/SeedQueryParameters/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedQueryParameters; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-sdk/query-parameters/src/SeedQueryParameters/User/Types/User.cs b/seed/csharp-sdk/query-parameters/src/SeedQueryParameters/User/Types/User.cs index 89d780b1758..b69cdd17275 100644 --- a/seed/csharp-sdk/query-parameters/src/SeedQueryParameters/User/Types/User.cs +++ b/seed/csharp-sdk/query-parameters/src/SeedQueryParameters/User/Types/User.cs @@ -10,5 +10,5 @@ public class User public string Name { get; init; } [JsonPropertyName("tags")] - public List Tags { get; init; } + public IEnumerable Tags { get; init; } } diff --git a/seed/csharp-sdk/reserved-keywords/src/SeedNurseryApi/Core/CollectionItemSerializer.cs b/seed/csharp-sdk/reserved-keywords/src/SeedNurseryApi/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..6822acff5f9 --- /dev/null +++ b/seed/csharp-sdk/reserved-keywords/src/SeedNurseryApi/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedNurseryApi; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-sdk/response-property/src/SeedResponseProperty/Core/CollectionItemSerializer.cs b/seed/csharp-sdk/response-property/src/SeedResponseProperty/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..96e36eb6465 --- /dev/null +++ b/seed/csharp-sdk/response-property/src/SeedResponseProperty/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedResponseProperty; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-sdk/server-sent-events/src/SeedServerSentEvents/Core/CollectionItemSerializer.cs b/seed/csharp-sdk/server-sent-events/src/SeedServerSentEvents/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..7f0d4c20352 --- /dev/null +++ b/seed/csharp-sdk/server-sent-events/src/SeedServerSentEvents/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedServerSentEvents; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-sdk/single-url-environment-default/src/SeedSingleUrlEnvironmentDefault/Core/CollectionItemSerializer.cs b/seed/csharp-sdk/single-url-environment-default/src/SeedSingleUrlEnvironmentDefault/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..09dde63fa38 --- /dev/null +++ b/seed/csharp-sdk/single-url-environment-default/src/SeedSingleUrlEnvironmentDefault/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedSingleUrlEnvironmentDefault; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-sdk/single-url-environment-no-default/src/SeedSingleUrlEnvironmentNoDefault/Core/CollectionItemSerializer.cs b/seed/csharp-sdk/single-url-environment-no-default/src/SeedSingleUrlEnvironmentNoDefault/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..20bb0c76012 --- /dev/null +++ b/seed/csharp-sdk/single-url-environment-no-default/src/SeedSingleUrlEnvironmentNoDefault/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedSingleUrlEnvironmentNoDefault; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-sdk/streaming/src/SeedStreaming/Core/CollectionItemSerializer.cs b/seed/csharp-sdk/streaming/src/SeedStreaming/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..76ad9ed09e4 --- /dev/null +++ b/seed/csharp-sdk/streaming/src/SeedStreaming/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedStreaming; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-sdk/trace/src/SeedTrace/Admin/AdminClient.cs b/seed/csharp-sdk/trace/src/SeedTrace/Admin/AdminClient.cs index b9cb83bdafa..6accb818688 100644 --- a/seed/csharp-sdk/trace/src/SeedTrace/Admin/AdminClient.cs +++ b/seed/csharp-sdk/trace/src/SeedTrace/Admin/AdminClient.cs @@ -89,7 +89,7 @@ StoreTracedTestCaseRequest request public async void StoreTracedTestCaseV2Async( Guid submissionId, string testCaseId, - List request + IEnumerable request ) { var response = await _client.MakeRequestAsync( @@ -117,7 +117,10 @@ StoreTracedWorkspaceRequest request ); } - public async void StoreTracedWorkspaceV2Async(Guid submissionId, List request) + public async void StoreTracedWorkspaceV2Async( + Guid submissionId, + IEnumerable request + ) { var response = await _client.MakeRequestAsync( new RawClient.ApiRequest diff --git a/seed/csharp-sdk/trace/src/SeedTrace/Admin/requests/StoreTracedTestCaseRequest.cs b/seed/csharp-sdk/trace/src/SeedTrace/Admin/requests/StoreTracedTestCaseRequest.cs index 2cb44362810..1384ad6d468 100644 --- a/seed/csharp-sdk/trace/src/SeedTrace/Admin/requests/StoreTracedTestCaseRequest.cs +++ b/seed/csharp-sdk/trace/src/SeedTrace/Admin/requests/StoreTracedTestCaseRequest.cs @@ -11,5 +11,5 @@ public class StoreTracedTestCaseRequest public TestCaseResultWithStdout Result { get; init; } [JsonPropertyName("traceResponses")] - public List TraceResponses { get; init; } + public IEnumerable TraceResponses { get; init; } } diff --git a/seed/csharp-sdk/trace/src/SeedTrace/Admin/requests/StoreTracedWorkspaceRequest.cs b/seed/csharp-sdk/trace/src/SeedTrace/Admin/requests/StoreTracedWorkspaceRequest.cs index c14b9d6f4c9..387983b4944 100644 --- a/seed/csharp-sdk/trace/src/SeedTrace/Admin/requests/StoreTracedWorkspaceRequest.cs +++ b/seed/csharp-sdk/trace/src/SeedTrace/Admin/requests/StoreTracedWorkspaceRequest.cs @@ -11,5 +11,5 @@ public class StoreTracedWorkspaceRequest public WorkspaceRunDetails WorkspaceRunDetails { get; init; } [JsonPropertyName("traceResponses")] - public List TraceResponses { get; init; } + public IEnumerable TraceResponses { get; init; } } diff --git a/seed/csharp-sdk/trace/src/SeedTrace/Commons/Types/DebugMapValue.cs b/seed/csharp-sdk/trace/src/SeedTrace/Commons/Types/DebugMapValue.cs index faf76f95d77..b8fc04a9e15 100644 --- a/seed/csharp-sdk/trace/src/SeedTrace/Commons/Types/DebugMapValue.cs +++ b/seed/csharp-sdk/trace/src/SeedTrace/Commons/Types/DebugMapValue.cs @@ -8,5 +8,5 @@ namespace SeedTrace; public class DebugMapValue { [JsonPropertyName("keyValuePairs")] - public List KeyValuePairs { get; init; } + public IEnumerable KeyValuePairs { get; init; } } diff --git a/seed/csharp-sdk/trace/src/SeedTrace/Commons/Types/MapValue.cs b/seed/csharp-sdk/trace/src/SeedTrace/Commons/Types/MapValue.cs index 232bf264188..dc3f6dfd10c 100644 --- a/seed/csharp-sdk/trace/src/SeedTrace/Commons/Types/MapValue.cs +++ b/seed/csharp-sdk/trace/src/SeedTrace/Commons/Types/MapValue.cs @@ -8,5 +8,5 @@ namespace SeedTrace; public class MapValue { [JsonPropertyName("keyValuePairs")] - public List KeyValuePairs { get; init; } + public IEnumerable KeyValuePairs { get; init; } } diff --git a/seed/csharp-sdk/trace/src/SeedTrace/Commons/Types/TestCase.cs b/seed/csharp-sdk/trace/src/SeedTrace/Commons/Types/TestCase.cs index 5f7b15e4e9e..bc9db263350 100644 --- a/seed/csharp-sdk/trace/src/SeedTrace/Commons/Types/TestCase.cs +++ b/seed/csharp-sdk/trace/src/SeedTrace/Commons/Types/TestCase.cs @@ -11,5 +11,5 @@ public class TestCase public string Id { get; init; } [JsonPropertyName("params")] - public List Params { get; init; } + public IEnumerable Params { get; init; } } diff --git a/seed/csharp-sdk/trace/src/SeedTrace/Core/CollectionItemSerializer.cs b/seed/csharp-sdk/trace/src/SeedTrace/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..68b213e0f1e --- /dev/null +++ b/seed/csharp-sdk/trace/src/SeedTrace/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedTrace; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-sdk/trace/src/SeedTrace/Homepage/HomepageClient.cs b/seed/csharp-sdk/trace/src/SeedTrace/Homepage/HomepageClient.cs index 440f764c3d0..0f9194368c9 100644 --- a/seed/csharp-sdk/trace/src/SeedTrace/Homepage/HomepageClient.cs +++ b/seed/csharp-sdk/trace/src/SeedTrace/Homepage/HomepageClient.cs @@ -14,7 +14,7 @@ public HomepageClient(RawClient client) _client = client; } - public async Task> GetHomepageProblemsAsync() + public async Task> GetHomepageProblemsAsync() { var response = await _client.MakeRequestAsync( new RawClient.ApiRequest { Method = HttpMethod.Get, Path = "" } @@ -22,12 +22,12 @@ public async Task> GetHomepageProblemsAsync() string responseBody = await response.Raw.Content.ReadAsStringAsync(); if (response.StatusCode >= 200 && response.StatusCode < 400) { - return JsonSerializer.Deserialize>(responseBody); + return JsonSerializer.Deserialize>(responseBody); } throw new Exception(responseBody); } - public async void SetHomepageProblemsAsync(List request) + public async void SetHomepageProblemsAsync(IEnumerable request) { var response = await _client.MakeRequestAsync( new RawClient.ApiRequest diff --git a/seed/csharp-sdk/trace/src/SeedTrace/Migration/MigrationClient.cs b/seed/csharp-sdk/trace/src/SeedTrace/Migration/MigrationClient.cs index f7041380a16..cb007093903 100644 --- a/seed/csharp-sdk/trace/src/SeedTrace/Migration/MigrationClient.cs +++ b/seed/csharp-sdk/trace/src/SeedTrace/Migration/MigrationClient.cs @@ -14,7 +14,7 @@ public MigrationClient(RawClient client) _client = client; } - public async Task> GetAttemptedMigrationsAsync( + public async Task> GetAttemptedMigrationsAsync( GetAttemptedMigrationsRequest request ) { @@ -33,7 +33,7 @@ GetAttemptedMigrationsRequest request string responseBody = await response.Raw.Content.ReadAsStringAsync(); if (response.StatusCode >= 200 && response.StatusCode < 400) { - return JsonSerializer.Deserialize>(responseBody); + return JsonSerializer.Deserialize>(responseBody); } throw new Exception(responseBody); } diff --git a/seed/csharp-sdk/trace/src/SeedTrace/Playlist/PlaylistClient.cs b/seed/csharp-sdk/trace/src/SeedTrace/Playlist/PlaylistClient.cs index 9c97fbf1cc9..e10bd1cf398 100644 --- a/seed/csharp-sdk/trace/src/SeedTrace/Playlist/PlaylistClient.cs +++ b/seed/csharp-sdk/trace/src/SeedTrace/Playlist/PlaylistClient.cs @@ -47,7 +47,7 @@ public async Task CreatePlaylistAsync(CreatePlaylistRequest request) /// /// Returns the user's playlists /// - public async Task> GetPlaylistsAsync(GetPlaylistsRequest request) + public async Task> GetPlaylistsAsync(GetPlaylistsRequest request) { var _query = new Dictionary() { @@ -74,7 +74,7 @@ public async Task> GetPlaylistsAsync(GetPlaylistsRequest request) string responseBody = await response.Raw.Content.ReadAsStringAsync(); if (response.StatusCode >= 200 && response.StatusCode < 400) { - return JsonSerializer.Deserialize>(responseBody); + return JsonSerializer.Deserialize>(responseBody); } throw new Exception(responseBody); } diff --git a/seed/csharp-sdk/trace/src/SeedTrace/Playlist/Types/Playlist.cs b/seed/csharp-sdk/trace/src/SeedTrace/Playlist/Types/Playlist.cs index 4cc6371f074..726c983284e 100644 --- a/seed/csharp-sdk/trace/src/SeedTrace/Playlist/Types/Playlist.cs +++ b/seed/csharp-sdk/trace/src/SeedTrace/Playlist/Types/Playlist.cs @@ -16,5 +16,5 @@ public class Playlist public string Name { get; init; } [JsonPropertyName("problems")] - public List Problems { get; init; } + public IEnumerable Problems { get; init; } } diff --git a/seed/csharp-sdk/trace/src/SeedTrace/Playlist/Types/PlaylistCreateRequest.cs b/seed/csharp-sdk/trace/src/SeedTrace/Playlist/Types/PlaylistCreateRequest.cs index efb787fd285..62530ba031f 100644 --- a/seed/csharp-sdk/trace/src/SeedTrace/Playlist/Types/PlaylistCreateRequest.cs +++ b/seed/csharp-sdk/trace/src/SeedTrace/Playlist/Types/PlaylistCreateRequest.cs @@ -10,5 +10,5 @@ public class PlaylistCreateRequest public string Name { get; init; } [JsonPropertyName("problems")] - public List Problems { get; init; } + public IEnumerable Problems { get; init; } } diff --git a/seed/csharp-sdk/trace/src/SeedTrace/Playlist/Types/UpdatePlaylistRequest.cs b/seed/csharp-sdk/trace/src/SeedTrace/Playlist/Types/UpdatePlaylistRequest.cs index 7d1de490adc..f89e1bb15c0 100644 --- a/seed/csharp-sdk/trace/src/SeedTrace/Playlist/Types/UpdatePlaylistRequest.cs +++ b/seed/csharp-sdk/trace/src/SeedTrace/Playlist/Types/UpdatePlaylistRequest.cs @@ -13,5 +13,5 @@ public class UpdatePlaylistRequest /// The problems that make up the playlist. /// [JsonPropertyName("problems")] - public List Problems { get; init; } + public IEnumerable Problems { get; init; } } diff --git a/seed/csharp-sdk/trace/src/SeedTrace/Problem/Types/CreateProblemRequest.cs b/seed/csharp-sdk/trace/src/SeedTrace/Problem/Types/CreateProblemRequest.cs index 64f5fa42fe1..373a8497437 100644 --- a/seed/csharp-sdk/trace/src/SeedTrace/Problem/Types/CreateProblemRequest.cs +++ b/seed/csharp-sdk/trace/src/SeedTrace/Problem/Types/CreateProblemRequest.cs @@ -17,13 +17,13 @@ public class CreateProblemRequest public Dictionary Files { get; init; } [JsonPropertyName("inputParams")] - public List InputParams { get; init; } + public IEnumerable InputParams { get; init; } [JsonPropertyName("outputType")] public VariableType OutputType { get; init; } [JsonPropertyName("testcases")] - public List Testcases { get; init; } + public IEnumerable Testcases { get; init; } [JsonPropertyName("methodName")] public string MethodName { get; init; } diff --git a/seed/csharp-sdk/trace/src/SeedTrace/Problem/Types/ProblemDescription.cs b/seed/csharp-sdk/trace/src/SeedTrace/Problem/Types/ProblemDescription.cs index cf5dab71129..893aa8191b6 100644 --- a/seed/csharp-sdk/trace/src/SeedTrace/Problem/Types/ProblemDescription.cs +++ b/seed/csharp-sdk/trace/src/SeedTrace/Problem/Types/ProblemDescription.cs @@ -8,5 +8,5 @@ namespace SeedTrace; public class ProblemDescription { [JsonPropertyName("boards")] - public List Boards { get; init; } + public IEnumerable Boards { get; init; } } diff --git a/seed/csharp-sdk/trace/src/SeedTrace/Problem/Types/ProblemFiles.cs b/seed/csharp-sdk/trace/src/SeedTrace/Problem/Types/ProblemFiles.cs index ae2c565062b..ea32573099d 100644 --- a/seed/csharp-sdk/trace/src/SeedTrace/Problem/Types/ProblemFiles.cs +++ b/seed/csharp-sdk/trace/src/SeedTrace/Problem/Types/ProblemFiles.cs @@ -11,5 +11,5 @@ public class ProblemFiles public FileInfo SolutionFile { get; init; } [JsonPropertyName("readOnlyFiles")] - public List ReadOnlyFiles { get; init; } + public IEnumerable ReadOnlyFiles { get; init; } } diff --git a/seed/csharp-sdk/trace/src/SeedTrace/Problem/Types/ProblemInfo.cs b/seed/csharp-sdk/trace/src/SeedTrace/Problem/Types/ProblemInfo.cs index 778c72fe952..0b264a0a2b7 100644 --- a/seed/csharp-sdk/trace/src/SeedTrace/Problem/Types/ProblemInfo.cs +++ b/seed/csharp-sdk/trace/src/SeedTrace/Problem/Types/ProblemInfo.cs @@ -23,13 +23,13 @@ public class ProblemInfo public Dictionary Files { get; init; } [JsonPropertyName("inputParams")] - public List InputParams { get; init; } + public IEnumerable InputParams { get; init; } [JsonPropertyName("outputType")] public VariableType OutputType { get; init; } [JsonPropertyName("testcases")] - public List Testcases { get; init; } + public IEnumerable Testcases { get; init; } [JsonPropertyName("methodName")] public string MethodName { get; init; } diff --git a/seed/csharp-sdk/trace/src/SeedTrace/Problem/requests/GetDefaultStarterFilesRequest.cs b/seed/csharp-sdk/trace/src/SeedTrace/Problem/requests/GetDefaultStarterFilesRequest.cs index 3a533a9b075..f51a556b0ed 100644 --- a/seed/csharp-sdk/trace/src/SeedTrace/Problem/requests/GetDefaultStarterFilesRequest.cs +++ b/seed/csharp-sdk/trace/src/SeedTrace/Problem/requests/GetDefaultStarterFilesRequest.cs @@ -8,7 +8,7 @@ namespace SeedTrace; public class GetDefaultStarterFilesRequest { [JsonPropertyName("inputParams")] - public List InputParams { get; init; } + public IEnumerable InputParams { get; init; } [JsonPropertyName("outputType")] public VariableType OutputType { get; init; } diff --git a/seed/csharp-sdk/trace/src/SeedTrace/Submission/Types/GetExecutionSessionStateResponse.cs b/seed/csharp-sdk/trace/src/SeedTrace/Submission/Types/GetExecutionSessionStateResponse.cs index 1141b0c2e67..38b404ca227 100644 --- a/seed/csharp-sdk/trace/src/SeedTrace/Submission/Types/GetExecutionSessionStateResponse.cs +++ b/seed/csharp-sdk/trace/src/SeedTrace/Submission/Types/GetExecutionSessionStateResponse.cs @@ -14,5 +14,5 @@ public class GetExecutionSessionStateResponse public int? NumWarmingInstances { get; init; } [JsonPropertyName("warmingSessionIds")] - public List WarmingSessionIds { get; init; } + public IEnumerable WarmingSessionIds { get; init; } } diff --git a/seed/csharp-sdk/trace/src/SeedTrace/Submission/Types/StackFrame.cs b/seed/csharp-sdk/trace/src/SeedTrace/Submission/Types/StackFrame.cs index 58358e85d27..863ab77beb6 100644 --- a/seed/csharp-sdk/trace/src/SeedTrace/Submission/Types/StackFrame.cs +++ b/seed/csharp-sdk/trace/src/SeedTrace/Submission/Types/StackFrame.cs @@ -14,5 +14,5 @@ public class StackFrame public int LineNumber { get; init; } [JsonPropertyName("scopes")] - public List Scopes { get; init; } + public IEnumerable Scopes { get; init; } } diff --git a/seed/csharp-sdk/trace/src/SeedTrace/Submission/Types/SubmitRequestV2.cs b/seed/csharp-sdk/trace/src/SeedTrace/Submission/Types/SubmitRequestV2.cs index 6c2e45d830b..bcbaf54ad24 100644 --- a/seed/csharp-sdk/trace/src/SeedTrace/Submission/Types/SubmitRequestV2.cs +++ b/seed/csharp-sdk/trace/src/SeedTrace/Submission/Types/SubmitRequestV2.cs @@ -14,7 +14,7 @@ public class SubmitRequestV2 public Language Language { get; init; } [JsonPropertyName("submissionFiles")] - public List SubmissionFiles { get; init; } + public IEnumerable SubmissionFiles { get; init; } [JsonPropertyName("problemId")] public string ProblemId { get; init; } diff --git a/seed/csharp-sdk/trace/src/SeedTrace/Submission/Types/TestSubmissionState.cs b/seed/csharp-sdk/trace/src/SeedTrace/Submission/Types/TestSubmissionState.cs index 4881e236ccb..20a6adfc8b3 100644 --- a/seed/csharp-sdk/trace/src/SeedTrace/Submission/Types/TestSubmissionState.cs +++ b/seed/csharp-sdk/trace/src/SeedTrace/Submission/Types/TestSubmissionState.cs @@ -11,10 +11,10 @@ public class TestSubmissionState public string ProblemId { get; init; } [JsonPropertyName("defaultTestCases")] - public List DefaultTestCases { get; init; } + public IEnumerable DefaultTestCases { get; init; } [JsonPropertyName("customTestCases")] - public List CustomTestCases { get; init; } + public IEnumerable CustomTestCases { get; init; } [JsonPropertyName("status")] public TestSubmissionStatus Status { get; init; } diff --git a/seed/csharp-sdk/trace/src/SeedTrace/Submission/Types/TestSubmissionStatusV2.cs b/seed/csharp-sdk/trace/src/SeedTrace/Submission/Types/TestSubmissionStatusV2.cs index 47d27dffc44..6f3acbdd886 100644 --- a/seed/csharp-sdk/trace/src/SeedTrace/Submission/Types/TestSubmissionStatusV2.cs +++ b/seed/csharp-sdk/trace/src/SeedTrace/Submission/Types/TestSubmissionStatusV2.cs @@ -9,7 +9,7 @@ namespace SeedTrace; public class TestSubmissionStatusV2 { [JsonPropertyName("updates")] - public List Updates { get; init; } + public IEnumerable Updates { get; init; } [JsonPropertyName("problemId")] public string ProblemId { get; init; } diff --git a/seed/csharp-sdk/trace/src/SeedTrace/Submission/Types/TraceResponsesPage.cs b/seed/csharp-sdk/trace/src/SeedTrace/Submission/Types/TraceResponsesPage.cs index 76c2da3894c..b806e45ef75 100644 --- a/seed/csharp-sdk/trace/src/SeedTrace/Submission/Types/TraceResponsesPage.cs +++ b/seed/csharp-sdk/trace/src/SeedTrace/Submission/Types/TraceResponsesPage.cs @@ -15,5 +15,5 @@ public class TraceResponsesPage public int? Offset { get; init; } [JsonPropertyName("traceResponses")] - public List TraceResponses { get; init; } + public IEnumerable TraceResponses { get; init; } } diff --git a/seed/csharp-sdk/trace/src/SeedTrace/Submission/Types/TraceResponsesPageV2.cs b/seed/csharp-sdk/trace/src/SeedTrace/Submission/Types/TraceResponsesPageV2.cs index a6ce2877895..67078091cc3 100644 --- a/seed/csharp-sdk/trace/src/SeedTrace/Submission/Types/TraceResponsesPageV2.cs +++ b/seed/csharp-sdk/trace/src/SeedTrace/Submission/Types/TraceResponsesPageV2.cs @@ -15,5 +15,5 @@ public class TraceResponsesPageV2 public int? Offset { get; init; } [JsonPropertyName("traceResponses")] - public List TraceResponses { get; init; } + public IEnumerable TraceResponses { get; init; } } diff --git a/seed/csharp-sdk/trace/src/SeedTrace/Submission/Types/WorkspaceFiles.cs b/seed/csharp-sdk/trace/src/SeedTrace/Submission/Types/WorkspaceFiles.cs index 3c9a0f3c732..e8349edcda4 100644 --- a/seed/csharp-sdk/trace/src/SeedTrace/Submission/Types/WorkspaceFiles.cs +++ b/seed/csharp-sdk/trace/src/SeedTrace/Submission/Types/WorkspaceFiles.cs @@ -11,5 +11,5 @@ public class WorkspaceFiles public FileInfo MainFile { get; init; } [JsonPropertyName("readOnlyFiles")] - public List ReadOnlyFiles { get; init; } + public IEnumerable ReadOnlyFiles { get; init; } } diff --git a/seed/csharp-sdk/trace/src/SeedTrace/Submission/Types/WorkspaceSubmissionStatusV2.cs b/seed/csharp-sdk/trace/src/SeedTrace/Submission/Types/WorkspaceSubmissionStatusV2.cs index e14a38d94de..26f9b5e3b04 100644 --- a/seed/csharp-sdk/trace/src/SeedTrace/Submission/Types/WorkspaceSubmissionStatusV2.cs +++ b/seed/csharp-sdk/trace/src/SeedTrace/Submission/Types/WorkspaceSubmissionStatusV2.cs @@ -8,5 +8,5 @@ namespace SeedTrace; public class WorkspaceSubmissionStatusV2 { [JsonPropertyName("updates")] - public List Updates { get; init; } + public IEnumerable Updates { get; init; } } diff --git a/seed/csharp-sdk/trace/src/SeedTrace/Submission/Types/WorkspaceSubmitRequest.cs b/seed/csharp-sdk/trace/src/SeedTrace/Submission/Types/WorkspaceSubmitRequest.cs index ae58a9b6c44..fe4fe672231 100644 --- a/seed/csharp-sdk/trace/src/SeedTrace/Submission/Types/WorkspaceSubmitRequest.cs +++ b/seed/csharp-sdk/trace/src/SeedTrace/Submission/Types/WorkspaceSubmitRequest.cs @@ -14,7 +14,7 @@ public class WorkspaceSubmitRequest public Language Language { get; init; } [JsonPropertyName("submissionFiles")] - public List SubmissionFiles { get; init; } + public IEnumerable SubmissionFiles { get; init; } [JsonPropertyName("userId")] public string? UserId { get; init; } diff --git a/seed/csharp-sdk/trace/src/SeedTrace/V2/Problem/ProblemClient.cs b/seed/csharp-sdk/trace/src/SeedTrace/V2/Problem/ProblemClient.cs index 44b50938b21..9431cb03d0d 100644 --- a/seed/csharp-sdk/trace/src/SeedTrace/V2/Problem/ProblemClient.cs +++ b/seed/csharp-sdk/trace/src/SeedTrace/V2/Problem/ProblemClient.cs @@ -18,7 +18,7 @@ public ProblemClient(RawClient client) /// /// Returns lightweight versions of all problems /// - public async Task> GetLightweightProblemsAsync() + public async Task> GetLightweightProblemsAsync() { var response = await _client.MakeRequestAsync( new RawClient.ApiRequest { Method = HttpMethod.Get, Path = "/lightweight-problem-info" } @@ -26,7 +26,7 @@ public async Task> GetLightweightProblemsAsync() string responseBody = await response.Raw.Content.ReadAsStringAsync(); if (response.StatusCode >= 200 && response.StatusCode < 400) { - return JsonSerializer.Deserialize>(responseBody); + return JsonSerializer.Deserialize>(responseBody); } throw new Exception(responseBody); } @@ -34,7 +34,7 @@ public async Task> GetLightweightProblemsAsync() /// /// Returns latest versions of all problems /// - public async Task> GetProblemsAsync() + public async Task> GetProblemsAsync() { var response = await _client.MakeRequestAsync( new RawClient.ApiRequest { Method = HttpMethod.Get, Path = "/problem-info" } @@ -42,7 +42,7 @@ public async Task> GetProblemsAsync() string responseBody = await response.Raw.Content.ReadAsStringAsync(); if (response.StatusCode >= 200 && response.StatusCode < 400) { - return JsonSerializer.Deserialize>(responseBody); + return JsonSerializer.Deserialize>(responseBody); } throw new Exception(responseBody); } diff --git a/seed/csharp-sdk/trace/src/SeedTrace/V2/Problem/Types/CreateProblemRequestV2.cs b/seed/csharp-sdk/trace/src/SeedTrace/V2/Problem/Types/CreateProblemRequestV2.cs index cbec1f98782..5b2472ca139 100644 --- a/seed/csharp-sdk/trace/src/SeedTrace/V2/Problem/Types/CreateProblemRequestV2.cs +++ b/seed/csharp-sdk/trace/src/SeedTrace/V2/Problem/Types/CreateProblemRequestV2.cs @@ -18,10 +18,10 @@ public class CreateProblemRequestV2 public CustomFiles CustomFiles { get; init; } [JsonPropertyName("customTestCaseTemplates")] - public List CustomTestCaseTemplates { get; init; } + public IEnumerable CustomTestCaseTemplates { get; init; } [JsonPropertyName("testcases")] - public List Testcases { get; init; } + public IEnumerable Testcases { get; init; } [JsonPropertyName("supportedLanguages")] public HashSet SupportedLanguages { get; init; } diff --git a/seed/csharp-sdk/trace/src/SeedTrace/V2/Problem/Types/DefaultProvidedFile.cs b/seed/csharp-sdk/trace/src/SeedTrace/V2/Problem/Types/DefaultProvidedFile.cs index b6a1a22e8a7..d02efc608b1 100644 --- a/seed/csharp-sdk/trace/src/SeedTrace/V2/Problem/Types/DefaultProvidedFile.cs +++ b/seed/csharp-sdk/trace/src/SeedTrace/V2/Problem/Types/DefaultProvidedFile.cs @@ -12,5 +12,5 @@ public class DefaultProvidedFile public FileInfoV2 File { get; init; } [JsonPropertyName("relatedTypes")] - public List RelatedTypes { get; init; } + public IEnumerable RelatedTypes { get; init; } } diff --git a/seed/csharp-sdk/trace/src/SeedTrace/V2/Problem/Types/Files.cs b/seed/csharp-sdk/trace/src/SeedTrace/V2/Problem/Types/Files.cs index 986a24d2e8b..d07a0a83b90 100644 --- a/seed/csharp-sdk/trace/src/SeedTrace/V2/Problem/Types/Files.cs +++ b/seed/csharp-sdk/trace/src/SeedTrace/V2/Problem/Types/Files.cs @@ -8,5 +8,5 @@ namespace SeedTrace.V2; public class Files { [JsonPropertyName("files")] - public List Files_ { get; init; } + public IEnumerable Files_ { get; init; } } diff --git a/seed/csharp-sdk/trace/src/SeedTrace/V2/Problem/Types/NonVoidFunctionSignature.cs b/seed/csharp-sdk/trace/src/SeedTrace/V2/Problem/Types/NonVoidFunctionSignature.cs index 5d19c98285a..923791760a5 100644 --- a/seed/csharp-sdk/trace/src/SeedTrace/V2/Problem/Types/NonVoidFunctionSignature.cs +++ b/seed/csharp-sdk/trace/src/SeedTrace/V2/Problem/Types/NonVoidFunctionSignature.cs @@ -9,7 +9,7 @@ namespace SeedTrace.V2; public class NonVoidFunctionSignature { [JsonPropertyName("parameters")] - public List Parameters { get; init; } + public IEnumerable Parameters { get; init; } [JsonPropertyName("returnType")] public VariableType ReturnType { get; init; } diff --git a/seed/csharp-sdk/trace/src/SeedTrace/V2/Problem/Types/ProblemInfoV2.cs b/seed/csharp-sdk/trace/src/SeedTrace/V2/Problem/Types/ProblemInfoV2.cs index 4c0cc644866..7a5577bd1f5 100644 --- a/seed/csharp-sdk/trace/src/SeedTrace/V2/Problem/Types/ProblemInfoV2.cs +++ b/seed/csharp-sdk/trace/src/SeedTrace/V2/Problem/Types/ProblemInfoV2.cs @@ -30,10 +30,10 @@ public class ProblemInfoV2 public GeneratedFiles GeneratedFiles { get; init; } [JsonPropertyName("customTestCaseTemplates")] - public List CustomTestCaseTemplates { get; init; } + public IEnumerable CustomTestCaseTemplates { get; init; } [JsonPropertyName("testcases")] - public List Testcases { get; init; } + public IEnumerable Testcases { get; init; } [JsonPropertyName("isPublic")] public bool IsPublic { get; init; } diff --git a/seed/csharp-sdk/trace/src/SeedTrace/V2/Problem/Types/TestCaseImplementationDescription.cs b/seed/csharp-sdk/trace/src/SeedTrace/V2/Problem/Types/TestCaseImplementationDescription.cs index b127c5be335..fb7ca3771f0 100644 --- a/seed/csharp-sdk/trace/src/SeedTrace/V2/Problem/Types/TestCaseImplementationDescription.cs +++ b/seed/csharp-sdk/trace/src/SeedTrace/V2/Problem/Types/TestCaseImplementationDescription.cs @@ -8,5 +8,5 @@ namespace SeedTrace.V2; public class TestCaseImplementationDescription { [JsonPropertyName("boards")] - public List Boards { get; init; } + public IEnumerable Boards { get; init; } } diff --git a/seed/csharp-sdk/trace/src/SeedTrace/V2/Problem/Types/VoidFunctionDefinition.cs b/seed/csharp-sdk/trace/src/SeedTrace/V2/Problem/Types/VoidFunctionDefinition.cs index 29c7b3f99fd..06c18cd0645 100644 --- a/seed/csharp-sdk/trace/src/SeedTrace/V2/Problem/Types/VoidFunctionDefinition.cs +++ b/seed/csharp-sdk/trace/src/SeedTrace/V2/Problem/Types/VoidFunctionDefinition.cs @@ -8,7 +8,7 @@ namespace SeedTrace.V2; public class VoidFunctionDefinition { [JsonPropertyName("parameters")] - public List Parameters { get; init; } + public IEnumerable Parameters { get; init; } [JsonPropertyName("code")] public FunctionImplementationForMultipleLanguages Code { get; init; } diff --git a/seed/csharp-sdk/trace/src/SeedTrace/V2/Problem/Types/VoidFunctionDefinitionThatTakesActualResult.cs b/seed/csharp-sdk/trace/src/SeedTrace/V2/Problem/Types/VoidFunctionDefinitionThatTakesActualResult.cs index 9f52c077452..5c3a9cf76fb 100644 --- a/seed/csharp-sdk/trace/src/SeedTrace/V2/Problem/Types/VoidFunctionDefinitionThatTakesActualResult.cs +++ b/seed/csharp-sdk/trace/src/SeedTrace/V2/Problem/Types/VoidFunctionDefinitionThatTakesActualResult.cs @@ -8,7 +8,7 @@ namespace SeedTrace.V2; public class VoidFunctionDefinitionThatTakesActualResult { [JsonPropertyName("additionalParameters")] - public List AdditionalParameters { get; init; } + public IEnumerable AdditionalParameters { get; init; } [JsonPropertyName("code")] public FunctionImplementationForMultipleLanguages Code { get; init; } diff --git a/seed/csharp-sdk/trace/src/SeedTrace/V2/Problem/Types/VoidFunctionSignature.cs b/seed/csharp-sdk/trace/src/SeedTrace/V2/Problem/Types/VoidFunctionSignature.cs index aac2f97652f..b4e42777fd1 100644 --- a/seed/csharp-sdk/trace/src/SeedTrace/V2/Problem/Types/VoidFunctionSignature.cs +++ b/seed/csharp-sdk/trace/src/SeedTrace/V2/Problem/Types/VoidFunctionSignature.cs @@ -8,5 +8,5 @@ namespace SeedTrace.V2; public class VoidFunctionSignature { [JsonPropertyName("parameters")] - public List Parameters { get; init; } + public IEnumerable Parameters { get; init; } } diff --git a/seed/csharp-sdk/trace/src/SeedTrace/V2/Problem/Types/VoidFunctionSignatureThatTakesActualResult.cs b/seed/csharp-sdk/trace/src/SeedTrace/V2/Problem/Types/VoidFunctionSignatureThatTakesActualResult.cs index 19462b0fe52..23afc7b6188 100644 --- a/seed/csharp-sdk/trace/src/SeedTrace/V2/Problem/Types/VoidFunctionSignatureThatTakesActualResult.cs +++ b/seed/csharp-sdk/trace/src/SeedTrace/V2/Problem/Types/VoidFunctionSignatureThatTakesActualResult.cs @@ -9,7 +9,7 @@ namespace SeedTrace.V2; public class VoidFunctionSignatureThatTakesActualResult { [JsonPropertyName("parameters")] - public List Parameters { get; init; } + public IEnumerable Parameters { get; init; } [JsonPropertyName("actualResultType")] public VariableType ActualResultType { get; init; } diff --git a/seed/csharp-sdk/trace/src/SeedTrace/V2/V3/Problem/ProblemClient.cs b/seed/csharp-sdk/trace/src/SeedTrace/V2/V3/Problem/ProblemClient.cs index 77819ba1383..930ed94e1a6 100644 --- a/seed/csharp-sdk/trace/src/SeedTrace/V2/V3/Problem/ProblemClient.cs +++ b/seed/csharp-sdk/trace/src/SeedTrace/V2/V3/Problem/ProblemClient.cs @@ -18,7 +18,7 @@ public ProblemClient(RawClient client) /// /// Returns lightweight versions of all problems /// - public async Task> GetLightweightProblemsAsync() + public async Task> GetLightweightProblemsAsync() { var response = await _client.MakeRequestAsync( new RawClient.ApiRequest { Method = HttpMethod.Get, Path = "/lightweight-problem-info" } @@ -26,7 +26,7 @@ public async Task> GetLightweightProblemsAsync() string responseBody = await response.Raw.Content.ReadAsStringAsync(); if (response.StatusCode >= 200 && response.StatusCode < 400) { - return JsonSerializer.Deserialize>(responseBody); + return JsonSerializer.Deserialize>(responseBody); } throw new Exception(responseBody); } @@ -34,7 +34,7 @@ public async Task> GetLightweightProblemsAsync() /// /// Returns latest versions of all problems /// - public async Task> GetProblemsAsync() + public async Task> GetProblemsAsync() { var response = await _client.MakeRequestAsync( new RawClient.ApiRequest { Method = HttpMethod.Get, Path = "/problem-info" } @@ -42,7 +42,7 @@ public async Task> GetProblemsAsync() string responseBody = await response.Raw.Content.ReadAsStringAsync(); if (response.StatusCode >= 200 && response.StatusCode < 400) { - return JsonSerializer.Deserialize>(responseBody); + return JsonSerializer.Deserialize>(responseBody); } throw new Exception(responseBody); } diff --git a/seed/csharp-sdk/trace/src/SeedTrace/V2/V3/Problem/Types/CreateProblemRequestV2.cs b/seed/csharp-sdk/trace/src/SeedTrace/V2/V3/Problem/Types/CreateProblemRequestV2.cs index 39906264b61..9145e590055 100644 --- a/seed/csharp-sdk/trace/src/SeedTrace/V2/V3/Problem/Types/CreateProblemRequestV2.cs +++ b/seed/csharp-sdk/trace/src/SeedTrace/V2/V3/Problem/Types/CreateProblemRequestV2.cs @@ -18,10 +18,10 @@ public class CreateProblemRequestV2 public CustomFiles CustomFiles { get; init; } [JsonPropertyName("customTestCaseTemplates")] - public List CustomTestCaseTemplates { get; init; } + public IEnumerable CustomTestCaseTemplates { get; init; } [JsonPropertyName("testcases")] - public List Testcases { get; init; } + public IEnumerable Testcases { get; init; } [JsonPropertyName("supportedLanguages")] public HashSet SupportedLanguages { get; init; } diff --git a/seed/csharp-sdk/trace/src/SeedTrace/V2/V3/Problem/Types/DefaultProvidedFile.cs b/seed/csharp-sdk/trace/src/SeedTrace/V2/V3/Problem/Types/DefaultProvidedFile.cs index 38dda0ad1d2..209adbc3596 100644 --- a/seed/csharp-sdk/trace/src/SeedTrace/V2/V3/Problem/Types/DefaultProvidedFile.cs +++ b/seed/csharp-sdk/trace/src/SeedTrace/V2/V3/Problem/Types/DefaultProvidedFile.cs @@ -12,5 +12,5 @@ public class DefaultProvidedFile public FileInfoV2 File { get; init; } [JsonPropertyName("relatedTypes")] - public List RelatedTypes { get; init; } + public IEnumerable RelatedTypes { get; init; } } diff --git a/seed/csharp-sdk/trace/src/SeedTrace/V2/V3/Problem/Types/Files.cs b/seed/csharp-sdk/trace/src/SeedTrace/V2/V3/Problem/Types/Files.cs index d2358441ed3..e259d8b6ba1 100644 --- a/seed/csharp-sdk/trace/src/SeedTrace/V2/V3/Problem/Types/Files.cs +++ b/seed/csharp-sdk/trace/src/SeedTrace/V2/V3/Problem/Types/Files.cs @@ -8,5 +8,5 @@ namespace SeedTrace.V2.V3; public class Files { [JsonPropertyName("files")] - public List Files_ { get; init; } + public IEnumerable Files_ { get; init; } } diff --git a/seed/csharp-sdk/trace/src/SeedTrace/V2/V3/Problem/Types/NonVoidFunctionSignature.cs b/seed/csharp-sdk/trace/src/SeedTrace/V2/V3/Problem/Types/NonVoidFunctionSignature.cs index 560d564cf43..fbfb0de7007 100644 --- a/seed/csharp-sdk/trace/src/SeedTrace/V2/V3/Problem/Types/NonVoidFunctionSignature.cs +++ b/seed/csharp-sdk/trace/src/SeedTrace/V2/V3/Problem/Types/NonVoidFunctionSignature.cs @@ -9,7 +9,7 @@ namespace SeedTrace.V2.V3; public class NonVoidFunctionSignature { [JsonPropertyName("parameters")] - public List Parameters { get; init; } + public IEnumerable Parameters { get; init; } [JsonPropertyName("returnType")] public VariableType ReturnType { get; init; } diff --git a/seed/csharp-sdk/trace/src/SeedTrace/V2/V3/Problem/Types/ProblemInfoV2.cs b/seed/csharp-sdk/trace/src/SeedTrace/V2/V3/Problem/Types/ProblemInfoV2.cs index a7b8de187fc..a02e026e758 100644 --- a/seed/csharp-sdk/trace/src/SeedTrace/V2/V3/Problem/Types/ProblemInfoV2.cs +++ b/seed/csharp-sdk/trace/src/SeedTrace/V2/V3/Problem/Types/ProblemInfoV2.cs @@ -30,10 +30,10 @@ public class ProblemInfoV2 public GeneratedFiles GeneratedFiles { get; init; } [JsonPropertyName("customTestCaseTemplates")] - public List CustomTestCaseTemplates { get; init; } + public IEnumerable CustomTestCaseTemplates { get; init; } [JsonPropertyName("testcases")] - public List Testcases { get; init; } + public IEnumerable Testcases { get; init; } [JsonPropertyName("isPublic")] public bool IsPublic { get; init; } diff --git a/seed/csharp-sdk/trace/src/SeedTrace/V2/V3/Problem/Types/TestCaseImplementationDescription.cs b/seed/csharp-sdk/trace/src/SeedTrace/V2/V3/Problem/Types/TestCaseImplementationDescription.cs index 1c2ed877ea0..3cf482f48e0 100644 --- a/seed/csharp-sdk/trace/src/SeedTrace/V2/V3/Problem/Types/TestCaseImplementationDescription.cs +++ b/seed/csharp-sdk/trace/src/SeedTrace/V2/V3/Problem/Types/TestCaseImplementationDescription.cs @@ -8,5 +8,5 @@ namespace SeedTrace.V2.V3; public class TestCaseImplementationDescription { [JsonPropertyName("boards")] - public List Boards { get; init; } + public IEnumerable Boards { get; init; } } diff --git a/seed/csharp-sdk/trace/src/SeedTrace/V2/V3/Problem/Types/VoidFunctionDefinition.cs b/seed/csharp-sdk/trace/src/SeedTrace/V2/V3/Problem/Types/VoidFunctionDefinition.cs index 869a8addd55..c570b2a78bf 100644 --- a/seed/csharp-sdk/trace/src/SeedTrace/V2/V3/Problem/Types/VoidFunctionDefinition.cs +++ b/seed/csharp-sdk/trace/src/SeedTrace/V2/V3/Problem/Types/VoidFunctionDefinition.cs @@ -8,7 +8,7 @@ namespace SeedTrace.V2.V3; public class VoidFunctionDefinition { [JsonPropertyName("parameters")] - public List Parameters { get; init; } + public IEnumerable Parameters { get; init; } [JsonPropertyName("code")] public FunctionImplementationForMultipleLanguages Code { get; init; } diff --git a/seed/csharp-sdk/trace/src/SeedTrace/V2/V3/Problem/Types/VoidFunctionDefinitionThatTakesActualResult.cs b/seed/csharp-sdk/trace/src/SeedTrace/V2/V3/Problem/Types/VoidFunctionDefinitionThatTakesActualResult.cs index dd0c0430617..145cdc2df2d 100644 --- a/seed/csharp-sdk/trace/src/SeedTrace/V2/V3/Problem/Types/VoidFunctionDefinitionThatTakesActualResult.cs +++ b/seed/csharp-sdk/trace/src/SeedTrace/V2/V3/Problem/Types/VoidFunctionDefinitionThatTakesActualResult.cs @@ -8,7 +8,7 @@ namespace SeedTrace.V2.V3; public class VoidFunctionDefinitionThatTakesActualResult { [JsonPropertyName("additionalParameters")] - public List AdditionalParameters { get; init; } + public IEnumerable AdditionalParameters { get; init; } [JsonPropertyName("code")] public FunctionImplementationForMultipleLanguages Code { get; init; } diff --git a/seed/csharp-sdk/trace/src/SeedTrace/V2/V3/Problem/Types/VoidFunctionSignature.cs b/seed/csharp-sdk/trace/src/SeedTrace/V2/V3/Problem/Types/VoidFunctionSignature.cs index dd8c8a0d5a9..c03ba728de7 100644 --- a/seed/csharp-sdk/trace/src/SeedTrace/V2/V3/Problem/Types/VoidFunctionSignature.cs +++ b/seed/csharp-sdk/trace/src/SeedTrace/V2/V3/Problem/Types/VoidFunctionSignature.cs @@ -8,5 +8,5 @@ namespace SeedTrace.V2.V3; public class VoidFunctionSignature { [JsonPropertyName("parameters")] - public List Parameters { get; init; } + public IEnumerable Parameters { get; init; } } diff --git a/seed/csharp-sdk/trace/src/SeedTrace/V2/V3/Problem/Types/VoidFunctionSignatureThatTakesActualResult.cs b/seed/csharp-sdk/trace/src/SeedTrace/V2/V3/Problem/Types/VoidFunctionSignatureThatTakesActualResult.cs index 73c2ef67861..594085a9a11 100644 --- a/seed/csharp-sdk/trace/src/SeedTrace/V2/V3/Problem/Types/VoidFunctionSignatureThatTakesActualResult.cs +++ b/seed/csharp-sdk/trace/src/SeedTrace/V2/V3/Problem/Types/VoidFunctionSignatureThatTakesActualResult.cs @@ -9,7 +9,7 @@ namespace SeedTrace.V2.V3; public class VoidFunctionSignatureThatTakesActualResult { [JsonPropertyName("parameters")] - public List Parameters { get; init; } + public IEnumerable Parameters { get; init; } [JsonPropertyName("actualResultType")] public VariableType ActualResultType { get; init; } diff --git a/seed/csharp-sdk/undiscriminated-unions/src/SeedUndiscriminatedUnions/Core/CollectionItemSerializer.cs b/seed/csharp-sdk/undiscriminated-unions/src/SeedUndiscriminatedUnions/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..ef3378fe044 --- /dev/null +++ b/seed/csharp-sdk/undiscriminated-unions/src/SeedUndiscriminatedUnions/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedUndiscriminatedUnions; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-sdk/undiscriminated-unions/src/SeedUndiscriminatedUnions/Union/UnionClient.cs b/seed/csharp-sdk/undiscriminated-unions/src/SeedUndiscriminatedUnions/Union/UnionClient.cs index 23eca4d1071..657d6257d81 100644 --- a/seed/csharp-sdk/undiscriminated-unions/src/SeedUndiscriminatedUnions/Union/UnionClient.cs +++ b/seed/csharp-sdk/undiscriminated-unions/src/SeedUndiscriminatedUnions/Union/UnionClient.cs @@ -16,9 +16,23 @@ public UnionClient(RawClient client) } public async Task< - OneOf, int, List, List>, HashSet> + OneOf< + string, + IEnumerable, + int, + IEnumerable, + IEnumerable>, + HashSet + > > GetAsync( - OneOf, int, List, List>, HashSet> request + OneOf< + string, + IEnumerable, + int, + IEnumerable, + IEnumerable>, + HashSet + > request ) { var response = await _client.MakeRequestAsync( @@ -33,7 +47,14 @@ OneOf, int, List, List>, HashSet> re if (response.StatusCode >= 200 && response.StatusCode < 400) { return JsonSerializer.Deserialize< - OneOf, int, List, List>, HashSet> + OneOf< + string, + IEnumerable, + int, + IEnumerable, + IEnumerable>, + HashSet + > >(responseBody); } throw new Exception(responseBody); diff --git a/seed/csharp-sdk/unions/src/SeedUnions/Core/CollectionItemSerializer.cs b/seed/csharp-sdk/unions/src/SeedUnions/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..b329843d776 --- /dev/null +++ b/seed/csharp-sdk/unions/src/SeedUnions/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedUnions; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-sdk/unknown/src/SeedUnknownAsAny/Core/CollectionItemSerializer.cs b/seed/csharp-sdk/unknown/src/SeedUnknownAsAny/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..df1f27aa4bf --- /dev/null +++ b/seed/csharp-sdk/unknown/src/SeedUnknownAsAny/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedUnknownAsAny; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-sdk/unknown/src/SeedUnknownAsAny/Unknown/UnknownClient.cs b/seed/csharp-sdk/unknown/src/SeedUnknownAsAny/Unknown/UnknownClient.cs index f636b9adc2a..7b18375c6e6 100644 --- a/seed/csharp-sdk/unknown/src/SeedUnknownAsAny/Unknown/UnknownClient.cs +++ b/seed/csharp-sdk/unknown/src/SeedUnknownAsAny/Unknown/UnknownClient.cs @@ -14,7 +14,7 @@ public UnknownClient(RawClient client) _client = client; } - public async Task> PostAsync(object request) + public async Task> PostAsync(object request) { var response = await _client.MakeRequestAsync( new RawClient.ApiRequest @@ -27,7 +27,7 @@ public async Task> PostAsync(object request) string responseBody = await response.Raw.Content.ReadAsStringAsync(); if (response.StatusCode >= 200 && response.StatusCode < 400) { - return JsonSerializer.Deserialize>(responseBody); + return JsonSerializer.Deserialize>(responseBody); } throw new Exception(responseBody); } diff --git a/seed/csharp-sdk/validation/src/SeedValidation/Core/CollectionItemSerializer.cs b/seed/csharp-sdk/validation/src/SeedValidation/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..643c3d3387e --- /dev/null +++ b/seed/csharp-sdk/validation/src/SeedValidation/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedValidation; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-sdk/variables/src/SeedVariables/Core/CollectionItemSerializer.cs b/seed/csharp-sdk/variables/src/SeedVariables/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..2e2b98b80cc --- /dev/null +++ b/seed/csharp-sdk/variables/src/SeedVariables/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedVariables; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +} diff --git a/seed/csharp-sdk/websocket/src/SeedWebsocket/Core/CollectionItemSerializer.cs b/seed/csharp-sdk/websocket/src/SeedWebsocket/Core/CollectionItemSerializer.cs new file mode 100644 index 00000000000..3259f23e4eb --- /dev/null +++ b/seed/csharp-sdk/websocket/src/SeedWebsocket/Core/CollectionItemSerializer.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace SeedWebsocket; + +/// +/// Json collection converter. +/// +/// Type of item to convert. +/// Converter to use for individual items. +public class CollectionItemSerializer + : JsonConverter> + where TConverterType : JsonConverter +{ + /// + /// Reads a json string and deserializes it into an object. + /// + /// Json reader. + /// Type to convert. + /// Serializer options. + /// Created object. + public override IEnumerable Read( + ref Utf8JsonReader reader, + Type typeToConvert, + JsonSerializerOptions options + ) + { + if (reader.TokenType == JsonTokenType.Null) + { + return default(IEnumerable); + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + List returnValue = new List(); + + while (reader.TokenType != JsonTokenType.EndArray) + { + if (reader.TokenType != JsonTokenType.StartArray) + { + returnValue.Add( + (TDatatype) + JsonSerializer.Deserialize( + ref reader, + typeof(TDatatype), + jsonSerializerOptions + ) + ); + } + + reader.Read(); + } + + return returnValue; + } + + /// + /// Writes a json string. + /// + /// Json writer. + /// Value to write. + /// Serializer options. + public override void Write( + Utf8JsonWriter writer, + IEnumerable value, + JsonSerializerOptions options + ) + { + if (value == null) + { + writer.WriteNullValue(); + return; + } + + JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions(options); + jsonSerializerOptions.Converters.Clear(); + jsonSerializerOptions.Converters.Add(Activator.CreateInstance()); + + writer.WriteStartArray(); + + foreach (TDatatype data in value) + { + JsonSerializer.Serialize(writer, data, jsonSerializerOptions); + } + + writer.WriteEndArray(); + } +}