From 97086cb47f95dc32ba68bb49927cb6b7ce5e1016 Mon Sep 17 00:00:00 2001 From: "jess.anderson" Date: Thu, 11 Dec 2014 14:42:01 -0700 Subject: [PATCH 1/3] Modified the solution to include a NET40 build of the project using the Microsoft Async nuget package. --- src/kafka-net.nuspec | 5 +- src/kafka-net.sln | 12 + src/kafka-net/Common/Extensions.cs | 8 +- src/kafka-net/Common/ThreadWall.cs | 13 +- src/kafka-net/KafkaTcpSocket.cs | 21 +- src/kafka-net/MetadataQueries.cs | 7 +- src/kafka-net/Producer.cs | 9 +- src/kafka-net40/app.config | 15 ++ src/kafka-net40/kafka-net40.csproj | 222 +++++++++++++++++++ src/kafka-net40/packages.config | 6 + src/kafka-tests/App.config | 4 +- src/kafka-tests/Unit/ConsumerTests.cs | 6 +- src/kafka-tests/Unit/KafkaConnectionTests.cs | 6 +- src/kafka-tests40/App.config | 19 ++ src/kafka-tests40/kafka-tests40.csproj | 195 ++++++++++++++++ src/kafka-tests40/packages.config | 12 + 16 files changed, 541 insertions(+), 19 deletions(-) create mode 100644 src/kafka-net40/app.config create mode 100644 src/kafka-net40/kafka-net40.csproj create mode 100644 src/kafka-net40/packages.config create mode 100644 src/kafka-tests40/App.config create mode 100644 src/kafka-tests40/kafka-tests40.csproj create mode 100644 src/kafka-tests40/packages.config diff --git a/src/kafka-net.nuspec b/src/kafka-net.nuspec index 292fe471..00d5b7b5 100644 --- a/src/kafka-net.nuspec +++ b/src/kafka-net.nuspec @@ -16,6 +16,7 @@ C# Apache Kafka - + + - \ No newline at end of file + diff --git a/src/kafka-net.sln b/src/kafka-net.sln index 7405a564..57295789 100644 --- a/src/kafka-net.sln +++ b/src/kafka-net.sln @@ -23,6 +23,10 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution ..\README.md = ..\README.md EndProjectSection EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "kafka-net40", "kafka-net40\kafka-net40.csproj", "{E8DBFB90-FAC3-4083-8116-74291B864443}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "kafka-tests40", "kafka-tests40\kafka-tests40.csproj", "{7A0D1379-A6E8-4F23-A3B5-56AD3121377D}" +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU @@ -41,6 +45,14 @@ Global {53E0B3CE-6C41-4C8A-8B66-9BD03667B1E0}.Debug|Any CPU.Build.0 = Debug|Any CPU {53E0B3CE-6C41-4C8A-8B66-9BD03667B1E0}.Release|Any CPU.ActiveCfg = Release|Any CPU {53E0B3CE-6C41-4C8A-8B66-9BD03667B1E0}.Release|Any CPU.Build.0 = Release|Any CPU + {E8DBFB90-FAC3-4083-8116-74291B864443}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {E8DBFB90-FAC3-4083-8116-74291B864443}.Debug|Any CPU.Build.0 = Debug|Any CPU + {E8DBFB90-FAC3-4083-8116-74291B864443}.Release|Any CPU.ActiveCfg = Release|Any CPU + {E8DBFB90-FAC3-4083-8116-74291B864443}.Release|Any CPU.Build.0 = Release|Any CPU + {7A0D1379-A6E8-4F23-A3B5-56AD3121377D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {7A0D1379-A6E8-4F23-A3B5-56AD3121377D}.Debug|Any CPU.Build.0 = Debug|Any CPU + {7A0D1379-A6E8-4F23-A3B5-56AD3121377D}.Release|Any CPU.ActiveCfg = Release|Any CPU + {7A0D1379-A6E8-4F23-A3B5-56AD3121377D}.Release|Any CPU.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE diff --git a/src/kafka-net/Common/Extensions.cs b/src/kafka-net/Common/Extensions.cs index 268740e0..c985104e 100644 --- a/src/kafka-net/Common/Extensions.cs +++ b/src/kafka-net/Common/Extensions.cs @@ -108,11 +108,15 @@ public static async Task WithCancellation(this Task task, CancellationT using (cancellationToken.Register(source => ((TaskCompletionSource)source).TrySetResult(true), tcs)) { +#if NET40 + if (task != await TaskEx.WhenAny(task, tcs.Task)) +#else if (task != await Task.WhenAny(task, tcs.Task)) +#endif { throw new OperationCanceledException(cancellationToken); - } - } + } + } return await task; } diff --git a/src/kafka-net/Common/ThreadWall.cs b/src/kafka-net/Common/ThreadWall.cs index 844e94d0..c29646e6 100644 --- a/src/kafka-net/Common/ThreadWall.cs +++ b/src/kafka-net/Common/ThreadWall.cs @@ -75,8 +75,12 @@ public void Release() /// Task handle to signal passage allowed. public Task RequestPassageAsync() { +#if NET40 + return AsTask(_semaphore.AvailableWaitHandle, new TimeSpan(0,0,0,0,-1)); +#else return AsTask(_semaphore.AvailableWaitHandle, Timeout.InfiniteTimeSpan); - } +#endif + } private static Task AsTask(WaitHandle handle, TimeSpan timeout) { @@ -89,8 +93,13 @@ private static Task AsTask(WaitHandle handle, TimeSpan timeout) else localTcs.TrySetResult(null); }, tcs, timeout, executeOnlyOnce: true); +#if NET40 + tcs.Task.ContinueWith((_) => registration.Unregister(null), TaskScheduler.Default); +#else tcs.Task.ContinueWith((_, state) => ((RegisteredWaitHandle)state).Unregister(null), registration, TaskScheduler.Default); - return tcs.Task; + +#endif + return tcs.Task; } } } diff --git a/src/kafka-net/KafkaTcpSocket.cs b/src/kafka-net/KafkaTcpSocket.cs index 2c1a941c..91f45ca8 100644 --- a/src/kafka-net/KafkaTcpSocket.cs +++ b/src/kafka-net/KafkaTcpSocket.cs @@ -44,7 +44,11 @@ public KafkaTcpSocket(IKafkaLog log, KafkaEndpoint endpoint, int delayConnectAtt { _log = log; _endpoint = endpoint; +#if NET40 + TaskEx.Delay(TimeSpan.FromMilliseconds(delayConnectAttemptMS)).ContinueWith(x => TriggerReconnection()); +#else Task.Delay(TimeSpan.FromMilliseconds(delayConnectAttemptMS)).ContinueWith(x => TriggerReconnection()); +#endif } #region Interface Implementation... @@ -127,8 +131,12 @@ private async Task EnsureReadAsync(int readSize, CancellationToken token { var cancelTaskToken = new CancellationTokenRegistration(); try - { - await _singleReaderSemaphore.WaitAsync(token); + { +#if NET40 + await TaskEx.Run(()=>_singleReaderSemaphore.Wait(token)); +#else + await _singleReaderSemaphore.WaitAsync(token); +#endif var result = new List(); var bytesReceived = 0; @@ -210,9 +218,12 @@ private async Task ReEstablishConnectionAsync() reconnectionDelay = reconnectionDelay * DefaultReconnectionTimeoutMultiplier; _log.WarnFormat("Failed re-connection to:{0}. Will retry in:{1}", _endpoint, reconnectionDelay); } - - await Task.Delay(TimeSpan.FromMilliseconds(reconnectionDelay), _disposeToken.Token); - } +#if NET40 + await TaskEx.Delay(TimeSpan.FromMilliseconds(reconnectionDelay), _disposeToken.Token); +#else + await Task.Delay(TimeSpan.FromMilliseconds(reconnectionDelay), _disposeToken.Token); +#endif + } return _client; } diff --git a/src/kafka-net/MetadataQueries.cs b/src/kafka-net/MetadataQueries.cs index f9331025..31b4a7b9 100644 --- a/src/kafka-net/MetadataQueries.cs +++ b/src/kafka-net/MetadataQueries.cs @@ -52,9 +52,14 @@ public Task> GetTopicOffsetAsync(string topic, int maxOffse return route.Connection.SendAsync(request); }).ToArray(); +#if NET40 + return TaskEx.WhenAll(sendRequests) + .ContinueWith(t => sendRequests.SelectMany(x => x.Result).ToList()); +#else return Task.WhenAll(sendRequests) .ContinueWith(t => sendRequests.SelectMany(x => x.Result).ToList()); - } +#endif + } /// /// Get metadata on the given topic. diff --git a/src/kafka-net/Producer.cs b/src/kafka-net/Producer.cs index dbcf8967..f7450243 100644 --- a/src/kafka-net/Producer.cs +++ b/src/kafka-net/Producer.cs @@ -93,9 +93,12 @@ into routes }; sendTasks.Add(route.Key.Connection.SendAsync(request)); - } - - await Task.WhenAll(sendTasks.ToArray()); + } +#if NET40 + await TaskEx.WhenAll(sendTasks.ToArray()); +#else + await Task.WhenAll(sendTasks.ToArray()); +#endif return sendTasks.SelectMany(t => t.Result).ToList(); } diff --git a/src/kafka-net40/app.config b/src/kafka-net40/app.config new file mode 100644 index 00000000..3c737829 --- /dev/null +++ b/src/kafka-net40/app.config @@ -0,0 +1,15 @@ + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/src/kafka-net40/kafka-net40.csproj b/src/kafka-net40/kafka-net40.csproj new file mode 100644 index 00000000..b8719f60 --- /dev/null +++ b/src/kafka-net40/kafka-net40.csproj @@ -0,0 +1,222 @@ + + + + + Debug + AnyCPU + {E8DBFB90-FAC3-4083-8116-74291B864443} + Library + Properties + KafkaNet + kafka-net + v4.0 + 512 + + ..\ + true + + + true + full + false + bin\Debug\ + TRACE;DEBUG;NET40 + prompt + 4 + false + + + pdbonly + true + bin\Release\ + TRACE;NET40 + prompt + 4 + false + + + + ..\packages\Microsoft.Bcl.Async.1.0.168\lib\net40\Microsoft.Threading.Tasks.dll + + + ..\packages\Microsoft.Bcl.Async.1.0.168\lib\net40\Microsoft.Threading.Tasks.Extensions.dll + + + ..\packages\Microsoft.Bcl.Async.1.0.168\lib\net40\Microsoft.Threading.Tasks.Extensions.Desktop.dll + + + + + ..\packages\Microsoft.Bcl.1.1.8\lib\net40\System.IO.dll + + + + ..\packages\Microsoft.Bcl.1.1.8\lib\net40\System.Runtime.dll + + + ..\packages\Microsoft.Bcl.1.1.8\lib\net40\System.Threading.Tasks.dll + + + + + + + + + + Common\ThreadWall.cs + + + Default\DefaultKafkaConnectionFactory.cs + + + Interfaces\IMetadataQueries.cs + + + Interfaces\IKafkaTcpSocket.cs + + + Model\BrokerRoute.cs + + + Common\ScheduledTimer.cs + + + Consumer.cs + + + Interfaces\IKafkaConnection.cs + + + Interfaces\IBrokerRouter.cs + + + MetadataQueries.cs + + + Model\ConsumerOptions.cs + + + Default\DefaultPartitionSelector.cs + + + Interfaces\IKafkaLog.cs + + + Interfaces\IPartitionSelector.cs + + + BrokerRouter.cs + + + Model\KafkaEndpoint.cs + + + KafkaMetadataProvider.cs + + + Protocol\Broker.cs + + + Common\ReadByteStream.cs + + + Common\Crc32.cs + + + Common\WriteByteStream.cs + + + Interfaces\IKafkaConnectionFactory.cs + + + Producer.cs + + + KafkaConnection.cs + + + Common\Extensions.cs + + + Model\KafkaOptions.cs + + + Protocol\ConsumerMetadataRequest.cs + + + Protocol\OffsetFetchRequest.cs + + + Protocol\Protocol.cs + + + Protocol\BaseRequest.cs + + + Interfaces\IKafkaRequest.cs + + + Protocol\FetchRequest.cs + + + Protocol\Message.cs + + + Properties\AssemblyInfo.cs + + + Protocol\Topic.cs + + + Protocol\MetadataRequest.cs + + + Protocol\OffsetCommitRequest.cs + + + Protocol\OffsetRequest.cs + + + Protocol\ProduceRequest.cs + + + Default\DefaultTraceLog.cs + + + KafkaTcpSocket.cs + + + + + + + + + + + + NewFolder1\.gitattributes + + + + + + + This project references NuGet package(s) that are missing on this computer. Enable NuGet Package Restore to download them. For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}. + + + + + + + + + + \ No newline at end of file diff --git a/src/kafka-net40/packages.config b/src/kafka-net40/packages.config new file mode 100644 index 00000000..fd0874c2 --- /dev/null +++ b/src/kafka-net40/packages.config @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/src/kafka-tests/App.config b/src/kafka-tests/App.config index 573bbfb7..3c99bb29 100644 --- a/src/kafka-tests/App.config +++ b/src/kafka-tests/App.config @@ -1,6 +1,6 @@  - - + + \ No newline at end of file diff --git a/src/kafka-tests/Unit/ConsumerTests.cs b/src/kafka-tests/Unit/ConsumerTests.cs index 9ee33fff..2b85474b 100644 --- a/src/kafka-tests/Unit/ConsumerTests.cs +++ b/src/kafka-tests/Unit/ConsumerTests.cs @@ -32,7 +32,11 @@ public void CancellationShouldInterruptConsumption() { var tokenSrc = new CancellationTokenSource(); - var consumeTask = Task.Run(() => consumer.Consume(tokenSrc.Token).FirstOrDefault()); +#if NET40 + var consumeTask = TaskEx.Run(() => consumer.Consume(tokenSrc.Token).FirstOrDefault()); +#else + var consumeTask = Task.Run(() => consumer.Consume(tokenSrc.Token).FirstOrDefault()); +#endif //wait until the fake broker is running and requesting fetches TaskTest.WaitFor(() => routerProxy.BrokerConn0.FetchRequestCallCount > 10); diff --git a/src/kafka-tests/Unit/KafkaConnectionTests.cs b/src/kafka-tests/Unit/KafkaConnectionTests.cs index 7f307044..f988983a 100644 --- a/src/kafka-tests/Unit/KafkaConnectionTests.cs +++ b/src/kafka-tests/Unit/KafkaConnectionTests.cs @@ -167,7 +167,11 @@ public void SendAsyncShouldTimeoutMultipleMessagesAtATime() conn.SendAsync(new MetadataRequest()) }; - Task.WhenAll(tasks); +#if NET40 + TaskEx.WhenAll(tasks); +#else + Task.WhenAll(tasks); +#endif TaskTest.WaitFor(() => tasks.Any(t => t.IsFaulted)); foreach (var task in tasks) diff --git a/src/kafka-tests40/App.config b/src/kafka-tests40/App.config new file mode 100644 index 00000000..99233752 --- /dev/null +++ b/src/kafka-tests40/App.config @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/src/kafka-tests40/kafka-tests40.csproj b/src/kafka-tests40/kafka-tests40.csproj new file mode 100644 index 00000000..375bd40e --- /dev/null +++ b/src/kafka-tests40/kafka-tests40.csproj @@ -0,0 +1,195 @@ + + + + + Debug + AnyCPU + {7A0D1379-A6E8-4F23-A3B5-56AD3121377D} + Library + Properties + kafka_tests + kafka-tests + v4.0 + 512 + ..\ + true + + + + true + full + false + bin\Debug\ + TRACE;DEBUG;NET40 + prompt + 4 + + + pdbonly + true + bin\Release\ + TRACE;NET40 + prompt + 4 + + + + ..\packages\Microsoft.Bcl.Async.1.0.168\lib\net40\Microsoft.Threading.Tasks.dll + + + ..\packages\Microsoft.Bcl.Async.1.0.168\lib\net40\Microsoft.Threading.Tasks.Extensions.dll + + + ..\packages\Microsoft.Bcl.Async.1.0.168\lib\net40\Microsoft.Threading.Tasks.Extensions.Desktop.dll + + + ..\packages\Moq.4.0.10827\lib\NET40\Moq.dll + + + ..\packages\Ninject.3.0.1.10\lib\net45-full\Ninject.dll + + + ..\packages\Ninject.MockingKernel.3.0.0.5\lib\net45-full\Ninject.MockingKernel.dll + + + ..\packages\Ninject.MockingKernel.Moq.3.0.0.5\lib\net45-full\Ninject.MockingKernel.Moq.dll + + + ..\packages\NSubstitute.1.7.2.0\lib\NET40\NSubstitute.dll + + + ..\packages\NUnit.2.6.3\lib\nunit.framework.dll + + + + + + ..\packages\Microsoft.Bcl.1.1.8\lib\net40\System.IO.dll + + + + ..\packages\Microsoft.Bcl.1.1.8\lib\net40\System.Runtime.dll + + + ..\packages\Microsoft.Bcl.1.1.8\lib\net40\System.Threading.Tasks.dll + + + + + + + + + + Fakes\BrokerRouterProxy.cs + + + Fakes\FakeKafkaConnection.cs + + + Fakes\FakeTcpServer.cs + + + Helpers\IntegrationConfig.cs + + + Helpers\MessageHelper.cs + + + Helpers\TaskTest.cs + + + Integration\GzipProducerConsumerTests.cs + + + Integration\KafkaMetadataProviderUnitTests.cs + + + Integration\OffsetManagementTests.cs + + + Integration\ProducerConsumerIntegrationTests.cs + + + Unit\FakeTcpServerTests.cs + + + Unit\KafkaConnectionTests.cs + + + Unit\KafkaEndpointTests.cs + + + Unit\KafkaMetadataProviderTests.cs + + + Unit\KafkaTcpSocketTests.cs + + + Integration\KafkaConnectionIntegrationTests.cs + + + RequestFactory.cs + + + Unit\BrokerRouterTests.cs + + + Unit\MetadataQueriesTests.cs + + + Unit\ConsumerTests.cs + + + Unit\DefaultPartitionSelectorTests.cs + + + Unit\ProducerTests.cs + + + Unit\ProtocolBaseRequestTests.cs + + + Unit\ProtocolMessageTests.cs + + + Properties\AssemblyInfo.cs + + + Unit\ScheduleTimerTests.cs + + + + + + + + + + + + {e8dbfb90-fac3-4083-8116-74291b864443} + kafka-net40 + + + + + + + This project references NuGet package(s) that are missing on this computer. Enable NuGet Package Restore to download them. For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}. + + + + + + + + + + \ No newline at end of file diff --git a/src/kafka-tests40/packages.config b/src/kafka-tests40/packages.config new file mode 100644 index 00000000..5d26e315 --- /dev/null +++ b/src/kafka-tests40/packages.config @@ -0,0 +1,12 @@ + + + + + + + + + + + + \ No newline at end of file From 4b7a6661dace44d8f754a4e5938ffc06d0d591d3 Mon Sep 17 00:00:00 2001 From: "jess.anderson" Date: Tue, 16 Dec 2014 09:50:00 -0700 Subject: [PATCH 2/3] Checked in the Microsoft.Bcl packages because they don't work with package restore --- .../Microsoft.Bcl.1.1.8/License-Stable.rtf | 118 + .../Microsoft.Bcl.1.1.8.nupkg | Bin 0 -> 1008954 bytes .../Microsoft.Bcl.1.1.8/content/net45/_._ | 0 .../content/portable-net45+win8+wp8+wpa81/_._ | 0 .../content/portable-net45+win8+wpa81/_._ | 0 .../content/portable-net451+win81+wpa81/_._ | 0 .../content/portable-net451+win81/_._ | 0 .../content/portable-win81+wp81+wpa81/_._ | 0 .../Microsoft.Bcl.1.1.8/content/sl4/_._ | 0 .../Microsoft.Bcl.1.1.8/content/sl5/_._ | 0 .../Microsoft.Bcl.1.1.8/content/win8/_._ | 0 .../Microsoft.Bcl.1.1.8/content/wp8/_._ | 0 .../Microsoft.Bcl.1.1.8/content/wpa81/_._ | 0 .../lib/net40/System.IO.dll | Bin 0 -> 21168 bytes .../lib/net40/System.IO.xml | 8 + .../lib/net40/System.Runtime.dll | Bin 0 -> 22208 bytes .../lib/net40/System.Runtime.xml | 56 + .../lib/net40/System.Threading.Tasks.dll | Bin 0 -> 34528 bytes .../lib/net40/System.Threading.Tasks.xml | 475 + .../lib/net40/ensureRedirect.xml | 0 .../Microsoft.Bcl.1.1.8/lib/net45/_._ | 0 .../System.IO.dll | Bin 0 -> 22704 bytes .../System.IO.xml | 51 + .../System.Runtime.dll | Bin 0 -> 39104 bytes .../System.Runtime.xml | 860 ++ .../System.Threading.Tasks.dll | Bin 0 -> 164576 bytes .../System.Threading.Tasks.xml | 8969 +++++++++++++++++ .../ensureRedirect.xml | 0 .../System.IO.dll | Bin 0 -> 22704 bytes .../System.IO.xml | 51 + .../System.Runtime.dll | Bin 0 -> 22208 bytes .../System.Runtime.xml | 56 + .../System.Threading.Tasks.dll | Bin 0 -> 164576 bytes .../System.Threading.Tasks.xml | 8969 +++++++++++++++++ .../ensureRedirect.xml | 0 .../lib/portable-net40+sl4+win8/System.IO.dll | Bin 0 -> 22704 bytes .../lib/portable-net40+sl4+win8/System.IO.xml | 51 + .../System.Runtime.dll | Bin 0 -> 22208 bytes .../System.Runtime.xml | 56 + .../System.Threading.Tasks.dll | Bin 0 -> 164576 bytes .../System.Threading.Tasks.xml | 8969 +++++++++++++++++ .../ensureRedirect.xml | 0 .../System.IO.dll | Bin 0 -> 22704 bytes .../System.IO.xml | 51 + .../System.Runtime.dll | Bin 0 -> 22208 bytes .../System.Runtime.xml | 56 + .../System.Threading.Tasks.dll | Bin 0 -> 34528 bytes .../System.Threading.Tasks.xml | 475 + .../ensureRedirect.xml | 0 .../System.IO.dll | Bin 0 -> 22704 bytes .../System.IO.xml | 51 + .../System.Runtime.dll | Bin 0 -> 22208 bytes .../System.Runtime.xml | 56 + .../System.Threading.Tasks.dll | Bin 0 -> 34528 bytes .../System.Threading.Tasks.xml | 475 + .../ensureRedirect.xml | 0 .../lib/portable-net40+win8/System.IO.dll | Bin 0 -> 21168 bytes .../lib/portable-net40+win8/System.IO.xml | 8 + .../portable-net40+win8/System.Runtime.dll | Bin 0 -> 22208 bytes .../portable-net40+win8/System.Runtime.xml | 56 + .../System.Threading.Tasks.dll | Bin 0 -> 34528 bytes .../System.Threading.Tasks.xml | 475 + .../portable-net40+win8/ensureRedirect.xml | 0 .../lib/portable-net45+win8+wp8+wpa81/_._ | 0 .../lib/portable-net45+win8+wpa81/_._ | 0 .../lib/portable-net451+win81+wpa81/_._ | 0 .../lib/portable-net451+win81/_._ | 0 .../lib/portable-win81+wp81+wpa81/_._ | 0 .../lib/sl4-windowsphone71/System.IO.dll | Bin 0 -> 22704 bytes .../lib/sl4-windowsphone71/System.IO.xml | 51 + .../lib/sl4-windowsphone71/System.Runtime.dll | Bin 0 -> 39104 bytes .../lib/sl4-windowsphone71/System.Runtime.xml | 860 ++ .../System.Threading.Tasks.dll | Bin 0 -> 164576 bytes .../System.Threading.Tasks.xml | 8969 +++++++++++++++++ .../lib/sl4-windowsphone71/ensureRedirect.xml | 0 .../Microsoft.Bcl.1.1.8/lib/sl4/System.IO.dll | Bin 0 -> 22704 bytes .../Microsoft.Bcl.1.1.8/lib/sl4/System.IO.xml | 51 + .../lib/sl4/System.Runtime.dll | Bin 0 -> 22208 bytes .../lib/sl4/System.Runtime.xml | 56 + .../lib/sl4/System.Threading.Tasks.dll | Bin 0 -> 164576 bytes .../lib/sl4/System.Threading.Tasks.xml | 8969 +++++++++++++++++ .../Microsoft.Bcl.1.1.8/lib/sl5/System.IO.dll | Bin 0 -> 22704 bytes .../Microsoft.Bcl.1.1.8/lib/sl5/System.IO.xml | 51 + .../lib/sl5/System.Runtime.dll | Bin 0 -> 22208 bytes .../lib/sl5/System.Runtime.xml | 56 + .../lib/sl5/System.Threading.Tasks.dll | Bin 0 -> 34528 bytes .../lib/sl5/System.Threading.Tasks.xml | 475 + src/packages/Microsoft.Bcl.1.1.8/lib/win8/_._ | 0 src/packages/Microsoft.Bcl.1.1.8/lib/wp8/_._ | 0 .../Microsoft.Bcl.1.1.8/lib/wpa81/_._ | 0 .../License-Stable.rtf | 118 + .../Microsoft.Bcl.Async.1.0.168.nupkg | Bin 0 -> 491429 bytes ...oft.Threading.Tasks.Extensions.Desktop.dll | Bin 0 -> 47424 bytes ...oft.Threading.Tasks.Extensions.Desktop.xml | 684 ++ .../Microsoft.Threading.Tasks.Extensions.dll | Bin 0 -> 31520 bytes .../Microsoft.Threading.Tasks.Extensions.xml | 275 + .../lib/net40/Microsoft.Threading.Tasks.dll | Bin 0 -> 37104 bytes .../lib/net40/Microsoft.Threading.Tasks.xml | 630 ++ .../Microsoft.Threading.Tasks.Extensions.dll | Bin 0 -> 31520 bytes .../Microsoft.Threading.Tasks.Extensions.xml | 275 + .../Microsoft.Threading.Tasks.dll | Bin 0 -> 37104 bytes .../Microsoft.Threading.Tasks.xml | 630 ++ .../Microsoft.Threading.Tasks.Extensions.dll | Bin 0 -> 31520 bytes .../Microsoft.Threading.Tasks.Extensions.xml | 275 + .../Microsoft.Threading.Tasks.dll | Bin 0 -> 37104 bytes .../Microsoft.Threading.Tasks.xml | 630 ++ .../Microsoft.Threading.Tasks.Extensions.dll | Bin 0 -> 31520 bytes .../Microsoft.Threading.Tasks.Extensions.xml | 275 + .../Microsoft.Threading.Tasks.dll | Bin 0 -> 37104 bytes .../Microsoft.Threading.Tasks.xml | 630 ++ ...osoft.Threading.Tasks.Extensions.Phone.dll | Bin 0 -> 28984 bytes ...osoft.Threading.Tasks.Extensions.Phone.xml | 141 + .../Microsoft.Threading.Tasks.Extensions.dll | Bin 0 -> 31520 bytes .../Microsoft.Threading.Tasks.Extensions.xml | 275 + .../Microsoft.Threading.Tasks.dll | Bin 0 -> 37104 bytes .../Microsoft.Threading.Tasks.xml | 630 ++ ...Threading.Tasks.Extensions.Silverlight.dll | Bin 0 -> 29008 bytes ...Threading.Tasks.Extensions.Silverlight.xml | 141 + .../Microsoft.Threading.Tasks.Extensions.dll | Bin 0 -> 31520 bytes .../Microsoft.Threading.Tasks.Extensions.xml | 275 + .../lib/sl4/Microsoft.Threading.Tasks.dll | Bin 0 -> 37104 bytes .../lib/sl4/Microsoft.Threading.Tasks.xml | 630 ++ .../Microsoft.Threading.Tasks.Extensions.dll | Bin 0 -> 31520 bytes .../Microsoft.Threading.Tasks.Extensions.xml | 275 + .../lib/win8/Microsoft.Threading.Tasks.dll | Bin 0 -> 37104 bytes .../lib/win8/Microsoft.Threading.Tasks.xml | 630 ++ ...osoft.Threading.Tasks.Extensions.Phone.dll | Bin 0 -> 28984 bytes ...osoft.Threading.Tasks.Extensions.Phone.xml | 141 + .../Microsoft.Threading.Tasks.Extensions.dll | Bin 0 -> 31520 bytes .../Microsoft.Threading.Tasks.Extensions.xml | 275 + .../lib/wp8/Microsoft.Threading.Tasks.dll | Bin 0 -> 37104 bytes .../lib/wp8/Microsoft.Threading.Tasks.xml | 630 ++ .../Microsoft.Threading.Tasks.Extensions.dll | Bin 0 -> 31520 bytes .../Microsoft.Threading.Tasks.Extensions.xml | 275 + .../lib/wpa81/Microsoft.Threading.Tasks.dll | Bin 0 -> 37104 bytes .../lib/wpa81/Microsoft.Threading.Tasks.xml | 630 ++ .../License-Stable.rtf | 118 + .../Microsoft.Bcl.Build.1.0.14.nupkg | Bin 0 -> 33795 bytes .../content/net40/_._ | 0 .../content/netcore45/_._ | 0 .../portable-net40+win8+sl4+wp71+wpa81/_._ | 0 .../content/sl4-windowsphone71/_._ | 0 .../content/sl4/_._ | 0 .../tools/Install.ps1 | 38 + .../tools/Microsoft.Bcl.Build.Tasks.dll | Bin 0 -> 37104 bytes .../tools/Microsoft.Bcl.Build.targets | 232 + .../tools/Uninstall.ps1 | 26 + 147 files changed, 59714 insertions(+) create mode 100644 src/packages/Microsoft.Bcl.1.1.8/License-Stable.rtf create mode 100644 src/packages/Microsoft.Bcl.1.1.8/Microsoft.Bcl.1.1.8.nupkg create mode 100644 src/packages/Microsoft.Bcl.1.1.8/content/net45/_._ create mode 100644 src/packages/Microsoft.Bcl.1.1.8/content/portable-net45+win8+wp8+wpa81/_._ create mode 100644 src/packages/Microsoft.Bcl.1.1.8/content/portable-net45+win8+wpa81/_._ create mode 100644 src/packages/Microsoft.Bcl.1.1.8/content/portable-net451+win81+wpa81/_._ create mode 100644 src/packages/Microsoft.Bcl.1.1.8/content/portable-net451+win81/_._ create mode 100644 src/packages/Microsoft.Bcl.1.1.8/content/portable-win81+wp81+wpa81/_._ create mode 100644 src/packages/Microsoft.Bcl.1.1.8/content/sl4/_._ create mode 100644 src/packages/Microsoft.Bcl.1.1.8/content/sl5/_._ create mode 100644 src/packages/Microsoft.Bcl.1.1.8/content/win8/_._ create mode 100644 src/packages/Microsoft.Bcl.1.1.8/content/wp8/_._ create mode 100644 src/packages/Microsoft.Bcl.1.1.8/content/wpa81/_._ create mode 100644 src/packages/Microsoft.Bcl.1.1.8/lib/net40/System.IO.dll create mode 100644 src/packages/Microsoft.Bcl.1.1.8/lib/net40/System.IO.xml create mode 100644 src/packages/Microsoft.Bcl.1.1.8/lib/net40/System.Runtime.dll create mode 100644 src/packages/Microsoft.Bcl.1.1.8/lib/net40/System.Runtime.xml create mode 100644 src/packages/Microsoft.Bcl.1.1.8/lib/net40/System.Threading.Tasks.dll create mode 100644 src/packages/Microsoft.Bcl.1.1.8/lib/net40/System.Threading.Tasks.xml create mode 100644 src/packages/Microsoft.Bcl.1.1.8/lib/net40/ensureRedirect.xml create mode 100644 src/packages/Microsoft.Bcl.1.1.8/lib/net45/_._ create mode 100644 src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+sl4+win8+wp71+wpa81/System.IO.dll create mode 100644 src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+sl4+win8+wp71+wpa81/System.IO.xml create mode 100644 src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+sl4+win8+wp71+wpa81/System.Runtime.dll create mode 100644 src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+sl4+win8+wp71+wpa81/System.Runtime.xml create mode 100644 src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+sl4+win8+wp71+wpa81/System.Threading.Tasks.dll create mode 100644 src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+sl4+win8+wp71+wpa81/System.Threading.Tasks.xml create mode 100644 src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+sl4+win8+wp71+wpa81/ensureRedirect.xml create mode 100644 src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+sl4+win8+wp8+wpa81/System.IO.dll create mode 100644 src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+sl4+win8+wp8+wpa81/System.IO.xml create mode 100644 src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+sl4+win8+wp8+wpa81/System.Runtime.dll create mode 100644 src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+sl4+win8+wp8+wpa81/System.Runtime.xml create mode 100644 src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+sl4+win8+wp8+wpa81/System.Threading.Tasks.dll create mode 100644 src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+sl4+win8+wp8+wpa81/System.Threading.Tasks.xml create mode 100644 src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+sl4+win8+wp8+wpa81/ensureRedirect.xml create mode 100644 src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+sl4+win8/System.IO.dll create mode 100644 src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+sl4+win8/System.IO.xml create mode 100644 src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+sl4+win8/System.Runtime.dll create mode 100644 src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+sl4+win8/System.Runtime.xml create mode 100644 src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+sl4+win8/System.Threading.Tasks.dll create mode 100644 src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+sl4+win8/System.Threading.Tasks.xml create mode 100644 src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+sl4+win8/ensureRedirect.xml create mode 100644 src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+sl5+win8+wp8+wpa81/System.IO.dll create mode 100644 src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+sl5+win8+wp8+wpa81/System.IO.xml create mode 100644 src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+sl5+win8+wp8+wpa81/System.Runtime.dll create mode 100644 src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+sl5+win8+wp8+wpa81/System.Runtime.xml create mode 100644 src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+sl5+win8+wp8+wpa81/System.Threading.Tasks.dll create mode 100644 src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+sl5+win8+wp8+wpa81/System.Threading.Tasks.xml create mode 100644 src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+sl5+win8+wp8+wpa81/ensureRedirect.xml create mode 100644 src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+win8+wp8+wpa81/System.IO.dll create mode 100644 src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+win8+wp8+wpa81/System.IO.xml create mode 100644 src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+win8+wp8+wpa81/System.Runtime.dll create mode 100644 src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+win8+wp8+wpa81/System.Runtime.xml create mode 100644 src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+win8+wp8+wpa81/System.Threading.Tasks.dll create mode 100644 src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+win8+wp8+wpa81/System.Threading.Tasks.xml create mode 100644 src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+win8+wp8+wpa81/ensureRedirect.xml create mode 100644 src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+win8/System.IO.dll create mode 100644 src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+win8/System.IO.xml create mode 100644 src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+win8/System.Runtime.dll create mode 100644 src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+win8/System.Runtime.xml create mode 100644 src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+win8/System.Threading.Tasks.dll create mode 100644 src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+win8/System.Threading.Tasks.xml create mode 100644 src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+win8/ensureRedirect.xml create mode 100644 src/packages/Microsoft.Bcl.1.1.8/lib/portable-net45+win8+wp8+wpa81/_._ create mode 100644 src/packages/Microsoft.Bcl.1.1.8/lib/portable-net45+win8+wpa81/_._ create mode 100644 src/packages/Microsoft.Bcl.1.1.8/lib/portable-net451+win81+wpa81/_._ create mode 100644 src/packages/Microsoft.Bcl.1.1.8/lib/portable-net451+win81/_._ create mode 100644 src/packages/Microsoft.Bcl.1.1.8/lib/portable-win81+wp81+wpa81/_._ create mode 100644 src/packages/Microsoft.Bcl.1.1.8/lib/sl4-windowsphone71/System.IO.dll create mode 100644 src/packages/Microsoft.Bcl.1.1.8/lib/sl4-windowsphone71/System.IO.xml create mode 100644 src/packages/Microsoft.Bcl.1.1.8/lib/sl4-windowsphone71/System.Runtime.dll create mode 100644 src/packages/Microsoft.Bcl.1.1.8/lib/sl4-windowsphone71/System.Runtime.xml create mode 100644 src/packages/Microsoft.Bcl.1.1.8/lib/sl4-windowsphone71/System.Threading.Tasks.dll create mode 100644 src/packages/Microsoft.Bcl.1.1.8/lib/sl4-windowsphone71/System.Threading.Tasks.xml create mode 100644 src/packages/Microsoft.Bcl.1.1.8/lib/sl4-windowsphone71/ensureRedirect.xml create mode 100644 src/packages/Microsoft.Bcl.1.1.8/lib/sl4/System.IO.dll create mode 100644 src/packages/Microsoft.Bcl.1.1.8/lib/sl4/System.IO.xml create mode 100644 src/packages/Microsoft.Bcl.1.1.8/lib/sl4/System.Runtime.dll create mode 100644 src/packages/Microsoft.Bcl.1.1.8/lib/sl4/System.Runtime.xml create mode 100644 src/packages/Microsoft.Bcl.1.1.8/lib/sl4/System.Threading.Tasks.dll create mode 100644 src/packages/Microsoft.Bcl.1.1.8/lib/sl4/System.Threading.Tasks.xml create mode 100644 src/packages/Microsoft.Bcl.1.1.8/lib/sl5/System.IO.dll create mode 100644 src/packages/Microsoft.Bcl.1.1.8/lib/sl5/System.IO.xml create mode 100644 src/packages/Microsoft.Bcl.1.1.8/lib/sl5/System.Runtime.dll create mode 100644 src/packages/Microsoft.Bcl.1.1.8/lib/sl5/System.Runtime.xml create mode 100644 src/packages/Microsoft.Bcl.1.1.8/lib/sl5/System.Threading.Tasks.dll create mode 100644 src/packages/Microsoft.Bcl.1.1.8/lib/sl5/System.Threading.Tasks.xml create mode 100644 src/packages/Microsoft.Bcl.1.1.8/lib/win8/_._ create mode 100644 src/packages/Microsoft.Bcl.1.1.8/lib/wp8/_._ create mode 100644 src/packages/Microsoft.Bcl.1.1.8/lib/wpa81/_._ create mode 100644 src/packages/Microsoft.Bcl.Async.1.0.168/License-Stable.rtf create mode 100644 src/packages/Microsoft.Bcl.Async.1.0.168/Microsoft.Bcl.Async.1.0.168.nupkg create mode 100644 src/packages/Microsoft.Bcl.Async.1.0.168/lib/net40/Microsoft.Threading.Tasks.Extensions.Desktop.dll create mode 100644 src/packages/Microsoft.Bcl.Async.1.0.168/lib/net40/Microsoft.Threading.Tasks.Extensions.Desktop.xml create mode 100644 src/packages/Microsoft.Bcl.Async.1.0.168/lib/net40/Microsoft.Threading.Tasks.Extensions.dll create mode 100644 src/packages/Microsoft.Bcl.Async.1.0.168/lib/net40/Microsoft.Threading.Tasks.Extensions.xml create mode 100644 src/packages/Microsoft.Bcl.Async.1.0.168/lib/net40/Microsoft.Threading.Tasks.dll create mode 100644 src/packages/Microsoft.Bcl.Async.1.0.168/lib/net40/Microsoft.Threading.Tasks.xml create mode 100644 src/packages/Microsoft.Bcl.Async.1.0.168/lib/portable-net40+sl4+win8+wp71+wpa81/Microsoft.Threading.Tasks.Extensions.dll create mode 100644 src/packages/Microsoft.Bcl.Async.1.0.168/lib/portable-net40+sl4+win8+wp71+wpa81/Microsoft.Threading.Tasks.Extensions.xml create mode 100644 src/packages/Microsoft.Bcl.Async.1.0.168/lib/portable-net40+sl4+win8+wp71+wpa81/Microsoft.Threading.Tasks.dll create mode 100644 src/packages/Microsoft.Bcl.Async.1.0.168/lib/portable-net40+sl4+win8+wp71+wpa81/Microsoft.Threading.Tasks.xml create mode 100644 src/packages/Microsoft.Bcl.Async.1.0.168/lib/portable-net45+win8+wp8+wpa81/Microsoft.Threading.Tasks.Extensions.dll create mode 100644 src/packages/Microsoft.Bcl.Async.1.0.168/lib/portable-net45+win8+wp8+wpa81/Microsoft.Threading.Tasks.Extensions.xml create mode 100644 src/packages/Microsoft.Bcl.Async.1.0.168/lib/portable-net45+win8+wp8+wpa81/Microsoft.Threading.Tasks.dll create mode 100644 src/packages/Microsoft.Bcl.Async.1.0.168/lib/portable-net45+win8+wp8+wpa81/Microsoft.Threading.Tasks.xml create mode 100644 src/packages/Microsoft.Bcl.Async.1.0.168/lib/portable-net45+win8+wpa81/Microsoft.Threading.Tasks.Extensions.dll create mode 100644 src/packages/Microsoft.Bcl.Async.1.0.168/lib/portable-net45+win8+wpa81/Microsoft.Threading.Tasks.Extensions.xml create mode 100644 src/packages/Microsoft.Bcl.Async.1.0.168/lib/portable-net45+win8+wpa81/Microsoft.Threading.Tasks.dll create mode 100644 src/packages/Microsoft.Bcl.Async.1.0.168/lib/portable-net45+win8+wpa81/Microsoft.Threading.Tasks.xml create mode 100644 src/packages/Microsoft.Bcl.Async.1.0.168/lib/sl4-windowsphone71/Microsoft.Threading.Tasks.Extensions.Phone.dll create mode 100644 src/packages/Microsoft.Bcl.Async.1.0.168/lib/sl4-windowsphone71/Microsoft.Threading.Tasks.Extensions.Phone.xml create mode 100644 src/packages/Microsoft.Bcl.Async.1.0.168/lib/sl4-windowsphone71/Microsoft.Threading.Tasks.Extensions.dll create mode 100644 src/packages/Microsoft.Bcl.Async.1.0.168/lib/sl4-windowsphone71/Microsoft.Threading.Tasks.Extensions.xml create mode 100644 src/packages/Microsoft.Bcl.Async.1.0.168/lib/sl4-windowsphone71/Microsoft.Threading.Tasks.dll create mode 100644 src/packages/Microsoft.Bcl.Async.1.0.168/lib/sl4-windowsphone71/Microsoft.Threading.Tasks.xml create mode 100644 src/packages/Microsoft.Bcl.Async.1.0.168/lib/sl4/Microsoft.Threading.Tasks.Extensions.Silverlight.dll create mode 100644 src/packages/Microsoft.Bcl.Async.1.0.168/lib/sl4/Microsoft.Threading.Tasks.Extensions.Silverlight.xml create mode 100644 src/packages/Microsoft.Bcl.Async.1.0.168/lib/sl4/Microsoft.Threading.Tasks.Extensions.dll create mode 100644 src/packages/Microsoft.Bcl.Async.1.0.168/lib/sl4/Microsoft.Threading.Tasks.Extensions.xml create mode 100644 src/packages/Microsoft.Bcl.Async.1.0.168/lib/sl4/Microsoft.Threading.Tasks.dll create mode 100644 src/packages/Microsoft.Bcl.Async.1.0.168/lib/sl4/Microsoft.Threading.Tasks.xml create mode 100644 src/packages/Microsoft.Bcl.Async.1.0.168/lib/win8/Microsoft.Threading.Tasks.Extensions.dll create mode 100644 src/packages/Microsoft.Bcl.Async.1.0.168/lib/win8/Microsoft.Threading.Tasks.Extensions.xml create mode 100644 src/packages/Microsoft.Bcl.Async.1.0.168/lib/win8/Microsoft.Threading.Tasks.dll create mode 100644 src/packages/Microsoft.Bcl.Async.1.0.168/lib/win8/Microsoft.Threading.Tasks.xml create mode 100644 src/packages/Microsoft.Bcl.Async.1.0.168/lib/wp8/Microsoft.Threading.Tasks.Extensions.Phone.dll create mode 100644 src/packages/Microsoft.Bcl.Async.1.0.168/lib/wp8/Microsoft.Threading.Tasks.Extensions.Phone.xml create mode 100644 src/packages/Microsoft.Bcl.Async.1.0.168/lib/wp8/Microsoft.Threading.Tasks.Extensions.dll create mode 100644 src/packages/Microsoft.Bcl.Async.1.0.168/lib/wp8/Microsoft.Threading.Tasks.Extensions.xml create mode 100644 src/packages/Microsoft.Bcl.Async.1.0.168/lib/wp8/Microsoft.Threading.Tasks.dll create mode 100644 src/packages/Microsoft.Bcl.Async.1.0.168/lib/wp8/Microsoft.Threading.Tasks.xml create mode 100644 src/packages/Microsoft.Bcl.Async.1.0.168/lib/wpa81/Microsoft.Threading.Tasks.Extensions.dll create mode 100644 src/packages/Microsoft.Bcl.Async.1.0.168/lib/wpa81/Microsoft.Threading.Tasks.Extensions.xml create mode 100644 src/packages/Microsoft.Bcl.Async.1.0.168/lib/wpa81/Microsoft.Threading.Tasks.dll create mode 100644 src/packages/Microsoft.Bcl.Async.1.0.168/lib/wpa81/Microsoft.Threading.Tasks.xml create mode 100644 src/packages/Microsoft.Bcl.Build.1.0.14/License-Stable.rtf create mode 100644 src/packages/Microsoft.Bcl.Build.1.0.14/Microsoft.Bcl.Build.1.0.14.nupkg create mode 100644 src/packages/Microsoft.Bcl.Build.1.0.14/content/net40/_._ create mode 100644 src/packages/Microsoft.Bcl.Build.1.0.14/content/netcore45/_._ create mode 100644 src/packages/Microsoft.Bcl.Build.1.0.14/content/portable-net40+win8+sl4+wp71+wpa81/_._ create mode 100644 src/packages/Microsoft.Bcl.Build.1.0.14/content/sl4-windowsphone71/_._ create mode 100644 src/packages/Microsoft.Bcl.Build.1.0.14/content/sl4/_._ create mode 100644 src/packages/Microsoft.Bcl.Build.1.0.14/tools/Install.ps1 create mode 100644 src/packages/Microsoft.Bcl.Build.1.0.14/tools/Microsoft.Bcl.Build.Tasks.dll create mode 100644 src/packages/Microsoft.Bcl.Build.1.0.14/tools/Microsoft.Bcl.Build.targets create mode 100644 src/packages/Microsoft.Bcl.Build.1.0.14/tools/Uninstall.ps1 diff --git a/src/packages/Microsoft.Bcl.1.1.8/License-Stable.rtf b/src/packages/Microsoft.Bcl.1.1.8/License-Stable.rtf new file mode 100644 index 00000000..3aec6b65 --- /dev/null +++ b/src/packages/Microsoft.Bcl.1.1.8/License-Stable.rtf @@ -0,0 +1,118 @@ +{\rtf1\ansi\ansicpg1252\deff0\nouicompat\deflang1033{\fonttbl{\f0\fswiss\fprq2\fcharset0 Tahoma;}{\f1\froman\fprq2\fcharset0 Times New Roman;}{\f2\fswiss\fprq2\fcharset0 Calibri;}{\f3\fnil\fcharset0 Calibri;}{\f4\fnil\fcharset2 Symbol;}} +{\colortbl ;\red31\green73\blue125;\red0\green0\blue255;} +{\*\listtable +{\list\listhybrid +{\listlevel\levelnfc0\leveljc0\levelstartat1{\leveltext\'02\'00.;}{\levelnumbers\'01;}\jclisttab\tx360} +{\listlevel\levelnfc4\leveljc0\levelstartat1{\leveltext\'02\'01.;}{\levelnumbers\'01;}\jclisttab\tx363} +{\listlevel\levelnfc2\leveljc0\levelstartat1{\leveltext\'02\'02.;}{\levelnumbers\'01;}\jclisttab\tx720}\listid1 } +{\list\listhybrid +{\listlevel\levelnfc0\leveljc0\levelstartat1{\leveltext\'02\'00.;}{\levelnumbers\'01;}\jclisttab\tx363} +{\listlevel\levelnfc4\leveljc0\levelstartat1{\leveltext\'02\'01.;}{\levelnumbers\'01;}\jclisttab\tx363}\listid2 }} +{\*\listoverridetable{\listoverride\listid1\listoverridecount0\ls1}{\listoverride\listid2\listoverridecount0\ls2}} +{\stylesheet{ Normal;}{\s1 heading 1;}{\s2 heading 2;}{\s3 heading 3;}} +{\*\generator Riched20 6.2.9200}\viewkind4\uc1 +\pard\nowidctlpar\sb120\sa120\b\f0\fs24 MICROSOFT SOFTWARE LICENSE TERMS\par + +\pard\brdrb\brdrs\brdrw10\brsp20 \nowidctlpar\sb120\sa120 MICROSOFT .NET LIBRARY \par + +\pard\nowidctlpar\sb120\sa120\fs19 These license terms are an agreement between Microsoft Corporation (or based on where you live, one of its affiliates) and you. Please read them. They apply to the software named above, which includes the media on which you received it, if any. The terms also apply to any Microsoft\par + +\pard{\pntext\f4\'B7\tab}{\*\pn\pnlvlblt\pnf4\pnindent363{\pntxtb\'B7}}\nowidctlpar\fi-363\li720\sb120\sa120\b0 updates,\par +{\pntext\f4\'B7\tab}supplements,\par +{\pntext\f4\'B7\tab}Internet-based services, and\par +{\pntext\f4\'B7\tab}support services\par + +\pard\nowidctlpar\sb120\sa120\b for this software, unless other terms accompany those items. If so, those terms apply.\par +BY USING THE SOFTWARE, YOU ACCEPT THESE TERMS. IF YOU DO NOT ACCEPT THEM, DO NOT USE THE SOFTWARE.\par + +\pard\brdrt\brdrs\brdrw10\brsp20 \nowidctlpar\sb120\sa120 IF YOU COMPLY WITH THESE LICENSE TERMS, YOU HAVE THE PERPETUAL RIGHTS BELOW.\par + +\pard +{\listtext\f0 1.\tab}\jclisttab\tx360\ls1\nowidctlpar\s1\fi-357\li357\sb120\sa120 INSTALLATION AND USE RIGHTS. \par + +\pard +{\listtext\f0 a.\tab}\jclisttab\tx363\ls1\ilvl1\nowidctlpar\s2\fi-363\li720\sb120\sa120 Installation and Use.\b0\fs20 You may install and use any number of copies of the software to design, develop and test your programs.\par +{\listtext\f0 b.\tab}\b\fs19 Third Party Programs.\b0\fs20 The software may include third party programs that Microsoft, not the third party, licenses to you under this agreement. Notices, if any, for the third party program are included for your information only.\b\fs19\par + +\pard +{\listtext\f0 2.\tab}\jclisttab\tx360\ls1\nowidctlpar\s1\fi-357\li357\sb120\sa120\fs20 ADDITIONAL LICENSING REQUIREMENTS AND/OR USE RIGHTS.\par + +\pard +{\listtext\f0 a.\tab}\jclisttab\tx363\ls1\ilvl1\nowidctlpar\s2\fi-363\li720\sb120\sa120 DISTRIBUTABLE CODE.\~ \b0 The software is comprised of Distributable Code. \f1\ldblquote\f0 Distributable Code\f1\rdblquote\f0 is code that you are permitted to distribute in programs you develop if you comply with the terms below.\b\par + +\pard +{\listtext\f0 i.\tab}\jclisttab\tx720\ls1\ilvl2\nowidctlpar\s3\fi-357\li1077\sb120\sa120\tx1077 Right to Use and Distribute. \par + +\pard{\pntext\f4\'B7\tab}{\*\pn\pnlvlblt\pnf4\pnindent360{\pntxtb\'B7}}\nowidctlpar\fi-357\li1434\sb120\sa120\b0 You may copy and distribute the object code form of the software.\par +{\pntext\f4\'B7\tab}Third Party Distribution. You may permit distributors of your programs to copy and distribute the Distributable Code as part of those programs.\par + +\pard\nowidctlpar\s3\fi-357\li1077\sb120\sa120\tx1077\b ii.\tab Distribution Requirements.\b0 \b For any Distributable Code you distribute, you must\par + +\pard{\pntext\f4\'B7\tab}{\*\pn\pnlvlblt\pnf4\pnindent360{\pntxtb\'B7}}\nowidctlpar\fi-357\li1434\sb120\sa120\b0 add significant primary functionality to it in your programs;\par +{\pntext\f4\'B7\tab}require distributors and external end users to agree to terms that protect it at least as much as this agreement;\par +{\pntext\f4\'B7\tab}display your valid copyright notice on your programs; and\par +{\pntext\f4\'B7\tab}indemnify, defend, and hold harmless Microsoft from any claims, including attorneys\rquote fees, related to the distribution or use of your programs.\par + +\pard\nowidctlpar\s3\fi-357\li1077\sb120\sa120\tx1077\b iii.\tab Distribution Restrictions.\b0 \b You may not\par + +\pard{\pntext\f4\'B7\tab}{\*\pn\pnlvlblt\pnf4\pnindent360{\pntxtb\'B7}}\nowidctlpar\fi-357\li1434\sb120\sa120\b0 alter any copyright, trademark or patent notice in the Distributable Code;\par +{\pntext\f4\'B7\tab}use Microsoft\rquote s trademarks in your programs\rquote names or in a way that suggests your programs come from or are endorsed by Microsoft;\par +{\pntext\f4\'B7\tab}include Distributable Code in malicious, deceptive or unlawful programs; or\par +{\pntext\f4\'B7\tab}modify or distribute the source code of any Distributable Code so that any part of it becomes subject to an Excluded License. An Excluded License is one that requires, as a condition of use, modification or distribution, that\par + +\pard{\pntext\f4\'B7\tab}{\*\pn\pnlvlblt\pnf4\pnindent360{\pntxtb\'B7}}\nowidctlpar\fi-358\li1792\sb120\sa120 the code be disclosed or distributed in source code form; or\cf1\f2\par +{\pntext\f4\'B7\tab}\cf0\f0 others have the right to modify it.\cf1\f2\par + +\pard\nowidctlpar\s1\fi-357\li357\sb120\sa120\cf0\b\f0 3.\tab\fs19 SCOPE OF LICENSE. \b0 The software is licensed, not sold. This agreement only gives you some rights to use the software. Microsoft reserves all other rights. Unless applicable law gives you more rights despite this limitation, you may use the software only as expressly permitted in this agreement. In doing so, you must comply with any technical limitations in the software that only allow you to use it in certain ways. You may not\par + +\pard{\pntext\f4\'B7\tab}{\*\pn\pnlvlblt\pnf4\pnindent363{\pntxtb\'B7}}\nowidctlpar\fi-363\li720\sb120\sa120 work around any technical limitations in the software;\par +{\pntext\f4\'B7\tab}reverse engineer, decompile or disassemble the software, except and only to the extent that applicable law expressly permits, despite this limitation;\par +{\pntext\f4\'B7\tab}publish the software for others to copy;\par +{\pntext\f4\'B7\tab}rent, lease or lend the software;\par +{\pntext\f4\'B7\tab}transfer the software or this agreement to any third party; or\par +{\pntext\f4\'B7\tab}use the software for commercial software hosting services.\par + +\pard\nowidctlpar\s1\fi-357\li357\sb120\sa120\b\fs20 4.\tab\fs19 BACKUP COPY. \b0 You may make one backup copy of the software. You may use it only to reinstall the software.\par +\b\fs20 5.\tab\fs19 DOCUMENTATION. \b0 Any person that has valid access to your computer or internal network may copy and use the documentation for your internal, reference purposes.\par +\b\fs20 6.\tab\fs19 EXPORT RESTRICTIONS. \b0 The software is subject to United States export laws and regulations. You must comply with all domestic and international export laws and regulations that apply to the software. These laws include restrictions on destinations, end users and end use. For additional information, see {\cf2\ul\fs20{\field{\*\fldinst{HYPERLINK www.microsoft.com/exporting }}{\fldrslt{www.microsoft.com/exporting}}}}\f0\fs19 .\cf2\ul\fs20\par +\cf0\ulnone\b 7.\tab\fs19 SUPPORT SERVICES. \b0 Because this software is \ldblquote as is,\rdblquote we may not provide support services for it.\par +\b\fs20 8.\tab\fs19 ENTIRE AGREEMENT. \b0 This agreement, and the terms for supplements, updates, Internet-based services and support services that you use, are the entire agreement for the software and support services.\par +\b\fs20 9.\tab\fs19 APPLICABLE LAW.\par + +\pard +{\listtext\f0 a.\tab}\jclisttab\tx363\ls2\ilvl1\nowidctlpar\s2\fi-363\li720\sb120\sa120 United States. \b0 If you acquired the software in the United States, Washington state law governs the interpretation of this agreement and applies to claims for breach of it, regardless of conflict of laws principles. The laws of the state where you live govern all other claims, including claims under state consumer protection laws, unfair competition laws, and in tort.\par +{\listtext\f0 b.\tab}\b Outside the United States. If you acquired the software in any other country, the laws of that country apply.\par + +\pard\nowidctlpar\s1\fi-357\li357\sb120\sa120\fs20 10.\tab\fs19 LEGAL EFFECT. \b0 This agreement describes certain legal rights. You may have other rights under the laws of your country. You may also have rights with respect to the party from whom you acquired the software. This agreement does not change your rights under the laws of your country if the laws of your country do not permit it to do so.\par +\b\fs20 11.\tab\fs19 DISCLAIMER OF WARRANTY. THE SOFTWARE IS LICENSED \ldblquote AS-IS.\rdblquote YOU BEAR THE RISK OF USING IT. MICROSOFT GIVES NO EXPRESS WARRANTIES, GUARANTEES OR CONDITIONS. YOU MAY HAVE ADDITIONAL CONSUMER RIGHTS OR STATUTORY GUARANTEES UNDER YOUR LOCAL LAWS WHICH THIS AGREEMENT CANNOT CHANGE. TO THE EXTENT PERMITTED UNDER YOUR LOCAL LAWS, MICROSOFT EXCLUDES THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.\par + +\pard\nowidctlpar\li357\sb120\sa120 FOR AUSTRALIA \endash YOU HAVE STATUTORY GUARANTEES UNDER THE AUSTRALIAN CONSUMER LAW AND NOTHING IN THESE TERMS IS INTENDED TO AFFECT THOSE RIGHTS.\par + +\pard\nowidctlpar\s1\fi-357\li357\sb120\sa120\fs20 12.\tab\fs19 LIMITATION ON AND EXCLUSION OF REMEDIES AND DAMAGES. YOU CAN RECOVER FROM MICROSOFT AND ITS SUPPLIERS ONLY DIRECT DAMAGES UP TO U.S. $5.00. YOU CANNOT RECOVER ANY OTHER DAMAGES, INCLUDING CONSEQUENTIAL, LOST PROFITS, SPECIAL, INDIRECT OR INCIDENTAL DAMAGES.\par + +\pard\nowidctlpar\li357\sb120\sa120\b0 This limitation applies to\par + +\pard{\pntext\f4\'B7\tab}{\*\pn\pnlvlblt\pnf4\pnindent363{\pntxtb\'B7}}\nowidctlpar\fi-363\li720\sb120\sa120 anything related to the software, services, content (including code) on third party Internet sites, or third party programs; and\par +{\pntext\f4\'B7\tab}claims for breach of contract, breach of warranty, guarantee or condition, strict liability, negligence, or other tort to the extent permitted by applicable law.\par + +\pard\nowidctlpar\sb120\sa120 It also applies even if Microsoft knew or should have known about the possibility of the damages. The above limitation or exclusion may not apply to you because your country may not allow the exclusion or limitation of incidental, consequential or other damages.\par +\lang9 Please note: As this software is distributed in Quebec, Canada, some of the clauses in this agreement are provided below in French.\par +Remarque : Ce logiciel \'e9tant distribu\'e9 au Qu\'e9bec, Canada, certaines des clauses dans ce contrat sont fournies ci-dessous en fran\'e7ais.\par + +\pard\nowidctlpar\s1\sb120\sa120\b\lang1033 EXON\'c9RATION DE GARANTIE. \b0 Le logiciel vis\'e9 par une licence est offert \'ab tel quel \'bb. Toute utilisation de ce logiciel est \'e0 votre seule risque et p\'e9ril. Microsoft n\rquote accorde aucune autre garantie expresse. Vous pouvez b\'e9n\'e9ficier de droits additionnels en vertu du droit local sur la protection des consommateurs, que ce contrat ne peut modifier. La ou elles sont permises par le droit locale, les garanties implicites de qualit\'e9 marchande, d\rquote ad\'e9quation \'e0 un usage particulier et d\rquote absence de contrefa\'e7on sont exclues.\par +\b LIMITATION DES DOMMAGES-INT\'c9R\'caTS ET EXCLUSION DE RESPONSABILIT\'c9 POUR LES DOMMAGES. \b0 Vous pouvez obtenir de Microsoft et de ses fournisseurs une indemnisation en cas de dommages directs uniquement \'e0 hauteur de 5,00 $ US. Vous ne pouvez pr\'e9tendre \'e0 aucune indemnisation pour les autres dommages, y compris les dommages sp\'e9ciaux, indirects ou accessoires et pertes de b\'e9n\'e9fices.\par + +\pard\nowidctlpar\sb120\sa120\lang9 Cette limitation concerne :\par + +\pard{\pntext\f4\'B7\tab}{\*\pn\pnlvlblt\pnf4\pnindent360{\pntxtb\'B7}}\nowidctlpar\li720\sb120\sa120 tout ce qui est reli\'e9 au logiciel, aux services ou au contenu (y compris le code) figurant sur des sites Internet tiers ou dans des programmes tiers ; et\par +{\pntext\f4\'B7\tab}les r\'e9clamations au titre de violation de contrat ou de garantie, ou au titre de responsabilit\'e9 stricte, de n\'e9gligence ou d\rquote une autre faute dans la limite autoris\'e9e par la loi en vigueur.\par + +\pard\nowidctlpar\sb120\sa120 Elle s\rquote applique \'e9galement, m\'eame si Microsoft connaissait ou devrait conna\'eetre l\rquote\'e9ventualit\'e9 d\rquote un tel dommage. Si votre pays n\rquote autorise pas l\rquote exclusion ou la limitation de responsabilit\'e9 pour les dommages indirects, accessoires ou de quelque nature que ce soit, il se peut que la limitation ou l\rquote exclusion ci-dessus ne s\rquote appliquera pas \'e0 votre \'e9gard.\par + +\pard\nowidctlpar\s1\sb120\sa120\b\lang1033 EFFET JURIDIQUE. \b0 Le pr\'e9sent contrat d\'e9crit certains droits juridiques. Vous pourriez avoir d\rquote autres droits pr\'e9vus par les lois de votre pays. Le pr\'e9sent contrat ne modifie pas les droits que vous conf\'e8rent les lois de votre pays si celles-ci ne le permettent pas.\par + +\pard\nowidctlpar\sb120\sa120\b\fs20\lang1036\par + +\pard\sa200\sl276\slmult1\b0\f3\fs22\lang9\par +} + \ No newline at end of file diff --git a/src/packages/Microsoft.Bcl.1.1.8/Microsoft.Bcl.1.1.8.nupkg b/src/packages/Microsoft.Bcl.1.1.8/Microsoft.Bcl.1.1.8.nupkg new file mode 100644 index 0000000000000000000000000000000000000000..b15f9c71b7d4ebb448928ed6166f7b31a63a2441 GIT binary patch literal 1008954 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%0Do=BC<5=7p5dDfDXa;+xXoXt1TINqELTVIKA~;q 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%0Dhy=rHqh=)xYJT@%0+a--D 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%0Aw(9NXj+Giz7 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

    A-5n@(ltyB=uH;P7!S|)|*R6K`{-P4$cOiit- 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%0DJ#P465ln)=r! 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 z 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 z zKX#bC?U0didi3e<`d>E;+=rXvUh^Vfw{;(s-(<3`hz^)9CpHvEIFBXzvU=UTHB_&s zn%WqmaaSD#9`Uckk$+BK*ZOt6SanX1>ue?jNeyTtXw0|e(Q%V; z8MAIAolDs}J5UxHRTfr~h=+V@3k3dig;%H7sYc{gq&Z5ULEoRQbx)dRh>a{M%(8J4 z`o5$&(;rh;ID(JA^D%oxsO(Op$=fm@RBO2su4$ADJpxeGA&WyYbG3+Z}1Muza5OVl8w#t_eY9 zZF5dT*Q_}ymtXD40hp@IJq(yjvr%0AD(mcc@!z22P2zkQor#U}kk|yBH`~l>k1s#y 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

    `$ZY)Kiz-h0< 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�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 literal 0 HcmV?d00001 diff --git a/src/packages/Microsoft.Bcl.1.1.8/content/net45/_._ b/src/packages/Microsoft.Bcl.1.1.8/content/net45/_._ new file mode 100644 index 00000000..e69de29b diff --git a/src/packages/Microsoft.Bcl.1.1.8/content/portable-net45+win8+wp8+wpa81/_._ b/src/packages/Microsoft.Bcl.1.1.8/content/portable-net45+win8+wp8+wpa81/_._ new file mode 100644 index 00000000..e69de29b diff --git a/src/packages/Microsoft.Bcl.1.1.8/content/portable-net45+win8+wpa81/_._ b/src/packages/Microsoft.Bcl.1.1.8/content/portable-net45+win8+wpa81/_._ new file mode 100644 index 00000000..e69de29b diff --git a/src/packages/Microsoft.Bcl.1.1.8/content/portable-net451+win81+wpa81/_._ b/src/packages/Microsoft.Bcl.1.1.8/content/portable-net451+win81+wpa81/_._ new file mode 100644 index 00000000..e69de29b diff --git a/src/packages/Microsoft.Bcl.1.1.8/content/portable-net451+win81/_._ b/src/packages/Microsoft.Bcl.1.1.8/content/portable-net451+win81/_._ new file mode 100644 index 00000000..e69de29b diff --git a/src/packages/Microsoft.Bcl.1.1.8/content/portable-win81+wp81+wpa81/_._ b/src/packages/Microsoft.Bcl.1.1.8/content/portable-win81+wp81+wpa81/_._ new file mode 100644 index 00000000..e69de29b diff --git a/src/packages/Microsoft.Bcl.1.1.8/content/sl4/_._ b/src/packages/Microsoft.Bcl.1.1.8/content/sl4/_._ new file mode 100644 index 00000000..e69de29b diff --git a/src/packages/Microsoft.Bcl.1.1.8/content/sl5/_._ b/src/packages/Microsoft.Bcl.1.1.8/content/sl5/_._ new file mode 100644 index 00000000..e69de29b diff --git a/src/packages/Microsoft.Bcl.1.1.8/content/win8/_._ b/src/packages/Microsoft.Bcl.1.1.8/content/win8/_._ new file mode 100644 index 00000000..e69de29b diff --git a/src/packages/Microsoft.Bcl.1.1.8/content/wp8/_._ b/src/packages/Microsoft.Bcl.1.1.8/content/wp8/_._ new file mode 100644 index 00000000..e69de29b diff --git a/src/packages/Microsoft.Bcl.1.1.8/content/wpa81/_._ b/src/packages/Microsoft.Bcl.1.1.8/content/wpa81/_._ new file mode 100644 index 00000000..e69de29b diff --git a/src/packages/Microsoft.Bcl.1.1.8/lib/net40/System.IO.dll b/src/packages/Microsoft.Bcl.1.1.8/lib/net40/System.IO.dll new file mode 100644 index 0000000000000000000000000000000000000000..34975c7cc3ae0655a38c51d24ff14af1077c62f2 GIT binary patch literal 21168 zcmeHv2|QKbxA?h(c}~U**O1wD?nNl`EMtg-xVVN4SJySBa7j{1MM%n!qGU{|s8lKx zX)Yx+QA9LQ)Z6EZG^ec$){f8MFP&Yt($Yp=c5+H3E_c6BC%fglJAeqX;r zPy=`)k0As8IY)ocq2p}Vr5aE+*QJ~TgCcO@R7wDq6pHgDg@sXQI3F^O8X1NQ z3d5P&JK;hpeq=ls7rX4YrX9>6$OeUhuJjo@&Gyy{p`|!b91z3_QkZ8_@k-#013yFX zgCJf;7(IhGl7QgPcoG2w>9r>zFfQ*+NKxef_xHCbk_4XHiV)iH=Joi4j zUEXD`(dLq#-uU^xLOc2PmrqB^m+L6EsSJLu-`(UmeqsH_y2;!M!(AQ(>-LP4UEHmr zhPyjkpH+p+8wKck9SE5!R9mVpbZ;`cIfcK?{-XR@6H$wS95w;m0fknzXbH3e7&W_+ zvD0#66og`+iO?iU0}tcXVReEIlEegs0Eh!LlGzAB+rYaQ2|LlKL16(ANQn@pnfa4h z=>*Y07-1n9ibHD48@||(9BRC1D-@9eRTqeJTtVKp&2hE40>V$X(;Fh4#`awUh@r0 z6yyiuXebckgVq4Lh%lfO11d5gfdO?G(1-!87;psxx-lS$0fQKD9RtP!C;;fU23iE| z1P}-10eBg3A`-@f-XEaw5C`-Eg!v(35MBgD11JOS0#KO&*`Wg<%nmgG=md=bxQqc! zpf4b7&49rW7LAA88Q}D|8LQCL-fwW~^U?DzcCWpdB(>VB#5s zLO}>0{G2vJM+jhxJXo{{`r9hfwWat)hLH6kr`QM@ITUYYkM|1+fs7&|$e}(Vv9@Fy z$&W-M8PNd$`9#vlv*jGg{vl*vS`Z}+3XSlkP(y-zzGXq*%i?`$6e<)(G;<)E$UT}v>@LI$dv3884y77nNNY4G%%Nd zp+L8@czl~`6G~_}m<_5EnHm*@pf!`gpoAkigcQRFMSLfU<4i@Q7|8Mo3JIdkpW#_{ zTp97hQ0D5-@DmW1m>G`uZ3`E{?~}ExJJQ^&%yH5HVvQf#bnoop*zHU>G>V%Wi$kHf znE>E3LV~QI8Y;06EH4O~2tip8kWa`W193+uBLbr75c$K>^~v>8<%7`@e994?%4x2_ zf$6nFJ2rpDM1>^V|Y%a-40D zFO?EO@u%TTDAaJu3~%FcIDiO_v0fu^RB{BEb+R8Gf<#e}z;9~+>j03Gh+l%&#={UK zjDpyWBZETxY)C%j5LSW)tO0A`2|#|KAPz=`F_jeN8^{BAhfInfdl;M8co2{R0-(S* zCPPMyb*2Kj1977uwmAU@WF;axAr=&bCWirC3f@Q@3C!3<5(q_|(Soj2Qn(!@Y;ILJ z2U01~5sb>9_^e%sR2Bn?4GQ1~Y$iu1Q>RkDv>s9F0{e9N+Zi5x7cod3-=!Wt9vWJj z>K;S_QPTq$PaZ*GG%_`m>=#6$kv--R#77bFnt0y`V6Cq8A`yMan!XxZ9R{^-L*#M^|FjZvLJ$7n-&G<`NhIFTi7_AtAP;pl@1-OlD{+B=hTH2sdL*|5)e$ zV*h_o0L7SG;a^Ps8Q}+HM&gg-oLQyF-eHv?1ZiWw=W1g#K*R-DVO{{5L5?6~1=&M( zAZ`VqIS3<96L#baBIlVI;(>MUZNSK#+3w5;j&BLzWeR>M&?*U{f_8#{El&n*hC%)i zg;7WrQ60dNrh*b-Pz1;)K{QZ~0%9{yH8vMCiUK&%K&c>*9`Ku%XpAy2H2Y5j@&RG6 zUj@cJ3Niuhg+k$sK4QU$NFWBJAb4y+i@u;;3h0{xu%dxQgOsL%(g>W7jV{Bgo*jiL zXd!}8HwcuSkFygL3vy^6KNQ%%2qhta3oF25wyq1vqk=Nu$4LYwmw=x(_#t@fLfoJ{ zLMfyjDtMCsZN6jvYae)E>xY1UV9x`ofx0%JUI3#OGM;dN6GFWJuopn~vgKf$e|_wD zP#OmrG1|w?YbOGvQb9iv3>>2X^aJ=Kk0}Fx`)_5DSwrxj9X}GAnSnnWhX#Y*4xkMR zXg3njnl_ID5a5Vk>8!z^^N)3YruNUY)@IZ(0;5325ehgb1hk9;T>IlJ{alYR(Emw* zoADXIOaCW3{lC8cw@`rL<3gh$n6AH{nN2CxGW8=DiUnOr*WUq>wxUre0td{-%%seX zL5ng$unjZ2GBXN`qHCd1*g}0+7Z#eA!UMBmP*5SZ7@Y{gQuFFz7d|+RJK=G8`dZK4 zAipy5+3E-NpY;mq0(6*;y$I7WM+-4%6dKL14hWHMRNJK3n3~LkBSA(bqykss4C)NEe zm~p`z2xc7oSX+AsM}j=OcqS?lW)c)0NT%XUoy>4%PIgPpHHq4)>RMV_s@g_cO9+c$ znVAuZ{dPp(40xE1lAcdt6cdD@qj&&ApxDuL6bfqVX%pd*+~Y#`x^GOp%^G^5;QWQ* zcgpRM+qG& zEi9z1EPL)PY~-VTg=~HlE9md?YVuIKai^!VpIXvHr#8gH8{C(S&(OCVvT|8Iv^VHo zI}h(?7LDaTA*hV7E4Y+4k1pRliS3?4Jf(t`M}m8#)X;#VQ6+Q~8=wdiEDlI2&W#ns zE`(Ms(jRVl%e?z6L2t?N3Jy==XcB{m#AUF;uwdds8I6etj^^R)!-k)uKG!K%U(~GQ zft`{1l2}{V8n!C5C^Sno38c}&m#V4xQbX{ev->=}FC|nhJU9qRRRcQ|#AOkoHaCq3 zUozMda3vlTfmboJf>p`H#DYR$ZQ$jw4Qt)%U-eSbFz+ZU)@Cn_ z+%zEeh^57@U{P6zti?iEd(G&YeU0+#cX--QF>lSunN-aGXejQOv^~lavvDk6=w#&s zcj=wJ%ZOf@pD*v!y*9#~m#ELYQ=31I)8?#t_qpL?MwjCk$;R_PVxO{3$1#bsZP}^A zVkc$S6A~YO=IC48_KDmW??+p+I>~4EWbzd5OBwd4k2fkLsWzDekVTc~w-2YgeI!0D zdD)UtD}82{!u{%PPCEiEEQ;=K3y7OPpQ&-)1z2z+J13Yz-g$1XFK0W z7n)A6%E~QRVHtBw{I1~%AjXD(7`r`Bj8*ehv2VSx?7(ASIDx~2pQr}M{w=~n29}yx z^rCaz0-OeZWSmn_0OACkC&&my4I)upU0r8JkZH_C;iTlh1-G9B**A%d`2&gkF9p*; zl}9m-YeFHuk!gLxu{W=yDioXymUbI%sN1go!quR3g@A^0Y3K2+DXmeJ)6yKgHM|AU(wkD^?N2SrtbSkeW$Qc6y>^A~TiK=hk32;!v6xn) zuT8?dFV}pO6Wtw?;p-JpDGf@Bo#)D#nEHBo*4a)U^N>kae0`;5`PBjWlv^7wn{Z@9Of~l8 zbuF`k$s170<97=cGf!H%tvj?@-S%NFOXAlQiL;w0sYIhOcm=Y!`LIA<95jbb2|vw` zI!r)ViHToHouH|ssjT5o@`ru22&yDMbuCp55=mW^v;;)8miYL>nnZOC4U*pv0y!BwbMExfv*;3=EE?2@nx(x)WW9tI+?5QxB3v;UL;1iTD58OS{^80b2JDiJ2Y z3=z0`Rz3j{Xa@r!I2#8dQ2(!qz&~i4_S4E`$UDNlFr@{q>PdGBF29~!dfU{Nb^n_+ zPu9AhjO|44Ym5rqpINkz<6=VbwzsyYvvodm_4ehz^OWUTl#wQ|G`{;-M_p^kX&n`_ z4YGXBaxfRySBqB|mgmp>Jyq5hh?nzz604?-*#`yhFPBYuIJ~FuNyNdCwW1Z)KKtLs zpI?|@dEK_wbaGU8cc}6Gf%q3fh53PjYzmX;oDn|E=>W%L&4YCjhi>{_U*50(Y}{`8 zYf|F=!^Gpv4%~O*9Xk*RQ7x7zmL4~!r#~X+MT^A zn=@qLk0Tm4e8p>w1D11JpIgd3aw2=_VeMy&cd;Hy^9N=dQzMXf2WR9RJ4szmlwqwA zej*m^#W2v=*>=fo**&J>hY}IQ0OdvyLF~qPiEMMakDv-G&xkPD?;^~R0#1@mfUXMi z5Ap?mJe*M^Es#P5{%VF*2JA6)0+C42Q6~anhL~qal!!$CNjdwkOsiU|n}-POcTRk- zHx6f<7v&V9zvwRITKn5q!C!I&d3&EMr6r4=R4XJ7eeJnmY$tPv3UzC`vTtdt#96%? z4Xm)W&M0k)wO*HR!SZl=@soncw9X?DrV00wy2qQwmK<#LFnd&WOs`iVFh}%oDK*07 ztx(ppY0WHZ;oT@NiD^5;T!)Lm^ z)ytgVa7v#4nIYUsRpeEWzM^HPS4h;$yk4Zuyvf7Pg|48)L_BGI&))atO;w+_W_m9x zSfLN*MfMIZTeA{u4Uk}~VID*> z@S{*)u}m-qyyi)--%1k1Di-I#V!_5C6<)y1_HADxfWk5{8V2U?TpAj&*rvM(cDLlx zv-@(rmz5DHhjbh7tHL64g%+Z*oD%H70}u&z>n4!V53-EAg6?hTBA@eoG5?fOAG=ew z+p~kP!;CDmf-PXPLX$$HRD-`R%jWo<3Rv40a5h7VInPQhAjK?UAe3k0K#FPqH7Pc8 zQh+QNWW9h^f0bWo6y&C(pCD&m^_pT>L#$u>np-Wb%U1~Yn)Fu>@$1Fgn&fL^eO*k8S6rVQELr99I3I0h zs^<0XVdZT)F>LB!HvhBNK`+aTRnA^j=H(`D&+C3){Aqz48(BN+ZJgxtGhKZy12EpD}4_3SYXQ?WO^0-})TV@-Fdj@&D3Z#Hpnvk&Fwx6_MPwA@GS8V_k} z9ttmU-Q~I=E2D6cC1&-<&XNFjTIrHuRW+fjFQ{4z-cf3F1L%{EwHfMyWC`x{$Gkm$ z?p(cw74=g zFqw0$>Y1ouNPN$+F~Rj81e0Y?rFE_?vmmJLee`sl-aTlek40BUT5E&wCvIv+bBSIR z+HmdHp!_}kyk)${wH#RQUetr>%q&2DkIc$%!9c`c3(i>n3Hc3cfukoNu{G6U#26(K z7*Vj*2GM_RyZ^7G_kp62nkU_syOiRC@gjXq{ZCu+R>(LU>v$||C(HAu>u{INF&d2H zd(CpkIa|OgYmxD;%3Kdv?jaOBu)b+%3k%OjZfx%8mTQvj>av>)#@+>psZ6bZnI`_~ zrCmu;vy4+)#wW8*wi|1zZd4m%izg3-><+l6@W|Y$I`zhL1#`T7MXLQuN6u#$mCtK4 zGvTn!<8E-lr;T@W>IS58Hcs5+A7?%36zX`~Ec1XRwA{jU^L|BF2aieJ%gVvgF-GBy_zvSIyMN z{906pw6*isNv4Yza2&JJ`zVm!hyP4^|8^t%gY@Q|6T(1x19=X?Nx6t@mBA)u!bus4 z3x6kmi+m4~{&w?%&KrA7uxNQ<=`ov#Rqt5%@#KFSssER@?ts?3Iq4TYFs4f$4<0`j z-Q5wp!WLD7r>%1j<>Wuwad!QV2K?;>#oI!C8eGxsb~t{AyvK2d{jO)KR_zt*6Gx?1 zoQWCRdShrA>P`RI9qde3Gc5Z@odh1+AKmrrWyab&iOnyv#+cPMVFq_9$x4TR{xJ0{ zCJ)c`k)=PpQP{3vdoVjSyP-&DUw~@M3hq}v9tMKBTX6>cETY88YlP)d1U+Rc$JJNi zdS5rO^FO)3PTD?tuR-Xw-PVK_P31Ku=Uz8%;4of)+leam25vhOL-ue-39&EazWH!r z?t9%+{;TR#)m~0+O1-wiWuPEDE2Kil=Jto!b4P^Zd=y8D^A$CiqeXpM^&~7yK1 zRL*po)IFaZ+ED-WU>Qxb!LDVU%mTS64qeA>>sFhaENrZ+tF{fedcgQ=Vysl+egW8j zz<9wL(X0EVrEZuEDi5A{XL(KK_I+ZajhvFDtk>#SE+dC}@(S9PQks(FY0P|YqNL8{ z)0^d;Pt>f{+fo!oIv!TUf9Tv1i_ry?>2zX9?UyGju5OcQ^=~Q=-@L#Nt*2V$wxi*h z)bsl4Hs9kh&P=zB@D3GO)uk~<>k9Woiayx2nLkomjabGSR_MNM@wvj0ls2imuO;kT z_r9^}{fHt{ws35?8g%tV*sH@i9R$U%+%4`N_iYyy-T$Pv-vGZ-Fu0Y!WST%%D1qq; z2Y{~^2FvZA^GnQle}8tHe0M$(;NhDcz&(`Vhqk! z#1eopI5cLcQ_Xc#=xpfIopxqSCv8Yud%&jgdlQ@lU3h7sSfc1}&V;_5ixr6`3jdK& zHeZhdpDLD)f=&;KC9G-jh>85&>UxD0S*6P9!ngWvyIg(EDP*xm zXVvl*J_dK!e4SVl^Q?$2w-lzMWxvk^Gl7m407-ld-rN3<>H6QFJIv!ePgwXn)))fE zT!aM$_->A~m^`KI3=Maze#|4j)F7Z4!smCPSee`ikVDFUQ>o2^z z#i?`ihPNt`kvPO3Qt5>C;E|I=ZbKJ5X@um6Sp^@w`mo7=Dun z?aL;$$pLwb_?&vR_Wq8(7-&%EO;h5gCnCL(5f23K7ISkyi9pL4vvu?dv>#oR;!BZ_ z&HtPqxKD(w19t$oe(3!3sg-46_If(L?amg`n6Nh^oOMVg7W3+2aovk?J43gXud%TWe<0Z#y;XRRyX);{kH=Dp6D=yMaBm9fT)Th) z%?k|ZiFpoR(daX@I+iZMnLG5N^JkRY*V8Az#d8bi4UH!c?tju8;gi{V ze)9G5cRCN%*73gPt5eY`2_Hxm(jQSWzp?$wDNCqG>+O}RFKoDQ_ay9lVE-4oh@!~i)Yjr08t9$*7i()Zy-Zbkdz+mP$--Z=6&xazb ztk;&gZ@)q$RkxF~PVYs9tc%-!!UMcSgQ!f@UIP1Q63ME*8o>Fhp{e1g>f=iwtEv-y zHA#Mc1TC@-{DarTGR*I}1Jf<~5g{!t>H5&Jwn%jLA0L7J_JoQO9>F*T1Kd65pGDZ& z3jwOImMW~x@SKol2>?7ND`6)vvTsLXz;iO|V*cX}W>3NXqzf7_C}tg0XmBNH-l;TL z-55Hsr1_}c9Ag!7C$LQZkF;0ayB+dS=7_hdkwQbTK^FC^zRwD>n-F0Ihrw+&ZtW$> ziZ5ewokI@_HsejtUtLkCf78Ki(~Ap@v0?7+8hwJd2|6t@ZYNn@+SF{ZPxQIsT4=R# z|3%^R(&huzp)YWk6(w2sri8X7awj)63HBtMWgWks7`yY<#G?Tdn-Biz1#90WZntLc z3Qgm5?@AIIepk!alBwpLpW)3SE0q+g(Y~u-`w>Ha;|iQX?+0G;dH1%&vWMG8Qdj33 ze9vc{x{2a*G#y`PufVlnvgP_t3k>_EC9S^q9)H{vw`$sb^N@dY?o`H`RdL1pyTsRT zvDz;2S^r{f`kPAumZgz3(;Xp)>I!=ox~5U$E#F#hv)?6gG(^^q^K?yR+Ms8KngPcO zw8z?t3K5&zHgR637S-EnRtDFcyT4lDm}Q%QQ^VHdD%)ONI>`SlM`VTETb$&^gBPDx zURl3o(zobD8MBA+;|ag$5oSWEiNn|Z75ymoK&v~#Sv?S6Qm8>bAPpbFF&9nR`4&RWbeH4!^3cVX0DZ%6W%PfxRq z)C;1`n-*7~4<5CAwK>$?ut{#@y|9pu*i`G|2SaCX9c1!LY`AwOu3qXgtIYbO+I`z} zJw9{vJM}jYp62m#faxr8z%lMK>r~;+yvcB?V18m2I4SLK(FMTqJ);X0zw3fO_MCs$ z3IyPQ(I�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 literal 0 HcmV?d00001 diff --git a/src/packages/Microsoft.Bcl.1.1.8/lib/net40/System.IO.xml b/src/packages/Microsoft.Bcl.1.1.8/lib/net40/System.IO.xml new file mode 100644 index 00000000..865aa1a4 --- /dev/null +++ b/src/packages/Microsoft.Bcl.1.1.8/lib/net40/System.IO.xml @@ -0,0 +1,8 @@ + + + + System.IO + + + + diff --git a/src/packages/Microsoft.Bcl.1.1.8/lib/net40/System.Runtime.dll b/src/packages/Microsoft.Bcl.1.1.8/lib/net40/System.Runtime.dll new file mode 100644 index 0000000000000000000000000000000000000000..967bb30a0d84f969455800059b74fae5c24271df GIT binary patch literal 22208 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 QU>aprW%>sEYaZx-0jWNPVE_OC literal 0 HcmV?d00001 diff --git a/src/packages/Microsoft.Bcl.1.1.8/lib/net40/System.Runtime.xml b/src/packages/Microsoft.Bcl.1.1.8/lib/net40/System.Runtime.xml new file mode 100644 index 00000000..93cb00d7 --- /dev/null +++ b/src/packages/Microsoft.Bcl.1.1.8/lib/net40/System.Runtime.xml @@ -0,0 +1,56 @@ + + + + System.Runtime + + + + Defines a provider for progress updates. + The type of progress update value. + + + Reports a progress update. + The value of the updated progress. + + + Identities the async state machine type for this method. + + + Identities the state machine type for this method. + + + Initializes the attribute. + The type that implements the state machine. + + + Gets the type that implements the state machine. + + + Initializes the attribute. + The type that implements the state machine. + + + + Allows you to obtain the method or property name of the caller to the method. + + + + + Allows you to obtain the line number in the source file at which the method is called. + + + + + Allows you to obtain the full path of the source file that contains the caller. + This is the file path at the time of compile. + + + + Identities the iterator state machine type for this method. + + + Initializes the attribute. + The type that implements the state machine. + + + diff --git a/src/packages/Microsoft.Bcl.1.1.8/lib/net40/System.Threading.Tasks.dll b/src/packages/Microsoft.Bcl.1.1.8/lib/net40/System.Threading.Tasks.dll new file mode 100644 index 0000000000000000000000000000000000000000..b8f78dafd6ddbae13acf85b07ecf545afb460b32 GIT binary patch literal 34528 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 Hh0y;2j36FU literal 0 HcmV?d00001 diff --git a/src/packages/Microsoft.Bcl.1.1.8/lib/net40/System.Threading.Tasks.xml b/src/packages/Microsoft.Bcl.1.1.8/lib/net40/System.Threading.Tasks.xml new file mode 100644 index 00000000..b47921e5 --- /dev/null +++ b/src/packages/Microsoft.Bcl.1.1.8/lib/net40/System.Threading.Tasks.xml @@ -0,0 +1,475 @@ + + + + System.Threading.Tasks + + + + Holds state related to the builder's IAsyncStateMachine. + This is a mutable struct. Be very delicate with it. + + + A reference to the heap-allocated state machine object associated with this builder. + + + Initiates the builder's execution with the associated state machine. + Specifies the type of the state machine. + The state machine instance, passed by reference. + The argument is null (Nothing in Visual Basic). + + + Associates the builder with the state machine it represents. + The heap-allocated state machine object. + The argument was null (Nothing in Visual Basic). + The builder is incorrectly initialized. + + + + Gets the Action to use with an awaiter's OnCompleted or UnsafeOnCompleted method. + On first invocation, the supplied state machine will be boxed. + + Specifies the type of the method builder used. + Specifies the type of the state machine used. + The builder. + The state machine. + An Action to provide to the awaiter. + + + Provides the ability to invoke a state machine's MoveNext method under a supplied ExecutionContext. + + + The context with which to run MoveNext. + + + The state machine whose MoveNext method should be invoked. + + + Initializes the runner. + The context with which to run MoveNext. + + + Invokes MoveNext under the provided context. + + + Cached delegate used with ExecutionContext.Run. + + + Invokes the MoveNext method on the supplied IAsyncStateMachine. + The IAsyncStateMachine machine instance. + + + Provides a base class used to cache tasks of a specific return type. + Specifies the type of results the cached tasks return. + + + + A singleton cache for this result type. + This may be null if there are no cached tasks for this TResult. + + + + Creates a non-disposable task. + The result for the task. + The cacheable task. + + + Creates a cache. + A task cache for this result type. + + + Gets a cached task if one exists. + The result for which we want a cached task. + A cached task if one exists; otherwise, null. + + + Provides a cache for Boolean tasks. + + + A true task. + + + A false task. + + + Gets a cached task for the Boolean result. + true or false + A cached task for the Boolean result. + + + Provides a cache for zero Int32 tasks. + + + The minimum value, inclusive, for which we want a cached task. + + + The maximum value, exclusive, for which we want a cached task. + + + The cache of Task{Int32}. + + + Creates an array of cached tasks for the values in the range [INCLUSIVE_MIN,EXCLUSIVE_MAX). + + + Gets a cached task for the zero Int32 result. + The integer value + A cached task for the Int32 result or null if not cached. + + + Throws the exception on the ThreadPool. + The exception to propagate. + The target context on which to propagate the exception. Null to use the ThreadPool. + + + Copies the exception's stack trace so its stack trace isn't overwritten. + The exception to prepare. + + + + Provides a builder for asynchronous methods that return . + This type is intended for compiler use only. + + + AsyncTaskMethodBuilder is a value type, and thus it is copied by value. + Prior to being copied, one of its Task, SetResult, or SetException members must be accessed, + or else the copies may end up building distinct Task instances. + + + + Represents an asynchronous method builder. + + + A cached VoidTaskResult task used for builders that complete synchronously. + + + The generic builder object to which this non-generic instance delegates. + + + Initializes a new . + The initialized . + + + Initiates the builder's execution with the associated state machine. + Specifies the type of the state machine. + The state machine instance, passed by reference. + + + Associates the builder with the state machine it represents. + The heap-allocated state machine object. + The argument was null (Nothing in Visual Basic). + The builder is incorrectly initialized. + + + Perform any initialization necessary prior to lifting the builder to the heap. + + + + Schedules the specified state machine to be pushed forward when the specified awaiter completes. + + Specifies the type of the awaiter. + Specifies the type of the state machine. + The awaiter. + The state machine. + + + + Schedules the specified state machine to be pushed forward when the specified awaiter completes. + + Specifies the type of the awaiter. + Specifies the type of the state machine. + The awaiter. + The state machine. + + + + Completes the in the + RanToCompletion state. + + The builder is not initialized. + The task has already completed. + + + + Completes the in the + Faulted state with the specified exception. + + The to use to fault the task. + The argument is null (Nothing in Visual Basic). + The builder is not initialized. + The task has already completed. + + + + Called by the debugger to request notification when the first wait operation + (await, Wait, Result, etc.) on this builder's task completes. + + + true to enable notification; false to disable a previously set notification. + + + + Gets the for this builder. + The representing the builder's asynchronous operation. + The builder is not initialized. + + + + Gets an object that may be used to uniquely identify this builder to the debugger. + + + This property lazily instantiates the ID in a non-thread-safe manner. + It must only be used by the debugger, and only in a single-threaded manner + when no other threads are in the middle of accessing this property or this.Task. + + + + + Provides a builder for asynchronous methods that return . + This type is intended for compiler use only. + + + AsyncTaskMethodBuilder{TResult} is a value type, and thus it is copied by value. + Prior to being copied, one of its Task, SetResult, or SetException members must be accessed, + or else the copies may end up building distinct Task instances. + + + + A cached task for default(TResult). + + + State related to the IAsyncStateMachine. + + + The lazily-initialized task. + Must be named m_task for debugger step-over to work correctly. + + + The lazily-initialized task completion source. + + + Temporary support for disabling crashing if tasks go unobserved. + + + Initializes a new . + The initialized . + + + Initiates the builder's execution with the associated state machine. + Specifies the type of the state machine. + The state machine instance, passed by reference. + + + Associates the builder with the state machine it represents. + The heap-allocated state machine object. + The argument was null (Nothing in Visual Basic). + The builder is incorrectly initialized. + + + Perform any initialization necessary prior to lifting the builder to the heap. + + + + Schedules the specified state machine to be pushed forward when the specified awaiter completes. + + Specifies the type of the awaiter. + Specifies the type of the state machine. + The awaiter. + The state machine. + + + + Schedules the specified state machine to be pushed forward when the specified awaiter completes. + + Specifies the type of the awaiter. + Specifies the type of the state machine. + The awaiter. + The state machine. + + + + Completes the in the + RanToCompletion state with the specified result. + + The result to use to complete the task. + The task has already completed. + + + + Completes the builder by using either the supplied completed task, or by completing + the builder's previously accessed task using default(TResult). + + A task already completed with the value default(TResult). + The task has already completed. + + + + Completes the in the + Faulted state with the specified exception. + + The to use to fault the task. + The argument is null (Nothing in Visual Basic). + The task has already completed. + + + + Called by the debugger to request notification when the first wait operation + (await, Wait, Result, etc.) on this builder's task completes. + + + true to enable notification; false to disable a previously set notification. + + + This should only be invoked from within an asynchronous method, + and only by the debugger. + + + + + Gets a task for the specified result. This will either + be a cached or new task, never null. + + The result for which we need a task. + The completed task containing the result. + + + Gets the lazily-initialized TaskCompletionSource. + + + Gets the for this builder. + The representing the builder's asynchronous operation. + + + + Gets an object that may be used to uniquely identify this builder to the debugger. + + + This property lazily instantiates the ID in a non-thread-safe manner. + It must only be used by the debugger, and only in a single-threaded manner + when no other threads are in the middle of accessing this property or this.Task. + + + + + Provides a builder for asynchronous methods that return void. + This type is intended for compiler use only. + + + + The synchronization context associated with this operation. + + + State related to the IAsyncStateMachine. + + + An object used by the debugger to uniquely identify this builder. Lazily initialized. + + + Temporary support for disabling crashing if tasks go unobserved. + + + Registers with UnobservedTaskException to suppress exception crashing. + + + Non-zero if PreventUnobservedTaskExceptions has already been invoked. + + + Initializes a new . + The initialized . + + + Initializes the . + The synchronizationContext associated with this operation. This may be null. + + + Initiates the builder's execution with the associated state machine. + Specifies the type of the state machine. + The state machine instance, passed by reference. + The argument was null (Nothing in Visual Basic). + + + Associates the builder with the state machine it represents. + The heap-allocated state machine object. + The argument was null (Nothing in Visual Basic). + The builder is incorrectly initialized. + + + Perform any initialization necessary prior to lifting the builder to the heap. + + + + Schedules the specified state machine to be pushed forward when the specified awaiter completes. + + Specifies the type of the awaiter. + Specifies the type of the state machine. + The awaiter. + The state machine. + + + + Schedules the specified state machine to be pushed forward when the specified awaiter completes. + + Specifies the type of the awaiter. + Specifies the type of the state machine. + The awaiter. + The state machine. + + + Completes the method builder successfully. + + + Faults the method builder with an exception. + The exception that is the cause of this fault. + The argument is null (Nothing in Visual Basic). + The builder is not initialized. + + + Notifies the current synchronization context that the operation completed. + + + + Gets an object that may be used to uniquely identify this builder to the debugger. + + + This property lazily instantiates the ID in a non-thread-safe manner. + It must only be used by the debugger and only in a single-threaded manner. + + + + + Represents state machines generated for asynchronous methods. + This type is intended for compiler use only. + + + + Moves the state machine to its next state. + + + Configures the state machine with a heap-allocated replica. + The heap-allocated replica. + + + + Represents an awaiter used to schedule continuations when an await operation completes. + + + + + Represents an operation that will schedule continuations when the operation completes. + + + + Schedules the continuation action to be invoked when the instance completes. + The action to invoke when the operation completes. + The argument is null (Nothing in Visual Basic). + + + Schedules the continuation action to be invoked when the instance completes. + The action to invoke when the operation completes. + The argument is null (Nothing in Visual Basic). + Unlike OnCompleted, UnsafeOnCompleted need not propagate ExecutionContext information. + + + Used with Task(of void) + + + diff --git a/src/packages/Microsoft.Bcl.1.1.8/lib/net40/ensureRedirect.xml b/src/packages/Microsoft.Bcl.1.1.8/lib/net40/ensureRedirect.xml new file mode 100644 index 00000000..e69de29b diff --git a/src/packages/Microsoft.Bcl.1.1.8/lib/net45/_._ b/src/packages/Microsoft.Bcl.1.1.8/lib/net45/_._ new file mode 100644 index 00000000..e69de29b diff --git a/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+sl4+win8+wp71+wpa81/System.IO.dll b/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+sl4+win8+wp71+wpa81/System.IO.dll new file mode 100644 index 0000000000000000000000000000000000000000..01edf729d6fd3f62b325ada34491065ecf202911 GIT binary patch literal 22704 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 + + + System.IO + + + + + A strongly-typed resource class, for looking up localized strings, etc. + + + + + Returns the cached ResourceManager instance used by this class. + + + + + Overrides the current thread's CurrentUICulture property for all + resource lookups using this strongly typed resource class. + + + + + Looks up a localized string similar to Found invalid data while decoding.. + + + + + The exception that is thrown when a data stream is in an invalid format. + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class with a specified error message. + + The error message that explains the reason for the exception. + + + + Initializes a new instance of the class with a reference to the inner exception that is the cause of this exception. + The error message that explains the reason for the exception. + The exception that is the cause of the current exception. If the parameter is not null, the current exception is raised in a catch block that handles the inner exception. + + + diff --git a/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+sl4+win8+wp71+wpa81/System.Runtime.dll b/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+sl4+win8+wp71+wpa81/System.Runtime.dll new file mode 100644 index 0000000000000000000000000000000000000000..57e106328f7453b222fa5cb4b6fed358d70d6927 GIT binary patch literal 39104 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 oq_&^^fK??^Uk1% + + + System.Runtime + + + + + A strongly-typed resource class, for looking up localized strings, etc. + + + + + Returns the cached ResourceManager instance used by this class. + + + + + Overrides the current thread's CurrentUICulture property for all + resource lookups using this strongly typed resource class. + + + + + Looks up a localized string similar to Argument must be of type {0}.. + + + + + Looks up a localized string similar to The last element of an eight element tuple must be a Tuple.. + + + + + Defines methods to support the comparison of objects for structural equality. + + + + + Determines whether an object is structurally equal to the current instance. + + The object to compare with the current instance. + An object that determines whether the current instance and other are equal. + true if the two objects are equal; otherwise, false. + + + + Returns a hash code for the current instance. + + An object that computes the hash code of the current object. + The hash code for the current instance. + + + + Supports the structural comparison of collection objects. + + + + + Determines whether the current collection object precedes, occurs in the same position as, or follows another object in the sort order. + + The object to compare with the current instance. + An object that compares members of the current collection object with the corresponding members of other. + An integer that indicates the relationship of the current collection object to other. + + This instance and other are not the same type. + + + + + Encapsulates a method that has five parameters and returns a value of the type specified by the TResult parameter. + + The type of the first parameter of the method that this delegate encapsulates. + The type of the second parameter of the method that this delegate encapsulates. + The type of the third parameter of the method that this delegate encapsulates. + The type of the fourth parameter of the method that this delegate encapsulates. + The type of the fifth parameter of the method that this delegate encapsulates. + The type of the return value of the method that this delegate encapsulates. + The first parameter of the method that this delegate encapsulates. + The second parameter of the method that this delegate encapsulates. + The third parameter of the method that this delegate encapsulates. + The fourth parameter of the method that this delegate encapsulates. + The fifth parameter of the method that this delegate encapsulates. + The return value of the method that this delegate encapsulates. + + + Defines a provider for progress updates. + The type of progress update value. + + + Reports a progress update. + The value of the updated progress. + + + Identities the async state machine type for this method. + + + Identities the state machine type for this method. + + + Initializes the attribute. + The type that implements the state machine. + + + Gets the type that implements the state machine. + + + Initializes the attribute. + The type that implements the state machine. + + + + Allows you to obtain the method or property name of the caller to the method. + + + + + Allows you to obtain the line number in the source file at which the method is called. + + + + + Allows you to obtain the full path of the source file that contains the caller. + This is the file path at the time of compile. + + + + Identities the iterator state machine type for this method. + + + Initializes the attribute. + The type that implements the state machine. + + + + Helper so we can call some tuple methods recursively without knowing the underlying types. + + + + + Provides static methods for creating tuple objects. + + + + + Creates a new 1-tuple, or singleton. + + The type of the only component of the tuple. + The value of the only component of the tuple. + A tuple whose value is (item1). + + + + Creates a new 3-tuple, or pair. + + The type of the first component of the tuple. + The type of the second component of the tuple. + The value of the first component of the tuple. + The value of the second component of the tuple. + An 2-tuple (pair) whose value is (item1, item2). + + + + Creates a new 3-tuple, or triple. + + The type of the first component of the tuple. + The type of the second component of the tuple. + The type of the third component of the tuple. + The value of the first component of the tuple. + The value of the second component of the tuple. + The value of the third component of the tuple. + An 3-tuple (triple) whose value is (item1, item2, item3). + + + + Creates a new 4-tuple, or quadruple. + + The type of the first component of the tuple. + The type of the second component of the tuple. + The type of the third component of the tuple. + The type of the fourth component of the tuple. + The value of the first component of the tuple. + The value of the second component of the tuple. + The value of the third component of the tuple. + The value of the fourth component of the tuple. + An 4-tuple (quadruple) whose value is (item1, item2, item3, item4). + + + + Creates a new 5-tuple, or quintuple. + + The type of the first component of the tuple. + The type of the second component of the tuple. + The type of the third component of the tuple. + The type of the fourth component of the tuple. + The type of the fifth component of the tuple. + The value of the first component of the tuple. + The value of the second component of the tuple. + The value of the third component of the tuple. + The value of the fourth component of the tuple. + The value of the fifth component of the tuple. + An 5-tuple (quintuple) whose value is (item1, item2, item3, item4, item5). + + + + Creates a new 6-tuple, or sextuple. + + The type of the first component of the tuple. + The type of the second component of the tuple. + The type of the third component of the tuple. + The type of the fourth component of the tuple. + The type of the fifth component of the tuple. + The type of the sixth component of the tuple. + The value of the first component of the tuple. + The value of the second component of the tuple. + The value of the third component of the tuple. + The value of the fourth component of the tuple. + The value of the fifth component of the tuple. + The value of the sixth component of the tuple. + An 6-tuple (sextuple) whose value is (item1, item2, item3, item4, item5, item6). + + + + Creates a new 7-tuple, or septuple. + + The type of the first component of the tuple. + The type of the second component of the tuple. + The type of the third component of the tuple. + The type of the fourth component of the tuple. + The type of the fifth component of the tuple. + The type of the sixth component of the tuple. + The type of the seventh component of the tuple. + The value of the first component of the tuple. + The value of the second component of the tuple. + The value of the third component of the tuple. + The value of the fourth component of the tuple. + The value of the fifth component of the tuple. + The value of the sixth component of the tuple. + The value of the seventh component of the tuple. + An 7-tuple (septuple) whose value is (item1, item2, item3, item4, item5, item6, item7). + + + + Creates a new 8-tuple, or octuple. + + The type of the first component of the tuple. + The type of the second component of the tuple. + The type of the third component of the tuple. + The type of the fourth component of the tuple. + The type of the fifth component of the tuple. + The type of the sixth component of the tuple. + The type of the seventh component of the tuple. + The type of the eighth component of the tuple. + The value of the first component of the tuple. + The value of the second component of the tuple. + The value of the third component of the tuple. + The value of the fourth component of the tuple. + The value of the fifth component of the tuple. + The value of the sixth component of the tuple. + The value of the seventh component of the tuple. + The value of the eighth component of the tuple. + An 8-tuple (octuple) whose value is (item1, item2, item3, item4, item5, item6, item7, item8). + + + + Represents a 1-tuple, or singleton. + + The type of the tuple's only component. + + + + Initializes a new instance of the class. + + The value of the current tuple object's single component. + + + + Returns a value that indicates whether the current tuple object is equal to a specified object. + + The object to compare with this instance. + true if the current instance is equal to the specified object; otherwise, false. + + + + Calculates the hash code for the current tuple object. + + A 32-bit signed integer hash code. + + + + Returns a string that represents the value of this tuple instance. + + The string representation of this tuple object. + + + + Gets the value of the tuple object's single component. + + + The value of the current tuple object's single component. + + + + + Represents an 2-tuple, or pair. + + The type of the first component of the tuple. + The type of the second component of the tuple. + + + + Initializes a new instance of the class. + + The value of the first component of the tuple. + The value of the second component of the tuple. + + + + Returns a value that indicates whether the current tuple object is equal to a specified object. + + The object to compare with this instance. + true if the current instance is equal to the specified object; otherwise, false. + + + + Calculates the hash code for the current tuple object. + + A 32-bit signed integer hash code. + + + + Returns a string that represents the value of this tuple instance. + + The string representation of this tuple object. + + + + Gets the value of the current tuple object's first component. + + + The value of the current tuple object's first component. + + + + + Gets the value of the current tuple object's second component. + + + The value of the current tuple object's second component. + + + + + Represents an 3-tuple, or triple. + + The type of the first component of the tuple. + The type of the second component of the tuple. + The type of the third component of the tuple. + + + + Initializes a new instance of the class. + + The value of the first component of the tuple. + The value of the second component of the tuple. + The value of the third component of the tuple. + + + + Returns a value that indicates whether the current tuple object is equal to a specified object. + + The object to compare with this instance. + true if the current instance is equal to the specified object; otherwise, false. + + + + Calculates the hash code for the current tuple object. + + A 32-bit signed integer hash code. + + + + Returns a string that represents the value of this tuple instance. + + The string representation of this tuple object. + + + + Gets the value of the current tuple object's first component. + + + The value of the current tuple object's first component. + + + + + Gets the value of the current tuple object's second component. + + + The value of the current tuple object's second component. + + + + + Gets the value of the current tuple object's third component. + + + The value of the current tuple object's third component. + + + + + Represents an 4-tuple, or quadruple. + + The type of the first component of the tuple. + The type of the second component of the tuple. + The type of the third component of the tuple. + The type of the fourth component of the tuple. + + + + Initializes a new instance of the class. + + The value of the first component of the tuple. + The value of the second component of the tuple. + The value of the third component of the tuple. + The value of the fourth component of the tuple. + + + + Returns a value that indicates whether the current tuple object is equal to a specified object. + + The object to compare with this instance. + true if the current instance is equal to the specified object; otherwise, false. + + + + Calculates the hash code for the current tuple object. + + A 32-bit signed integer hash code. + + + + Returns a string that represents the value of this tuple instance. + + The string representation of this tuple object. + + + + Gets the value of the current tuple object's first component. + + + The value of the current tuple object's first component. + + + + + Gets the value of the current tuple object's second component. + + + The value of the current tuple object's second component. + + + + + Gets the value of the current tuple object's third component. + + + The value of the current tuple object's third component. + + + + + Gets the value of the current tuple object's fourth component. + + + The value of the current tuple object's fourth component. + + + + + Represents an 5-tuple, or quintuple. + + The type of the first component of the tuple. + The type of the second component of the tuple. + The type of the third component of the tuple. + The type of the fourth component of the tuple. + The type of the fifth component of the tuple. + + + + Initializes a new instance of the class. + + The value of the first component of the tuple. + The value of the second component of the tuple. + The value of the third component of the tuple. + The value of the fourth component of the tuple. + The value of the fifth component of the tuple. + + + + Returns a value that indicates whether the current tuple object is equal to a specified object. + + The object to compare with this instance. + true if the current instance is equal to the specified object; otherwise, false. + + + + Calculates the hash code for the current tuple object. + + A 32-bit signed integer hash code. + + + + Returns a string that represents the value of this tuple instance. + + The string representation of this tuple object. + + + + Gets the value of the current tuple object's first component. + + + The value of the current tuple object's first component. + + + + + Gets the value of the current tuple object's second component. + + + The value of the current tuple object's second component. + + + + + Gets the value of the current tuple object's third component. + + + The value of the current tuple object's third component. + + + + + Gets the value of the current tuple object's fourth component. + + + The value of the current tuple object's fourth component. + + + + + Gets the value of the current tuple object's fifth component. + + + The value of the current tuple object's fifth component. + + + + + Represents an 6-tuple, or sextuple. + + The type of the first component of the tuple. + The type of the second component of the tuple. + The type of the third component of the tuple. + The type of the fourth component of the tuple. + The type of the fifth component of the tuple. + The type of the sixth component of the tuple. + + + + Initializes a new instance of the class. + + The value of the first component of the tuple. + The value of the second component of the tuple. + The value of the third component of the tuple. + The value of the fourth component of the tuple. + The value of the fifth component of the tuple. + The value of the sixth component of the tuple. + + + + Returns a value that indicates whether the current tuple object is equal to a specified object. + + The object to compare with this instance. + true if the current instance is equal to the specified object; otherwise, false. + + + + Calculates the hash code for the current tuple object. + + A 32-bit signed integer hash code. + + + + Returns a string that represents the value of this tuple instance. + + The string representation of this tuple object. + + + + Gets the value of the current tuple object's first component. + + + The value of the current tuple object's first component. + + + + + Gets the value of the current tuple object's second component. + + + The value of the current tuple object's second component. + + + + + Gets the value of the current tuple object's third component. + + + The value of the current tuple object's third component. + + + + + Gets the value of the current tuple object's fourth component. + + + The value of the current tuple object's fourth component. + + + + + Gets the value of the current tuple object's fifth component. + + + The value of the current tuple object's fifth component. + + + + + Gets the value of the current tuple object's sixth component. + + + The value of the current tuple object's sixth component. + + + + + Represents an 7-tuple, or septuple. + + The type of the first component of the tuple. + The type of the second component of the tuple. + The type of the third component of the tuple. + The type of the fourth component of the tuple. + The type of the fifth component of the tuple. + The type of the sixth component of the tuple. + The type of the seventh component of the tuple. + + + + Initializes a new instance of the class. + + The value of the first component of the tuple. + The value of the second component of the tuple. + The value of the third component of the tuple. + The value of the fourth component of the tuple. + The value of the fifth component of the tuple. + The value of the sixth component of the tuple. + The value of the seventh component of the tuple. + + + + Returns a value that indicates whether the current tuple object is equal to a specified object. + + The object to compare with this instance. + true if the current instance is equal to the specified object; otherwise, false. + + + + Calculates the hash code for the current tuple object. + + A 32-bit signed integer hash code. + + + + Returns a string that represents the value of this tuple instance. + + The string representation of this tuple object. + + + + Gets the value of the current tuple object's first component. + + + The value of the current tuple object's first component. + + + + + Gets the value of the current tuple object's second component. + + + The value of the current tuple object's second component. + + + + + Gets the value of the current tuple object's third component. + + + The value of the current tuple object's third component. + + + + + Gets the value of the current tuple object's fourth component. + + + The value of the current tuple object's fourth component. + + + + + Gets the value of the current tuple object's fifth component. + + + The value of the current tuple object's fifth component. + + + + + Gets the value of the current tuple object's sixth component. + + + The value of the current tuple object's sixth component. + + + + + Gets the value of the current tuple object's seventh component. + + + The value of the current tuple object's seventh component. + + + + + Represents an n-tuple, where n is 8 or greater. + + The type of the first component of the tuple. + The type of the second component of the tuple. + The type of the third component of the tuple. + The type of the fourth component of the tuple. + The type of the fifth component of the tuple. + The type of the sixth component of the tuple. + The type of the seventh component of the tuple. + Any generic Tuple object that defines the types of the tuple's remaining components. + + + + Initializes a new instance of the class. + + The value of the first component of the tuple. + The value of the second component of the tuple. + The value of the third component of the tuple. + The value of the fourth component of the tuple. + The value of the fifth component of the tuple. + The value of the sixth component of the tuple. + The value of the seventh component of the tuple. + Any generic Tuple object that contains the values of the tuple's remaining components. + + rest is not a generic Tuple object. + + + + + Returns a value that indicates whether the current tuple object is equal to a specified object. + + The object to compare with this instance. + true if the current instance is equal to the specified object; otherwise, false. + + + + Calculates the hash code for the current tuple object. + + A 32-bit signed integer hash code. + + + + Returns a string that represents the value of this tuple instance. + + The string representation of this tuple object. + + + + Gets the value of the current tuple object's first component. + + + The value of the current tuple object's first component. + + + + + Gets the value of the current tuple object's second component. + + + The value of the current tuple object's second component. + + + + + Gets the value of the current tuple object's third component. + + + The value of the current tuple object's third component. + + + + + Gets the value of the current tuple object's fourth component. + + + The value of the current tuple object's fourth component. + + + + + Gets the value of the current tuple object's fifth component. + + + The value of the current tuple object's fifth component. + + + + + Gets the value of the current tuple object's sixth component. + + + The value of the current tuple object's sixth component. + + + + + Gets the value of the current tuple object's seventh component. + + + The value of the current tuple object's seventh component. + + + + + Gets the current tuple object's remaining components. + + + The value of the current tuple object's remaining components. + + + + diff --git a/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+sl4+win8+wp71+wpa81/System.Threading.Tasks.dll b/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+sl4+win8+wp71+wpa81/System.Threading.Tasks.dll new file mode 100644 index 0000000000000000000000000000000000000000..03d08ad93e7cc6f8ae5664b89516ba2010a4f749 GIT binary patch literal 164576 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
    A;XM&re5ZI=Miv% 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 E10+ctx&QzG literal 0 HcmV?d00001 diff --git a/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+sl4+win8+wp71+wpa81/System.Threading.Tasks.xml b/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+sl4+win8+wp71+wpa81/System.Threading.Tasks.xml new file mode 100644 index 00000000..6c770122 --- /dev/null +++ b/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+sl4+win8+wp71+wpa81/System.Threading.Tasks.xml @@ -0,0 +1,8969 @@ + + + + System.Threading.Tasks + + + + Represents one or more errors that occur during application execution. + + is used to consolidate multiple failures into a single, throwable + exception object. + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class with + a specified error message. + + The error message that explains the reason for the exception. + + + + Initializes a new instance of the class with a specified error + message and a reference to the inner exception that is the cause of this exception. + + The error message that explains the reason for the exception. + The exception that is the cause of the current exception. + The argument + is null. + + + + Initializes a new instance of the class with + references to the inner exceptions that are the cause of this exception. + + The exceptions that are the cause of the current exception. + The argument + is null. + An element of is + null. + + + + Initializes a new instance of the class with + references to the inner exceptions that are the cause of this exception. + + The exceptions that are the cause of the current exception. + The argument + is null. + An element of is + null. + + + + Initializes a new instance of the class with a specified error + message and references to the inner exceptions that are the cause of this exception. + + The error message that explains the reason for the exception. + The exceptions that are the cause of the current exception. + The argument + is null. + An element of is + null. + + + + Initializes a new instance of the class with a specified error + message and references to the inner exceptions that are the cause of this exception. + + The error message that explains the reason for the exception. + The exceptions that are the cause of the current exception. + The argument + is null. + An element of is + null. + + + + Allocates a new aggregate exception with the specified message and list of inner exceptions. + + The error message that explains the reason for the exception. + The exceptions that are the cause of the current exception. + The argument + is null. + An element of is + null. + + + + Returns the that is the root cause of this exception. + + + + + Invokes a handler on each contained by this . + + The predicate to execute for each exception. The predicate accepts as an + argument the to be processed and returns a Boolean to indicate + whether the exception was handled. + + Each invocation of the returns true or false to indicate whether the + was handled. After all invocations, if any exceptions went + unhandled, all unhandled exceptions will be put into a new + which will be thrown. Otherwise, the method simply returns. If any + invocations of the throws an exception, it will halt the processing + of any more exceptions and immediately propagate the thrown exception as-is. + + An exception contained by this was not handled. + The argument is + null. + + + + Flattens an instances into a single, new instance. + + A new, flattened . + + If any inner exceptions are themselves instances of + , this method will recursively flatten all of them. The + inner exceptions returned in the new + will be the union of all of the the inner exceptions from exception tree rooted at the provided + instance. + + + + + Creates and returns a string representation of the current . + + A string representation of the current exception. + + + + Gets a read-only collection of the instances that caused the + current exception. + + + + + A strongly-typed resource class, for looking up localized strings, etc. + + + + + Returns the cached ResourceManager instance used by this class. + + + + + Overrides the current thread's CurrentUICulture property for all + resource lookups using this strongly typed resource class. + + + + + Looks up a localized string similar to One or more errors occurred.. + + + + + Looks up a localized string similar to An element of innerExceptions was null.. + + + + + Looks up a localized string similar to {0}{1}---> (Inner Exception #{2}) {3}{4}{5}. + + + + + Looks up a localized string similar to No tokens were supplied.. + + + + + Looks up a localized string similar to The CancellationTokenSource associated with this CancellationToken has been disposed.. + + + + + Looks up a localized string similar to The CancellationTokenSource has been disposed.. + + + + + Looks up a localized string similar to The SyncRoot property may not be used for the synchronization of concurrent collections.. + + + + + Looks up a localized string similar to The array is multidimensional, or the type parameter for the set cannot be cast automatically to the type of the destination array.. + + + + + Looks up a localized string similar to The index is equal to or greater than the length of the array, or the number of elements in the dictionary is greater than the available space from index to the end of the destination array.. + + + + + Looks up a localized string similar to The capacity argument must be greater than or equal to zero.. + + + + + Looks up a localized string similar to The concurrencyLevel argument must be positive.. + + + + + Looks up a localized string similar to The index argument is less than zero.. + + + + + Looks up a localized string similar to TKey is a reference type and item.Key is null.. + + + + + Looks up a localized string similar to The key already existed in the dictionary.. + + + + + Looks up a localized string similar to The source argument contains duplicate keys.. + + + + + Looks up a localized string similar to The key was of an incorrect type for this dictionary.. + + + + + Looks up a localized string similar to The value was of an incorrect type for this dictionary.. + + + + + Looks up a localized string similar to The lazily-initialized type does not have a public, parameterless constructor.. + + + + + Looks up a localized string similar to ValueFactory returned null.. + + + + + Looks up a localized string similar to The spinCount argument must be in the range 0 to {0}, inclusive.. + + + + + Looks up a localized string similar to There are too many threads currently waiting on the event. A maximum of {0} waiting threads are supported.. + + + + + Looks up a localized string similar to The event has been disposed.. + + + + + Looks up a localized string similar to The operation was canceled.. + + + + + Looks up a localized string similar to The condition argument is null.. + + + + + Looks up a localized string similar to The timeout must represent a value between -1 and Int32.MaxValue, inclusive.. + + + + + Looks up a localized string similar to The specified TaskContinuationOptions combined LongRunning and ExecuteSynchronously. Synchronous continuations should not be long running.. + + + + + Looks up a localized string similar to The specified TaskContinuationOptions excluded all continuation kinds.. + + + + + Looks up a localized string similar to (Internal)An attempt was made to create a LongRunning SelfReplicating task.. + + + + + Looks up a localized string similar to The value needs to translate in milliseconds to -1 (signifying an infinite timeout), 0 or a positive integer less than or equal to Int32.MaxValue.. + + + + + Looks up a localized string similar to The value needs to be either -1 (signifying an infinite timeout), 0 or a positive integer.. + + + + + Looks up a localized string similar to A task may only be disposed if it is in a completion state (RanToCompletion, Faulted or Canceled).. + + + + + Looks up a localized string similar to It is invalid to specify TaskCreationOptions.LongRunning in calls to FromAsync.. + + + + + Looks up a localized string similar to It is invalid to specify TaskCreationOptions.PreferFairness in calls to FromAsync.. + + + + + Looks up a localized string similar to It is invalid to specify TaskCreationOptions.SelfReplicating in calls to FromAsync.. + + + + + Looks up a localized string similar to FromAsync was called with a TaskManager that had already shut down.. + + + + + Looks up a localized string similar to The tasks argument contains no tasks.. + + + + + Looks up a localized string similar to It is invalid to exclude specific continuation kinds for continuations off of multiple tasks.. + + + + + Looks up a localized string similar to The tasks argument included a null value.. + + + + + Looks up a localized string similar to RunSynchronously may not be called on a task that was already started.. + + + + + Looks up a localized string similar to RunSynchronously may not be called on a continuation task.. + + + + + Looks up a localized string similar to RunSynchronously may not be called on a task not bound to a delegate, such as the task returned from an asynchronous method.. + + + + + Looks up a localized string similar to RunSynchronously may not be called on a task that has already completed.. + + + + + Looks up a localized string similar to Start may not be called on a task that was already started.. + + + + + Looks up a localized string similar to Start may not be called on a continuation task.. + + + + + Looks up a localized string similar to Start may not be called on a task with null action.. + + + + + Looks up a localized string similar to Start may not be called on a promise-style task.. + + + + + Looks up a localized string similar to Start may not be called on a task that has completed.. + + + + + Looks up a localized string similar to The task has been disposed.. + + + + + Looks up a localized string similar to The tasks array included at least one null element.. + + + + + Looks up a localized string similar to The awaited task has not yet completed.. + + + + + Looks up a localized string similar to A task was canceled.. + + + + + Looks up a localized string similar to The exceptions collection was empty.. + + + + + Looks up a localized string similar to The exceptions collection included at least one null element.. + + + + + Looks up a localized string similar to A Task's exception(s) were not observed either by Waiting on the Task or accessing its Exception property. As a result, the unobserved exception was rethrown by the finalizer thread.. + + + + + Looks up a localized string similar to (Internal)Expected an Exception or an IEnumerable<Exception>. + + + + + Looks up a localized string similar to ExecuteTask may not be called for a task which was already executed.. + + + + + Looks up a localized string similar to ExecuteTask may not be called for a task which was previously queued to a different TaskScheduler.. + + + + + Looks up a localized string similar to The current SynchronizationContext may not be used as a TaskScheduler.. + + + + + Looks up a localized string similar to The TryExecuteTaskInline call to the underlying scheduler succeeded, but the task body was not invoked.. + + + + + Looks up a localized string similar to An exception was thrown by a TaskScheduler.. + + + + + Looks up a localized string similar to It is invalid to specify TaskCreationOptions.SelfReplicating for a Task<TResult>.. + + + + + Looks up a localized string similar to {Not yet computed}. + + + + + Looks up a localized string similar to A task's Exception may only be set directly if the task was created without a function.. + + + + + Looks up a localized string similar to An attempt was made to transition a task to a final state when it had already completed.. + + + + + Represents a thread-safe collection of keys and values. + + The type of the keys in the dictionary. + The type of the values in the dictionary. + + All public and protected members of are thread-safe and may be used + concurrently from multiple threads. + + + + + Initializes a new instance of the + class that is empty, has the default concurrency level, has the default initial capacity, and + uses the default comparer for the key type. + + + + + Initializes a new instance of the + class that is empty, has the specified concurrency level and capacity, and uses the default + comparer for the key type. + + The estimated number of threads that will update the + concurrently. + The initial number of elements that the + can contain. + is + less than 1. + is less than + 0. + + + + Initializes a new instance of the + class that contains elements copied from the specified , has the default concurrency + level, has the default initial capacity, and uses the default comparer for the key type. + + The whose elements are copied to + the new + . + is a null reference + (Nothing in Visual Basic). + contains one or more + duplicate keys. + + + + Initializes a new instance of the + class that is empty, has the specified concurrency level and capacity, and uses the specified + . + + The + implementation to use when comparing keys. + is a null reference + (Nothing in Visual Basic). + + + + Initializes a new instance of the + class that contains elements copied from the specified , has the default concurrency level, has the default + initial capacity, and uses the specified + . + + The whose elements are copied to + the new + . + The + implementation to use when comparing keys. + is a null reference + (Nothing in Visual Basic). -or- + is a null reference (Nothing in Visual Basic). + + + + + Initializes a new instance of the + class that contains elements copied from the specified , + has the specified concurrency level, has the specified initial capacity, and uses the specified + . + + The estimated number of threads that will update the + concurrently. + The whose elements are copied to the new + . + The implementation to use + when comparing keys. + + is a null reference (Nothing in Visual Basic). + -or- + is a null reference (Nothing in Visual Basic). + + + is less than 1. + + contains one or more duplicate keys. + + + + Initializes a new instance of the + class that is empty, has the specified concurrency level, has the specified initial capacity, and + uses the specified . + + The estimated number of threads that will update the + concurrently. + The initial number of elements that the + can contain. + The + implementation to use when comparing keys. + + is less than 1. -or- + is less than 0. + + is a null reference + (Nothing in Visual Basic). + + + + Attempts to add the specified key and value to the . + + The key of the element to add. + The value of the element to add. The value can be a null reference (Nothing + in Visual Basic) for reference types. + true if the key/value pair was added to the + successfully; otherwise, false. + is null reference + (Nothing in Visual Basic). + The + contains too many elements. + + + + Determines whether the contains the specified + key. + + The key to locate in the . + true if the contains an element with + the specified key; otherwise, false. + is a null reference + (Nothing in Visual Basic). + + + + Attempts to remove and return the the value with the specified key from the + . + + The key of the element to remove and return. + When this method returns, contains the object removed from the + or the default value of + if the operation failed. + true if an object was removed successfully; otherwise, false. + is a null reference + (Nothing in Visual Basic). + + + + Removes the specified key from the dictionary if it exists and returns its associated value. + If matchValue flag is set, the key will be removed only if is associated with a particular + value. + + The key to search for and remove if it exists. + The variable into which the removed value, if found, is stored. + Whether removal of the key is conditional on its value. + The conditional value to compare against if is true + + + + + Attempts to get the value associated with the specified key from the . + + The key of the value to get. + When this method returns, contains the object from + the + with the spedified key or the default value of + , if the operation failed. + true if the key was found in the ; + otherwise, false. + is a null reference + (Nothing in Visual Basic). + + + + Compares the existing value for the specified key with a specified value, and if they’re equal, + updates the key with a third value. + + The key whose value is compared with and + possibly replaced. + The value that replaces the value of the element with if the comparison results in equality. + The value that is compared to the value of the element with + . + true if the value with was equal to and replaced with ; otherwise, + false. + is a null + reference. + + + + Removes all keys and values from the . + + + + + Copies the elements of the to an array of + type , starting at the + specified array index. + + The one-dimensional array of type + that is the destination of the elements copied from the . The array must have zero-based indexing. + The zero-based index in at which copying + begins. + is a null reference + (Nothing in Visual Basic). + is less than + 0. + is equal to or greater than + the length of the . -or- The number of elements in the source + is greater than the available space from to the end of the destination + . + + + + Copies the key and value pairs stored in the to a + new array. + + A new array containing a snapshot of key and value pairs copied from the . + + + + Copy dictionary contents to an array - shared implementation between ToArray and CopyTo. + + Important: the caller must hold all locks in m_locks before calling CopyToPairs. + + + + + Copy dictionary contents to an array - shared implementation between ToArray and CopyTo. + + Important: the caller must hold all locks in m_locks before calling CopyToEntries. + + + + + Copy dictionary contents to an array - shared implementation between ToArray and CopyTo. + + Important: the caller must hold all locks in m_locks before calling CopyToObjects. + + + + Returns an enumerator that iterates through the . + An enumerator for the . + + The enumerator returned from the dictionary is safe to use concurrently with + reads and writes to the dictionary, however it does not represent a moment-in-time snapshot + of the dictionary. The contents exposed through the enumerator may contain modifications + made to the dictionary after was called. + + + + + Shared internal implementation for inserts and updates. + If key exists, we always return false; and if updateIfExists == true we force update with value; + If key doesn't exist, we always add value and return true; + + + + + Adds a key/value pair to the + if the key does not already exist. + + The key of the element to add. + The function used to generate a value for the key + is a null reference + (Nothing in Visual Basic). + is a null reference + (Nothing in Visual Basic). + The dictionary contains too many + elements. + The value for the key. This will be either the existing value for the key if the + key is already in the dictionary, or the new value for the key as returned by valueFactory + if the key was not in the dictionary. + + + + Adds a key/value pair to the + if the key does not already exist. + + The key of the element to add. + the value to be added, if the key does not already exist + is a null reference + (Nothing in Visual Basic). + The dictionary contains too many + elements. + The value for the key. This will be either the existing value for the key if the + key is already in the dictionary, or the new value if the key was not in the dictionary. + + + + Adds a key/value pair to the if the key does not already + exist, or updates a key/value pair in the if the key + already exists. + + The key to be added or whose value should be updated + The function used to generate a value for an absent key + The function used to generate a new value for an existing key + based on the key's existing value + is a null reference + (Nothing in Visual Basic). + is a null reference + (Nothing in Visual Basic). + is a null reference + (Nothing in Visual Basic). + The dictionary contains too many + elements. + The new value for the key. This will be either be the result of addValueFactory (if the key was + absent) or the result of updateValueFactory (if the key was present). + + + + Adds a key/value pair to the if the key does not already + exist, or updates a key/value pair in the if the key + already exists. + + The key to be added or whose value should be updated + The value to be added for an absent key + The function used to generate a new value for an existing key based on + the key's existing value + is a null reference + (Nothing in Visual Basic). + is a null reference + (Nothing in Visual Basic). + The dictionary contains too many + elements. + The new value for the key. This will be either be the result of addValueFactory (if the key was + absent) or the result of updateValueFactory (if the key was present). + + + + Adds the specified key and value to the . + + The object to use as the key of the element to add. + The object to use as the value of the element to add. + is a null reference + (Nothing in Visual Basic). + The dictionary contains too many + elements. + + An element with the same key already exists in the . + + + + Removes the element with the specified key from the . + + The key of the element to remove. + true if the element is successfully remove; otherwise false. This method also returns + false if + was not found in the original . + + is a null reference + (Nothing in Visual Basic). + + + + Adds the specified value to the + with the specified key. + + The + structure representing the key and value to add to the . + The of is null. + The + contains too many elements. + An element with the same key already exists in the + + + + + Determines whether the + contains a specific key and value. + + The + structure to locate in the . + true if the is found in the ; otherwise, false. + + + + Removes a key and value from the dictionary. + + The + structure representing the key and value to remove from the . + true if the key and value represented by is successfully + found and removed; otherwise, false. + The Key property of is a null reference (Nothing in Visual Basic). + + + Returns an enumerator that iterates through the . + An enumerator for the . + + The enumerator returned from the dictionary is safe to use concurrently with + reads and writes to the dictionary, however it does not represent a moment-in-time snapshot + of the dictionary. The contents exposed through the enumerator may contain modifications + made to the dictionary after was called. + + + + + Adds the specified key and value to the dictionary. + + The object to use as the key. + The object to use as the value. + is a null reference + (Nothing in Visual Basic). + The dictionary contains too many + elements. + + is of a type that is not assignable to the key type of the . -or- + is of a type that is not assignable to , + the type of values in the . + -or- A value with the same key already exists in the . + + + + + Gets whether the contains an + element with the specified key. + + The key to locate in the . + true if the contains + an element with the specified key; otherwise, false. + is a null reference + (Nothing in Visual Basic). + + + Provides an for the + . + An for the . + + + + Removes the element with the specified key from the . + + The key of the element to remove. + is a null reference + (Nothing in Visual Basic). + + + + Copies the elements of the to an array, starting + at the specified array index. + + The one-dimensional array that is the destination of the elements copied from + the . The array must have zero-based + indexing. + The zero-based index in at which copying + begins. + is a null reference + (Nothing in Visual Basic). + is less than + 0. + is equal to or greater than + the length of the . -or- The number of elements in the source + is greater than the available space from to the end of the destination + . + + + + Replaces the internal table with a larger one. To prevent multiple threads from resizing the + table as a result of races, the table of buckets that was deemed too small is passed in as + an argument to GrowTable(). GrowTable() obtains a lock, and then checks whether the bucket + table has been replaced in the meantime or not. + + Reference to the bucket table that was deemed too small. + + + + Computes the bucket and lock number for a particular key. + + + + + Acquires all locks for this hash table, and increments locksAcquired by the number + of locks that were successfully acquired. The locks are acquired in an increasing + order. + + + + + Acquires a contiguous range of locks for this hash table, and increments locksAcquired + by the number of locks that were successfully acquired. The locks are acquired in an + increasing order. + + + + + Releases a contiguous range of locks. + + + + + Gets a collection containing the keys in the dictionary. + + + + + Gets a collection containing the values in the dictionary. + + + + + A helper method for asserts. + + + + + Get the data array to be serialized + + + + + Construct the dictionary from a previously seiralized one + + + + + Gets or sets the value associated with the specified key. + + The key of the value to get or set. + The value associated with the specified key. If the specified key is not found, a get + operation throws a + , and a set operation creates a new + element with the specified key. + is a null reference + (Nothing in Visual Basic). + The property is retrieved and + + does not exist in the collection. + + + + Gets the number of key/value pairs contained in the . + + The dictionary contains too many + elements. + The number of key/value paris contained in the . + Count has snapshot semantics and represents the number of items in the + at the moment when Count was accessed. + + + + Gets a value that indicates whether the is empty. + + true if the is empty; otherwise, + false. + + + + Gets a collection containing the keys in the . + + An containing the keys in the + . + + + + Gets a collection containing the values in the . + + An containing the values in + the + . + + + + Gets a value indicating whether the dictionary is read-only. + + true if the is + read-only; otherwise, false. For , this property always returns + false. + + + + Gets a value indicating whether the has a fixed size. + + true if the has a + fixed size; otherwise, false. For , this property always + returns false. + + + + Gets a value indicating whether the is read-only. + + true if the is + read-only; otherwise, false. For , this property always + returns false. + + + + Gets an containing the keys of the . + + An containing the keys of the . + + + + Gets an containing the values in the . + + An containing the values in the . + + + + Gets or sets the value associated with the specified key. + + The key of the value to get or set. + The value associated with the specified key, or a null reference (Nothing in Visual Basic) + if is not in the dictionary or is of a type that is + not assignable to the key type of the . + is a null reference + (Nothing in Visual Basic). + + A value is being assigned, and is of a type that is not assignable to the + key type of the . -or- A value is being + assigned, and is of a type that is not assignable to the value type + of the + + + + + Gets a value indicating whether access to the is + synchronized with the SyncRoot. + + true if access to the is synchronized + (thread safe); otherwise, false. For , this property always + returns false. + + + + Gets an object that can be used to synchronize access to the . This property is not supported. + + The SyncRoot property is not supported. + + + + The number of concurrent writes for which to optimize by default. + + + + + A node in a singly-linked list representing a particular hash table bucket. + + + + + A private class to represent enumeration over the dictionary that implements the + IDictionaryEnumerator interface. + + + + Throws the exception on the ThreadPool. + The exception to propagate. + The target context on which to propagate the exception. Null to use the ThreadPool. + + + Copies the exception's stack trace so its stack trace isn't overwritten. + The exception to prepare. + + + + Provides a builder for asynchronous methods that return . + This type is intended for compiler use only. + + + AsyncTaskMethodBuilder is a value type, and thus it is copied by value. + Prior to being copied, one of its Task, SetResult, or SetException members must be accessed, + or else the copies may end up building distinct Task instances. + + + + Represents an asynchronous method builder. + + + A cached VoidTaskResult task used for builders that complete synchronously. + + + The generic builder object to which this non-generic instance delegates. + + + Initializes a new . + The initialized . + + + Initiates the builder's execution with the associated state machine. + Specifies the type of the state machine. + The state machine instance, passed by reference. + + + Associates the builder with the state machine it represents. + The heap-allocated state machine object. + The argument was null (Nothing in Visual Basic). + The builder is incorrectly initialized. + + + Perform any initialization necessary prior to lifting the builder to the heap. + + + + Schedules the specified state machine to be pushed forward when the specified awaiter completes. + + Specifies the type of the awaiter. + Specifies the type of the state machine. + The awaiter. + The state machine. + + + + Schedules the specified state machine to be pushed forward when the specified awaiter completes. + + Specifies the type of the awaiter. + Specifies the type of the state machine. + The awaiter. + The state machine. + + + + Completes the in the + RanToCompletion state. + + The builder is not initialized. + The task has already completed. + + + + Completes the in the + Faulted state with the specified exception. + + The to use to fault the task. + The argument is null (Nothing in Visual Basic). + The builder is not initialized. + The task has already completed. + + + + Called by the debugger to request notification when the first wait operation + (await, Wait, Result, etc.) on this builder's task completes. + + + true to enable notification; false to disable a previously set notification. + + + + Gets the for this builder. + The representing the builder's asynchronous operation. + The builder is not initialized. + + + + Gets an object that may be used to uniquely identify this builder to the debugger. + + + This property lazily instantiates the ID in a non-thread-safe manner. + It must only be used by the debugger, and only in a single-threaded manner + when no other threads are in the middle of accessing this property or this.Task. + + + + Holds state related to the builder's IAsyncStateMachine. + This is a mutable struct. Be very delicate with it. + + + A reference to the heap-allocated state machine object associated with this builder. + + + Initiates the builder's execution with the associated state machine. + Specifies the type of the state machine. + The state machine instance, passed by reference. + The argument is null (Nothing in Visual Basic). + + + Associates the builder with the state machine it represents. + The heap-allocated state machine object. + The argument was null (Nothing in Visual Basic). + The builder is incorrectly initialized. + + + + Gets the Action to use with an awaiter's OnCompleted or UnsafeOnCompleted method. + On first invocation, the supplied state machine will be boxed. + + Specifies the type of the method builder used. + Specifies the type of the state machine used. + The builder. + The state machine. + An Action to provide to the awaiter. + + + Provides the ability to invoke a state machine's MoveNext method under a supplied ExecutionContext. + + + The context with which to run MoveNext. + + + The state machine whose MoveNext method should be invoked. + + + Initializes the runner. + The context with which to run MoveNext. + + + Invokes MoveNext under the provided context. + + + Cached delegate used with ExecutionContext.Run. + + + Invokes the MoveNext method on the supplied IAsyncStateMachine. + The IAsyncStateMachine machine instance. + + + + Provides a builder for asynchronous methods that return void. + This type is intended for compiler use only. + + + + The synchronization context associated with this operation. + + + State related to the IAsyncStateMachine. + + + An object used by the debugger to uniquely identify this builder. Lazily initialized. + + + Temporary support for disabling crashing if tasks go unobserved. + + + Registers with UnobservedTaskException to suppress exception crashing. + + + Non-zero if PreventUnobservedTaskExceptions has already been invoked. + + + Initializes a new . + The initialized . + + + Initializes the . + The synchronizationContext associated with this operation. This may be null. + + + Initiates the builder's execution with the associated state machine. + Specifies the type of the state machine. + The state machine instance, passed by reference. + The argument was null (Nothing in Visual Basic). + + + Associates the builder with the state machine it represents. + The heap-allocated state machine object. + The argument was null (Nothing in Visual Basic). + The builder is incorrectly initialized. + + + Perform any initialization necessary prior to lifting the builder to the heap. + + + + Schedules the specified state machine to be pushed forward when the specified awaiter completes. + + Specifies the type of the awaiter. + Specifies the type of the state machine. + The awaiter. + The state machine. + + + + Schedules the specified state machine to be pushed forward when the specified awaiter completes. + + Specifies the type of the awaiter. + Specifies the type of the state machine. + The awaiter. + The state machine. + + + Completes the method builder successfully. + + + Faults the method builder with an exception. + The exception that is the cause of this fault. + The argument is null (Nothing in Visual Basic). + The builder is not initialized. + + + Notifies the current synchronization context that the operation completed. + + + + Gets an object that may be used to uniquely identify this builder to the debugger. + + + This property lazily instantiates the ID in a non-thread-safe manner. + It must only be used by the debugger and only in a single-threaded manner. + + + + + Provides a builder for asynchronous methods that return . + This type is intended for compiler use only. + + + AsyncTaskMethodBuilder{TResult} is a value type, and thus it is copied by value. + Prior to being copied, one of its Task, SetResult, or SetException members must be accessed, + or else the copies may end up building distinct Task instances. + + + + A cached task for default(TResult). + + + State related to the IAsyncStateMachine. + + + The lazily-initialized task. + Must be named m_task for debugger step-over to work correctly. + + + The lazily-initialized task completion source. + + + Temporary support for disabling crashing if tasks go unobserved. + + + Initializes a new . + The initialized . + + + Initiates the builder's execution with the associated state machine. + Specifies the type of the state machine. + The state machine instance, passed by reference. + + + Associates the builder with the state machine it represents. + The heap-allocated state machine object. + The argument was null (Nothing in Visual Basic). + The builder is incorrectly initialized. + + + Perform any initialization necessary prior to lifting the builder to the heap. + + + + Schedules the specified state machine to be pushed forward when the specified awaiter completes. + + Specifies the type of the awaiter. + Specifies the type of the state machine. + The awaiter. + The state machine. + + + + Schedules the specified state machine to be pushed forward when the specified awaiter completes. + + Specifies the type of the awaiter. + Specifies the type of the state machine. + The awaiter. + The state machine. + + + + Completes the in the + RanToCompletion state with the specified result. + + The result to use to complete the task. + The task has already completed. + + + + Completes the builder by using either the supplied completed task, or by completing + the builder's previously accessed task using default(TResult). + + A task already completed with the value default(TResult). + The task has already completed. + + + + Completes the in the + Faulted state with the specified exception. + + The to use to fault the task. + The argument is null (Nothing in Visual Basic). + The task has already completed. + + + + Called by the debugger to request notification when the first wait operation + (await, Wait, Result, etc.) on this builder's task completes. + + + true to enable notification; false to disable a previously set notification. + + + This should only be invoked from within an asynchronous method, + and only by the debugger. + + + + + Gets a task for the specified result. This will either + be a cached or new task, never null. + + The result for which we need a task. + The completed task containing the result. + + + Gets the lazily-initialized TaskCompletionSource. + + + Gets the for this builder. + The representing the builder's asynchronous operation. + + + + Gets an object that may be used to uniquely identify this builder to the debugger. + + + This property lazily instantiates the ID in a non-thread-safe manner. + It must only be used by the debugger, and only in a single-threaded manner + when no other threads are in the middle of accessing this property or this.Task. + + + + Provides a base class used to cache tasks of a specific return type. + Specifies the type of results the cached tasks return. + + + + A singleton cache for this result type. + This may be null if there are no cached tasks for this TResult. + + + + Creates a non-disposable task. + The result for the task. + The cacheable task. + + + Creates a cache. + A task cache for this result type. + + + Gets a cached task if one exists. + The result for which we want a cached task. + A cached task if one exists; otherwise, null. + + + Provides a cache for Boolean tasks. + + + A true task. + + + A false task. + + + Gets a cached task for the Boolean result. + true or false + A cached task for the Boolean result. + + + Provides a cache for zero Int32 tasks. + + + The minimum value, inclusive, for which we want a cached task. + + + The maximum value, exclusive, for which we want a cached task. + + + The cache of Task{Int32}. + + + Creates an array of cached tasks for the values in the range [INCLUSIVE_MIN,EXCLUSIVE_MAX). + + + Gets a cached task for the zero Int32 result. + The integer value + A cached task for the Int32 result or null if not cached. + + + + Represents state machines generated for asynchronous methods. + This type is intended for compiler use only. + + + + Moves the state machine to its next state. + + + Configures the state machine with a heap-allocated replica. + The heap-allocated replica. + + + + Represents an awaiter used to schedule continuations when an await operation completes. + + + + + Represents an operation that will schedule continuations when the operation completes. + + + + Schedules the continuation action to be invoked when the instance completes. + The action to invoke when the operation completes. + The argument is null (Nothing in Visual Basic). + + + Schedules the continuation action to be invoked when the instance completes. + The action to invoke when the operation completes. + The argument is null (Nothing in Visual Basic). + Unlike OnCompleted, UnsafeOnCompleted need not propagate ExecutionContext information. + + + Used with Task(of void) + + + + An interface similar to the one added in .NET 4.0. + + + + The exception that is thrown in a thread upon cancellation of an operation that the thread was executing. + + + Initializes the exception. + + + Initializes the exception. + The error message that explains the reason for the exception. + + + Initializes the exception. + The error message that explains the reason for the exception. + The exception that is the cause of the current exception. + + + Initializes the exception. + A cancellation token associated with the operation that was canceled. + + + Initializes the exception. + The error message that explains the reason for the exception. + A cancellation token associated with the operation that was canceled. + + + Initializes the exception. + The error message that explains the reason for the exception. + The exception that is the cause of the current exception. + A cancellation token associated with the operation that was canceled. + + + Gets a token associated with the operation that was canceled. + + + + A dummy replacement for the .NET internal class StackCrawlMark. + + + + + Propogates notification that operations should be canceled. + + + + A may be created directly in an unchangeable canceled or non-canceled state + using the CancellationToken's constructors. However, to have a CancellationToken that can change + from a non-canceled to a canceled state, + CancellationTokenSource must be used. + CancellationTokenSource exposes the associated CancellationToken that may be canceled by the source through its + Token property. + + + Once canceled, a token may not transition to a non-canceled state, and a token whose + is false will never change to one that can be canceled. + + + All members of this struct are thread-safe and may be used concurrently from multiple threads. + + + + + + Internal constructor only a CancellationTokenSource should create a CancellationToken + + + + + Initializes the CancellationToken. + + + The canceled state for the token. + + + Tokens created with this constructor will remain in the canceled state specified + by the parameter. If is false, + both and will be false. + If is true, + both and will be true. + + + + + Registers a delegate that will be called when this CancellationToken is canceled. + + + + If this token is already in the canceled state, the + delegate will be run immediately and synchronously. Any exception the delegate generates will be + propogated out of this method call. + + + The delegate to be executed when the CancellationToken is canceled. + The instance that can + be used to deregister the callback. + is null. + The associated CancellationTokenSource has been disposed. + + + + Registers a delegate that will be called when this + CancellationToken is canceled. + + + + If this token is already in the canceled state, the + delegate will be run immediately and synchronously. Any exception the delegate generates will be + propogated out of this method call. + + + The delegate to be executed when the CancellationToken is canceled. + A Boolean value that indicates whether to capture + the current SynchronizationContext and use it + when invoking the . + The instance that can + be used to deregister the callback. + is null. + The associated CancellationTokenSource has been disposed. + + + + Registers a delegate that will be called when this + CancellationToken is canceled. + + + + If this token is already in the canceled state, the + delegate will be run immediately and synchronously. Any exception the delegate generates will be + propogated out of this method call. + + + The delegate to be executed when the CancellationToken is canceled. + The state to pass to the when the delegate is invoked. This may be null. + The instance that can + be used to deregister the callback. + is null. + The associated CancellationTokenSource has been disposed. + + + + Registers a delegate that will be called when this + CancellationToken is canceled. + + + + If this token is already in the canceled state, the + delegate will be run immediately and synchronously. Any exception the delegate generates will be + propogated out of this method call. + + + The delegate to be executed when the CancellationToken is canceled. + The state to pass to the when the delegate is invoked. This may be null. + A Boolean value that indicates whether to capture + the current SynchronizationContext and use it + when invoking the . + The instance that can + be used to deregister the callback. + is null. + The associated CancellationTokenSource has been disposed. + + + + Determines whether the current CancellationToken instance is equal to the + specified token. + + The other CancellationToken to which to compare this + instance. + True if the instances are equal; otherwise, false. Two tokens are equal if they are associated + with the same CancellationTokenSource or if they were both constructed + from public CancellationToken constructors and their values are equal. + + + + Determines whether the current CancellationToken instance is equal to the + specified . + + The other object to which to compare this instance. + True if is a CancellationToken + and if the two instances are equal; otherwise, false. Two tokens are equal if they are associated + with the same CancellationTokenSource or if they were both constructed + from public CancellationToken constructors and their values are equal. + An associated CancellationTokenSource has been disposed. + + + + Serves as a hash function for a CancellationToken. + + A hash code for the current CancellationToken instance. + + + + Determines whether two CancellationToken instances are equal. + + The first instance. + The second instance. + True if the instances are equal; otherwise, false. + An associated CancellationTokenSource has been disposed. + + + + Determines whether two CancellationToken instances are not equal. + + The first instance. + The second instance. + True if the instances are not equal; otherwise, false. + An associated CancellationTokenSource has been disposed. + + + + Throws a OperationCanceledException if + this token has had cancellation requested. + + + This method provides functionality equivalent to: + + if (token.IsCancellationRequested) + throw new OperationCanceledException(token); + + + The token has had cancellation requested. + The associated CancellationTokenSource has been disposed. + + + + Returns an empty CancellationToken value. + + + The value returned by this property will be non-cancelable by default. + + + + + Gets whether cancellation has been requested for this token. + + Whether cancellation has been requested for this token. + + + This property indicates whether cancellation has been requested for this token, + either through the token initially being construted in a canceled state, or through + calling Cancel + on the token's associated . + + + If this property is true, it only guarantees that cancellation has been requested. + It does not guarantee that every registered handler + has finished executing, nor that cancellation requests have finished propagating + to all registered handlers. Additional synchronization may be required, + particularly in situations where related objects are being canceled concurrently. + + + + + + Gets whether this token is capable of being in the canceled state. + + + If CanBeCanceled returns false, it is guaranteed that the token will never transition + into a canceled state, meaning that will never + return true. + + + + + Gets a that is signaled when the token is canceled. + + Accessing this property causes a WaitHandle + to be instantiated. It is preferable to only use this property when necessary, and to then + dispose the associated instance at the earliest opportunity (disposing + the source will dispose of this allocated handle). The handle should not be closed or disposed directly. + + The associated CancellationTokenSource has been disposed. + + + + Represents a callback delegate that has been registered with a CancellationToken. + + + To unregister a callback, dispose the corresponding Registration instance. + + + + + Attempts to deregister the item. If it's already being run, this may fail. + Entails a full memory fence. + + True if the callback was found and deregistered, false otherwise. + + + + Disposes of the registration and unregisters the target callback from the associated + CancellationToken. + If the target callback is currently executing this method will wait until it completes, except + in the degenerate cases where a callback method deregisters itself. + + + + + Determines whether two CancellationTokenRegistration + instances are equal. + + The first instance. + The second instance. + True if the instances are equal; otherwise, false. + + + + Determines whether two CancellationTokenRegistration instances are not equal. + + The first instance. + The second instance. + True if the instances are not equal; otherwise, false. + + + + Determines whether the current CancellationTokenRegistration instance is equal to the + specified . + + The other object to which to compare this instance. + True, if both this and are equal. False, otherwise. + Two CancellationTokenRegistration instances are equal if + they both refer to the output of a single call to the same Register method of a + CancellationToken. + + + + + Determines whether the current CancellationToken instance is equal to the + specified . + + The other CancellationTokenRegistration to which to compare this instance. + True, if both this and are equal. False, otherwise. + Two CancellationTokenRegistration instances are equal if + they both refer to the output of a single call to the same Register method of a + CancellationToken. + + + + + Serves as a hash function for a CancellationTokenRegistration.. + + A hash code for the current CancellationTokenRegistration instance. + + + + Signals to a that it should be canceled. + + + + is used to instantiate a + (via the source's Token property) + that can be handed to operations that wish to be notified of cancellation or that can be used to + register asynchronous operations for cancellation. That token may have cancellation requested by + calling to the source's Cancel + method. + + + All members of this class, except Dispose, are thread-safe and may be used + concurrently from multiple threads. + + + + + The ID of the thread currently executing the main body of CTS.Cancel() + this helps us to know if a call to ctr.Dispose() is running 'within' a cancellation callback. + This is updated as we move between the main thread calling cts.Cancel() and any syncContexts that are used to + actually run the callbacks. + + + + Initializes the . + + + + + Communicates a request for cancellation. + + + + The associated will be + notified of the cancellation and will transition to a state where + IsCancellationRequested returns true. + Any callbacks or cancelable operations + registered with the will be executed. + + + Cancelable operations and callbacks registered with the token should not throw exceptions. + However, this overload of Cancel will aggregate any exceptions thrown into a , + such that one callback throwing an exception will not prevent other registered callbacks from being executed. + + + The that was captured when each callback was registered + will be reestablished when the callback is invoked. + + + An aggregate exception containing all the exceptions thrown + by the registered callbacks on the associated . + This has been disposed. + + + + Communicates a request for cancellation. + + + + The associated will be + notified of the cancellation and will transition to a state where + IsCancellationRequested returns true. + Any callbacks or cancelable operations + registered with the will be executed. + + + Cancelable operations and callbacks registered with the token should not throw exceptions. + If is true, an exception will immediately propagate out of the + call to Cancel, preventing the remaining callbacks and cancelable operations from being processed. + If is false, this overload will aggregate any + exceptions thrown into a , + such that one callback throwing an exception will not prevent other registered callbacks from being executed. + + + The that was captured when each callback was registered + will be reestablished when the callback is invoked. + + + Specifies whether exceptions should immediately propagate. + An aggregate exception containing all the exceptions thrown + by the registered callbacks on the associated . + This has been disposed. + + + + Releases the resources used by this . + + + This method is not thread-safe for any other concurrent calls. + + + + + Throws an exception if the source has been disposed. + + + + + InternalGetStaticSource() + + Whether the source should be set. + A static source to be shared among multiple tokens. + + + + Registers a callback object. If cancellation has already occurred, the + callback will have been run by the time this method returns. + + + + + + + + + + Invoke the Canceled event. + + + The handlers are invoked synchronously in LIFO order. + + + + + Creates a CancellationTokenSource that will be in the canceled state + when any of the source tokens are in the canceled state. + + The first CancellationToken to observe. + The second CancellationToken to observe. + A CancellationTokenSource that is linked + to the source tokens. + A CancellationTokenSource associated with + one of the source tokens has been disposed. + + + + Creates a CancellationTokenSource that will be in the canceled state + when any of the source tokens are in the canceled state. + + The CancellationToken instances to observe. + A CancellationTokenSource that is linked + to the source tokens. + is null. + A CancellationTokenSource associated with + one of the source tokens has been disposed. + + + + Gets whether cancellation has been requested for this CancellationTokenSource. + + Whether cancellation has been requested for this CancellationTokenSource. + + + This property indicates whether cancellation has been requested for this token source, such as + due to a call to its + Cancel method. + + + If this property returns true, it only guarantees that cancellation has been requested. It does not + guarantee that every handler registered with the corresponding token has finished executing, nor + that cancellation requests have finished propagating to all registered handlers. Additional + synchronization may be required, particularly in situations where related objects are being + canceled concurrently. + + + + + + A simple helper to determine whether cancellation has finished. + + + + + A simple helper to determine whether disposal has occured. + + + + + The ID of the thread that is running callbacks. + + + + + Gets the CancellationToken + associated with this . + + The CancellationToken + associated with this . + The token source has been + disposed. + + + + + + + + + + + + + + The currently executing callback + + + + + A helper class for collating the various bits of information required to execute + cancellation callbacks. + + + + + InternalExecuteCallbackSynchronously_GeneralPath + This will be called on the target synchronization context, however, we still need to restore the required execution context + + + + + A sparsely populated array. Elements can be sparse and some null, but this allows for + lock-free additions and growth, and also for constant time removal (by nulling out). + + The kind of elements contained within. + + + + Allocates a new array with the given initial size. + + How many array slots to pre-allocate. + + + + Adds an element in the first available slot, beginning the search from the tail-to-head. + If no slots are available, the array is grown. The method doesn't return until successful. + + The element to add. + Information about where the add happened, to enable O(1) deregistration. + + + + The tail of the doubly linked list. + + + + + A struct to hold a link to the exact spot in an array an element was inserted, enabling + constant time removal later on. + + + + + A fragment of a sparsely populated array, doubly linked. + + The kind of elements contained within. + + + + Provides lazy initialization routines. + + + These routines avoid needing to allocate a dedicated, lazy-initialization instance, instead using + references to ensure targets have been initialized as they are accessed. + + + + + Initializes a target reference type with the type's default constructor if the target has not + already been initialized. + + The refence type of the reference to be initialized. + A reference of type to initialize if it has not + already been initialized. + The initialized reference of type . + Type does not have a default + constructor. + + Permissions to access the constructor of type were missing. + + + + This method may only be used on reference types. To ensure initialization of value + types, see other overloads of EnsureInitialized. + + + This method may be used concurrently by multiple threads to initialize . + In the event that multiple threads access this method concurrently, multiple instances of + may be created, but only one will be stored into . In such an occurrence, this method will not dispose of the + objects that were not stored. If such objects must be disposed, it is up to the caller to determine + if an object was not used and to then dispose of the object appropriately. + + + + + + Initializes a target reference type using the specified function if it has not already been + initialized. + + The reference type of the reference to be initialized. + The reference of type to initialize if it has not + already been initialized. + The invoked to initialize the + reference. + The initialized reference of type . + Type does not have a + default constructor. + returned + null. + + + This method may only be used on reference types, and may + not return a null reference (Nothing in Visual Basic). To ensure initialization of value types or + to allow null reference types, see other overloads of EnsureInitialized. + + + This method may be used concurrently by multiple threads to initialize . + In the event that multiple threads access this method concurrently, multiple instances of + may be created, but only one will be stored into . In such an occurrence, this method will not dispose of the + objects that were not stored. If such objects must be disposed, it is up to the caller to determine + if an object was not used and to then dispose of the object appropriately. + + + + + + Initialize the target using the given delegate (slow path). + + The reference type of the reference to be initialized. + The variable that need to be initialized + The delegate that will be executed to initialize the target + The initialized variable + + + + Initializes a target reference or value type with its default constructor if it has not already + been initialized. + + The type of the reference to be initialized. + A reference or value of type to initialize if it + has not already been initialized. + A reference to a boolean that determines whether the target has already + been initialized. + A reference to an object used as the mutually exclusive lock for initializing + . + The initialized value of type . + + + + Initializes a target reference or value type with a specified function if it has not already been + initialized. + + The type of the reference to be initialized. + A reference or value of type to initialize if it + has not already been initialized. + A reference to a boolean that determines whether the target has already + been initialized. + A reference to an object used as the mutually exclusive lock for initializing + . + The invoked to initialize the + reference or value. + The initialized value of type . + + + + Ensure the target is initialized and return the value (slow path). This overload permits nulls + and also works for value type targets. Uses the supplied function to create the value. + + The type of target. + A reference to the target to be initialized. + A reference to a location tracking whether the target has been initialized. + A reference to a location containing a mutual exclusive lock. + + The to invoke in order to produce the lazily-initialized value. + + The initialized object. + + + + Provides a slimmed down version of . + + + All public and protected members of are thread-safe and may be used + concurrently from multiple threads, with the exception of Dispose, which + must only be used when all other operations on the have + completed, and Reset, which should only be used when no other threads are + accessing the event. + + + + + Initializes a new instance of the + class with an initial state of nonsignaled. + + + + + Initializes a new instance of the + class with a Boolen value indicating whether to set the intial state to signaled. + + true to set the initial state signaled; false to set the initial state + to nonsignaled. + + + + Initializes a new instance of the + class with a Boolen value indicating whether to set the intial state to signaled and a specified + spin count. + + true to set the initial state to signaled; false to set the initial state + to nonsignaled. + The number of spin waits that will occur before falling back to a true + wait. + is less than + 0 or greater than the maximum allowed value. + + + + Initializes the internal state of the event. + + Whether the event is set initially or not. + The spin count that decides when the event will block. + + + + Helper to ensure the lock object is created before first use. + + + + + This method lazily initializes the event object. It uses CAS to guarantee that + many threads racing to call this at once don't result in more than one event + being stored and used. The event will be signaled or unsignaled depending on + the state of the thin-event itself, with synchronization taken into account. + + True if a new event was created and stored, false otherwise. + + + + Sets the state of the event to signaled, which allows one or more threads waiting on the event to + proceed. + + + + + Private helper to actually perform the Set. + + Indicates whether we are calling Set() during cancellation. + The object has been canceled. + + + + Sets the state of the event to nonsignaled, which causes threads to block. + + + Unlike most of the members of , is not + thread-safe and may not be used concurrently with other members of this instance. + + + + + Blocks the current thread until the current is set. + + + The maximum number of waiters has been exceeded. + + + The caller of this method blocks indefinitely until the current instance is set. The caller will + return immediately if the event is currently in a set state. + + + + + Blocks the current thread until the current receives a signal, + while observing a . + + The to + observe. + + The maximum number of waiters has been exceeded. + + was + canceled. + + The caller of this method blocks indefinitely until the current instance is set. The caller will + return immediately if the event is currently in a set state. + + + + + Blocks the current thread until the current is set, using a + to measure the time interval. + + A that represents the number of milliseconds + to wait, or a that represents -1 milliseconds to wait indefinitely. + + true if the was set; otherwise, + false. + is a negative + number other than -1 milliseconds, which represents an infinite time-out -or- timeout is greater + than . + + The maximum number of waiters has been exceeded. + + + + + Blocks the current thread until the current is set, using a + to measure the time interval, while observing a . + + A that represents the number of milliseconds + to wait, or a that represents -1 milliseconds to wait indefinitely. + + The to + observe. + true if the was set; otherwise, + false. + is a negative + number other than -1 milliseconds, which represents an infinite time-out -or- timeout is greater + than . + was canceled. + + The maximum number of waiters has been exceeded. + + + + + Blocks the current thread until the current is set, using a + 32-bit signed integer to measure the time interval. + + The number of milliseconds to wait, or (-1) to wait indefinitely. + true if the was set; otherwise, + false. + is a + negative number other than -1, which represents an infinite time-out. + + The maximum number of waiters has been exceeded. + + + + + Blocks the current thread until the current is set, using a + 32-bit signed integer to measure the time interval, while observing a . + + The number of milliseconds to wait, or (-1) to wait indefinitely. + The to + observe. + true if the was set; otherwise, + false. + is a + negative number other than -1, which represents an infinite time-out. + + The maximum number of waiters has been exceeded. + + was canceled. + + + + Releases all resources used by the current instance of . + + + Unlike most of the members of , is not + thread-safe and may not be used concurrently with other members of this instance. + + + + + When overridden in a derived class, releases the unmanaged resources used by the + , and optionally releases the managed resources. + + true to release both managed and unmanaged resources; + false to release only unmanaged resources. + + Unlike most of the members of , is not + thread-safe and may not be used concurrently with other members of this instance. + + + + + Throw ObjectDisposedException if the MRES is disposed + + + + + Private helper method to wake up waiters when a cancellationToken gets canceled. + + + + + Private helper method for updating parts of a bit-string state value. + Mainly called from the IsSet and Waiters properties setters + + + Note: the parameter types must be int as CompareExchange cannot take a Uint + + The new value + The mask used to set the bits + + + + Private helper method - performs Mask and shift, particular helpful to extract a field from a packed word. + eg ExtractStatePortionAndShiftRight(0x12345678, 0xFF000000, 24) => 0x12, ie extracting the top 8-bits as a simple integer + + ?? is there a common place to put this rather than being private to MRES? + + + + + + + + + Performs a Mask operation, but does not perform the shift. + This is acceptable for boolean values for which the shift is unnecessary + eg (val & Mask) != 0 is an appropriate way to extract a boolean rather than using + ((val & Mask) >> shiftAmount) == 1 + + ?? is there a common place to put this rather than being private to MRES? + + + + + + + Helper function to measure and update the wait time + + The first time (in Ticks) observed when the wait started. + The orginal wait timeoutout in milliseconds. + The new wait time in milliseconds, -1 if the time expired, -2 if overflow in counters + has occurred. + + + + Gets the underlying object for this . + + The underlying event object fore this . + + Accessing this property forces initialization of an underlying event object if one hasn't + already been created. To simply wait on this , + the public Wait methods should be preferred. + + + + + Gets whether the event is set. + + true if the event has is set; otherwise, false. + + + + Gets the number of spin waits that will be occur before falling back to a true wait. + + + + + How many threads are waiting. + + + + + Provides support for spin-based waiting. + + + + encapsulates common spinning logic. On single-processor machines, yields are + always used instead of busy waits, and on computers with Intel™ processors employing Hyper-Threading™ + technology, it helps to prevent hardware thread starvation. SpinWait encapsulates a good mixture of + spinning and true yielding. + + + is a value type, which means that low-level code can utilize SpinWait without + fear of unnecessary allocation overheads. SpinWait is not generally useful for ordinary applications. + In most cases, you should use the synchronization classes provided by the .NET Framework, such as + . For most purposes where spin waiting is required, however, + the type should be preferred over the System.Threading.Thread.SpinWait method. + + + While SpinWait is designed to be used in concurrent applications, it is not designed to be + used from multiple threads concurrently. SpinWait's members are not thread-safe. If multiple + threads must spin, each should use its own instance of SpinWait. + + + + + + Performs a single spin. + + + This is typically called in a loop, and may change in behavior based on the number of times a + has been called thus far on this instance. + + + + + Resets the spin counter. + + + This makes and behave as though no calls + to had been issued on this instance. If a instance + is reused many times, it may be useful to reset it to avoid yielding too soon. + + + + + Spins until the specified condition is satisfied. + + A delegate to be executed over and over until it returns true. + The argument is null. + + + + Spins until the specified condition is satisfied or until the specified timeout is expired. + + A delegate to be executed over and over until it returns true. + + A that represents the number of milliseconds to wait, + or a TimeSpan that represents -1 milliseconds to wait indefinitely. + True if the condition is satisfied within the timeout; otherwise, false + The argument is null. + is a negative number + other than -1 milliseconds, which represents an infinite time-out -or- timeout is greater than + . + + + + Spins until the specified condition is satisfied or until the specified timeout is expired. + + A delegate to be executed over and over until it returns true. + The number of milliseconds to wait, or (-1) to wait indefinitely. + True if the condition is satisfied within the timeout; otherwise, false + The argument is null. + is a + negative number other than -1, which represents an infinite time-out. + + + + Gets the number of times has been called on this instance. + + + + + Gets whether the next call to will yield the processor, triggering a + forced context switch. + + Whether the next call to will yield the processor, triggering a + forced context switch. + + On a single-CPU machine, always yields the processor. On machines with + multiple CPUs, may yield after an unspecified number of calls. + + + + + A helper class to get the number of preocessors, it updates the numbers of processors every sampling interval + + + + + Gets the number of available processors + + + + + Gets whether the current machine has only a single processor. + + + + + Represents an asynchronous operation that produces a result at some time in the future. + + + The type of the result produced by this . + + + + instances may be created in a variety of ways. The most common approach is by + using the task's property to retrieve a instance that can be used to create tasks for several + purposes. For example, to create a that runs a function, the factory's StartNew + method may be used: + + // C# + var t = Task<int>.Factory.StartNew(() => GenerateResult()); + - or - + var t = Task.Factory.StartNew(() => GenerateResult()); + + ' Visual Basic + Dim t = Task<int>.Factory.StartNew(Function() GenerateResult()) + - or - + Dim t = Task.Factory.StartNew(Function() GenerateResult()) + + + + The class also provides constructors that initialize the task but that do not + schedule it for execution. For performance reasons, the StartNew method should be the + preferred mechanism for creating and scheduling computational tasks, but for scenarios where creation + and scheduling must be separated, the constructors may be used, and the task's + Start + method may then be used to schedule the task for execution at a later time. + + + All members of , except for + Dispose, are thread-safe + and may be used from multiple threads concurrently. + + + + + + Represents an asynchronous operation. + + + + instances may be created in a variety of ways. The most common approach is by + using the Task type's property to retrieve a instance that can be used to create tasks for several + purposes. For example, to create a that runs an action, the factory's StartNew + method may be used: + + // C# + var t = Task.Factory.StartNew(() => DoAction()); + + ' Visual Basic + Dim t = Task.Factory.StartNew(Function() DoAction()) + + + + The class also provides constructors that initialize the Task but that do not + schedule it for execution. For performance reasons, TaskFactory's StartNew method should be the + preferred mechanism for creating and scheduling computational tasks, but for scenarios where creation + and scheduling must be separated, the constructors may be used, and the task's + method may then be used to schedule the task for execution at a later time. + + + All members of , except for , are thread-safe + and may be used from multiple threads concurrently. + + + For operations that return values, the class + should be used. + + + For developers implementing custom debuggers, several internal and private members of Task may be + useful (these may change from release to release). The Int32 m_taskId field serves as the backing + store for the property, however accessing this field directly from a debugger may be + more efficient than accessing the same value through the property's getter method (the + s_taskIdCounter Int32 counter is used to retrieve the next available ID for a Task). Similarly, the + Int32 m_stateFlags field stores information about the current lifecycle stage of the Task, + information also accessible through the property. The m_action System.Object + field stores a reference to the Task's delegate, and the m_stateObject System.Object field stores the + async state passed to the Task by the developer. Finally, for debuggers that parse stack frames, the + InternalWait method serves a potential marker for when a Task is entering a wait operation. + + + + + + A type initializer that runs with the appropriate permissions. + + + + + Initializes a new with the specified action. + + The delegate that represents the code to execute in the Task. + The argument is null. + + + + Initializes a new with the specified action and CancellationToken. + + The delegate that represents the code to execute in the Task. + The CancellationToken + that will be assigned to the new Task. + The argument is null. + The provided CancellationToken + has already been disposed. + + + + + Initializes a new with the specified action and creation options. + + The delegate that represents the code to execute in the task. + + The TaskCreationOptions used to + customize the Task's behavior. + + + The argument is null. + + + The argument specifies an invalid value for . + + + + + Initializes a new with the specified action and creation options. + + The delegate that represents the code to execute in the task. + The that will be assigned to the new task. + + The TaskCreationOptions used to + customize the Task's behavior. + + + The argument is null. + + + The argument specifies an invalid value for . + + The provided CancellationToken + has already been disposed. + + + + + Initializes a new with the specified action and state. + + The delegate that represents the code to execute in the task. + An object representing data to be used by the action. + + The argument is null. + + + + + Initializes a new with the specified action, state, snd options. + + The delegate that represents the code to execute in the task. + An object representing data to be used by the action. + The that will be assigned to the new task. + + The argument is null. + + The provided CancellationToken + has already been disposed. + + + + + Initializes a new with the specified action, state, snd options. + + The delegate that represents the code to execute in the task. + An object representing data to be used by the action. + + The TaskCreationOptions used to + customize the Task's behavior. + + + The argument is null. + + + The argument specifies an invalid value for . + + + + + Initializes a new with the specified action, state, snd options. + + The delegate that represents the code to execute in the task. + An object representing data to be used by the action. + The that will be assigned to the new task. + + The TaskCreationOptions used to + customize the Task's behavior. + + + The argument is null. + + + The argument specifies an invalid value for . + + The provided CancellationToken + has already been disposed. + + + + + An internal constructor used by the factory methods on task and its descendent(s). + This variant does not capture the ExecutionContext; it is up to the caller to do that. + + An action to execute. + Optional state to pass to the action. + Parent of Task. + A CancellationToken for the task. + A task scheduler under which the task will run. + Options to control its execution. + Internal options to control its execution + + + + Common logic used by the following internal ctors: + Task() + Task(object action, object state, Task parent, TaskCreationOptions options, TaskScheduler taskScheduler) + + ASSUMES THAT m_creatingTask IS ALREADY SET. + + + Action for task to execute. + Object to which to pass to action (may be null) + Task scheduler on which to run thread (only used by continuation tasks). + A CancellationToken for the Task. + Options to customize behavior of Task. + Internal options to customize behavior of Task. + + + + Checks if we registered a CT callback during construction, and deregisters it. + This should be called when we know the registration isn't useful anymore. Specifically from Finish() if the task has completed + successfully or with an exception. + + + + + Captures the ExecutionContext so long as flow isn't suppressed. + + A stack crawl mark pointing to the frame of the caller. + + + + Internal function that will be called by a new child task to add itself to + the children list of the parent (this). + + Since a child task can only be created from the thread executing the action delegate + of this task, reentrancy is neither required nor supported. This should not be called from + anywhere other than the task construction/initialization codepaths. + + + + + Starts the , scheduling it for execution to the current TaskScheduler. + + + A task may only be started and run only once. Any attempts to schedule a task a second time + will result in an exception. + + + The is not in a valid state to be started. It may have already been started, + executed, or canceled, or it may have been created in a manner that doesn't support direct + scheduling. + + + The instance has been disposed. + + + + + Starts the , scheduling it for execution to the specified TaskScheduler. + + + A task may only be started and run only once. Any attempts to schedule a task a second time will + result in an exception. + + + The TaskScheduler with which to associate + and execute this task. + + + The argument is null. + + + The is not in a valid state to be started. It may have already been started, + executed, or canceled, or it may have been created in a manner that doesn't support direct + scheduling. + + + The instance has been disposed. + + + + + Runs the synchronously on the current TaskScheduler. + + + + A task may only be started and run only once. Any attempts to schedule a task a second time will + result in an exception. + + + Tasks executed with will be associated with the current TaskScheduler. + + + If the target scheduler does not support running this Task on the current thread, the Task will + be scheduled for execution on the scheduler, and the current thread will block until the + Task has completed execution. + + + + The is not in a valid state to be started. It may have already been started, + executed, or canceled, or it may have been created in a manner that doesn't support direct + scheduling. + + + The instance has been disposed. + + + + + Runs the synchronously on the scheduler provided. + + + + A task may only be started and run only once. Any attempts to schedule a task a second time will + result in an exception. + + + If the target scheduler does not support running this Task on the current thread, the Task will + be scheduled for execution on the scheduler, and the current thread will block until the + Task has completed execution. + + + + The is not in a valid state to be started. It may have already been started, + executed, or canceled, or it may have been created in a manner that doesn't support direct + scheduling. + + + The instance has been disposed. + + The parameter + is null. + The scheduler on which to attempt to run this task inline. + + + + Throws an exception if the task has been disposed, and hence can no longer be accessed. + + The task has been disposed. + + + + Sets the internal completion event. + + + + + Disposes the , releasing all of its unmanaged resources. + + + Unlike most of the members of , this method is not thread-safe. + Also, may only be called on a that is in one of + the final states: RanToCompletion, + Faulted, or + Canceled. + + + The exception that is thrown if the is not in + one of the final states: RanToCompletion, + Faulted, or + Canceled. + + + + + Disposes the , releasing all of its unmanaged resources. + + + A Boolean value that indicates whether this method is being called due to a call to . + + + Unlike most of the members of , this method is not thread-safe. + + + + + Schedules the task for execution. + + If true, TASK_STATE_STARTED bit is turned on in + an atomic fashion, making sure that TASK_STATE_CANCELED does not get set + underneath us. If false, TASK_STATE_STARTED bit is OR-ed right in. This + allows us to streamline things a bit for StartNew(), where competing cancellations + are not a problem. + + + + Adds an exception to the list of exceptions this task has thrown. + + An object representing either an Exception or a collection of Exceptions. + + + + Returns a list of exceptions by aggregating the holder's contents. Or null if + no exceptions have been thrown. + + Whether to include a TCE if cancelled. + An aggregate exception, or null if no exceptions have been caught. + + + + Throws an aggregate exception if the task contains exceptions. + + + + + Checks whether this is an attached task, and whether we are being called by the parent task. + And sets the TASK_STATE_EXCEPTIONOBSERVEDBYPARENT status flag based on that. + + This is meant to be used internally when throwing an exception, and when WaitAll is gathering + exceptions for tasks it waited on. If this flag gets set, the implicit wait on children + will skip exceptions to prevent duplication. + + This should only be called when this task has completed with an exception + + + + + + Signals completion of this particular task. + + The bUserDelegateExecuted parameter indicates whether this Finish() call comes following the + full execution of the user delegate. + + If bUserDelegateExecuted is false, it mean user delegate wasn't invoked at all (either due to + a cancellation request, or because this task is a promise style Task). In this case, the steps + involving child tasks (i.e. WaitForChildren) will be skipped. + + + + + + FinishStageTwo is to be executed as soon as we known there are no more children to complete. + It can happen i) either on the thread that originally executed this task (if no children were spawned, or they all completed by the time this task's delegate quit) + ii) or on the thread that executed the last child. + + + + + Final stage of the task completion code path. Notifies the parent (if any) that another of its childre are done, and runs continuations. + This function is only separated out from FinishStageTwo because these two operations are also needed to be called from CancellationCleanupLogic() + + + + + This is called by children of this task when they are completed. + + + + + This is to be called just before the task does its final state transition. + It traverses the list of exceptional children, and appends their aggregate exceptions into this one's exception list + + + + + Special purpose Finish() entry point to be used when the task delegate throws a ThreadAbortedException + This makes a note in the state flags so that we avoid any costly synchronous operations in the finish codepath + such as inlined continuations + + + Indicates whether the ThreadAbortException was added to this task's exception holder. + This should always be true except for the case of non-root self replicating task copies. + + Whether the delegate was executed. + + + + Executes the task. This method will only be called once, and handles bookeeping associated with + self-replicating tasks, in addition to performing necessary exception marshaling. + + The task has already been disposed. + + + + IThreadPoolWorkItem override, which is the entry function for this task when the TP scheduler decides to run it. + + + + + + Outermost entry function to execute this task. Handles all aspects of executing a task on the caller thread. + Currently this is called by IThreadPoolWorkItem.ExecuteWorkItem(), and TaskManager.TryExecuteInline. + + + Performs atomic updates to prevent double execution. Should only be set to true + in codepaths servicing user provided TaskSchedulers. The ConcRT or ThreadPool schedulers don't need this. + + + + The actual code which invokes the body of the task. This can be overriden in derived types. + + + + + Alternate InnerInvoke prototype to be called from ExecuteSelfReplicating() so that + the Parallel Debugger can discover the actual task being invoked. + Details: Here, InnerInvoke is actually being called on the rootTask object while we are actually executing the + childTask. And the debugger needs to discover the childTask, so we pass that down as an argument. + The NoOptimization and NoInlining flags ensure that the childTask pointer is retained, and that this + function appears on the callstack. + + + + + + Performs whatever handling is necessary for an unhandled exception. Normally + this just entails adding the exception to the holder object. + + The exception that went unhandled. + + + + Waits for the to complete execution. + + + The was canceled -or- an exception was thrown during + the execution of the . + + + The has been disposed. + + + + + Waits for the to complete execution. + + + A that represents the number of milliseconds to wait, or a that represents -1 milliseconds to wait indefinitely. + + + true if the completed execution within the allotted time; otherwise, false. + + + The was canceled -or- an exception was thrown during the execution of the . + + + is a negative number other than -1 milliseconds, which represents an + infinite time-out -or- timeout is greater than + . + + + The has been disposed. + + + + + Waits for the to complete execution. + + + A to observe while waiting for the task to complete. + + + The was canceled. + + + The was canceled -or- an exception was thrown during the execution of the . + + + The + has been disposed. + + + + + Waits for the to complete execution. + + + The number of milliseconds to wait, or (-1) to + wait indefinitely. + true if the completed execution within the allotted time; otherwise, + false. + + + is a negative number other than -1, which represents an + infinite time-out. + + + The was canceled -or- an exception was thrown during the execution of the . + + + The + has been disposed. + + + + + Waits for the to complete execution. + + + The number of milliseconds to wait, or (-1) to + wait indefinitely. + + + A to observe while waiting for the task to complete. + + + true if the completed execution within the allotted time; otherwise, false. + + + The was canceled -or- an exception was thrown during the execution of the . + + + The + has been disposed. + + + is a negative number other than -1, which represents an + infinite time-out. + + + The was canceled. + + + + + The core wait function, which is only accesible internally. It's meant to be used in places in TPL code where + the current context is known or cached. + + + + + Cancels the . + + Indiactes whether we should only cancel non-invoked tasks. + For the default scheduler this option will only be serviced through TryDequeue. + For custom schedulers we also attempt an atomic state transition. + true if the task was successfully canceled; otherwise, false. + The + has been disposed. + + + + Sets the task's cancellation acknowledged flag. + + + + + Runs all of the continuations, as appropriate. + + + + + Helper function to determine whether the current task is in the state desired by the + continuation kind under evaluation. Three possibilities exist: the task failed with + an unhandled exception (OnFailed), the task was canceled before running (OnAborted), + or the task completed successfully (OnCompletedSuccessfully). Note that the last + one includes completing due to cancellation. + + The continuation options under evaluation. + True if the continuation should be run given the task's current state. + + + + Creates a continuation that executes when the target completes. + + + An action to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed, whether it completes due to running to completion successfully, faulting due to an + unhandled exception, or exiting out early due to being canceled. + + + The argument is null. + + + The has been disposed. + + + + + Creates a continuation that executes when the target completes. + + + An action to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + The that will be assigned to the new continuation task. + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed, whether it completes due to running to completion successfully, faulting due to an + unhandled exception, or exiting out early due to being canceled. + + + The argument is null. + + + The has been disposed. + + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation that executes when the target completes. + + + An action to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + + The to associate with the continuation task and to use for its execution. + + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed, whether it completes due to running to completion successfully, faulting due to an + unhandled exception, or exiting out early due to being canceled. + + + The argument is null. + + + The argument is null. + + + The has been disposed. + + + + + Creates a continuation that executes when the target completes. + + + An action to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + + Options for when the continuation is scheduled and how it behaves. This includes criteria, such + as OnlyOnCanceled, as + well as execution options, such as ExecuteSynchronously. + + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed. If the continuation criteria specified through the parameter are not met, the continuation task will be canceled + instead of scheduled. + + + The argument is null. + + + The argument specifies an invalid value for TaskContinuationOptions. + + + The has been disposed. + + + + + Creates a continuation that executes when the target completes. + + + An action to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + + Options for when the continuation is scheduled and how it behaves. This includes criteria, such + as OnlyOnCanceled, as + well as execution options, such as ExecuteSynchronously. + + The that will be assigned to the new continuation task. + + The to associate with the continuation task and to use for its + execution. + + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed. If the criteria specified through the parameter + are not met, the continuation task will be canceled instead of scheduled. + + + The argument is null. + + + The argument specifies an invalid value for TaskContinuationOptions. + + + The argument is null. + + + The has been disposed. + + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation that executes when the target completes. + + + The type of the result produced by the continuation. + + + A function to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed, whether it completes due to running to completion successfully, faulting due to an + unhandled exception, or exiting out early due to being canceled. + + + The argument is null. + + + The has been disposed. + + + + + Creates a continuation that executes when the target completes. + + + The type of the result produced by the continuation. + + + A function to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + The that will be assigned to the new continuation task. + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed, whether it completes due to running to completion successfully, faulting due to an + unhandled exception, or exiting out early due to being canceled. + + + The argument is null. + + + The has been disposed. + + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation that executes when the target completes. + + + The type of the result produced by the continuation. + + + A function to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + + The to associate with the continuation task and to use for its execution. + + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed, whether it completes due to running to completion successfully, faulting due to an + unhandled exception, or exiting out early due to being canceled. + + + The argument is null. + + + The argument is null. + + + The has been disposed. + + + + + Creates a continuation that executes when the target completes. + + + The type of the result produced by the continuation. + + + A function to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + + Options for when the continuation is scheduled and how it behaves. This includes criteria, such + as OnlyOnCanceled, as + well as execution options, such as ExecuteSynchronously. + + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed. If the continuation criteria specified through the parameter are not met, the continuation task will be canceled + instead of scheduled. + + + The argument is null. + + + The argument specifies an invalid value for TaskContinuationOptions. + + + The has been disposed. + + + + + Creates a continuation that executes when the target completes. + + + The type of the result produced by the continuation. + + + A function to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + The that will be assigned to the new continuation task. + + Options for when the continuation is scheduled and how it behaves. This includes criteria, such + as OnlyOnCanceled, as + well as execution options, such as ExecuteSynchronously. + + + The to associate with the continuation task and to use for its + execution. + + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed. If the criteria specified through the parameter + are not met, the continuation task will be canceled instead of scheduled. + + + The argument is null. + + + The argument specifies an invalid value for TaskContinuationOptions. + + + The argument is null. + + + The has been disposed. + + The provided CancellationToken + has already been disposed. + + + + + Converts TaskContinuationOptions to TaskCreationOptions, and also does + some validity checking along the way. + + Incoming TaskContinuationOptions + Outgoing TaskCreationOptions + Outgoing InternalTaskOptions + + + + Registers the continuation and possibly runs it (if the task is already finished). + + The continuation task itself. + TaskScheduler with which to associate continuation task. + Restrictions on when the continuation becomes active. + + + + Waits for all of the provided objects to complete execution. + + + An array of instances on which to wait. + + + The argument is null. + + + The argument contains a null element. + + + At least one of the instances was canceled -or- an exception was thrown during + the execution of at least one of the instances. + + + The has been disposed. + + + + + Waits for all of the provided objects to complete execution. + + + true if all of the instances completed execution within the allotted time; + otherwise, false. + + + An array of instances on which to wait. + + + A that represents the number of milliseconds to wait, or a that represents -1 milliseconds to wait indefinitely. + + + The argument is null. + + + The argument contains a null element. + + + At least one of the instances was canceled -or- an exception was thrown during + the execution of at least one of the instances. + + + is a negative number other than -1 milliseconds, which represents an + infinite time-out -or- timeout is greater than + . + + + The has been disposed. + + + + + Waits for all of the provided objects to complete execution. + + + true if all of the instances completed execution within the allotted time; + otherwise, false. + + + The number of milliseconds to wait, or (-1) to + wait indefinitely. + An array of instances on which to wait. + + + The argument is null. + + + The argument contains a null element. + + + At least one of the instances was canceled -or- an exception was thrown during + the execution of at least one of the instances. + + + The has been disposed. + + + is a negative number other than -1, which represents an + infinite time-out. + + + + + Waits for all of the provided objects to complete execution. + + + true if all of the instances completed execution within the allotted time; + otherwise, false. + + + An array of instances on which to wait. + + + A to observe while waiting for the tasks to complete. + + + The argument is null. + + + The argument contains a null element. + + + At least one of the instances was canceled -or- an exception was thrown during + the execution of at least one of the instances. + + + The was canceled. + + + The has been disposed. + + + + + Waits for all of the provided objects to complete execution. + + + true if all of the instances completed execution within the allotted time; + otherwise, false. + + + An array of instances on which to wait. + + + The number of milliseconds to wait, or (-1) to + wait indefinitely. + + + A to observe while waiting for the tasks to complete. + + + The argument is null. + + + The argument contains a null element. + + + At least one of the instances was canceled -or- an exception was thrown during + the execution of at least one of the instances. + + + The has been disposed. + + + is a negative number other than -1, which represents an + infinite time-out. + + + The was canceled. + + + + + Waits for a set of handles in a STA-aware way. In other words, it will wait for each + of the events individually if we're on a STA thread, because MsgWaitForMultipleObjectsEx + can't do a true wait-all due to its hidden message queue event. This is not atomic, + of course, but we only wait on one-way (MRE) events anyway so this is OK. + + An array of wait handles to wait on. + The timeout to use during waits. + The cancellationToken that enables a wait to be canceled. + True if all waits succeeded, false if a timeout occurred. + + + + Internal WaitAll implementation which is meant to be used with small number of tasks, + optimized for Parallel.Invoke and other structured primitives. + + + + + This internal function is only meant to be called by WaitAll() + If the completed task is canceled or it has other exceptions, here we will add those + into the passed in exception list (which will be lazily initialized here). + + + + + Waits for any of the provided objects to complete execution. + + + An array of instances on which to wait. + + The index of the completed task in the array argument. + + The argument is null. + + + The argument contains a null element. + + + The has been disposed. + + + + + Waits for any of the provided objects to complete execution. + + + An array of instances on which to wait. + + + A that represents the number of milliseconds to wait, or a that represents -1 milliseconds to wait indefinitely. + + + The index of the completed task in the array argument, or -1 if the + timeout occurred. + + + The argument is null. + + + The argument contains a null element. + + + The has been disposed. + + + is a negative number other than -1 milliseconds, which represents an + infinite time-out -or- timeout is greater than + . + + + + + Waits for any of the provided objects to complete execution. + + + An array of instances on which to wait. + + + A to observe while waiting for a task to complete. + + + The index of the completed task in the array argument. + + + The argument is null. + + + The argument contains a null element. + + + The has been disposed. + + + The was canceled. + + + + + Waits for any of the provided objects to complete execution. + + + An array of instances on which to wait. + + + The number of milliseconds to wait, or (-1) to + wait indefinitely. + + + The index of the completed task in the array argument, or -1 if the + timeout occurred. + + + The argument is null. + + + The argument contains a null element. + + + The has been disposed. + + + is a negative number other than -1, which represents an + infinite time-out. + + + + + Waits for any of the provided objects to complete execution. + + + An array of instances on which to wait. + + + The number of milliseconds to wait, or (-1) to + wait indefinitely. + + + A to observe while waiting for a task to complete. + + + The index of the completed task in the array argument, or -1 if the + timeout occurred. + + + The argument is null. + + + The argument contains a null element. + + + The has been disposed. + + + is a negative number other than -1, which represents an + infinite time-out. + + + The was canceled. + + + + + Gets a unique ID for this Task instance. + + + Task IDs are assigned on-demand and do not necessarily represent the order in the which Task + instances were created. + + + + + Returns the unique ID of the currently executing Task. + + + + + Gets the Task instance currently executing, or + null if none exists. + + + + + Gets the Exception that caused the Task to end prematurely. If the Task completed successfully or has not yet thrown any + exceptions, this will return null. + + + Tasks that throw unhandled exceptions store the resulting exception and propagate it wrapped in a + in calls to Wait + or in accesses to the property. Any exceptions not observed by the time + the Task instance is garbage collected will be propagated on the finalizer thread. + + + The Task + has been disposed. + + + + + Gets the TaskStatus of this Task. + + + + + Gets whether this Task instance has completed + execution due to being canceled. + + + A Task will complete in Canceled state either if its CancellationToken + was marked for cancellation before the task started executing, or if the task acknowledged the cancellation request on + its already signaled CancellationToken by throwing an + OperationCanceledException2 that bears the same + CancellationToken. + + + + + Returns true if this task has a cancellation token and it was signaled. + To be used internally in execute entry codepaths. + + + + + This internal property provides access to the CancellationToken that was set on the task + when it was constructed. + + + + + Gets whether this threw an OperationCanceledException2 while its CancellationToken was signaled. + + + + + Gets whether this Task has completed. + + + will return true when the Task is in one of the three + final states: RanToCompletion, + Faulted, or + Canceled. + + + + + Checks whether this task has been disposed. + + + + + Gets the TaskCreationOptions used + to create this task. + + + + + Gets a that can be used to wait for the task to + complete. + + + Using the wait functionality provided by + should be preferred over using for similar + functionality. + + + The has been disposed. + + + + + Gets the state object supplied when the Task was created, + or null if none was supplied. + + + + + Gets an indication of whether the asynchronous operation completed synchronously. + + true if the asynchronous operation completed synchronously; otherwise, false. + + + + Provides access to the TaskScheduler responsible for executing this Task. + + + + + Provides access to factory methods for creating and instances. + + + The factory returned from is a default instance + of , as would result from using + the default constructor on TaskFactory. + + + + + Provides an event that can be used to wait for completion. + Only called by Wait*(), which means that we really do need to instantiate a completion event. + + + + + Determines whether this is the root task of a self replicating group. + + + + + Determines whether the task is a replica itself. + + + + + The property formerly known as IsFaulted. + + + + + Gets whether the completed due to an unhandled exception. + + + If is true, the Task's will be equal to + TaskStatus.Faulted, and its + property will be non-null. + + + + + Checks whether the TASK_STATE_EXCEPTIONOBSERVEDBYPARENT status flag is set, + This will only be used by the implicit wait to prevent double throws + + + + + + Checks whether the body was ever invoked. Used by task scheduler code to verify custom schedulers actually ran the task. + + + + + A structure to hold continuation information. + + + + + Constructs a new continuation structure. + + The task to be activated. + The continuation options. + The scheduler to use for the continuation. + + + + Invokes the continuation for the target completion task. + + The completed task. + Whether the continuation can be inlined. + + + + Initializes a new with the specified function. + + + The delegate that represents the code to execute in the task. When the function has completed, + the task's property will be set to return the result value of the function. + + + The argument is null. + + + + + Initializes a new with the specified function. + + + The delegate that represents the code to execute in the task. When the function has completed, + the task's property will be set to return the result value of the function. + + The to be assigned to this task. + + The argument is null. + + The provided CancellationToken + has already been disposed. + + + + + Initializes a new with the specified function and creation options. + + + The delegate that represents the code to execute in the task. When the function has completed, + the task's property will be set to return the result value of the function. + + + The TaskCreationOptions used to + customize the task's behavior. + + + The argument is null. + + + The argument specifies an invalid value for . + + + + + Initializes a new with the specified function and creation options. + + + The delegate that represents the code to execute in the task. When the function has completed, + the task's property will be set to return the result value of the function. + + The that will be assigned to the new task. + + The TaskCreationOptions used to + customize the task's behavior. + + + The argument is null. + + + The argument specifies an invalid value for . + + The provided CancellationToken + has already been disposed. + + + + + Initializes a new with the specified function and state. + + + The delegate that represents the code to execute in the task. When the function has completed, + the task's property will be set to return the result value of the function. + + An object representing data to be used by the action. + + The argument is null. + + + + + Initializes a new with the specified action, state, and options. + + + The delegate that represents the code to execute in the task. When the function has completed, + the task's property will be set to return the result value of the function. + + An object representing data to be used by the function. + The to be assigned to the new task. + + The argument is null. + + The provided CancellationToken + has already been disposed. + + + + + Initializes a new with the specified action, state, and options. + + + The delegate that represents the code to execute in the task. When the function has completed, + the task's property will be set to return the result value of the function. + + An object representing data to be used by the function. + + The TaskCreationOptions used to + customize the task's behavior. + + + The argument is null. + + + The argument specifies an invalid value for . + + + + + Initializes a new with the specified action, state, and options. + + + The delegate that represents the code to execute in the task. When the function has completed, + the task's property will be set to return the result value of the function. + + An object representing data to be used by the function. + The to be assigned to the new task. + + The TaskCreationOptions used to + customize the task's behavior. + + + The argument is null. + + + The argument specifies an invalid value for . + + The provided CancellationToken + has already been disposed. + + + + + Creates a new future object. + + The parent task for this future. + A function that yields the future value. + The task scheduler which will be used to execute the future. + The CancellationToken for the task. + Options to control the future's behavior. + Internal options to control the future's behavior. + The argument specifies + a SelfReplicating , which is illegal."/>. + + + + Creates a new future object. + + The parent task for this future. + An object containing data to be used by the action; may be null. + A function that yields the future value. + The CancellationToken for the task. + The task scheduler which will be used to execute the future. + Options to control the future's behavior. + Internal options to control the future's behavior. + The argument specifies + a SelfReplicating , which is illegal."/>. + + + + Evaluates the value selector of the Task which is passed in as an object and stores the result. + + + + + Creates a continuation that executes when the target completes. + + + An action to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed, whether it completes due to running to completion successfully, faulting due to an + unhandled exception, or exiting out early due to being canceled. + + + The argument is null. + + + The has been disposed. + + + + + Creates a continuation that executes when the target completes. + + + An action to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + The that will be assigned to the new continuation task. + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed, whether it completes due to running to completion successfully, faulting due to an + unhandled exception, or exiting out early due to being canceled. + + + The argument is null. + + + The has been disposed. + + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation that executes when the target completes. + + + An action to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + + The to associate with the continuation task and to use for its execution. + + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed, whether it completes due to running to completion successfully, faulting due to an + unhandled exception, or exiting out early due to being canceled. + + + The argument is null. + + + The argument is null. + + + The has been disposed. + + + + + Creates a continuation that executes when the target completes. + + + An action to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + + Options for when the continuation is scheduled and how it behaves. This includes criteria, such + as OnlyOnCanceled, as + well as execution options, such as ExecuteSynchronously. + + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed. If the continuation criteria specified through the parameter are not met, the continuation task will be canceled + instead of scheduled. + + + The argument is null. + + + The argument specifies an invalid value for TaskContinuationOptions. + + + The has been disposed. + + + + + Creates a continuation that executes when the target completes. + + + An action to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + The that will be assigned to the new continuation task. + + Options for when the continuation is scheduled and how it behaves. This includes criteria, such + as OnlyOnCanceled, as + well as execution options, such as ExecuteSynchronously. + + + The to associate with the continuation task and to use for its + execution. + + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed. If the criteria specified through the parameter + are not met, the continuation task will be canceled instead of scheduled. + + + The argument is null. + + + The argument specifies an invalid value for TaskContinuationOptions. + + + The argument is null. + + + The has been disposed. + + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation that executes when the target completes. + + + The type of the result produced by the continuation. + + + A function to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + A new continuation . + + The returned will not be scheduled for execution until the current + task has completed, whether it completes due to running to completion successfully, faulting due + to an unhandled exception, or exiting out early due to being canceled. + + + The argument is null. + + + The has been disposed. + + + + + Creates a continuation that executes when the target completes. + + + The type of the result produced by the continuation. + + + A function to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + The that will be assigned to the new task. + A new continuation . + + The returned will not be scheduled for execution until the current + task has completed, whether it completes due to running to completion successfully, faulting due + to an unhandled exception, or exiting out early due to being canceled. + + + The argument is null. + + + The has been disposed. + + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation that executes when the target completes. + + + The type of the result produced by the continuation. + + + A function to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + + The to associate with the continuation task and to use for its execution. + + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed, whether it completes due to running to completion successfully, faulting due to an + unhandled exception, or exiting out early due to being canceled. + + + The argument is null. + + + The argument is null. + + + The has been disposed. + + + + + Creates a continuation that executes when the target completes. + + + The type of the result produced by the continuation. + + + A function to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + + Options for when the continuation is scheduled and how it behaves. This includes criteria, such + as OnlyOnCanceled, as + well as execution options, such as ExecuteSynchronously. + + A new continuation . + + + The returned will not be scheduled for execution until the current + task has completed, whether it completes due to running to completion successfully, faulting due + to an unhandled exception, or exiting out early due to being canceled. + + + The , when executed, should return a . This task's completion state will be transferred to the task returned + from the ContinueWith call. + + + + The argument is null. + + + The argument specifies an invalid value for TaskContinuationOptions. + + + The has been disposed. + + + + + Creates a continuation that executes when the target completes. + + + The type of the result produced by the continuation. + + + A function to run when the completes. When run, the delegate will be passed as + an argument this completed task. + + The that will be assigned to the new task. + + Options for when the continuation is scheduled and how it behaves. This includes criteria, such + as OnlyOnCanceled, as + well as execution options, such as ExecuteSynchronously. + + + The to associate with the continuation task and to use for its + execution. + + A new continuation . + + + The returned will not be scheduled for execution until the current task has + completed, whether it completes due to running to completion successfully, faulting due to an + unhandled exception, or exiting out early due to being canceled. + + + The , when executed, should return a . + This task's completion state will be transferred to the task returned from the + ContinueWith call. + + + + The argument is null. + + + The argument specifies an invalid value for TaskContinuationOptions. + + + The argument is null. + + + The has been disposed. + + The provided CancellationToken + has already been disposed. + + + + + Gets the result value of this . + + + The get accessor for this property ensures that the asynchronous operation is complete before + returning. Once the result of the computation is available, it is stored and will be returned + immediately on later calls to . + + + + + Provides access to factory methods for creating instances. + + + The factory returned from is a default instance + of , as would result from using + the default constructor on the factory type. + + + + + Provides support for creating and scheduling + Task{TResult} objects. + + The type of the results that are available though + the Task{TResult} objects that are associated with + the methods in this class. + + + There are many common patterns for which tasks are relevant. The + class encodes some of these patterns into methods that pick up default settings, which are + configurable through its constructors. + + + A default instance of is available through the + Task{TResult}.Factory property. + + + + + + Initializes a instance with the default configuration. + + + This constructor creates a instance with a default configuration. The + property is initialized to + TaskCreationOptions.None, the + property is initialized to TaskContinuationOptions.None, + and the TaskScheduler property is + initialized to the current scheduler (see TaskScheduler.Current). + + + + + Initializes a instance with the default configuration. + + The default that will be assigned + to tasks created by this unless another CancellationToken is explicitly specified + while calling the factory methods. + + This constructor creates a instance with a default configuration. The + property is initialized to + TaskCreationOptions.None, the + property is initialized to TaskContinuationOptions.None, + and the TaskScheduler property is + initialized to the current scheduler (see TaskScheduler.Current). + + + + + Initializes a instance with the specified configuration. + + + The + TaskScheduler to use to schedule any tasks created with this TaskFactory{TResult}. A null value + indicates that the current TaskScheduler should be used. + + + With this constructor, the + property is initialized to + TaskCreationOptions.None, the + property is initialized to TaskContinuationOptions.None, + and the TaskScheduler property is + initialized to , unless it's null, in which case the property is + initialized to the current scheduler (see TaskScheduler.Current). + + + + + Initializes a instance with the specified configuration. + + + The default + TaskCreationOptions to use when creating tasks with this TaskFactory{TResult}. + + + The default + TaskContinuationOptions to use when creating continuation tasks with this TaskFactory{TResult}. + + + The exception that is thrown when the + argument or the + argument specifies an invalid value. + + + With this constructor, the + property is initialized to , + the + property is initialized to , and the TaskScheduler property is initialized to the + current scheduler (see TaskScheduler.Current). + + + + + Initializes a instance with the specified configuration. + + The default that will be assigned + to tasks created by this unless another CancellationToken is explicitly specified + while calling the factory methods. + + The default + TaskCreationOptions to use when creating tasks with this TaskFactory{TResult}. + + + The default + TaskContinuationOptions to use when creating continuation tasks with this TaskFactory{TResult}. + + + The default + TaskScheduler to use to schedule any Tasks created with this TaskFactory{TResult}. A null value + indicates that TaskScheduler.Current should be used. + + + The exception that is thrown when the + argument or the + argumentspecifies an invalid value. + + + With this constructor, the + property is initialized to , + the + property is initialized to , and the TaskScheduler property is initialized to + , unless it's null, in which case the property is initialized to the + current scheduler (see TaskScheduler.Current). + + + + + Creates and starts a . + + A function delegate that returns the future result to be available through + the . + The started . + The exception that is thrown when the + argument is null. + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + A function delegate that returns the future result to be available through + the . + The that will be assigned to the new task. + The started . + The exception that is thrown when the + argument is null. + The provided CancellationToken + has already been disposed. + + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + A function delegate that returns the future result to be available through + the . + A TaskCreationOptions value that controls the behavior of the + created + . + The started . + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + A function delegate that returns the future result to be available through + the . + A TaskCreationOptions value that controls the behavior of the + created + . + The that will be assigned to the new task. + The TaskScheduler + that is used to schedule the created + Task{TResult}. + The started . + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The provided CancellationToken + has already been disposed. + + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + A function delegate that returns the future result to be available through + the . + An object containing data to be used by the + delegate. + The started . + The exception that is thrown when the + argument is null. + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + A function delegate that returns the future result to be available through + the . + An object containing data to be used by the + delegate. + The that will be assigned to the new task. + The started . + The exception that is thrown when the + argument is null. + The provided CancellationToken + has already been disposed. + + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + A function delegate that returns the future result to be available through + the . + An object containing data to be used by the + delegate. + A TaskCreationOptions value that controls the behavior of the + created + . + The started . + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + A function delegate that returns the future result to be available through + the . + An object containing data to be used by the + delegate. + The that will be assigned to the new task. + A TaskCreationOptions value that controls the behavior of the + created + . + The TaskScheduler + that is used to schedule the created + Task{TResult}. + The started . + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The provided CancellationToken + has already been disposed. + + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates a Task that executes an end + method function when a specified IAsyncResult completes. + + The IAsyncResult whose completion should trigger the processing of the + . + The function delegate that processes the completed . + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + A Task that represents the + asynchronous operation. + + + + Creates a Task that executes an end + method function when a specified IAsyncResult completes. + + The IAsyncResult whose completion should trigger the processing of the + . + The function delegate that processes the completed . + The TaskCreationOptions value that controls the behavior of the + created Task. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + A Task that represents the + asynchronous operation. + + + + Creates a Task that executes an end + method function when a specified IAsyncResult completes. + + The IAsyncResult whose completion should trigger the processing of the + . + The function delegate that processes the completed . + The TaskScheduler + that is used to schedule the task that executes the end method. + The TaskCreationOptions value that controls the behavior of the + created Task. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + A Task that represents the + asynchronous operation. + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The TaskCreationOptions value that controls the behavior of the + created Task. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The TaskCreationOptions value that controls the behavior of the + created Task. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the delegate. + The type of the second argument passed to + delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The second argument passed to the + delegate. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the delegate. + The type of the second argument passed to + delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The second argument passed to the + delegate. + The TaskCreationOptions value that controls the behavior of the + created Task. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the delegate. + The type of the second argument passed to + delegate. + The type of the third argument passed to + delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The second argument passed to the + delegate. + The third argument passed to the + delegate. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the delegate. + The type of the second argument passed to + delegate. + The type of the third argument passed to + delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The second argument passed to the + delegate. + The third argument passed to the + delegate. + The TaskCreationOptions value that controls the behavior of the + created Task. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The array of tasks from which to continue. + The function delegate to execute when all tasks in + the array have completed. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The array of tasks from which to continue. + The function delegate to execute when all tasks in + the array have completed. + The CancellationToken + that will be assigned to the new continuation task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The array of tasks from which to continue. + The function delegate to execute when all tasks in the array have completed. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAll. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The array of tasks from which to continue. + The function delegate to execute when all tasks in the array have completed. + The CancellationToken + that will be assigned to the new continuation task. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The TaskScheduler + that is used to schedule the created continuation Task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAll. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result of the antecedent . + The array of tasks from which to continue. + The function delegate to execute when all tasks in the + array have completed. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result of the antecedent . + The array of tasks from which to continue. + The function delegate to execute when all tasks in the + array have completed. + The CancellationToken + that will be assigned to the new continuation task. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result of the antecedent . + The array of tasks from which to continue. + The function delegate to execute when all tasks in the + array have completed. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAll. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result of the antecedent . + The array of tasks from which to continue. + The function delegate to execute when all tasks in the + array have completed. + The CancellationToken + that will be assigned to the new continuation task. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The TaskScheduler + that is used to schedule the created continuation . + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAll. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the array completes. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the array completes. + The CancellationToken + that will be assigned to the new continuation task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the array completes. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAny. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the array completes. + The CancellationToken + that will be assigned to the new continuation task. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The TaskScheduler + that is used to schedule the created continuation Task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAny. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result of the antecedent . + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the + array completes. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result of the antecedent . + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the + array completes. + The CancellationToken + that will be assigned to the new continuation task. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result of the antecedent . + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the + array completes. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAny. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result of the antecedent . + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the + array completes. + The CancellationToken + that will be assigned to the new continuation task. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The TaskScheduler + that is used to schedule the created continuation . + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAny. + + + + + Gets the default CancellationToken of this + TaskFactory. + + + This property returns the default that will be assigned to all + tasks created by this factory unless another CancellationToken value is explicitly specified + during the call to the factory methods. + + + + + Gets the TaskScheduler of this + TaskFactory{TResult}. + + + This property returns the default scheduler for this factory. It will be used to schedule all + tasks unless another scheduler is explicitly specified during calls to this factory's methods. + If null, TaskScheduler.Current + will be used. + + + + + Gets the TaskCreationOptions + value of this TaskFactory{TResult}. + + + This property returns the default creation options for this factory. They will be used to create all + tasks unless other options are explicitly specified during calls to this factory's methods. + + + + + Gets the TaskContinuationOptions + value of this TaskFactory{TResult}. + + + This property returns the default continuation options for this factory. They will be used to create + all continuation tasks unless other options are explicitly specified during calls to this factory's methods. + + + + + Represents the current stage in the lifecycle of a . + + + + + The task has been initialized but has not yet been scheduled. + + + + + The task is waiting to be activated and scheduled internally by the .NET Framework infrastructure. + + + + + The task has been scheduled for execution but has not yet begun executing. + + + + + The task is running but has not yet completed. + + + + + The task has finished executing and is implicitly waiting for + attached child tasks to complete. + + + + + The task completed execution successfully. + + + + + The task acknowledged cancellation by throwing an OperationCanceledException2 with its own CancellationToken + while the token was in signaled state, or the task's CancellationToken was already signaled before the + task started executing. + + + + + The task completed due to an unhandled exception. + + + + + Specifies flags that control optional behavior for the creation and execution of tasks. + + + + + Specifies that the default behavior should be used. + + + + + A hint to a TaskScheduler to schedule a + task in as fair a manner as possible, meaning that tasks scheduled sooner will be more likely to + be run sooner, and tasks scheduled later will be more likely to be run later. + + + + + Specifies that a task will be a long-running, course-grained operation. It provides a hint to the + TaskScheduler that oversubscription may be + warranted. + + + + + Specifies that a task is attached to a parent in the task hierarchy. + + + + + Task creation flags which are only used internally. + + + + Specifies "No internal task options" + + + Used to filter out internal vs. public task creation options. + + + Specifies that the task will be queued by the runtime before handing it over to the user. + This flag will be used to skip the cancellationtoken registration step, which is only meant for unstarted tasks. + + + + Specifies flags that control optional behavior for the creation and execution of continuation tasks. + + + + + Default = "Continue on any, no task options, run asynchronously" + Specifies that the default behavior should be used. Continuations, by default, will + be scheduled when the antecedent task completes, regardless of the task's final TaskStatus. + + + + + A hint to a TaskScheduler to schedule a + task in as fair a manner as possible, meaning that tasks scheduled sooner will be more likely to + be run sooner, and tasks scheduled later will be more likely to be run later. + + + + + Specifies that a task will be a long-running, course-grained operation. It provides + a hint to the TaskScheduler that + oversubscription may be warranted. + + + + + Specifies that a task is attached to a parent in the task hierarchy. + + + + + Specifies that the continuation task should not be scheduled if its antecedent ran to completion. + This option is not valid for multi-task continuations. + + + + + Specifies that the continuation task should not be scheduled if its antecedent threw an unhandled + exception. This option is not valid for multi-task continuations. + + + + + Specifies that the continuation task should not be scheduled if its antecedent was canceled. This + option is not valid for multi-task continuations. + + + + + Specifies that the continuation task should be scheduled only if its antecedent ran to + completion. This option is not valid for multi-task continuations. + + + + + Specifies that the continuation task should be scheduled only if its antecedent threw an + unhandled exception. This option is not valid for multi-task continuations. + + + + + Specifies that the continuation task should be scheduled only if its antecedent was canceled. + This option is not valid for multi-task continuations. + + + + + Specifies that the continuation task should be executed synchronously. With this option + specified, the continuation will be run on the same thread that causes the antecedent task to + transition into its final state. If the antecedent is already complete when the continuation is + created, the continuation will run on the thread creating the continuation. Only very + short-running continuations should be executed synchronously. + + + + + Represents an exception used to communicate task cancellation. + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the + class with a specified error message. + + The error message that explains the reason for the exception. + + + + Initializes a new instance of the + class with a specified error message and a reference to the inner exception that is the cause of + this exception. + + The error message that explains the reason for the exception. + The exception that is the cause of the current exception. + + + + Initializes a new instance of the class + with a reference to the that has been canceled. + + A task that has been canceled. + + + + Gets the task associated with this exception. + + + It is permissible for no Task to be associated with a + , in which case + this property will return null. + + + + + Represents the producer side of a unbound to a + delegate, providing access to the consumer side through the property. + + + + It is often the case that a is desired to + represent another asynchronous operation. + TaskCompletionSource is provided for this purpose. It enables + the creation of a task that can be handed out to consumers, and those consumers can use the members + of the task as they would any other. However, unlike most tasks, the state of a task created by a + TaskCompletionSource is controlled explicitly by the methods on TaskCompletionSource. This enables the + completion of the external asynchronous operation to be propagated to the underlying Task. The + separation also ensures that consumers are not able to transition the state without access to the + corresponding TaskCompletionSource. + + + All members of are thread-safe + and may be used from multiple threads concurrently. + + + The type of the result value assocatied with this . + + + + Creates a . + + + + + Creates a + with the specified options. + + + The created + by this instance and accessible through its property + will be instantiated using the specified . + + The options to use when creating the underlying + . + + The represent options invalid for use + with a . + + + + + Creates a + with the specified state. + + The state to use as the underlying + 's AsyncState. + + + + Creates a with + the specified state and options. + + The options to use when creating the underlying + . + The state to use as the underlying + 's AsyncState. + + The represent options invalid for use + with a . + + + + + Attempts to transition the underlying + into the + Faulted + state. + + The exception to bind to this . + True if the operation was successful; otherwise, false. + This operation will return false if the + is already in one + of the three final states: + RanToCompletion, + Faulted, or + Canceled. + + The argument is null. + The was disposed. + + + + Attempts to transition the underlying + into the + Faulted + state. + + The collection of exceptions to bind to this . + True if the operation was successful; otherwise, false. + This operation will return false if the + is already in one + of the three final states: + RanToCompletion, + Faulted, or + Canceled. + + The argument is null. + There are one or more null elements in . + The collection is empty. + The was disposed. + + + + Transitions the underlying + into the + Faulted + state. + + The exception to bind to this . + The argument is null. + + The underlying is already in one + of the three final states: + RanToCompletion, + Faulted, or + Canceled. + + The was disposed. + + + + Transitions the underlying + into the + Faulted + state. + + The collection of exceptions to bind to this . + The argument is null. + There are one or more null elements in . + + The underlying is already in one + of the three final states: + RanToCompletion, + Faulted, or + Canceled. + + The was disposed. + + + + Attempts to transition the underlying + into the + RanToCompletion + state. + + The result value to bind to this . + True if the operation was successful; otherwise, false. + This operation will return false if the + is already in one + of the three final states: + RanToCompletion, + Faulted, or + Canceled. + + The was disposed. + + + + Transitions the underlying + into the + RanToCompletion + state. + + The result value to bind to this . + + The underlying is already in one + of the three final states: + RanToCompletion, + Faulted, or + Canceled. + + The was disposed. + + + + Transitions the underlying + into the + Canceled + state. + + + The underlying is already in one + of the three final states: + RanToCompletion, + Faulted, or + Canceled. + + The was disposed. + + + + Attempts to transition the underlying + into the + Canceled + state. + + True if the operation was successful; otherwise, false. + This operation will return false if the + is already in one + of the three final states: + RanToCompletion, + Faulted, or + Canceled. + + The was disposed. + + + + Gets the created + by this . + + + This property enables a consumer access to the that is controlled by this instance. + The , , + , and + methods (and their "Try" variants) on this instance all result in the relevant state + transitions on this underlying Task. + + + + + An exception holder manages a list of exceptions for one particular task. + It offers the ability to aggregate, but more importantly, also offers intrinsic + support for propagating unhandled exceptions that are never observed. It does + this by aggregating and throwing if the holder is ever GC'd without the holder's + contents ever having been requested (e.g. by a Task.Wait, Task.get_Exception, etc). + + + + + Creates a new holder; it will be registered for finalization. + + The task this holder belongs to. + + + + A finalizer that repropagates unhandled exceptions. + + + + + Add an exception to the internal list. This will ensure the holder is + in the proper state (handled/unhandled) depending on the list's contents. + + An exception object (either an Exception or an + IEnumerable{Exception}) to add to the list. + + + + A private helper method that ensures the holder is considered + unhandled, i.e. it is registered for finalization. + + + + + A private helper method that ensures the holder is considered + handled, i.e. it is not registered for finalization. + + Whether this is called from the finalizer thread. + + + + Allocates a new aggregate exception and adds the contents of the list to + it. By calling this method, the holder assumes exceptions to have been + "observed", such that the finalization check will be subsequently skipped. + + Whether this is being called from a finalizer. + An extra exception to be included (optionally). + The aggregate exception to throw. + + + + Provides a set of static (Shared in Visual Basic) methods for working with specific kinds of + instances. + + + + + Creates a proxy Task that represents the + asynchronous operation of a Task{Task}. + + + It is often useful to be able to return a Task from a + Task{TResult}, where the inner Task represents work done as part of the outer Task{TResult}. However, + doing so results in a Task{Task}, which, if not dealt with carefully, could produce unexpected behavior. Unwrap + solves this problem by creating a proxy Task that represents the entire asynchronous operation of such a Task{Task}. + + The Task{Task} to unwrap. + The exception that is thrown if the + argument is null. + A Task that represents the asynchronous operation of the provided Task{Task}. + + + + Creates a proxy Task{TResult} that represents the + asynchronous operation of a Task{Task{TResult}}. + + + It is often useful to be able to return a Task{TResult} from a Task{TResult}, where the inner Task{TResult} + represents work done as part of the outer Task{TResult}. However, doing so results in a Task{Task{TResult}}, + which, if not dealt with carefully, could produce unexpected behavior. Unwrap solves this problem by + creating a proxy Task{TResult} that represents the entire asynchronous operation of such a Task{Task{TResult}}. + + The Task{Task{TResult}} to unwrap. + The exception that is thrown if the + argument is null. + A Task{TResult} that represents the asynchronous operation of the provided Task{Task{TResult}}. /// Unwraps a Task that returns another Task. + + + + Provides support for creating and scheduling + Tasks. + + + + There are many common patterns for which tasks are relevant. The + class encodes some of these patterns into methods that pick up default settings, which are + configurable through its constructors. + + + A default instance of is available through the + Task.Factory property. + + + + + + Initializes a instance with the default configuration. + + + This constructor creates a instance with a default configuration. The + property is initialized to + TaskCreationOptions.None, the + property is initialized to TaskContinuationOptions.None, + and the TaskScheduler property is + initialized to the current scheduler (see TaskScheduler.Current). + + + + + Initializes a instance with the specified configuration. + + The default that will be assigned + to tasks created by this unless another CancellationToken is explicitly specified + while calling the factory methods. + + This constructor creates a instance with a default configuration. The + property is initialized to + TaskCreationOptions.None, the + property is initialized to TaskContinuationOptions.None, + and the TaskScheduler property is + initialized to the current scheduler (see TaskScheduler.Current). + + + + + Initializes a instance with the specified configuration. + + + The + TaskScheduler to use to schedule any tasks created with this TaskFactory. A null value + indicates that the current TaskScheduler should be used. + + + With this constructor, the + property is initialized to + TaskCreationOptions.None, the + property is initialized to TaskContinuationOptions.None, + and the TaskScheduler property is + initialized to , unless it's null, in which case the property is + initialized to the current scheduler (see TaskScheduler.Current). + + + + + Initializes a instance with the specified configuration. + + + The default + TaskCreationOptions to use when creating tasks with this TaskFactory. + + + The default + TaskContinuationOptions to use when creating continuation tasks with this TaskFactory. + + + The exception that is thrown when the + argument or the + argument specifies an invalid value. + + + With this constructor, the + property is initialized to , + the + property is initialized to , and the TaskScheduler property is initialized to the + current scheduler (see TaskScheduler.Current). + + + + + Initializes a instance with the specified configuration. + + The default that will be assigned + to tasks created by this unless another CancellationToken is explicitly specified + while calling the factory methods. + + The default + TaskCreationOptions to use when creating tasks with this TaskFactory. + + + The default + TaskContinuationOptions to use when creating continuation tasks with this TaskFactory. + + + The default + TaskScheduler to use to schedule any Tasks created with this TaskFactory. A null value + indicates that TaskScheduler.Current should be used. + + + The exception that is thrown when the + argument or the + argumentspecifies an invalid value. + + + With this constructor, the + property is initialized to , + the + property is initialized to , and the TaskScheduler property is initialized to + , unless it's null, in which case the property is initialized to the + current scheduler (see TaskScheduler.Current). + + + + + Creates and starts a Task. + + The action delegate to execute asynchronously. + The started Task. + The exception that is thrown when the + argument is null. + + Calling StartNew is functionally equivalent to creating a Task using one of its constructors + and then calling + Start to schedule it for execution. However, + unless creation and scheduling must be separated, StartNew is the recommended + approach for both simplicity and performance. + + + + + Creates and starts a Task. + + The action delegate to execute asynchronously. + The that will be assigned to the new task. + The started Task. + The exception that is thrown when the + argument is null. + The provided CancellationToken + has already been disposed. + + + Calling StartNew is functionally equivalent to creating a Task using one of its constructors + and then calling + Start to schedule it for execution. However, + unless creation and scheduling must be separated, StartNew is the recommended + approach for both simplicity and performance. + + + + + Creates and starts a Task. + + The action delegate to execute asynchronously. + A TaskCreationOptions value that controls the behavior of the + created + Task. + The started Task. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + + Calling StartNew is functionally equivalent to creating a Task using one of its constructors and + then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a Task. + + The action delegate to execute asynchronously. + The that will be assigned to the new + A TaskCreationOptions value that controls the behavior of the + created + Task. + The TaskScheduler + that is used to schedule the created Task. + The started Task. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The provided CancellationToken + has already been disposed. + + + Calling StartNew is functionally equivalent to creating a Task using one of its constructors and + then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a Task. + + The action delegate to execute asynchronously. + An object containing data to be used by the + delegate. + The started Task. + The exception that is thrown when the + argument is null. + + Calling StartNew is functionally equivalent to creating a Task using one of its constructors and + then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a Task. + + The action delegate to execute asynchronously. + An object containing data to be used by the + delegate. + The that will be assigned to the new + The started Task. + The exception that is thrown when the + argument is null. + The provided CancellationToken + has already been disposed. + + + Calling StartNew is functionally equivalent to creating a Task using one of its constructors and + then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a Task. + + The action delegate to execute asynchronously. + An object containing data to be used by the + delegate. + A TaskCreationOptions value that controls the behavior of the + created + Task. + The started Task. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + + Calling StartNew is functionally equivalent to creating a Task using one of its constructors and + then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a Task. + + The action delegate to execute asynchronously. + An object containing data to be used by the + delegate. + The that will be assigned to the new task. + A TaskCreationOptions value that controls the behavior of the + created + Task. + The TaskScheduler + that is used to schedule the created Task. + The started Task. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The provided CancellationToken + has already been disposed. + + + Calling StartNew is functionally equivalent to creating a Task using one of its constructors and + then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + The type of the result available through the + Task. + + A function delegate that returns the future result to be available through + the . + The started . + The exception that is thrown when the + argument is null. + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + The type of the result available through the + Task. + + A function delegate that returns the future result to be available through + the . + The that will be assigned to the new + The started . + The exception that is thrown when the + argument is null. + The provided CancellationToken + has already been disposed. + + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + The type of the result available through the + Task. + + A function delegate that returns the future result to be available through + the . + A TaskCreationOptions value that controls the behavior of the + created + . + The started . + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + The type of the result available through the + Task. + + A function delegate that returns the future result to be available through + the . + The that will be assigned to the new task. + A TaskCreationOptions value that controls the behavior of the + created + . + The TaskScheduler + that is used to schedule the created + Task{TResult}. + The started . + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The provided CancellationToken + has already been disposed. + + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + The type of the result available through the + Task. + + A function delegate that returns the future result to be available through + the . + An object containing data to be used by the + delegate. + The started . + The exception that is thrown when the + argument is null. + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + The type of the result available through the + Task. + + A function delegate that returns the future result to be available through + the . + An object containing data to be used by the + delegate. + The that will be assigned to the new + The started . + The exception that is thrown when the + argument is null. + The provided CancellationToken + has already been disposed. + + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + The type of the result available through the + Task. + + A function delegate that returns the future result to be available through + the . + An object containing data to be used by the + delegate. + A TaskCreationOptions value that controls the behavior of the + created + . + The started . + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + The type of the result available through the + Task. + + A function delegate that returns the future result to be available through + the . + An object containing data to be used by the + delegate. + The that will be assigned to the new task. + A TaskCreationOptions value that controls the behavior of the + created + . + The TaskScheduler + that is used to schedule the created + Task{TResult}. + The started . + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The provided CancellationToken + has already been disposed. + + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates a Task that executes an end method action + when a specified IAsyncResult completes. + + The IAsyncResult whose completion should trigger the processing of the + . + The action delegate that processes the completed . + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + A Task that represents the asynchronous + operation. + + + + Creates a Task that executes an end method action + when a specified IAsyncResult completes. + + The IAsyncResult whose completion should trigger the processing of the + . + The action delegate that processes the completed . + The TaskCreationOptions value that controls the behavior of the + created Task. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + A Task that represents the asynchronous + operation. + + + + Creates a Task that executes an end method action + when a specified IAsyncResult completes. + + The IAsyncResult whose completion should trigger the processing of the + . + The action delegate that processes the completed . + The TaskScheduler + that is used to schedule the task that executes the end method. + The TaskCreationOptions value that controls the behavior of the + created Task. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + A Task that represents the asynchronous + operation. + + + + Creates a Task that represents a pair of begin + and end methods that conform to the Asynchronous Programming Model pattern. + + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The created Task that represents the + asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of begin + and end methods that conform to the Asynchronous Programming Model pattern. + + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The TaskCreationOptions value that controls the behavior of the + created Task. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The created Task that represents the + asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of begin + and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the + delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The created Task that represents the + asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of begin + and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the + delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The TaskCreationOptions value that controls the behavior of the + created Task. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The created Task that represents the + asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of begin + and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the + delegate. + The type of the second argument passed to + delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The second argument passed to the + delegate. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The created Task that represents the + asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of begin + and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the + delegate. + The type of the second argument passed to + delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The second argument passed to the + delegate. + The TaskCreationOptions value that controls the behavior of the + created Task. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The created Task that represents the + asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of begin + and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the + delegate. + The type of the second argument passed to + delegate. + The type of the third argument passed to + delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The second argument passed to the + delegate. + The third argument passed to the + delegate. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The created Task that represents the + asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of begin + and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the + delegate. + The type of the second argument passed to + delegate. + The type of the third argument passed to + delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The second argument passed to the + delegate. + The third argument passed to the + delegate. + The TaskCreationOptions value that controls the behavior of the + created Task. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The created Task that represents the + asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that executes an end + method function when a specified IAsyncResult completes. + + The type of the result available through the + Task. + + The IAsyncResult whose completion should trigger the processing of the + . + The function delegate that processes the completed . + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + A Task that represents the + asynchronous operation. + + + + Creates a Task that executes an end + method function when a specified IAsyncResult completes. + + The type of the result available through the + Task. + + The IAsyncResult whose completion should trigger the processing of the + . + The function delegate that processes the completed . + The TaskCreationOptions value that controls the behavior of the + created Task. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + A Task that represents the + asynchronous operation. + + + + Creates a Task that executes an end + method function when a specified IAsyncResult completes. + + The type of the result available through the + Task. + + The IAsyncResult whose completion should trigger the processing of the + . + The function delegate that processes the completed . + The TaskScheduler + that is used to schedule the task that executes the end method. + The TaskCreationOptions value that controls the behavior of the + created Task. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + A Task that represents the + asynchronous operation. + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the result available through the + Task. + + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the result available through the + Task. + + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The TaskCreationOptions value that controls the behavior of the + created Task. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the delegate. + The type of the result available through the + Task. + + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the delegate. + The type of the result available through the + Task. + + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The TaskCreationOptions value that controls the behavior of the + created Task. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the delegate. + The type of the second argument passed to + delegate. + The type of the result available through the + Task. + + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The second argument passed to the + delegate. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the delegate. + The type of the second argument passed to + delegate. + The type of the result available through the + Task. + + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The second argument passed to the + delegate. + The TaskCreationOptions value that controls the behavior of the + created Task. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the delegate. + The type of the second argument passed to + delegate. + The type of the third argument passed to + delegate. + The type of the result available through the + Task. + + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The second argument passed to the + delegate. + The third argument passed to the + delegate. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the delegate. + The type of the second argument passed to + delegate. + The type of the third argument passed to + delegate. + The type of the result available through the + Task. + + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The second argument passed to the + delegate. + The third argument passed to the + delegate. + The TaskCreationOptions value that controls the behavior of the + created Task. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Check validity of options passed to FromAsync method + + The options to be validated. + determines type of FromAsync method that called this method + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The array of tasks from which to continue. + The action delegate to execute when all tasks in + the array have completed. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The array of tasks from which to continue. + The action delegate to execute when all tasks in + the array have completed. + The CancellationToken + that will be assigned to the new continuation task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The array of tasks from which to continue. + The action delegate to execute when all tasks in the array have completed. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAll. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The array of tasks from which to continue. + The action delegate to execute when all tasks in the array have completed. + The CancellationToken + that will be assigned to the new continuation task. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The TaskScheduler + that is used to schedule the created continuation Task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAll. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result of the antecedent . + The array of tasks from which to continue. + The action delegate to execute when all tasks in + the array have completed. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result of the antecedent . + The array of tasks from which to continue. + The action delegate to execute when all tasks in + the array have completed. + The CancellationToken + that will be assigned to the new continuation task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result of the antecedent . + The array of tasks from which to continue. + The action delegate to execute when all tasks in the array have completed. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAll. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result of the antecedent . + The array of tasks from which to continue. + The action delegate to execute when all tasks in the array have completed. + The CancellationToken + that will be assigned to the new continuation task. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The TaskScheduler + that is used to schedule the created continuation Task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAll. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result that is returned by the + delegate and associated with the created . + The array of tasks from which to continue. + The function delegate to execute when all tasks in the + array have completed. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result that is returned by the + delegate and associated with the created . + The array of tasks from which to continue. + The function delegate to execute when all tasks in the + array have completed. + The CancellationToken + that will be assigned to the new continuation task. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result that is returned by the + delegate and associated with the created . + The array of tasks from which to continue. + The function delegate to execute when all tasks in the + array have completed. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAll. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result that is returned by the + delegate and associated with the created . + The array of tasks from which to continue. + The function delegate to execute when all tasks in the + array have completed. + The CancellationToken + that will be assigned to the new continuation task. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The TaskScheduler + that is used to schedule the created continuation . + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAll. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result that is returned by the + delegate and associated with the created . + The type of the result of the antecedent . + The array of tasks from which to continue. + The function delegate to execute when all tasks in the + array have completed. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result that is returned by the + delegate and associated with the created . + The type of the result of the antecedent . + The array of tasks from which to continue. + The function delegate to execute when all tasks in the + array have completed. + The CancellationToken + that will be assigned to the new continuation task. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result that is returned by the + delegate and associated with the created . + The type of the result of the antecedent . + The array of tasks from which to continue. + The function delegate to execute when all tasks in the + array have completed. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAll. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result that is returned by the + delegate and associated with the created . + The type of the result of the antecedent . + The array of tasks from which to continue. + The function delegate to execute when all tasks in the + array have completed. + The CancellationToken + that will be assigned to the new continuation task. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The TaskScheduler + that is used to schedule the created continuation . + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAll. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The array of tasks from which to continue when one task completes. + The action delegate to execute when one task in the array completes. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The array of tasks from which to continue when one task completes. + The action delegate to execute when one task in the array completes. + The CancellationToken + that will be assigned to the new continuation task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The array of tasks from which to continue when one task completes. + The action delegate to execute when one task in the array completes. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAny. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The array of tasks from which to continue when one task completes. + The action delegate to execute when one task in the array completes. + The CancellationToken + that will be assigned to the new continuation task. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The TaskScheduler + that is used to schedule the created continuation Task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAny. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result that is returned by the + delegate and associated with the created . + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the + array completes. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result that is returned by the + delegate and associated with the created . + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the + array completes. + The CancellationToken + that will be assigned to the new continuation task. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result that is returned by the + delegate and associated with the created . + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the + array completes. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAny. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result that is returned by the + delegate and associated with the created . + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the + array completes. + The CancellationToken + that will be assigned to the new continuation task. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The TaskScheduler + that is used to schedule the created continuation . + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAny. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result that is returned by the + delegate and associated with the created . + The type of the result of the antecedent . + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the + array completes. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result that is returned by the + delegate and associated with the created . + The type of the result of the antecedent . + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the + array completes. + The CancellationToken + that will be assigned to the new continuation task. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result that is returned by the + delegate and associated with the created . + The type of the result of the antecedent . + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the + array completes. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAny. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result that is returned by the + delegate and associated with the created . + The type of the result of the antecedent . + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the + array completes. + The CancellationToken + that will be assigned to the new continuation task. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The TaskScheduler + that is used to schedule the created continuation . + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAny. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result of the antecedent . + The array of tasks from which to continue when one task completes. + The action delegate to execute when one task in the + array completes. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result of the antecedent . + The array of tasks from which to continue when one task completes. + The action delegate to execute when one task in the + array completes. + The CancellationToken + that will be assigned to the new continuation task. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result of the antecedent . + The array of tasks from which to continue when one task completes. + The action delegate to execute when one task in the + array completes. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAny. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result of the antecedent . + The array of tasks from which to continue when one task completes. + The action delegate to execute when one task in the + array completes. + The CancellationToken + that will be assigned to the new continuation task. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The TaskScheduler + that is used to schedule the created continuation . + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAny. + + + + + Gets the default CancellationToken of this + TaskFactory. + + + This property returns the default that will be assigned to all + tasks created by this factory unless another CancellationToken value is explicitly specified + during the call to the factory methods. + + + + + Gets the TaskScheduler of this + TaskFactory. + + + This property returns the default scheduler for this factory. It will be used to schedule all + tasks unless another scheduler is explicitly specified during calls to this factory's methods. + If null, TaskScheduler.Current + will be used. + + + + + Gets the TaskCreationOptions + value of this TaskFactory. + + + This property returns the default creation options for this factory. They will be used to create all + tasks unless other options are explicitly specified during calls to this factory's methods. + + + + + Gets the TaskContinuationOptions + value of this TaskFactory. + + + This property returns the default continuation options for this factory. They will be used to create + all continuation tasks unless other options are explicitly specified during calls to this factory's methods. + + + + + Represents an abstract scheduler for tasks. + + + + TaskScheduler acts as the extension point for all + pluggable scheduling logic. This includes mechanisms such as how to schedule a task for execution, and + how scheduled tasks should be exposed to debuggers. + + + All members of the abstract type are thread-safe + and may be used from multiple threads concurrently. + + + + + + Queues a Task to the scheduler. + + + + A class derived from TaskScheduler + implements this method to accept tasks being scheduled on the scheduler. + A typical implementation would store the task in an internal data structure, which would + be serviced by threads that would execute those tasks at some time in the future. + + + This method is only meant to be called by the .NET Framework and + should not be called directly by the derived class. This is necessary + for maintaining the consistency of the system. + + + The Task to be queued. + The argument is null. + + + + Determines whether the provided Task + can be executed synchronously in this call, and if it can, executes it. + + + + A class derived from TaskScheduler implements this function to + support inline execution of a task on a thread that initiates a wait on that task object. Inline + execution is optional, and the request may be rejected by returning false. However, better + scalability typically results the more tasks that can be inlined, and in fact a scheduler that + inlines too little may be prone to deadlocks. A proper implementation should ensure that a + request executing under the policies guaranteed by the scheduler can successfully inline. For + example, if a scheduler uses a dedicated thread to execute tasks, any inlining requests from that + thread should succeed. + + + If a scheduler decides to perform the inline execution, it should do so by calling to the base + TaskScheduler's + TryExecuteTask method with the provided task object, propagating + the return value. It may also be appropriate for the scheduler to remove an inlined task from its + internal data structures if it decides to honor the inlining request. Note, however, that under + some circumstances a scheduler may be asked to inline a task that was not previously provided to + it with the method. + + + The derived scheduler is responsible for making sure that the calling thread is suitable for + executing the given task as far as its own scheduling and execution policies are concerned. + + + The Task to be + executed. + A Boolean denoting whether or not task has previously been + queued. If this parameter is True, then the task may have been previously queued (scheduled); if + False, then the task is known not to have been queued, and this call is being made in order to + execute the task inline without queueing it. + A Boolean value indicating whether the task was executed inline. + The argument is + null. + The was already + executed. + + + + Generates an enumerable of Task instances + currently queued to the scheduler waiting to be executed. + + + + A class derived from implements this method in order to support + integration with debuggers. This method will only be invoked by the .NET Framework when the + debugger requests access to the data. The enumerable returned will be traversed by debugging + utilities to access the tasks currently queued to this scheduler, enabling the debugger to + provide a representation of this information in the user interface. + + + It is important to note that, when this method is called, all other threads in the process will + be frozen. Therefore, it's important to avoid synchronization with other threads that may lead to + blocking. If synchronization is necessary, the method should prefer to throw a + than to block, which could cause a debugger to experience delays. Additionally, this method and + the enumerable returned must not modify any globally visible state. + + + The returned enumerable should never be null. If there are currently no queued tasks, an empty + enumerable should be returned instead. + + + For developers implementing a custom debugger, this method shouldn't be called directly, but + rather this functionality should be accessed through the internal wrapper method + GetScheduledTasksForDebugger: + internal Task[] GetScheduledTasksForDebugger(). This method returns an array of tasks, + rather than an enumerable. In order to retrieve a list of active schedulers, a debugger may use + another internal method: internal static TaskScheduler[] GetTaskSchedulersForDebugger(). + This static method returns an array of all active TaskScheduler instances. + GetScheduledTasksForDebugger then may be used on each of these scheduler instances to retrieve + the list of scheduled tasks for each. + + + An enumerable that allows traversal of tasks currently queued to this scheduler. + + + This scheduler is unable to generate a list of queued tasks at this time. + + + + + Retrieves some thread static state that can be cached and passed to multiple + TryRunInline calls, avoiding superflous TLS fetches. + + A bag of TLS state (or null if none exists). + + + + Attempts to execute the target task synchronously. + + The task to run. + True if the task may have been previously queued, + false if the task was absolutely not previously queued. + The state retrieved from GetThreadStatics + True if it ran, false otherwise. + + + + Attempts to dequeue a Task that was previously queued to + this scheduler. + + The Task to be dequeued. + A Boolean denoting whether the argument was successfully dequeued. + The argument is null. + + + + Notifies the scheduler that a work item has made progress. + + + + + Initializes the . + + + + + Frees all resources associated with this scheduler. + + + + + Creates a + associated with the current . + + + All Task instances queued to + the returned scheduler will be executed through a call to the + Post method + on that context. + + + A associated with + the current SynchronizationContext, as + determined by SynchronizationContext.Current. + + + The current SynchronizationContext may not be used as a TaskScheduler. + + + + + Attempts to execute the provided Task + on this scheduler. + + + + Scheduler implementations are provided with Task + instances to be executed through either the method or the + method. When the scheduler deems it appropriate to run the + provided task, should be used to do so. TryExecuteTask handles all + aspects of executing a task, including action invocation, exception handling, state management, + and lifecycle control. + + + must only be used for tasks provided to this scheduler by the .NET + Framework infrastructure. It should not be used to execute arbitrary tasks obtained through + custom mechanisms. + + + + A Task object to be executed. + + The is not associated with this scheduler. + + A Boolean that is true if was successfully executed, false if it + was not. A common reason for execution failure is that the task had previously been executed or + is in the process of being executed by another thread. + + + + Provides an array of all queued Task instances + for the debugger. + + + The returned array is populated through a call to . + Note that this function is only meant to be invoked by a debugger remotely. + It should not be called by any other codepaths. + + An array of Task instances. + + This scheduler is unable to generate a list of queued tasks at this time. + + + + + Provides an array of all active TaskScheduler + instances for the debugger. + + + This function is only meant to be invoked by a debugger remotely. + It should not be called by any other codepaths. + + An array of TaskScheduler instances. + + + + Registers a new TaskScheduler instance in the global collection of schedulers. + + + + + Removes a TaskScheduler instance from the global collection of schedulers. + + + + + Indicates the maximum concurrency level this + is able to support. + + + + + Indicates whether this is a custom scheduler, in which case the safe code paths will be taken upon task entry + using a CAS to transition from queued state to executing. + + + + + Gets the default TaskScheduler instance. + + + + + Gets the TaskScheduler + associated with the currently executing task. + + + When not called from within a task, will return the scheduler. + + + + + Gets the unique ID for this . + + + + + Occurs when a faulted 's unobserved exception is about to trigger exception escalation + policy, which, by default, would terminate the process. + + + This AppDomain-wide event provides a mechanism to prevent exception + escalation policy (which, by default, terminates the process) from triggering. + Each handler is passed a + instance, which may be used to examine the exception and to mark it as observed. + + + + + Nested class that provides debugger view for TaskScheduler + + + + Default thread pool scheduler. + + + + A TaskScheduler implementation that executes all tasks queued to it through a call to + on the + that its associated with. The default constructor for this class binds to the current + + + + + Constructs a SynchronizationContextTaskScheduler associated with + + This constructor expects to be set. + + + + Implemetation of for this scheduler class. + + Simply posts the tasks to be executed on the associated . + + + + + + Implementation of for this scheduler class. + + The task will be executed inline only if the call happens within + the associated . + + + + + + + Implementes the property for + this scheduler class. + + By default it returns 1, because a based + scheduler only supports execution on a single thread. + + + + + Provides data for the event that is raised when a faulted 's + exception goes unobserved. + + + The Exception property is used to examine the exception without marking it + as observed, whereas the method is used to mark the exception + as observed. Marking the exception as observed prevents it from triggering exception escalation policy + which, by default, terminates the process. + + + + + Initializes a new instance of the class + with the unobserved exception. + + The Exception that has gone unobserved. + + + + Marks the as "observed," thus preventing it + from triggering exception escalation policy which, by default, terminates the process. + + + + + Gets whether this exception has been marked as "observed." + + + + + The Exception that went unobserved. + + + + + Represents an exception used to communicate an invalid operation by a + . + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the + class with a specified error message. + + The error message that explains the reason for the exception. + + + + Initializes a new instance of the + class using the default error message and a reference to the inner exception that is the cause of + this exception. + + The exception that is the cause of the current exception. + + + + Initializes a new instance of the + class with a specified error message and a reference to the inner exception that is the cause of + this exception. + + The error message that explains the reason for the exception. + The exception that is the cause of the current exception. + + + diff --git a/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+sl4+win8+wp71+wpa81/ensureRedirect.xml b/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+sl4+win8+wp71+wpa81/ensureRedirect.xml new file mode 100644 index 00000000..e69de29b diff --git a/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+sl4+win8+wp8+wpa81/System.IO.dll b/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+sl4+win8+wp8+wpa81/System.IO.dll new file mode 100644 index 0000000000000000000000000000000000000000..01edf729d6fd3f62b325ada34491065ecf202911 GIT binary patch literal 22704 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 + + + System.IO + + + + + A strongly-typed resource class, for looking up localized strings, etc. + + + + + Returns the cached ResourceManager instance used by this class. + + + + + Overrides the current thread's CurrentUICulture property for all + resource lookups using this strongly typed resource class. + + + + + Looks up a localized string similar to Found invalid data while decoding.. + + + + + The exception that is thrown when a data stream is in an invalid format. + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class with a specified error message. + + The error message that explains the reason for the exception. + + + + Initializes a new instance of the class with a reference to the inner exception that is the cause of this exception. + The error message that explains the reason for the exception. + The exception that is the cause of the current exception. If the parameter is not null, the current exception is raised in a catch block that handles the inner exception. + + + diff --git a/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+sl4+win8+wp8+wpa81/System.Runtime.dll b/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+sl4+win8+wp8+wpa81/System.Runtime.dll new file mode 100644 index 0000000000000000000000000000000000000000..967bb30a0d84f969455800059b74fae5c24271df GIT binary patch literal 22208 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 QU>aprW%>sEYaZx-0jWNPVE_OC literal 0 HcmV?d00001 diff --git a/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+sl4+win8+wp8+wpa81/System.Runtime.xml b/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+sl4+win8+wp8+wpa81/System.Runtime.xml new file mode 100644 index 00000000..93cb00d7 --- /dev/null +++ b/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+sl4+win8+wp8+wpa81/System.Runtime.xml @@ -0,0 +1,56 @@ + + + + System.Runtime + + + + Defines a provider for progress updates. + The type of progress update value. + + + Reports a progress update. + The value of the updated progress. + + + Identities the async state machine type for this method. + + + Identities the state machine type for this method. + + + Initializes the attribute. + The type that implements the state machine. + + + Gets the type that implements the state machine. + + + Initializes the attribute. + The type that implements the state machine. + + + + Allows you to obtain the method or property name of the caller to the method. + + + + + Allows you to obtain the line number in the source file at which the method is called. + + + + + Allows you to obtain the full path of the source file that contains the caller. + This is the file path at the time of compile. + + + + Identities the iterator state machine type for this method. + + + Initializes the attribute. + The type that implements the state machine. + + + diff --git a/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+sl4+win8+wp8+wpa81/System.Threading.Tasks.dll b/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+sl4+win8+wp8+wpa81/System.Threading.Tasks.dll new file mode 100644 index 0000000000000000000000000000000000000000..03d08ad93e7cc6f8ae5664b89516ba2010a4f749 GIT binary patch literal 164576 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
    A;XM&re5ZI=Miv% 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 E10+ctx&QzG literal 0 HcmV?d00001 diff --git a/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+sl4+win8+wp8+wpa81/System.Threading.Tasks.xml b/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+sl4+win8+wp8+wpa81/System.Threading.Tasks.xml new file mode 100644 index 00000000..6c770122 --- /dev/null +++ b/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+sl4+win8+wp8+wpa81/System.Threading.Tasks.xml @@ -0,0 +1,8969 @@ + + + + System.Threading.Tasks + + + + Represents one or more errors that occur during application execution. + + is used to consolidate multiple failures into a single, throwable + exception object. + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class with + a specified error message. + + The error message that explains the reason for the exception. + + + + Initializes a new instance of the class with a specified error + message and a reference to the inner exception that is the cause of this exception. + + The error message that explains the reason for the exception. + The exception that is the cause of the current exception. + The argument + is null. + + + + Initializes a new instance of the class with + references to the inner exceptions that are the cause of this exception. + + The exceptions that are the cause of the current exception. + The argument + is null. + An element of is + null. + + + + Initializes a new instance of the class with + references to the inner exceptions that are the cause of this exception. + + The exceptions that are the cause of the current exception. + The argument + is null. + An element of is + null. + + + + Initializes a new instance of the class with a specified error + message and references to the inner exceptions that are the cause of this exception. + + The error message that explains the reason for the exception. + The exceptions that are the cause of the current exception. + The argument + is null. + An element of is + null. + + + + Initializes a new instance of the class with a specified error + message and references to the inner exceptions that are the cause of this exception. + + The error message that explains the reason for the exception. + The exceptions that are the cause of the current exception. + The argument + is null. + An element of is + null. + + + + Allocates a new aggregate exception with the specified message and list of inner exceptions. + + The error message that explains the reason for the exception. + The exceptions that are the cause of the current exception. + The argument + is null. + An element of is + null. + + + + Returns the that is the root cause of this exception. + + + + + Invokes a handler on each contained by this . + + The predicate to execute for each exception. The predicate accepts as an + argument the to be processed and returns a Boolean to indicate + whether the exception was handled. + + Each invocation of the returns true or false to indicate whether the + was handled. After all invocations, if any exceptions went + unhandled, all unhandled exceptions will be put into a new + which will be thrown. Otherwise, the method simply returns. If any + invocations of the throws an exception, it will halt the processing + of any more exceptions and immediately propagate the thrown exception as-is. + + An exception contained by this was not handled. + The argument is + null. + + + + Flattens an instances into a single, new instance. + + A new, flattened . + + If any inner exceptions are themselves instances of + , this method will recursively flatten all of them. The + inner exceptions returned in the new + will be the union of all of the the inner exceptions from exception tree rooted at the provided + instance. + + + + + Creates and returns a string representation of the current . + + A string representation of the current exception. + + + + Gets a read-only collection of the instances that caused the + current exception. + + + + + A strongly-typed resource class, for looking up localized strings, etc. + + + + + Returns the cached ResourceManager instance used by this class. + + + + + Overrides the current thread's CurrentUICulture property for all + resource lookups using this strongly typed resource class. + + + + + Looks up a localized string similar to One or more errors occurred.. + + + + + Looks up a localized string similar to An element of innerExceptions was null.. + + + + + Looks up a localized string similar to {0}{1}---> (Inner Exception #{2}) {3}{4}{5}. + + + + + Looks up a localized string similar to No tokens were supplied.. + + + + + Looks up a localized string similar to The CancellationTokenSource associated with this CancellationToken has been disposed.. + + + + + Looks up a localized string similar to The CancellationTokenSource has been disposed.. + + + + + Looks up a localized string similar to The SyncRoot property may not be used for the synchronization of concurrent collections.. + + + + + Looks up a localized string similar to The array is multidimensional, or the type parameter for the set cannot be cast automatically to the type of the destination array.. + + + + + Looks up a localized string similar to The index is equal to or greater than the length of the array, or the number of elements in the dictionary is greater than the available space from index to the end of the destination array.. + + + + + Looks up a localized string similar to The capacity argument must be greater than or equal to zero.. + + + + + Looks up a localized string similar to The concurrencyLevel argument must be positive.. + + + + + Looks up a localized string similar to The index argument is less than zero.. + + + + + Looks up a localized string similar to TKey is a reference type and item.Key is null.. + + + + + Looks up a localized string similar to The key already existed in the dictionary.. + + + + + Looks up a localized string similar to The source argument contains duplicate keys.. + + + + + Looks up a localized string similar to The key was of an incorrect type for this dictionary.. + + + + + Looks up a localized string similar to The value was of an incorrect type for this dictionary.. + + + + + Looks up a localized string similar to The lazily-initialized type does not have a public, parameterless constructor.. + + + + + Looks up a localized string similar to ValueFactory returned null.. + + + + + Looks up a localized string similar to The spinCount argument must be in the range 0 to {0}, inclusive.. + + + + + Looks up a localized string similar to There are too many threads currently waiting on the event. A maximum of {0} waiting threads are supported.. + + + + + Looks up a localized string similar to The event has been disposed.. + + + + + Looks up a localized string similar to The operation was canceled.. + + + + + Looks up a localized string similar to The condition argument is null.. + + + + + Looks up a localized string similar to The timeout must represent a value between -1 and Int32.MaxValue, inclusive.. + + + + + Looks up a localized string similar to The specified TaskContinuationOptions combined LongRunning and ExecuteSynchronously. Synchronous continuations should not be long running.. + + + + + Looks up a localized string similar to The specified TaskContinuationOptions excluded all continuation kinds.. + + + + + Looks up a localized string similar to (Internal)An attempt was made to create a LongRunning SelfReplicating task.. + + + + + Looks up a localized string similar to The value needs to translate in milliseconds to -1 (signifying an infinite timeout), 0 or a positive integer less than or equal to Int32.MaxValue.. + + + + + Looks up a localized string similar to The value needs to be either -1 (signifying an infinite timeout), 0 or a positive integer.. + + + + + Looks up a localized string similar to A task may only be disposed if it is in a completion state (RanToCompletion, Faulted or Canceled).. + + + + + Looks up a localized string similar to It is invalid to specify TaskCreationOptions.LongRunning in calls to FromAsync.. + + + + + Looks up a localized string similar to It is invalid to specify TaskCreationOptions.PreferFairness in calls to FromAsync.. + + + + + Looks up a localized string similar to It is invalid to specify TaskCreationOptions.SelfReplicating in calls to FromAsync.. + + + + + Looks up a localized string similar to FromAsync was called with a TaskManager that had already shut down.. + + + + + Looks up a localized string similar to The tasks argument contains no tasks.. + + + + + Looks up a localized string similar to It is invalid to exclude specific continuation kinds for continuations off of multiple tasks.. + + + + + Looks up a localized string similar to The tasks argument included a null value.. + + + + + Looks up a localized string similar to RunSynchronously may not be called on a task that was already started.. + + + + + Looks up a localized string similar to RunSynchronously may not be called on a continuation task.. + + + + + Looks up a localized string similar to RunSynchronously may not be called on a task not bound to a delegate, such as the task returned from an asynchronous method.. + + + + + Looks up a localized string similar to RunSynchronously may not be called on a task that has already completed.. + + + + + Looks up a localized string similar to Start may not be called on a task that was already started.. + + + + + Looks up a localized string similar to Start may not be called on a continuation task.. + + + + + Looks up a localized string similar to Start may not be called on a task with null action.. + + + + + Looks up a localized string similar to Start may not be called on a promise-style task.. + + + + + Looks up a localized string similar to Start may not be called on a task that has completed.. + + + + + Looks up a localized string similar to The task has been disposed.. + + + + + Looks up a localized string similar to The tasks array included at least one null element.. + + + + + Looks up a localized string similar to The awaited task has not yet completed.. + + + + + Looks up a localized string similar to A task was canceled.. + + + + + Looks up a localized string similar to The exceptions collection was empty.. + + + + + Looks up a localized string similar to The exceptions collection included at least one null element.. + + + + + Looks up a localized string similar to A Task's exception(s) were not observed either by Waiting on the Task or accessing its Exception property. As a result, the unobserved exception was rethrown by the finalizer thread.. + + + + + Looks up a localized string similar to (Internal)Expected an Exception or an IEnumerable<Exception>. + + + + + Looks up a localized string similar to ExecuteTask may not be called for a task which was already executed.. + + + + + Looks up a localized string similar to ExecuteTask may not be called for a task which was previously queued to a different TaskScheduler.. + + + + + Looks up a localized string similar to The current SynchronizationContext may not be used as a TaskScheduler.. + + + + + Looks up a localized string similar to The TryExecuteTaskInline call to the underlying scheduler succeeded, but the task body was not invoked.. + + + + + Looks up a localized string similar to An exception was thrown by a TaskScheduler.. + + + + + Looks up a localized string similar to It is invalid to specify TaskCreationOptions.SelfReplicating for a Task<TResult>.. + + + + + Looks up a localized string similar to {Not yet computed}. + + + + + Looks up a localized string similar to A task's Exception may only be set directly if the task was created without a function.. + + + + + Looks up a localized string similar to An attempt was made to transition a task to a final state when it had already completed.. + + + + + Represents a thread-safe collection of keys and values. + + The type of the keys in the dictionary. + The type of the values in the dictionary. + + All public and protected members of are thread-safe and may be used + concurrently from multiple threads. + + + + + Initializes a new instance of the + class that is empty, has the default concurrency level, has the default initial capacity, and + uses the default comparer for the key type. + + + + + Initializes a new instance of the + class that is empty, has the specified concurrency level and capacity, and uses the default + comparer for the key type. + + The estimated number of threads that will update the + concurrently. + The initial number of elements that the + can contain. + is + less than 1. + is less than + 0. + + + + Initializes a new instance of the + class that contains elements copied from the specified , has the default concurrency + level, has the default initial capacity, and uses the default comparer for the key type. + + The whose elements are copied to + the new + . + is a null reference + (Nothing in Visual Basic). + contains one or more + duplicate keys. + + + + Initializes a new instance of the + class that is empty, has the specified concurrency level and capacity, and uses the specified + . + + The + implementation to use when comparing keys. + is a null reference + (Nothing in Visual Basic). + + + + Initializes a new instance of the + class that contains elements copied from the specified , has the default concurrency level, has the default + initial capacity, and uses the specified + . + + The whose elements are copied to + the new + . + The + implementation to use when comparing keys. + is a null reference + (Nothing in Visual Basic). -or- + is a null reference (Nothing in Visual Basic). + + + + + Initializes a new instance of the + class that contains elements copied from the specified , + has the specified concurrency level, has the specified initial capacity, and uses the specified + . + + The estimated number of threads that will update the + concurrently. + The whose elements are copied to the new + . + The implementation to use + when comparing keys. + + is a null reference (Nothing in Visual Basic). + -or- + is a null reference (Nothing in Visual Basic). + + + is less than 1. + + contains one or more duplicate keys. + + + + Initializes a new instance of the + class that is empty, has the specified concurrency level, has the specified initial capacity, and + uses the specified . + + The estimated number of threads that will update the + concurrently. + The initial number of elements that the + can contain. + The + implementation to use when comparing keys. + + is less than 1. -or- + is less than 0. + + is a null reference + (Nothing in Visual Basic). + + + + Attempts to add the specified key and value to the . + + The key of the element to add. + The value of the element to add. The value can be a null reference (Nothing + in Visual Basic) for reference types. + true if the key/value pair was added to the + successfully; otherwise, false. + is null reference + (Nothing in Visual Basic). + The + contains too many elements. + + + + Determines whether the contains the specified + key. + + The key to locate in the . + true if the contains an element with + the specified key; otherwise, false. + is a null reference + (Nothing in Visual Basic). + + + + Attempts to remove and return the the value with the specified key from the + . + + The key of the element to remove and return. + When this method returns, contains the object removed from the + or the default value of + if the operation failed. + true if an object was removed successfully; otherwise, false. + is a null reference + (Nothing in Visual Basic). + + + + Removes the specified key from the dictionary if it exists and returns its associated value. + If matchValue flag is set, the key will be removed only if is associated with a particular + value. + + The key to search for and remove if it exists. + The variable into which the removed value, if found, is stored. + Whether removal of the key is conditional on its value. + The conditional value to compare against if is true + + + + + Attempts to get the value associated with the specified key from the . + + The key of the value to get. + When this method returns, contains the object from + the + with the spedified key or the default value of + , if the operation failed. + true if the key was found in the ; + otherwise, false. + is a null reference + (Nothing in Visual Basic). + + + + Compares the existing value for the specified key with a specified value, and if they’re equal, + updates the key with a third value. + + The key whose value is compared with and + possibly replaced. + The value that replaces the value of the element with if the comparison results in equality. + The value that is compared to the value of the element with + . + true if the value with was equal to and replaced with ; otherwise, + false. + is a null + reference. + + + + Removes all keys and values from the . + + + + + Copies the elements of the to an array of + type , starting at the + specified array index. + + The one-dimensional array of type + that is the destination of the elements copied from the . The array must have zero-based indexing. + The zero-based index in at which copying + begins. + is a null reference + (Nothing in Visual Basic). + is less than + 0. + is equal to or greater than + the length of the . -or- The number of elements in the source + is greater than the available space from to the end of the destination + . + + + + Copies the key and value pairs stored in the to a + new array. + + A new array containing a snapshot of key and value pairs copied from the . + + + + Copy dictionary contents to an array - shared implementation between ToArray and CopyTo. + + Important: the caller must hold all locks in m_locks before calling CopyToPairs. + + + + + Copy dictionary contents to an array - shared implementation between ToArray and CopyTo. + + Important: the caller must hold all locks in m_locks before calling CopyToEntries. + + + + + Copy dictionary contents to an array - shared implementation between ToArray and CopyTo. + + Important: the caller must hold all locks in m_locks before calling CopyToObjects. + + + + Returns an enumerator that iterates through the . + An enumerator for the . + + The enumerator returned from the dictionary is safe to use concurrently with + reads and writes to the dictionary, however it does not represent a moment-in-time snapshot + of the dictionary. The contents exposed through the enumerator may contain modifications + made to the dictionary after was called. + + + + + Shared internal implementation for inserts and updates. + If key exists, we always return false; and if updateIfExists == true we force update with value; + If key doesn't exist, we always add value and return true; + + + + + Adds a key/value pair to the + if the key does not already exist. + + The key of the element to add. + The function used to generate a value for the key + is a null reference + (Nothing in Visual Basic). + is a null reference + (Nothing in Visual Basic). + The dictionary contains too many + elements. + The value for the key. This will be either the existing value for the key if the + key is already in the dictionary, or the new value for the key as returned by valueFactory + if the key was not in the dictionary. + + + + Adds a key/value pair to the + if the key does not already exist. + + The key of the element to add. + the value to be added, if the key does not already exist + is a null reference + (Nothing in Visual Basic). + The dictionary contains too many + elements. + The value for the key. This will be either the existing value for the key if the + key is already in the dictionary, or the new value if the key was not in the dictionary. + + + + Adds a key/value pair to the if the key does not already + exist, or updates a key/value pair in the if the key + already exists. + + The key to be added or whose value should be updated + The function used to generate a value for an absent key + The function used to generate a new value for an existing key + based on the key's existing value + is a null reference + (Nothing in Visual Basic). + is a null reference + (Nothing in Visual Basic). + is a null reference + (Nothing in Visual Basic). + The dictionary contains too many + elements. + The new value for the key. This will be either be the result of addValueFactory (if the key was + absent) or the result of updateValueFactory (if the key was present). + + + + Adds a key/value pair to the if the key does not already + exist, or updates a key/value pair in the if the key + already exists. + + The key to be added or whose value should be updated + The value to be added for an absent key + The function used to generate a new value for an existing key based on + the key's existing value + is a null reference + (Nothing in Visual Basic). + is a null reference + (Nothing in Visual Basic). + The dictionary contains too many + elements. + The new value for the key. This will be either be the result of addValueFactory (if the key was + absent) or the result of updateValueFactory (if the key was present). + + + + Adds the specified key and value to the . + + The object to use as the key of the element to add. + The object to use as the value of the element to add. + is a null reference + (Nothing in Visual Basic). + The dictionary contains too many + elements. + + An element with the same key already exists in the . + + + + Removes the element with the specified key from the . + + The key of the element to remove. + true if the element is successfully remove; otherwise false. This method also returns + false if + was not found in the original . + + is a null reference + (Nothing in Visual Basic). + + + + Adds the specified value to the + with the specified key. + + The + structure representing the key and value to add to the . + The of is null. + The + contains too many elements. + An element with the same key already exists in the + + + + + Determines whether the + contains a specific key and value. + + The + structure to locate in the . + true if the is found in the ; otherwise, false. + + + + Removes a key and value from the dictionary. + + The + structure representing the key and value to remove from the . + true if the key and value represented by is successfully + found and removed; otherwise, false. + The Key property of is a null reference (Nothing in Visual Basic). + + + Returns an enumerator that iterates through the . + An enumerator for the . + + The enumerator returned from the dictionary is safe to use concurrently with + reads and writes to the dictionary, however it does not represent a moment-in-time snapshot + of the dictionary. The contents exposed through the enumerator may contain modifications + made to the dictionary after was called. + + + + + Adds the specified key and value to the dictionary. + + The object to use as the key. + The object to use as the value. + is a null reference + (Nothing in Visual Basic). + The dictionary contains too many + elements. + + is of a type that is not assignable to the key type of the . -or- + is of a type that is not assignable to , + the type of values in the . + -or- A value with the same key already exists in the . + + + + + Gets whether the contains an + element with the specified key. + + The key to locate in the . + true if the contains + an element with the specified key; otherwise, false. + is a null reference + (Nothing in Visual Basic). + + + Provides an for the + . + An for the . + + + + Removes the element with the specified key from the . + + The key of the element to remove. + is a null reference + (Nothing in Visual Basic). + + + + Copies the elements of the to an array, starting + at the specified array index. + + The one-dimensional array that is the destination of the elements copied from + the . The array must have zero-based + indexing. + The zero-based index in at which copying + begins. + is a null reference + (Nothing in Visual Basic). + is less than + 0. + is equal to or greater than + the length of the . -or- The number of elements in the source + is greater than the available space from to the end of the destination + . + + + + Replaces the internal table with a larger one. To prevent multiple threads from resizing the + table as a result of races, the table of buckets that was deemed too small is passed in as + an argument to GrowTable(). GrowTable() obtains a lock, and then checks whether the bucket + table has been replaced in the meantime or not. + + Reference to the bucket table that was deemed too small. + + + + Computes the bucket and lock number for a particular key. + + + + + Acquires all locks for this hash table, and increments locksAcquired by the number + of locks that were successfully acquired. The locks are acquired in an increasing + order. + + + + + Acquires a contiguous range of locks for this hash table, and increments locksAcquired + by the number of locks that were successfully acquired. The locks are acquired in an + increasing order. + + + + + Releases a contiguous range of locks. + + + + + Gets a collection containing the keys in the dictionary. + + + + + Gets a collection containing the values in the dictionary. + + + + + A helper method for asserts. + + + + + Get the data array to be serialized + + + + + Construct the dictionary from a previously seiralized one + + + + + Gets or sets the value associated with the specified key. + + The key of the value to get or set. + The value associated with the specified key. If the specified key is not found, a get + operation throws a + , and a set operation creates a new + element with the specified key. + is a null reference + (Nothing in Visual Basic). + The property is retrieved and + + does not exist in the collection. + + + + Gets the number of key/value pairs contained in the . + + The dictionary contains too many + elements. + The number of key/value paris contained in the . + Count has snapshot semantics and represents the number of items in the + at the moment when Count was accessed. + + + + Gets a value that indicates whether the is empty. + + true if the is empty; otherwise, + false. + + + + Gets a collection containing the keys in the . + + An containing the keys in the + . + + + + Gets a collection containing the values in the . + + An containing the values in + the + . + + + + Gets a value indicating whether the dictionary is read-only. + + true if the is + read-only; otherwise, false. For , this property always returns + false. + + + + Gets a value indicating whether the has a fixed size. + + true if the has a + fixed size; otherwise, false. For , this property always + returns false. + + + + Gets a value indicating whether the is read-only. + + true if the is + read-only; otherwise, false. For , this property always + returns false. + + + + Gets an containing the keys of the . + + An containing the keys of the . + + + + Gets an containing the values in the . + + An containing the values in the . + + + + Gets or sets the value associated with the specified key. + + The key of the value to get or set. + The value associated with the specified key, or a null reference (Nothing in Visual Basic) + if is not in the dictionary or is of a type that is + not assignable to the key type of the . + is a null reference + (Nothing in Visual Basic). + + A value is being assigned, and is of a type that is not assignable to the + key type of the . -or- A value is being + assigned, and is of a type that is not assignable to the value type + of the + + + + + Gets a value indicating whether access to the is + synchronized with the SyncRoot. + + true if access to the is synchronized + (thread safe); otherwise, false. For , this property always + returns false. + + + + Gets an object that can be used to synchronize access to the . This property is not supported. + + The SyncRoot property is not supported. + + + + The number of concurrent writes for which to optimize by default. + + + + + A node in a singly-linked list representing a particular hash table bucket. + + + + + A private class to represent enumeration over the dictionary that implements the + IDictionaryEnumerator interface. + + + + Throws the exception on the ThreadPool. + The exception to propagate. + The target context on which to propagate the exception. Null to use the ThreadPool. + + + Copies the exception's stack trace so its stack trace isn't overwritten. + The exception to prepare. + + + + Provides a builder for asynchronous methods that return . + This type is intended for compiler use only. + + + AsyncTaskMethodBuilder is a value type, and thus it is copied by value. + Prior to being copied, one of its Task, SetResult, or SetException members must be accessed, + or else the copies may end up building distinct Task instances. + + + + Represents an asynchronous method builder. + + + A cached VoidTaskResult task used for builders that complete synchronously. + + + The generic builder object to which this non-generic instance delegates. + + + Initializes a new . + The initialized . + + + Initiates the builder's execution with the associated state machine. + Specifies the type of the state machine. + The state machine instance, passed by reference. + + + Associates the builder with the state machine it represents. + The heap-allocated state machine object. + The argument was null (Nothing in Visual Basic). + The builder is incorrectly initialized. + + + Perform any initialization necessary prior to lifting the builder to the heap. + + + + Schedules the specified state machine to be pushed forward when the specified awaiter completes. + + Specifies the type of the awaiter. + Specifies the type of the state machine. + The awaiter. + The state machine. + + + + Schedules the specified state machine to be pushed forward when the specified awaiter completes. + + Specifies the type of the awaiter. + Specifies the type of the state machine. + The awaiter. + The state machine. + + + + Completes the in the + RanToCompletion state. + + The builder is not initialized. + The task has already completed. + + + + Completes the in the + Faulted state with the specified exception. + + The to use to fault the task. + The argument is null (Nothing in Visual Basic). + The builder is not initialized. + The task has already completed. + + + + Called by the debugger to request notification when the first wait operation + (await, Wait, Result, etc.) on this builder's task completes. + + + true to enable notification; false to disable a previously set notification. + + + + Gets the for this builder. + The representing the builder's asynchronous operation. + The builder is not initialized. + + + + Gets an object that may be used to uniquely identify this builder to the debugger. + + + This property lazily instantiates the ID in a non-thread-safe manner. + It must only be used by the debugger, and only in a single-threaded manner + when no other threads are in the middle of accessing this property or this.Task. + + + + Holds state related to the builder's IAsyncStateMachine. + This is a mutable struct. Be very delicate with it. + + + A reference to the heap-allocated state machine object associated with this builder. + + + Initiates the builder's execution with the associated state machine. + Specifies the type of the state machine. + The state machine instance, passed by reference. + The argument is null (Nothing in Visual Basic). + + + Associates the builder with the state machine it represents. + The heap-allocated state machine object. + The argument was null (Nothing in Visual Basic). + The builder is incorrectly initialized. + + + + Gets the Action to use with an awaiter's OnCompleted or UnsafeOnCompleted method. + On first invocation, the supplied state machine will be boxed. + + Specifies the type of the method builder used. + Specifies the type of the state machine used. + The builder. + The state machine. + An Action to provide to the awaiter. + + + Provides the ability to invoke a state machine's MoveNext method under a supplied ExecutionContext. + + + The context with which to run MoveNext. + + + The state machine whose MoveNext method should be invoked. + + + Initializes the runner. + The context with which to run MoveNext. + + + Invokes MoveNext under the provided context. + + + Cached delegate used with ExecutionContext.Run. + + + Invokes the MoveNext method on the supplied IAsyncStateMachine. + The IAsyncStateMachine machine instance. + + + + Provides a builder for asynchronous methods that return void. + This type is intended for compiler use only. + + + + The synchronization context associated with this operation. + + + State related to the IAsyncStateMachine. + + + An object used by the debugger to uniquely identify this builder. Lazily initialized. + + + Temporary support for disabling crashing if tasks go unobserved. + + + Registers with UnobservedTaskException to suppress exception crashing. + + + Non-zero if PreventUnobservedTaskExceptions has already been invoked. + + + Initializes a new . + The initialized . + + + Initializes the . + The synchronizationContext associated with this operation. This may be null. + + + Initiates the builder's execution with the associated state machine. + Specifies the type of the state machine. + The state machine instance, passed by reference. + The argument was null (Nothing in Visual Basic). + + + Associates the builder with the state machine it represents. + The heap-allocated state machine object. + The argument was null (Nothing in Visual Basic). + The builder is incorrectly initialized. + + + Perform any initialization necessary prior to lifting the builder to the heap. + + + + Schedules the specified state machine to be pushed forward when the specified awaiter completes. + + Specifies the type of the awaiter. + Specifies the type of the state machine. + The awaiter. + The state machine. + + + + Schedules the specified state machine to be pushed forward when the specified awaiter completes. + + Specifies the type of the awaiter. + Specifies the type of the state machine. + The awaiter. + The state machine. + + + Completes the method builder successfully. + + + Faults the method builder with an exception. + The exception that is the cause of this fault. + The argument is null (Nothing in Visual Basic). + The builder is not initialized. + + + Notifies the current synchronization context that the operation completed. + + + + Gets an object that may be used to uniquely identify this builder to the debugger. + + + This property lazily instantiates the ID in a non-thread-safe manner. + It must only be used by the debugger and only in a single-threaded manner. + + + + + Provides a builder for asynchronous methods that return . + This type is intended for compiler use only. + + + AsyncTaskMethodBuilder{TResult} is a value type, and thus it is copied by value. + Prior to being copied, one of its Task, SetResult, or SetException members must be accessed, + or else the copies may end up building distinct Task instances. + + + + A cached task for default(TResult). + + + State related to the IAsyncStateMachine. + + + The lazily-initialized task. + Must be named m_task for debugger step-over to work correctly. + + + The lazily-initialized task completion source. + + + Temporary support for disabling crashing if tasks go unobserved. + + + Initializes a new . + The initialized . + + + Initiates the builder's execution with the associated state machine. + Specifies the type of the state machine. + The state machine instance, passed by reference. + + + Associates the builder with the state machine it represents. + The heap-allocated state machine object. + The argument was null (Nothing in Visual Basic). + The builder is incorrectly initialized. + + + Perform any initialization necessary prior to lifting the builder to the heap. + + + + Schedules the specified state machine to be pushed forward when the specified awaiter completes. + + Specifies the type of the awaiter. + Specifies the type of the state machine. + The awaiter. + The state machine. + + + + Schedules the specified state machine to be pushed forward when the specified awaiter completes. + + Specifies the type of the awaiter. + Specifies the type of the state machine. + The awaiter. + The state machine. + + + + Completes the in the + RanToCompletion state with the specified result. + + The result to use to complete the task. + The task has already completed. + + + + Completes the builder by using either the supplied completed task, or by completing + the builder's previously accessed task using default(TResult). + + A task already completed with the value default(TResult). + The task has already completed. + + + + Completes the in the + Faulted state with the specified exception. + + The to use to fault the task. + The argument is null (Nothing in Visual Basic). + The task has already completed. + + + + Called by the debugger to request notification when the first wait operation + (await, Wait, Result, etc.) on this builder's task completes. + + + true to enable notification; false to disable a previously set notification. + + + This should only be invoked from within an asynchronous method, + and only by the debugger. + + + + + Gets a task for the specified result. This will either + be a cached or new task, never null. + + The result for which we need a task. + The completed task containing the result. + + + Gets the lazily-initialized TaskCompletionSource. + + + Gets the for this builder. + The representing the builder's asynchronous operation. + + + + Gets an object that may be used to uniquely identify this builder to the debugger. + + + This property lazily instantiates the ID in a non-thread-safe manner. + It must only be used by the debugger, and only in a single-threaded manner + when no other threads are in the middle of accessing this property or this.Task. + + + + Provides a base class used to cache tasks of a specific return type. + Specifies the type of results the cached tasks return. + + + + A singleton cache for this result type. + This may be null if there are no cached tasks for this TResult. + + + + Creates a non-disposable task. + The result for the task. + The cacheable task. + + + Creates a cache. + A task cache for this result type. + + + Gets a cached task if one exists. + The result for which we want a cached task. + A cached task if one exists; otherwise, null. + + + Provides a cache for Boolean tasks. + + + A true task. + + + A false task. + + + Gets a cached task for the Boolean result. + true or false + A cached task for the Boolean result. + + + Provides a cache for zero Int32 tasks. + + + The minimum value, inclusive, for which we want a cached task. + + + The maximum value, exclusive, for which we want a cached task. + + + The cache of Task{Int32}. + + + Creates an array of cached tasks for the values in the range [INCLUSIVE_MIN,EXCLUSIVE_MAX). + + + Gets a cached task for the zero Int32 result. + The integer value + A cached task for the Int32 result or null if not cached. + + + + Represents state machines generated for asynchronous methods. + This type is intended for compiler use only. + + + + Moves the state machine to its next state. + + + Configures the state machine with a heap-allocated replica. + The heap-allocated replica. + + + + Represents an awaiter used to schedule continuations when an await operation completes. + + + + + Represents an operation that will schedule continuations when the operation completes. + + + + Schedules the continuation action to be invoked when the instance completes. + The action to invoke when the operation completes. + The argument is null (Nothing in Visual Basic). + + + Schedules the continuation action to be invoked when the instance completes. + The action to invoke when the operation completes. + The argument is null (Nothing in Visual Basic). + Unlike OnCompleted, UnsafeOnCompleted need not propagate ExecutionContext information. + + + Used with Task(of void) + + + + An interface similar to the one added in .NET 4.0. + + + + The exception that is thrown in a thread upon cancellation of an operation that the thread was executing. + + + Initializes the exception. + + + Initializes the exception. + The error message that explains the reason for the exception. + + + Initializes the exception. + The error message that explains the reason for the exception. + The exception that is the cause of the current exception. + + + Initializes the exception. + A cancellation token associated with the operation that was canceled. + + + Initializes the exception. + The error message that explains the reason for the exception. + A cancellation token associated with the operation that was canceled. + + + Initializes the exception. + The error message that explains the reason for the exception. + The exception that is the cause of the current exception. + A cancellation token associated with the operation that was canceled. + + + Gets a token associated with the operation that was canceled. + + + + A dummy replacement for the .NET internal class StackCrawlMark. + + + + + Propogates notification that operations should be canceled. + + + + A may be created directly in an unchangeable canceled or non-canceled state + using the CancellationToken's constructors. However, to have a CancellationToken that can change + from a non-canceled to a canceled state, + CancellationTokenSource must be used. + CancellationTokenSource exposes the associated CancellationToken that may be canceled by the source through its + Token property. + + + Once canceled, a token may not transition to a non-canceled state, and a token whose + is false will never change to one that can be canceled. + + + All members of this struct are thread-safe and may be used concurrently from multiple threads. + + + + + + Internal constructor only a CancellationTokenSource should create a CancellationToken + + + + + Initializes the CancellationToken. + + + The canceled state for the token. + + + Tokens created with this constructor will remain in the canceled state specified + by the parameter. If is false, + both and will be false. + If is true, + both and will be true. + + + + + Registers a delegate that will be called when this CancellationToken is canceled. + + + + If this token is already in the canceled state, the + delegate will be run immediately and synchronously. Any exception the delegate generates will be + propogated out of this method call. + + + The delegate to be executed when the CancellationToken is canceled. + The instance that can + be used to deregister the callback. + is null. + The associated CancellationTokenSource has been disposed. + + + + Registers a delegate that will be called when this + CancellationToken is canceled. + + + + If this token is already in the canceled state, the + delegate will be run immediately and synchronously. Any exception the delegate generates will be + propogated out of this method call. + + + The delegate to be executed when the CancellationToken is canceled. + A Boolean value that indicates whether to capture + the current SynchronizationContext and use it + when invoking the . + The instance that can + be used to deregister the callback. + is null. + The associated CancellationTokenSource has been disposed. + + + + Registers a delegate that will be called when this + CancellationToken is canceled. + + + + If this token is already in the canceled state, the + delegate will be run immediately and synchronously. Any exception the delegate generates will be + propogated out of this method call. + + + The delegate to be executed when the CancellationToken is canceled. + The state to pass to the when the delegate is invoked. This may be null. + The instance that can + be used to deregister the callback. + is null. + The associated CancellationTokenSource has been disposed. + + + + Registers a delegate that will be called when this + CancellationToken is canceled. + + + + If this token is already in the canceled state, the + delegate will be run immediately and synchronously. Any exception the delegate generates will be + propogated out of this method call. + + + The delegate to be executed when the CancellationToken is canceled. + The state to pass to the when the delegate is invoked. This may be null. + A Boolean value that indicates whether to capture + the current SynchronizationContext and use it + when invoking the . + The instance that can + be used to deregister the callback. + is null. + The associated CancellationTokenSource has been disposed. + + + + Determines whether the current CancellationToken instance is equal to the + specified token. + + The other CancellationToken to which to compare this + instance. + True if the instances are equal; otherwise, false. Two tokens are equal if they are associated + with the same CancellationTokenSource or if they were both constructed + from public CancellationToken constructors and their values are equal. + + + + Determines whether the current CancellationToken instance is equal to the + specified . + + The other object to which to compare this instance. + True if is a CancellationToken + and if the two instances are equal; otherwise, false. Two tokens are equal if they are associated + with the same CancellationTokenSource or if they were both constructed + from public CancellationToken constructors and their values are equal. + An associated CancellationTokenSource has been disposed. + + + + Serves as a hash function for a CancellationToken. + + A hash code for the current CancellationToken instance. + + + + Determines whether two CancellationToken instances are equal. + + The first instance. + The second instance. + True if the instances are equal; otherwise, false. + An associated CancellationTokenSource has been disposed. + + + + Determines whether two CancellationToken instances are not equal. + + The first instance. + The second instance. + True if the instances are not equal; otherwise, false. + An associated CancellationTokenSource has been disposed. + + + + Throws a OperationCanceledException if + this token has had cancellation requested. + + + This method provides functionality equivalent to: + + if (token.IsCancellationRequested) + throw new OperationCanceledException(token); + + + The token has had cancellation requested. + The associated CancellationTokenSource has been disposed. + + + + Returns an empty CancellationToken value. + + + The value returned by this property will be non-cancelable by default. + + + + + Gets whether cancellation has been requested for this token. + + Whether cancellation has been requested for this token. + + + This property indicates whether cancellation has been requested for this token, + either through the token initially being construted in a canceled state, or through + calling Cancel + on the token's associated . + + + If this property is true, it only guarantees that cancellation has been requested. + It does not guarantee that every registered handler + has finished executing, nor that cancellation requests have finished propagating + to all registered handlers. Additional synchronization may be required, + particularly in situations where related objects are being canceled concurrently. + + + + + + Gets whether this token is capable of being in the canceled state. + + + If CanBeCanceled returns false, it is guaranteed that the token will never transition + into a canceled state, meaning that will never + return true. + + + + + Gets a that is signaled when the token is canceled. + + Accessing this property causes a WaitHandle + to be instantiated. It is preferable to only use this property when necessary, and to then + dispose the associated instance at the earliest opportunity (disposing + the source will dispose of this allocated handle). The handle should not be closed or disposed directly. + + The associated CancellationTokenSource has been disposed. + + + + Represents a callback delegate that has been registered with a CancellationToken. + + + To unregister a callback, dispose the corresponding Registration instance. + + + + + Attempts to deregister the item. If it's already being run, this may fail. + Entails a full memory fence. + + True if the callback was found and deregistered, false otherwise. + + + + Disposes of the registration and unregisters the target callback from the associated + CancellationToken. + If the target callback is currently executing this method will wait until it completes, except + in the degenerate cases where a callback method deregisters itself. + + + + + Determines whether two CancellationTokenRegistration + instances are equal. + + The first instance. + The second instance. + True if the instances are equal; otherwise, false. + + + + Determines whether two CancellationTokenRegistration instances are not equal. + + The first instance. + The second instance. + True if the instances are not equal; otherwise, false. + + + + Determines whether the current CancellationTokenRegistration instance is equal to the + specified . + + The other object to which to compare this instance. + True, if both this and are equal. False, otherwise. + Two CancellationTokenRegistration instances are equal if + they both refer to the output of a single call to the same Register method of a + CancellationToken. + + + + + Determines whether the current CancellationToken instance is equal to the + specified . + + The other CancellationTokenRegistration to which to compare this instance. + True, if both this and are equal. False, otherwise. + Two CancellationTokenRegistration instances are equal if + they both refer to the output of a single call to the same Register method of a + CancellationToken. + + + + + Serves as a hash function for a CancellationTokenRegistration.. + + A hash code for the current CancellationTokenRegistration instance. + + + + Signals to a that it should be canceled. + + + + is used to instantiate a + (via the source's Token property) + that can be handed to operations that wish to be notified of cancellation or that can be used to + register asynchronous operations for cancellation. That token may have cancellation requested by + calling to the source's Cancel + method. + + + All members of this class, except Dispose, are thread-safe and may be used + concurrently from multiple threads. + + + + + The ID of the thread currently executing the main body of CTS.Cancel() + this helps us to know if a call to ctr.Dispose() is running 'within' a cancellation callback. + This is updated as we move between the main thread calling cts.Cancel() and any syncContexts that are used to + actually run the callbacks. + + + + Initializes the . + + + + + Communicates a request for cancellation. + + + + The associated will be + notified of the cancellation and will transition to a state where + IsCancellationRequested returns true. + Any callbacks or cancelable operations + registered with the will be executed. + + + Cancelable operations and callbacks registered with the token should not throw exceptions. + However, this overload of Cancel will aggregate any exceptions thrown into a , + such that one callback throwing an exception will not prevent other registered callbacks from being executed. + + + The that was captured when each callback was registered + will be reestablished when the callback is invoked. + + + An aggregate exception containing all the exceptions thrown + by the registered callbacks on the associated . + This has been disposed. + + + + Communicates a request for cancellation. + + + + The associated will be + notified of the cancellation and will transition to a state where + IsCancellationRequested returns true. + Any callbacks or cancelable operations + registered with the will be executed. + + + Cancelable operations and callbacks registered with the token should not throw exceptions. + If is true, an exception will immediately propagate out of the + call to Cancel, preventing the remaining callbacks and cancelable operations from being processed. + If is false, this overload will aggregate any + exceptions thrown into a , + such that one callback throwing an exception will not prevent other registered callbacks from being executed. + + + The that was captured when each callback was registered + will be reestablished when the callback is invoked. + + + Specifies whether exceptions should immediately propagate. + An aggregate exception containing all the exceptions thrown + by the registered callbacks on the associated . + This has been disposed. + + + + Releases the resources used by this . + + + This method is not thread-safe for any other concurrent calls. + + + + + Throws an exception if the source has been disposed. + + + + + InternalGetStaticSource() + + Whether the source should be set. + A static source to be shared among multiple tokens. + + + + Registers a callback object. If cancellation has already occurred, the + callback will have been run by the time this method returns. + + + + + + + + + + Invoke the Canceled event. + + + The handlers are invoked synchronously in LIFO order. + + + + + Creates a CancellationTokenSource that will be in the canceled state + when any of the source tokens are in the canceled state. + + The first CancellationToken to observe. + The second CancellationToken to observe. + A CancellationTokenSource that is linked + to the source tokens. + A CancellationTokenSource associated with + one of the source tokens has been disposed. + + + + Creates a CancellationTokenSource that will be in the canceled state + when any of the source tokens are in the canceled state. + + The CancellationToken instances to observe. + A CancellationTokenSource that is linked + to the source tokens. + is null. + A CancellationTokenSource associated with + one of the source tokens has been disposed. + + + + Gets whether cancellation has been requested for this CancellationTokenSource. + + Whether cancellation has been requested for this CancellationTokenSource. + + + This property indicates whether cancellation has been requested for this token source, such as + due to a call to its + Cancel method. + + + If this property returns true, it only guarantees that cancellation has been requested. It does not + guarantee that every handler registered with the corresponding token has finished executing, nor + that cancellation requests have finished propagating to all registered handlers. Additional + synchronization may be required, particularly in situations where related objects are being + canceled concurrently. + + + + + + A simple helper to determine whether cancellation has finished. + + + + + A simple helper to determine whether disposal has occured. + + + + + The ID of the thread that is running callbacks. + + + + + Gets the CancellationToken + associated with this . + + The CancellationToken + associated with this . + The token source has been + disposed. + + + + + + + + + + + + + + The currently executing callback + + + + + A helper class for collating the various bits of information required to execute + cancellation callbacks. + + + + + InternalExecuteCallbackSynchronously_GeneralPath + This will be called on the target synchronization context, however, we still need to restore the required execution context + + + + + A sparsely populated array. Elements can be sparse and some null, but this allows for + lock-free additions and growth, and also for constant time removal (by nulling out). + + The kind of elements contained within. + + + + Allocates a new array with the given initial size. + + How many array slots to pre-allocate. + + + + Adds an element in the first available slot, beginning the search from the tail-to-head. + If no slots are available, the array is grown. The method doesn't return until successful. + + The element to add. + Information about where the add happened, to enable O(1) deregistration. + + + + The tail of the doubly linked list. + + + + + A struct to hold a link to the exact spot in an array an element was inserted, enabling + constant time removal later on. + + + + + A fragment of a sparsely populated array, doubly linked. + + The kind of elements contained within. + + + + Provides lazy initialization routines. + + + These routines avoid needing to allocate a dedicated, lazy-initialization instance, instead using + references to ensure targets have been initialized as they are accessed. + + + + + Initializes a target reference type with the type's default constructor if the target has not + already been initialized. + + The refence type of the reference to be initialized. + A reference of type to initialize if it has not + already been initialized. + The initialized reference of type . + Type does not have a default + constructor. + + Permissions to access the constructor of type were missing. + + + + This method may only be used on reference types. To ensure initialization of value + types, see other overloads of EnsureInitialized. + + + This method may be used concurrently by multiple threads to initialize . + In the event that multiple threads access this method concurrently, multiple instances of + may be created, but only one will be stored into . In such an occurrence, this method will not dispose of the + objects that were not stored. If such objects must be disposed, it is up to the caller to determine + if an object was not used and to then dispose of the object appropriately. + + + + + + Initializes a target reference type using the specified function if it has not already been + initialized. + + The reference type of the reference to be initialized. + The reference of type to initialize if it has not + already been initialized. + The invoked to initialize the + reference. + The initialized reference of type . + Type does not have a + default constructor. + returned + null. + + + This method may only be used on reference types, and may + not return a null reference (Nothing in Visual Basic). To ensure initialization of value types or + to allow null reference types, see other overloads of EnsureInitialized. + + + This method may be used concurrently by multiple threads to initialize . + In the event that multiple threads access this method concurrently, multiple instances of + may be created, but only one will be stored into . In such an occurrence, this method will not dispose of the + objects that were not stored. If such objects must be disposed, it is up to the caller to determine + if an object was not used and to then dispose of the object appropriately. + + + + + + Initialize the target using the given delegate (slow path). + + The reference type of the reference to be initialized. + The variable that need to be initialized + The delegate that will be executed to initialize the target + The initialized variable + + + + Initializes a target reference or value type with its default constructor if it has not already + been initialized. + + The type of the reference to be initialized. + A reference or value of type to initialize if it + has not already been initialized. + A reference to a boolean that determines whether the target has already + been initialized. + A reference to an object used as the mutually exclusive lock for initializing + . + The initialized value of type . + + + + Initializes a target reference or value type with a specified function if it has not already been + initialized. + + The type of the reference to be initialized. + A reference or value of type to initialize if it + has not already been initialized. + A reference to a boolean that determines whether the target has already + been initialized. + A reference to an object used as the mutually exclusive lock for initializing + . + The invoked to initialize the + reference or value. + The initialized value of type . + + + + Ensure the target is initialized and return the value (slow path). This overload permits nulls + and also works for value type targets. Uses the supplied function to create the value. + + The type of target. + A reference to the target to be initialized. + A reference to a location tracking whether the target has been initialized. + A reference to a location containing a mutual exclusive lock. + + The to invoke in order to produce the lazily-initialized value. + + The initialized object. + + + + Provides a slimmed down version of . + + + All public and protected members of are thread-safe and may be used + concurrently from multiple threads, with the exception of Dispose, which + must only be used when all other operations on the have + completed, and Reset, which should only be used when no other threads are + accessing the event. + + + + + Initializes a new instance of the + class with an initial state of nonsignaled. + + + + + Initializes a new instance of the + class with a Boolen value indicating whether to set the intial state to signaled. + + true to set the initial state signaled; false to set the initial state + to nonsignaled. + + + + Initializes a new instance of the + class with a Boolen value indicating whether to set the intial state to signaled and a specified + spin count. + + true to set the initial state to signaled; false to set the initial state + to nonsignaled. + The number of spin waits that will occur before falling back to a true + wait. + is less than + 0 or greater than the maximum allowed value. + + + + Initializes the internal state of the event. + + Whether the event is set initially or not. + The spin count that decides when the event will block. + + + + Helper to ensure the lock object is created before first use. + + + + + This method lazily initializes the event object. It uses CAS to guarantee that + many threads racing to call this at once don't result in more than one event + being stored and used. The event will be signaled or unsignaled depending on + the state of the thin-event itself, with synchronization taken into account. + + True if a new event was created and stored, false otherwise. + + + + Sets the state of the event to signaled, which allows one or more threads waiting on the event to + proceed. + + + + + Private helper to actually perform the Set. + + Indicates whether we are calling Set() during cancellation. + The object has been canceled. + + + + Sets the state of the event to nonsignaled, which causes threads to block. + + + Unlike most of the members of , is not + thread-safe and may not be used concurrently with other members of this instance. + + + + + Blocks the current thread until the current is set. + + + The maximum number of waiters has been exceeded. + + + The caller of this method blocks indefinitely until the current instance is set. The caller will + return immediately if the event is currently in a set state. + + + + + Blocks the current thread until the current receives a signal, + while observing a . + + The to + observe. + + The maximum number of waiters has been exceeded. + + was + canceled. + + The caller of this method blocks indefinitely until the current instance is set. The caller will + return immediately if the event is currently in a set state. + + + + + Blocks the current thread until the current is set, using a + to measure the time interval. + + A that represents the number of milliseconds + to wait, or a that represents -1 milliseconds to wait indefinitely. + + true if the was set; otherwise, + false. + is a negative + number other than -1 milliseconds, which represents an infinite time-out -or- timeout is greater + than . + + The maximum number of waiters has been exceeded. + + + + + Blocks the current thread until the current is set, using a + to measure the time interval, while observing a . + + A that represents the number of milliseconds + to wait, or a that represents -1 milliseconds to wait indefinitely. + + The to + observe. + true if the was set; otherwise, + false. + is a negative + number other than -1 milliseconds, which represents an infinite time-out -or- timeout is greater + than . + was canceled. + + The maximum number of waiters has been exceeded. + + + + + Blocks the current thread until the current is set, using a + 32-bit signed integer to measure the time interval. + + The number of milliseconds to wait, or (-1) to wait indefinitely. + true if the was set; otherwise, + false. + is a + negative number other than -1, which represents an infinite time-out. + + The maximum number of waiters has been exceeded. + + + + + Blocks the current thread until the current is set, using a + 32-bit signed integer to measure the time interval, while observing a . + + The number of milliseconds to wait, or (-1) to wait indefinitely. + The to + observe. + true if the was set; otherwise, + false. + is a + negative number other than -1, which represents an infinite time-out. + + The maximum number of waiters has been exceeded. + + was canceled. + + + + Releases all resources used by the current instance of . + + + Unlike most of the members of , is not + thread-safe and may not be used concurrently with other members of this instance. + + + + + When overridden in a derived class, releases the unmanaged resources used by the + , and optionally releases the managed resources. + + true to release both managed and unmanaged resources; + false to release only unmanaged resources. + + Unlike most of the members of , is not + thread-safe and may not be used concurrently with other members of this instance. + + + + + Throw ObjectDisposedException if the MRES is disposed + + + + + Private helper method to wake up waiters when a cancellationToken gets canceled. + + + + + Private helper method for updating parts of a bit-string state value. + Mainly called from the IsSet and Waiters properties setters + + + Note: the parameter types must be int as CompareExchange cannot take a Uint + + The new value + The mask used to set the bits + + + + Private helper method - performs Mask and shift, particular helpful to extract a field from a packed word. + eg ExtractStatePortionAndShiftRight(0x12345678, 0xFF000000, 24) => 0x12, ie extracting the top 8-bits as a simple integer + + ?? is there a common place to put this rather than being private to MRES? + + + + + + + + + Performs a Mask operation, but does not perform the shift. + This is acceptable for boolean values for which the shift is unnecessary + eg (val & Mask) != 0 is an appropriate way to extract a boolean rather than using + ((val & Mask) >> shiftAmount) == 1 + + ?? is there a common place to put this rather than being private to MRES? + + + + + + + Helper function to measure and update the wait time + + The first time (in Ticks) observed when the wait started. + The orginal wait timeoutout in milliseconds. + The new wait time in milliseconds, -1 if the time expired, -2 if overflow in counters + has occurred. + + + + Gets the underlying object for this . + + The underlying event object fore this . + + Accessing this property forces initialization of an underlying event object if one hasn't + already been created. To simply wait on this , + the public Wait methods should be preferred. + + + + + Gets whether the event is set. + + true if the event has is set; otherwise, false. + + + + Gets the number of spin waits that will be occur before falling back to a true wait. + + + + + How many threads are waiting. + + + + + Provides support for spin-based waiting. + + + + encapsulates common spinning logic. On single-processor machines, yields are + always used instead of busy waits, and on computers with Intel™ processors employing Hyper-Threading™ + technology, it helps to prevent hardware thread starvation. SpinWait encapsulates a good mixture of + spinning and true yielding. + + + is a value type, which means that low-level code can utilize SpinWait without + fear of unnecessary allocation overheads. SpinWait is not generally useful for ordinary applications. + In most cases, you should use the synchronization classes provided by the .NET Framework, such as + . For most purposes where spin waiting is required, however, + the type should be preferred over the System.Threading.Thread.SpinWait method. + + + While SpinWait is designed to be used in concurrent applications, it is not designed to be + used from multiple threads concurrently. SpinWait's members are not thread-safe. If multiple + threads must spin, each should use its own instance of SpinWait. + + + + + + Performs a single spin. + + + This is typically called in a loop, and may change in behavior based on the number of times a + has been called thus far on this instance. + + + + + Resets the spin counter. + + + This makes and behave as though no calls + to had been issued on this instance. If a instance + is reused many times, it may be useful to reset it to avoid yielding too soon. + + + + + Spins until the specified condition is satisfied. + + A delegate to be executed over and over until it returns true. + The argument is null. + + + + Spins until the specified condition is satisfied or until the specified timeout is expired. + + A delegate to be executed over and over until it returns true. + + A that represents the number of milliseconds to wait, + or a TimeSpan that represents -1 milliseconds to wait indefinitely. + True if the condition is satisfied within the timeout; otherwise, false + The argument is null. + is a negative number + other than -1 milliseconds, which represents an infinite time-out -or- timeout is greater than + . + + + + Spins until the specified condition is satisfied or until the specified timeout is expired. + + A delegate to be executed over and over until it returns true. + The number of milliseconds to wait, or (-1) to wait indefinitely. + True if the condition is satisfied within the timeout; otherwise, false + The argument is null. + is a + negative number other than -1, which represents an infinite time-out. + + + + Gets the number of times has been called on this instance. + + + + + Gets whether the next call to will yield the processor, triggering a + forced context switch. + + Whether the next call to will yield the processor, triggering a + forced context switch. + + On a single-CPU machine, always yields the processor. On machines with + multiple CPUs, may yield after an unspecified number of calls. + + + + + A helper class to get the number of preocessors, it updates the numbers of processors every sampling interval + + + + + Gets the number of available processors + + + + + Gets whether the current machine has only a single processor. + + + + + Represents an asynchronous operation that produces a result at some time in the future. + + + The type of the result produced by this . + + + + instances may be created in a variety of ways. The most common approach is by + using the task's property to retrieve a instance that can be used to create tasks for several + purposes. For example, to create a that runs a function, the factory's StartNew + method may be used: + + // C# + var t = Task<int>.Factory.StartNew(() => GenerateResult()); + - or - + var t = Task.Factory.StartNew(() => GenerateResult()); + + ' Visual Basic + Dim t = Task<int>.Factory.StartNew(Function() GenerateResult()) + - or - + Dim t = Task.Factory.StartNew(Function() GenerateResult()) + + + + The class also provides constructors that initialize the task but that do not + schedule it for execution. For performance reasons, the StartNew method should be the + preferred mechanism for creating and scheduling computational tasks, but for scenarios where creation + and scheduling must be separated, the constructors may be used, and the task's + Start + method may then be used to schedule the task for execution at a later time. + + + All members of , except for + Dispose, are thread-safe + and may be used from multiple threads concurrently. + + + + + + Represents an asynchronous operation. + + + + instances may be created in a variety of ways. The most common approach is by + using the Task type's property to retrieve a instance that can be used to create tasks for several + purposes. For example, to create a that runs an action, the factory's StartNew + method may be used: + + // C# + var t = Task.Factory.StartNew(() => DoAction()); + + ' Visual Basic + Dim t = Task.Factory.StartNew(Function() DoAction()) + + + + The class also provides constructors that initialize the Task but that do not + schedule it for execution. For performance reasons, TaskFactory's StartNew method should be the + preferred mechanism for creating and scheduling computational tasks, but for scenarios where creation + and scheduling must be separated, the constructors may be used, and the task's + method may then be used to schedule the task for execution at a later time. + + + All members of , except for , are thread-safe + and may be used from multiple threads concurrently. + + + For operations that return values, the class + should be used. + + + For developers implementing custom debuggers, several internal and private members of Task may be + useful (these may change from release to release). The Int32 m_taskId field serves as the backing + store for the property, however accessing this field directly from a debugger may be + more efficient than accessing the same value through the property's getter method (the + s_taskIdCounter Int32 counter is used to retrieve the next available ID for a Task). Similarly, the + Int32 m_stateFlags field stores information about the current lifecycle stage of the Task, + information also accessible through the property. The m_action System.Object + field stores a reference to the Task's delegate, and the m_stateObject System.Object field stores the + async state passed to the Task by the developer. Finally, for debuggers that parse stack frames, the + InternalWait method serves a potential marker for when a Task is entering a wait operation. + + + + + + A type initializer that runs with the appropriate permissions. + + + + + Initializes a new with the specified action. + + The delegate that represents the code to execute in the Task. + The argument is null. + + + + Initializes a new with the specified action and CancellationToken. + + The delegate that represents the code to execute in the Task. + The CancellationToken + that will be assigned to the new Task. + The argument is null. + The provided CancellationToken + has already been disposed. + + + + + Initializes a new with the specified action and creation options. + + The delegate that represents the code to execute in the task. + + The TaskCreationOptions used to + customize the Task's behavior. + + + The argument is null. + + + The argument specifies an invalid value for . + + + + + Initializes a new with the specified action and creation options. + + The delegate that represents the code to execute in the task. + The that will be assigned to the new task. + + The TaskCreationOptions used to + customize the Task's behavior. + + + The argument is null. + + + The argument specifies an invalid value for . + + The provided CancellationToken + has already been disposed. + + + + + Initializes a new with the specified action and state. + + The delegate that represents the code to execute in the task. + An object representing data to be used by the action. + + The argument is null. + + + + + Initializes a new with the specified action, state, snd options. + + The delegate that represents the code to execute in the task. + An object representing data to be used by the action. + The that will be assigned to the new task. + + The argument is null. + + The provided CancellationToken + has already been disposed. + + + + + Initializes a new with the specified action, state, snd options. + + The delegate that represents the code to execute in the task. + An object representing data to be used by the action. + + The TaskCreationOptions used to + customize the Task's behavior. + + + The argument is null. + + + The argument specifies an invalid value for . + + + + + Initializes a new with the specified action, state, snd options. + + The delegate that represents the code to execute in the task. + An object representing data to be used by the action. + The that will be assigned to the new task. + + The TaskCreationOptions used to + customize the Task's behavior. + + + The argument is null. + + + The argument specifies an invalid value for . + + The provided CancellationToken + has already been disposed. + + + + + An internal constructor used by the factory methods on task and its descendent(s). + This variant does not capture the ExecutionContext; it is up to the caller to do that. + + An action to execute. + Optional state to pass to the action. + Parent of Task. + A CancellationToken for the task. + A task scheduler under which the task will run. + Options to control its execution. + Internal options to control its execution + + + + Common logic used by the following internal ctors: + Task() + Task(object action, object state, Task parent, TaskCreationOptions options, TaskScheduler taskScheduler) + + ASSUMES THAT m_creatingTask IS ALREADY SET. + + + Action for task to execute. + Object to which to pass to action (may be null) + Task scheduler on which to run thread (only used by continuation tasks). + A CancellationToken for the Task. + Options to customize behavior of Task. + Internal options to customize behavior of Task. + + + + Checks if we registered a CT callback during construction, and deregisters it. + This should be called when we know the registration isn't useful anymore. Specifically from Finish() if the task has completed + successfully or with an exception. + + + + + Captures the ExecutionContext so long as flow isn't suppressed. + + A stack crawl mark pointing to the frame of the caller. + + + + Internal function that will be called by a new child task to add itself to + the children list of the parent (this). + + Since a child task can only be created from the thread executing the action delegate + of this task, reentrancy is neither required nor supported. This should not be called from + anywhere other than the task construction/initialization codepaths. + + + + + Starts the , scheduling it for execution to the current TaskScheduler. + + + A task may only be started and run only once. Any attempts to schedule a task a second time + will result in an exception. + + + The is not in a valid state to be started. It may have already been started, + executed, or canceled, or it may have been created in a manner that doesn't support direct + scheduling. + + + The instance has been disposed. + + + + + Starts the , scheduling it for execution to the specified TaskScheduler. + + + A task may only be started and run only once. Any attempts to schedule a task a second time will + result in an exception. + + + The TaskScheduler with which to associate + and execute this task. + + + The argument is null. + + + The is not in a valid state to be started. It may have already been started, + executed, or canceled, or it may have been created in a manner that doesn't support direct + scheduling. + + + The instance has been disposed. + + + + + Runs the synchronously on the current TaskScheduler. + + + + A task may only be started and run only once. Any attempts to schedule a task a second time will + result in an exception. + + + Tasks executed with will be associated with the current TaskScheduler. + + + If the target scheduler does not support running this Task on the current thread, the Task will + be scheduled for execution on the scheduler, and the current thread will block until the + Task has completed execution. + + + + The is not in a valid state to be started. It may have already been started, + executed, or canceled, or it may have been created in a manner that doesn't support direct + scheduling. + + + The instance has been disposed. + + + + + Runs the synchronously on the scheduler provided. + + + + A task may only be started and run only once. Any attempts to schedule a task a second time will + result in an exception. + + + If the target scheduler does not support running this Task on the current thread, the Task will + be scheduled for execution on the scheduler, and the current thread will block until the + Task has completed execution. + + + + The is not in a valid state to be started. It may have already been started, + executed, or canceled, or it may have been created in a manner that doesn't support direct + scheduling. + + + The instance has been disposed. + + The parameter + is null. + The scheduler on which to attempt to run this task inline. + + + + Throws an exception if the task has been disposed, and hence can no longer be accessed. + + The task has been disposed. + + + + Sets the internal completion event. + + + + + Disposes the , releasing all of its unmanaged resources. + + + Unlike most of the members of , this method is not thread-safe. + Also, may only be called on a that is in one of + the final states: RanToCompletion, + Faulted, or + Canceled. + + + The exception that is thrown if the is not in + one of the final states: RanToCompletion, + Faulted, or + Canceled. + + + + + Disposes the , releasing all of its unmanaged resources. + + + A Boolean value that indicates whether this method is being called due to a call to . + + + Unlike most of the members of , this method is not thread-safe. + + + + + Schedules the task for execution. + + If true, TASK_STATE_STARTED bit is turned on in + an atomic fashion, making sure that TASK_STATE_CANCELED does not get set + underneath us. If false, TASK_STATE_STARTED bit is OR-ed right in. This + allows us to streamline things a bit for StartNew(), where competing cancellations + are not a problem. + + + + Adds an exception to the list of exceptions this task has thrown. + + An object representing either an Exception or a collection of Exceptions. + + + + Returns a list of exceptions by aggregating the holder's contents. Or null if + no exceptions have been thrown. + + Whether to include a TCE if cancelled. + An aggregate exception, or null if no exceptions have been caught. + + + + Throws an aggregate exception if the task contains exceptions. + + + + + Checks whether this is an attached task, and whether we are being called by the parent task. + And sets the TASK_STATE_EXCEPTIONOBSERVEDBYPARENT status flag based on that. + + This is meant to be used internally when throwing an exception, and when WaitAll is gathering + exceptions for tasks it waited on. If this flag gets set, the implicit wait on children + will skip exceptions to prevent duplication. + + This should only be called when this task has completed with an exception + + + + + + Signals completion of this particular task. + + The bUserDelegateExecuted parameter indicates whether this Finish() call comes following the + full execution of the user delegate. + + If bUserDelegateExecuted is false, it mean user delegate wasn't invoked at all (either due to + a cancellation request, or because this task is a promise style Task). In this case, the steps + involving child tasks (i.e. WaitForChildren) will be skipped. + + + + + + FinishStageTwo is to be executed as soon as we known there are no more children to complete. + It can happen i) either on the thread that originally executed this task (if no children were spawned, or they all completed by the time this task's delegate quit) + ii) or on the thread that executed the last child. + + + + + Final stage of the task completion code path. Notifies the parent (if any) that another of its childre are done, and runs continuations. + This function is only separated out from FinishStageTwo because these two operations are also needed to be called from CancellationCleanupLogic() + + + + + This is called by children of this task when they are completed. + + + + + This is to be called just before the task does its final state transition. + It traverses the list of exceptional children, and appends their aggregate exceptions into this one's exception list + + + + + Special purpose Finish() entry point to be used when the task delegate throws a ThreadAbortedException + This makes a note in the state flags so that we avoid any costly synchronous operations in the finish codepath + such as inlined continuations + + + Indicates whether the ThreadAbortException was added to this task's exception holder. + This should always be true except for the case of non-root self replicating task copies. + + Whether the delegate was executed. + + + + Executes the task. This method will only be called once, and handles bookeeping associated with + self-replicating tasks, in addition to performing necessary exception marshaling. + + The task has already been disposed. + + + + IThreadPoolWorkItem override, which is the entry function for this task when the TP scheduler decides to run it. + + + + + + Outermost entry function to execute this task. Handles all aspects of executing a task on the caller thread. + Currently this is called by IThreadPoolWorkItem.ExecuteWorkItem(), and TaskManager.TryExecuteInline. + + + Performs atomic updates to prevent double execution. Should only be set to true + in codepaths servicing user provided TaskSchedulers. The ConcRT or ThreadPool schedulers don't need this. + + + + The actual code which invokes the body of the task. This can be overriden in derived types. + + + + + Alternate InnerInvoke prototype to be called from ExecuteSelfReplicating() so that + the Parallel Debugger can discover the actual task being invoked. + Details: Here, InnerInvoke is actually being called on the rootTask object while we are actually executing the + childTask. And the debugger needs to discover the childTask, so we pass that down as an argument. + The NoOptimization and NoInlining flags ensure that the childTask pointer is retained, and that this + function appears on the callstack. + + + + + + Performs whatever handling is necessary for an unhandled exception. Normally + this just entails adding the exception to the holder object. + + The exception that went unhandled. + + + + Waits for the to complete execution. + + + The was canceled -or- an exception was thrown during + the execution of the . + + + The has been disposed. + + + + + Waits for the to complete execution. + + + A that represents the number of milliseconds to wait, or a that represents -1 milliseconds to wait indefinitely. + + + true if the completed execution within the allotted time; otherwise, false. + + + The was canceled -or- an exception was thrown during the execution of the . + + + is a negative number other than -1 milliseconds, which represents an + infinite time-out -or- timeout is greater than + . + + + The has been disposed. + + + + + Waits for the to complete execution. + + + A to observe while waiting for the task to complete. + + + The was canceled. + + + The was canceled -or- an exception was thrown during the execution of the . + + + The + has been disposed. + + + + + Waits for the to complete execution. + + + The number of milliseconds to wait, or (-1) to + wait indefinitely. + true if the completed execution within the allotted time; otherwise, + false. + + + is a negative number other than -1, which represents an + infinite time-out. + + + The was canceled -or- an exception was thrown during the execution of the . + + + The + has been disposed. + + + + + Waits for the to complete execution. + + + The number of milliseconds to wait, or (-1) to + wait indefinitely. + + + A to observe while waiting for the task to complete. + + + true if the completed execution within the allotted time; otherwise, false. + + + The was canceled -or- an exception was thrown during the execution of the . + + + The + has been disposed. + + + is a negative number other than -1, which represents an + infinite time-out. + + + The was canceled. + + + + + The core wait function, which is only accesible internally. It's meant to be used in places in TPL code where + the current context is known or cached. + + + + + Cancels the . + + Indiactes whether we should only cancel non-invoked tasks. + For the default scheduler this option will only be serviced through TryDequeue. + For custom schedulers we also attempt an atomic state transition. + true if the task was successfully canceled; otherwise, false. + The + has been disposed. + + + + Sets the task's cancellation acknowledged flag. + + + + + Runs all of the continuations, as appropriate. + + + + + Helper function to determine whether the current task is in the state desired by the + continuation kind under evaluation. Three possibilities exist: the task failed with + an unhandled exception (OnFailed), the task was canceled before running (OnAborted), + or the task completed successfully (OnCompletedSuccessfully). Note that the last + one includes completing due to cancellation. + + The continuation options under evaluation. + True if the continuation should be run given the task's current state. + + + + Creates a continuation that executes when the target completes. + + + An action to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed, whether it completes due to running to completion successfully, faulting due to an + unhandled exception, or exiting out early due to being canceled. + + + The argument is null. + + + The has been disposed. + + + + + Creates a continuation that executes when the target completes. + + + An action to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + The that will be assigned to the new continuation task. + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed, whether it completes due to running to completion successfully, faulting due to an + unhandled exception, or exiting out early due to being canceled. + + + The argument is null. + + + The has been disposed. + + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation that executes when the target completes. + + + An action to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + + The to associate with the continuation task and to use for its execution. + + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed, whether it completes due to running to completion successfully, faulting due to an + unhandled exception, or exiting out early due to being canceled. + + + The argument is null. + + + The argument is null. + + + The has been disposed. + + + + + Creates a continuation that executes when the target completes. + + + An action to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + + Options for when the continuation is scheduled and how it behaves. This includes criteria, such + as OnlyOnCanceled, as + well as execution options, such as ExecuteSynchronously. + + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed. If the continuation criteria specified through the parameter are not met, the continuation task will be canceled + instead of scheduled. + + + The argument is null. + + + The argument specifies an invalid value for TaskContinuationOptions. + + + The has been disposed. + + + + + Creates a continuation that executes when the target completes. + + + An action to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + + Options for when the continuation is scheduled and how it behaves. This includes criteria, such + as OnlyOnCanceled, as + well as execution options, such as ExecuteSynchronously. + + The that will be assigned to the new continuation task. + + The to associate with the continuation task and to use for its + execution. + + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed. If the criteria specified through the parameter + are not met, the continuation task will be canceled instead of scheduled. + + + The argument is null. + + + The argument specifies an invalid value for TaskContinuationOptions. + + + The argument is null. + + + The has been disposed. + + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation that executes when the target completes. + + + The type of the result produced by the continuation. + + + A function to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed, whether it completes due to running to completion successfully, faulting due to an + unhandled exception, or exiting out early due to being canceled. + + + The argument is null. + + + The has been disposed. + + + + + Creates a continuation that executes when the target completes. + + + The type of the result produced by the continuation. + + + A function to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + The that will be assigned to the new continuation task. + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed, whether it completes due to running to completion successfully, faulting due to an + unhandled exception, or exiting out early due to being canceled. + + + The argument is null. + + + The has been disposed. + + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation that executes when the target completes. + + + The type of the result produced by the continuation. + + + A function to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + + The to associate with the continuation task and to use for its execution. + + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed, whether it completes due to running to completion successfully, faulting due to an + unhandled exception, or exiting out early due to being canceled. + + + The argument is null. + + + The argument is null. + + + The has been disposed. + + + + + Creates a continuation that executes when the target completes. + + + The type of the result produced by the continuation. + + + A function to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + + Options for when the continuation is scheduled and how it behaves. This includes criteria, such + as OnlyOnCanceled, as + well as execution options, such as ExecuteSynchronously. + + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed. If the continuation criteria specified through the parameter are not met, the continuation task will be canceled + instead of scheduled. + + + The argument is null. + + + The argument specifies an invalid value for TaskContinuationOptions. + + + The has been disposed. + + + + + Creates a continuation that executes when the target completes. + + + The type of the result produced by the continuation. + + + A function to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + The that will be assigned to the new continuation task. + + Options for when the continuation is scheduled and how it behaves. This includes criteria, such + as OnlyOnCanceled, as + well as execution options, such as ExecuteSynchronously. + + + The to associate with the continuation task and to use for its + execution. + + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed. If the criteria specified through the parameter + are not met, the continuation task will be canceled instead of scheduled. + + + The argument is null. + + + The argument specifies an invalid value for TaskContinuationOptions. + + + The argument is null. + + + The has been disposed. + + The provided CancellationToken + has already been disposed. + + + + + Converts TaskContinuationOptions to TaskCreationOptions, and also does + some validity checking along the way. + + Incoming TaskContinuationOptions + Outgoing TaskCreationOptions + Outgoing InternalTaskOptions + + + + Registers the continuation and possibly runs it (if the task is already finished). + + The continuation task itself. + TaskScheduler with which to associate continuation task. + Restrictions on when the continuation becomes active. + + + + Waits for all of the provided objects to complete execution. + + + An array of instances on which to wait. + + + The argument is null. + + + The argument contains a null element. + + + At least one of the instances was canceled -or- an exception was thrown during + the execution of at least one of the instances. + + + The has been disposed. + + + + + Waits for all of the provided objects to complete execution. + + + true if all of the instances completed execution within the allotted time; + otherwise, false. + + + An array of instances on which to wait. + + + A that represents the number of milliseconds to wait, or a that represents -1 milliseconds to wait indefinitely. + + + The argument is null. + + + The argument contains a null element. + + + At least one of the instances was canceled -or- an exception was thrown during + the execution of at least one of the instances. + + + is a negative number other than -1 milliseconds, which represents an + infinite time-out -or- timeout is greater than + . + + + The has been disposed. + + + + + Waits for all of the provided objects to complete execution. + + + true if all of the instances completed execution within the allotted time; + otherwise, false. + + + The number of milliseconds to wait, or (-1) to + wait indefinitely. + An array of instances on which to wait. + + + The argument is null. + + + The argument contains a null element. + + + At least one of the instances was canceled -or- an exception was thrown during + the execution of at least one of the instances. + + + The has been disposed. + + + is a negative number other than -1, which represents an + infinite time-out. + + + + + Waits for all of the provided objects to complete execution. + + + true if all of the instances completed execution within the allotted time; + otherwise, false. + + + An array of instances on which to wait. + + + A to observe while waiting for the tasks to complete. + + + The argument is null. + + + The argument contains a null element. + + + At least one of the instances was canceled -or- an exception was thrown during + the execution of at least one of the instances. + + + The was canceled. + + + The has been disposed. + + + + + Waits for all of the provided objects to complete execution. + + + true if all of the instances completed execution within the allotted time; + otherwise, false. + + + An array of instances on which to wait. + + + The number of milliseconds to wait, or (-1) to + wait indefinitely. + + + A to observe while waiting for the tasks to complete. + + + The argument is null. + + + The argument contains a null element. + + + At least one of the instances was canceled -or- an exception was thrown during + the execution of at least one of the instances. + + + The has been disposed. + + + is a negative number other than -1, which represents an + infinite time-out. + + + The was canceled. + + + + + Waits for a set of handles in a STA-aware way. In other words, it will wait for each + of the events individually if we're on a STA thread, because MsgWaitForMultipleObjectsEx + can't do a true wait-all due to its hidden message queue event. This is not atomic, + of course, but we only wait on one-way (MRE) events anyway so this is OK. + + An array of wait handles to wait on. + The timeout to use during waits. + The cancellationToken that enables a wait to be canceled. + True if all waits succeeded, false if a timeout occurred. + + + + Internal WaitAll implementation which is meant to be used with small number of tasks, + optimized for Parallel.Invoke and other structured primitives. + + + + + This internal function is only meant to be called by WaitAll() + If the completed task is canceled or it has other exceptions, here we will add those + into the passed in exception list (which will be lazily initialized here). + + + + + Waits for any of the provided objects to complete execution. + + + An array of instances on which to wait. + + The index of the completed task in the array argument. + + The argument is null. + + + The argument contains a null element. + + + The has been disposed. + + + + + Waits for any of the provided objects to complete execution. + + + An array of instances on which to wait. + + + A that represents the number of milliseconds to wait, or a that represents -1 milliseconds to wait indefinitely. + + + The index of the completed task in the array argument, or -1 if the + timeout occurred. + + + The argument is null. + + + The argument contains a null element. + + + The has been disposed. + + + is a negative number other than -1 milliseconds, which represents an + infinite time-out -or- timeout is greater than + . + + + + + Waits for any of the provided objects to complete execution. + + + An array of instances on which to wait. + + + A to observe while waiting for a task to complete. + + + The index of the completed task in the array argument. + + + The argument is null. + + + The argument contains a null element. + + + The has been disposed. + + + The was canceled. + + + + + Waits for any of the provided objects to complete execution. + + + An array of instances on which to wait. + + + The number of milliseconds to wait, or (-1) to + wait indefinitely. + + + The index of the completed task in the array argument, or -1 if the + timeout occurred. + + + The argument is null. + + + The argument contains a null element. + + + The has been disposed. + + + is a negative number other than -1, which represents an + infinite time-out. + + + + + Waits for any of the provided objects to complete execution. + + + An array of instances on which to wait. + + + The number of milliseconds to wait, or (-1) to + wait indefinitely. + + + A to observe while waiting for a task to complete. + + + The index of the completed task in the array argument, or -1 if the + timeout occurred. + + + The argument is null. + + + The argument contains a null element. + + + The has been disposed. + + + is a negative number other than -1, which represents an + infinite time-out. + + + The was canceled. + + + + + Gets a unique ID for this Task instance. + + + Task IDs are assigned on-demand and do not necessarily represent the order in the which Task + instances were created. + + + + + Returns the unique ID of the currently executing Task. + + + + + Gets the Task instance currently executing, or + null if none exists. + + + + + Gets the Exception that caused the Task to end prematurely. If the Task completed successfully or has not yet thrown any + exceptions, this will return null. + + + Tasks that throw unhandled exceptions store the resulting exception and propagate it wrapped in a + in calls to Wait + or in accesses to the property. Any exceptions not observed by the time + the Task instance is garbage collected will be propagated on the finalizer thread. + + + The Task + has been disposed. + + + + + Gets the TaskStatus of this Task. + + + + + Gets whether this Task instance has completed + execution due to being canceled. + + + A Task will complete in Canceled state either if its CancellationToken + was marked for cancellation before the task started executing, or if the task acknowledged the cancellation request on + its already signaled CancellationToken by throwing an + OperationCanceledException2 that bears the same + CancellationToken. + + + + + Returns true if this task has a cancellation token and it was signaled. + To be used internally in execute entry codepaths. + + + + + This internal property provides access to the CancellationToken that was set on the task + when it was constructed. + + + + + Gets whether this threw an OperationCanceledException2 while its CancellationToken was signaled. + + + + + Gets whether this Task has completed. + + + will return true when the Task is in one of the three + final states: RanToCompletion, + Faulted, or + Canceled. + + + + + Checks whether this task has been disposed. + + + + + Gets the TaskCreationOptions used + to create this task. + + + + + Gets a that can be used to wait for the task to + complete. + + + Using the wait functionality provided by + should be preferred over using for similar + functionality. + + + The has been disposed. + + + + + Gets the state object supplied when the Task was created, + or null if none was supplied. + + + + + Gets an indication of whether the asynchronous operation completed synchronously. + + true if the asynchronous operation completed synchronously; otherwise, false. + + + + Provides access to the TaskScheduler responsible for executing this Task. + + + + + Provides access to factory methods for creating and instances. + + + The factory returned from is a default instance + of , as would result from using + the default constructor on TaskFactory. + + + + + Provides an event that can be used to wait for completion. + Only called by Wait*(), which means that we really do need to instantiate a completion event. + + + + + Determines whether this is the root task of a self replicating group. + + + + + Determines whether the task is a replica itself. + + + + + The property formerly known as IsFaulted. + + + + + Gets whether the completed due to an unhandled exception. + + + If is true, the Task's will be equal to + TaskStatus.Faulted, and its + property will be non-null. + + + + + Checks whether the TASK_STATE_EXCEPTIONOBSERVEDBYPARENT status flag is set, + This will only be used by the implicit wait to prevent double throws + + + + + + Checks whether the body was ever invoked. Used by task scheduler code to verify custom schedulers actually ran the task. + + + + + A structure to hold continuation information. + + + + + Constructs a new continuation structure. + + The task to be activated. + The continuation options. + The scheduler to use for the continuation. + + + + Invokes the continuation for the target completion task. + + The completed task. + Whether the continuation can be inlined. + + + + Initializes a new with the specified function. + + + The delegate that represents the code to execute in the task. When the function has completed, + the task's property will be set to return the result value of the function. + + + The argument is null. + + + + + Initializes a new with the specified function. + + + The delegate that represents the code to execute in the task. When the function has completed, + the task's property will be set to return the result value of the function. + + The to be assigned to this task. + + The argument is null. + + The provided CancellationToken + has already been disposed. + + + + + Initializes a new with the specified function and creation options. + + + The delegate that represents the code to execute in the task. When the function has completed, + the task's property will be set to return the result value of the function. + + + The TaskCreationOptions used to + customize the task's behavior. + + + The argument is null. + + + The argument specifies an invalid value for . + + + + + Initializes a new with the specified function and creation options. + + + The delegate that represents the code to execute in the task. When the function has completed, + the task's property will be set to return the result value of the function. + + The that will be assigned to the new task. + + The TaskCreationOptions used to + customize the task's behavior. + + + The argument is null. + + + The argument specifies an invalid value for . + + The provided CancellationToken + has already been disposed. + + + + + Initializes a new with the specified function and state. + + + The delegate that represents the code to execute in the task. When the function has completed, + the task's property will be set to return the result value of the function. + + An object representing data to be used by the action. + + The argument is null. + + + + + Initializes a new with the specified action, state, and options. + + + The delegate that represents the code to execute in the task. When the function has completed, + the task's property will be set to return the result value of the function. + + An object representing data to be used by the function. + The to be assigned to the new task. + + The argument is null. + + The provided CancellationToken + has already been disposed. + + + + + Initializes a new with the specified action, state, and options. + + + The delegate that represents the code to execute in the task. When the function has completed, + the task's property will be set to return the result value of the function. + + An object representing data to be used by the function. + + The TaskCreationOptions used to + customize the task's behavior. + + + The argument is null. + + + The argument specifies an invalid value for . + + + + + Initializes a new with the specified action, state, and options. + + + The delegate that represents the code to execute in the task. When the function has completed, + the task's property will be set to return the result value of the function. + + An object representing data to be used by the function. + The to be assigned to the new task. + + The TaskCreationOptions used to + customize the task's behavior. + + + The argument is null. + + + The argument specifies an invalid value for . + + The provided CancellationToken + has already been disposed. + + + + + Creates a new future object. + + The parent task for this future. + A function that yields the future value. + The task scheduler which will be used to execute the future. + The CancellationToken for the task. + Options to control the future's behavior. + Internal options to control the future's behavior. + The argument specifies + a SelfReplicating , which is illegal."/>. + + + + Creates a new future object. + + The parent task for this future. + An object containing data to be used by the action; may be null. + A function that yields the future value. + The CancellationToken for the task. + The task scheduler which will be used to execute the future. + Options to control the future's behavior. + Internal options to control the future's behavior. + The argument specifies + a SelfReplicating , which is illegal."/>. + + + + Evaluates the value selector of the Task which is passed in as an object and stores the result. + + + + + Creates a continuation that executes when the target completes. + + + An action to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed, whether it completes due to running to completion successfully, faulting due to an + unhandled exception, or exiting out early due to being canceled. + + + The argument is null. + + + The has been disposed. + + + + + Creates a continuation that executes when the target completes. + + + An action to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + The that will be assigned to the new continuation task. + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed, whether it completes due to running to completion successfully, faulting due to an + unhandled exception, or exiting out early due to being canceled. + + + The argument is null. + + + The has been disposed. + + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation that executes when the target completes. + + + An action to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + + The to associate with the continuation task and to use for its execution. + + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed, whether it completes due to running to completion successfully, faulting due to an + unhandled exception, or exiting out early due to being canceled. + + + The argument is null. + + + The argument is null. + + + The has been disposed. + + + + + Creates a continuation that executes when the target completes. + + + An action to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + + Options for when the continuation is scheduled and how it behaves. This includes criteria, such + as OnlyOnCanceled, as + well as execution options, such as ExecuteSynchronously. + + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed. If the continuation criteria specified through the parameter are not met, the continuation task will be canceled + instead of scheduled. + + + The argument is null. + + + The argument specifies an invalid value for TaskContinuationOptions. + + + The has been disposed. + + + + + Creates a continuation that executes when the target completes. + + + An action to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + The that will be assigned to the new continuation task. + + Options for when the continuation is scheduled and how it behaves. This includes criteria, such + as OnlyOnCanceled, as + well as execution options, such as ExecuteSynchronously. + + + The to associate with the continuation task and to use for its + execution. + + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed. If the criteria specified through the parameter + are not met, the continuation task will be canceled instead of scheduled. + + + The argument is null. + + + The argument specifies an invalid value for TaskContinuationOptions. + + + The argument is null. + + + The has been disposed. + + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation that executes when the target completes. + + + The type of the result produced by the continuation. + + + A function to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + A new continuation . + + The returned will not be scheduled for execution until the current + task has completed, whether it completes due to running to completion successfully, faulting due + to an unhandled exception, or exiting out early due to being canceled. + + + The argument is null. + + + The has been disposed. + + + + + Creates a continuation that executes when the target completes. + + + The type of the result produced by the continuation. + + + A function to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + The that will be assigned to the new task. + A new continuation . + + The returned will not be scheduled for execution until the current + task has completed, whether it completes due to running to completion successfully, faulting due + to an unhandled exception, or exiting out early due to being canceled. + + + The argument is null. + + + The has been disposed. + + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation that executes when the target completes. + + + The type of the result produced by the continuation. + + + A function to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + + The to associate with the continuation task and to use for its execution. + + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed, whether it completes due to running to completion successfully, faulting due to an + unhandled exception, or exiting out early due to being canceled. + + + The argument is null. + + + The argument is null. + + + The has been disposed. + + + + + Creates a continuation that executes when the target completes. + + + The type of the result produced by the continuation. + + + A function to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + + Options for when the continuation is scheduled and how it behaves. This includes criteria, such + as OnlyOnCanceled, as + well as execution options, such as ExecuteSynchronously. + + A new continuation . + + + The returned will not be scheduled for execution until the current + task has completed, whether it completes due to running to completion successfully, faulting due + to an unhandled exception, or exiting out early due to being canceled. + + + The , when executed, should return a . This task's completion state will be transferred to the task returned + from the ContinueWith call. + + + + The argument is null. + + + The argument specifies an invalid value for TaskContinuationOptions. + + + The has been disposed. + + + + + Creates a continuation that executes when the target completes. + + + The type of the result produced by the continuation. + + + A function to run when the completes. When run, the delegate will be passed as + an argument this completed task. + + The that will be assigned to the new task. + + Options for when the continuation is scheduled and how it behaves. This includes criteria, such + as OnlyOnCanceled, as + well as execution options, such as ExecuteSynchronously. + + + The to associate with the continuation task and to use for its + execution. + + A new continuation . + + + The returned will not be scheduled for execution until the current task has + completed, whether it completes due to running to completion successfully, faulting due to an + unhandled exception, or exiting out early due to being canceled. + + + The , when executed, should return a . + This task's completion state will be transferred to the task returned from the + ContinueWith call. + + + + The argument is null. + + + The argument specifies an invalid value for TaskContinuationOptions. + + + The argument is null. + + + The has been disposed. + + The provided CancellationToken + has already been disposed. + + + + + Gets the result value of this . + + + The get accessor for this property ensures that the asynchronous operation is complete before + returning. Once the result of the computation is available, it is stored and will be returned + immediately on later calls to . + + + + + Provides access to factory methods for creating instances. + + + The factory returned from is a default instance + of , as would result from using + the default constructor on the factory type. + + + + + Provides support for creating and scheduling + Task{TResult} objects. + + The type of the results that are available though + the Task{TResult} objects that are associated with + the methods in this class. + + + There are many common patterns for which tasks are relevant. The + class encodes some of these patterns into methods that pick up default settings, which are + configurable through its constructors. + + + A default instance of is available through the + Task{TResult}.Factory property. + + + + + + Initializes a instance with the default configuration. + + + This constructor creates a instance with a default configuration. The + property is initialized to + TaskCreationOptions.None, the + property is initialized to TaskContinuationOptions.None, + and the TaskScheduler property is + initialized to the current scheduler (see TaskScheduler.Current). + + + + + Initializes a instance with the default configuration. + + The default that will be assigned + to tasks created by this unless another CancellationToken is explicitly specified + while calling the factory methods. + + This constructor creates a instance with a default configuration. The + property is initialized to + TaskCreationOptions.None, the + property is initialized to TaskContinuationOptions.None, + and the TaskScheduler property is + initialized to the current scheduler (see TaskScheduler.Current). + + + + + Initializes a instance with the specified configuration. + + + The + TaskScheduler to use to schedule any tasks created with this TaskFactory{TResult}. A null value + indicates that the current TaskScheduler should be used. + + + With this constructor, the + property is initialized to + TaskCreationOptions.None, the + property is initialized to TaskContinuationOptions.None, + and the TaskScheduler property is + initialized to , unless it's null, in which case the property is + initialized to the current scheduler (see TaskScheduler.Current). + + + + + Initializes a instance with the specified configuration. + + + The default + TaskCreationOptions to use when creating tasks with this TaskFactory{TResult}. + + + The default + TaskContinuationOptions to use when creating continuation tasks with this TaskFactory{TResult}. + + + The exception that is thrown when the + argument or the + argument specifies an invalid value. + + + With this constructor, the + property is initialized to , + the + property is initialized to , and the TaskScheduler property is initialized to the + current scheduler (see TaskScheduler.Current). + + + + + Initializes a instance with the specified configuration. + + The default that will be assigned + to tasks created by this unless another CancellationToken is explicitly specified + while calling the factory methods. + + The default + TaskCreationOptions to use when creating tasks with this TaskFactory{TResult}. + + + The default + TaskContinuationOptions to use when creating continuation tasks with this TaskFactory{TResult}. + + + The default + TaskScheduler to use to schedule any Tasks created with this TaskFactory{TResult}. A null value + indicates that TaskScheduler.Current should be used. + + + The exception that is thrown when the + argument or the + argumentspecifies an invalid value. + + + With this constructor, the + property is initialized to , + the + property is initialized to , and the TaskScheduler property is initialized to + , unless it's null, in which case the property is initialized to the + current scheduler (see TaskScheduler.Current). + + + + + Creates and starts a . + + A function delegate that returns the future result to be available through + the . + The started . + The exception that is thrown when the + argument is null. + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + A function delegate that returns the future result to be available through + the . + The that will be assigned to the new task. + The started . + The exception that is thrown when the + argument is null. + The provided CancellationToken + has already been disposed. + + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + A function delegate that returns the future result to be available through + the . + A TaskCreationOptions value that controls the behavior of the + created + . + The started . + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + A function delegate that returns the future result to be available through + the . + A TaskCreationOptions value that controls the behavior of the + created + . + The that will be assigned to the new task. + The TaskScheduler + that is used to schedule the created + Task{TResult}. + The started . + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The provided CancellationToken + has already been disposed. + + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + A function delegate that returns the future result to be available through + the . + An object containing data to be used by the + delegate. + The started . + The exception that is thrown when the + argument is null. + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + A function delegate that returns the future result to be available through + the . + An object containing data to be used by the + delegate. + The that will be assigned to the new task. + The started . + The exception that is thrown when the + argument is null. + The provided CancellationToken + has already been disposed. + + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + A function delegate that returns the future result to be available through + the . + An object containing data to be used by the + delegate. + A TaskCreationOptions value that controls the behavior of the + created + . + The started . + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + A function delegate that returns the future result to be available through + the . + An object containing data to be used by the + delegate. + The that will be assigned to the new task. + A TaskCreationOptions value that controls the behavior of the + created + . + The TaskScheduler + that is used to schedule the created + Task{TResult}. + The started . + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The provided CancellationToken + has already been disposed. + + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates a Task that executes an end + method function when a specified IAsyncResult completes. + + The IAsyncResult whose completion should trigger the processing of the + . + The function delegate that processes the completed . + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + A Task that represents the + asynchronous operation. + + + + Creates a Task that executes an end + method function when a specified IAsyncResult completes. + + The IAsyncResult whose completion should trigger the processing of the + . + The function delegate that processes the completed . + The TaskCreationOptions value that controls the behavior of the + created Task. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + A Task that represents the + asynchronous operation. + + + + Creates a Task that executes an end + method function when a specified IAsyncResult completes. + + The IAsyncResult whose completion should trigger the processing of the + . + The function delegate that processes the completed . + The TaskScheduler + that is used to schedule the task that executes the end method. + The TaskCreationOptions value that controls the behavior of the + created Task. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + A Task that represents the + asynchronous operation. + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The TaskCreationOptions value that controls the behavior of the + created Task. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The TaskCreationOptions value that controls the behavior of the + created Task. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the delegate. + The type of the second argument passed to + delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The second argument passed to the + delegate. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the delegate. + The type of the second argument passed to + delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The second argument passed to the + delegate. + The TaskCreationOptions value that controls the behavior of the + created Task. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the delegate. + The type of the second argument passed to + delegate. + The type of the third argument passed to + delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The second argument passed to the + delegate. + The third argument passed to the + delegate. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the delegate. + The type of the second argument passed to + delegate. + The type of the third argument passed to + delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The second argument passed to the + delegate. + The third argument passed to the + delegate. + The TaskCreationOptions value that controls the behavior of the + created Task. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The array of tasks from which to continue. + The function delegate to execute when all tasks in + the array have completed. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The array of tasks from which to continue. + The function delegate to execute when all tasks in + the array have completed. + The CancellationToken + that will be assigned to the new continuation task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The array of tasks from which to continue. + The function delegate to execute when all tasks in the array have completed. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAll. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The array of tasks from which to continue. + The function delegate to execute when all tasks in the array have completed. + The CancellationToken + that will be assigned to the new continuation task. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The TaskScheduler + that is used to schedule the created continuation Task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAll. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result of the antecedent . + The array of tasks from which to continue. + The function delegate to execute when all tasks in the + array have completed. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result of the antecedent . + The array of tasks from which to continue. + The function delegate to execute when all tasks in the + array have completed. + The CancellationToken + that will be assigned to the new continuation task. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result of the antecedent . + The array of tasks from which to continue. + The function delegate to execute when all tasks in the + array have completed. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAll. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result of the antecedent . + The array of tasks from which to continue. + The function delegate to execute when all tasks in the + array have completed. + The CancellationToken + that will be assigned to the new continuation task. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The TaskScheduler + that is used to schedule the created continuation . + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAll. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the array completes. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the array completes. + The CancellationToken + that will be assigned to the new continuation task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the array completes. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAny. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the array completes. + The CancellationToken + that will be assigned to the new continuation task. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The TaskScheduler + that is used to schedule the created continuation Task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAny. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result of the antecedent . + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the + array completes. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result of the antecedent . + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the + array completes. + The CancellationToken + that will be assigned to the new continuation task. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result of the antecedent . + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the + array completes. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAny. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result of the antecedent . + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the + array completes. + The CancellationToken + that will be assigned to the new continuation task. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The TaskScheduler + that is used to schedule the created continuation . + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAny. + + + + + Gets the default CancellationToken of this + TaskFactory. + + + This property returns the default that will be assigned to all + tasks created by this factory unless another CancellationToken value is explicitly specified + during the call to the factory methods. + + + + + Gets the TaskScheduler of this + TaskFactory{TResult}. + + + This property returns the default scheduler for this factory. It will be used to schedule all + tasks unless another scheduler is explicitly specified during calls to this factory's methods. + If null, TaskScheduler.Current + will be used. + + + + + Gets the TaskCreationOptions + value of this TaskFactory{TResult}. + + + This property returns the default creation options for this factory. They will be used to create all + tasks unless other options are explicitly specified during calls to this factory's methods. + + + + + Gets the TaskContinuationOptions + value of this TaskFactory{TResult}. + + + This property returns the default continuation options for this factory. They will be used to create + all continuation tasks unless other options are explicitly specified during calls to this factory's methods. + + + + + Represents the current stage in the lifecycle of a . + + + + + The task has been initialized but has not yet been scheduled. + + + + + The task is waiting to be activated and scheduled internally by the .NET Framework infrastructure. + + + + + The task has been scheduled for execution but has not yet begun executing. + + + + + The task is running but has not yet completed. + + + + + The task has finished executing and is implicitly waiting for + attached child tasks to complete. + + + + + The task completed execution successfully. + + + + + The task acknowledged cancellation by throwing an OperationCanceledException2 with its own CancellationToken + while the token was in signaled state, or the task's CancellationToken was already signaled before the + task started executing. + + + + + The task completed due to an unhandled exception. + + + + + Specifies flags that control optional behavior for the creation and execution of tasks. + + + + + Specifies that the default behavior should be used. + + + + + A hint to a TaskScheduler to schedule a + task in as fair a manner as possible, meaning that tasks scheduled sooner will be more likely to + be run sooner, and tasks scheduled later will be more likely to be run later. + + + + + Specifies that a task will be a long-running, course-grained operation. It provides a hint to the + TaskScheduler that oversubscription may be + warranted. + + + + + Specifies that a task is attached to a parent in the task hierarchy. + + + + + Task creation flags which are only used internally. + + + + Specifies "No internal task options" + + + Used to filter out internal vs. public task creation options. + + + Specifies that the task will be queued by the runtime before handing it over to the user. + This flag will be used to skip the cancellationtoken registration step, which is only meant for unstarted tasks. + + + + Specifies flags that control optional behavior for the creation and execution of continuation tasks. + + + + + Default = "Continue on any, no task options, run asynchronously" + Specifies that the default behavior should be used. Continuations, by default, will + be scheduled when the antecedent task completes, regardless of the task's final TaskStatus. + + + + + A hint to a TaskScheduler to schedule a + task in as fair a manner as possible, meaning that tasks scheduled sooner will be more likely to + be run sooner, and tasks scheduled later will be more likely to be run later. + + + + + Specifies that a task will be a long-running, course-grained operation. It provides + a hint to the TaskScheduler that + oversubscription may be warranted. + + + + + Specifies that a task is attached to a parent in the task hierarchy. + + + + + Specifies that the continuation task should not be scheduled if its antecedent ran to completion. + This option is not valid for multi-task continuations. + + + + + Specifies that the continuation task should not be scheduled if its antecedent threw an unhandled + exception. This option is not valid for multi-task continuations. + + + + + Specifies that the continuation task should not be scheduled if its antecedent was canceled. This + option is not valid for multi-task continuations. + + + + + Specifies that the continuation task should be scheduled only if its antecedent ran to + completion. This option is not valid for multi-task continuations. + + + + + Specifies that the continuation task should be scheduled only if its antecedent threw an + unhandled exception. This option is not valid for multi-task continuations. + + + + + Specifies that the continuation task should be scheduled only if its antecedent was canceled. + This option is not valid for multi-task continuations. + + + + + Specifies that the continuation task should be executed synchronously. With this option + specified, the continuation will be run on the same thread that causes the antecedent task to + transition into its final state. If the antecedent is already complete when the continuation is + created, the continuation will run on the thread creating the continuation. Only very + short-running continuations should be executed synchronously. + + + + + Represents an exception used to communicate task cancellation. + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the + class with a specified error message. + + The error message that explains the reason for the exception. + + + + Initializes a new instance of the + class with a specified error message and a reference to the inner exception that is the cause of + this exception. + + The error message that explains the reason for the exception. + The exception that is the cause of the current exception. + + + + Initializes a new instance of the class + with a reference to the that has been canceled. + + A task that has been canceled. + + + + Gets the task associated with this exception. + + + It is permissible for no Task to be associated with a + , in which case + this property will return null. + + + + + Represents the producer side of a unbound to a + delegate, providing access to the consumer side through the property. + + + + It is often the case that a is desired to + represent another asynchronous operation. + TaskCompletionSource is provided for this purpose. It enables + the creation of a task that can be handed out to consumers, and those consumers can use the members + of the task as they would any other. However, unlike most tasks, the state of a task created by a + TaskCompletionSource is controlled explicitly by the methods on TaskCompletionSource. This enables the + completion of the external asynchronous operation to be propagated to the underlying Task. The + separation also ensures that consumers are not able to transition the state without access to the + corresponding TaskCompletionSource. + + + All members of are thread-safe + and may be used from multiple threads concurrently. + + + The type of the result value assocatied with this . + + + + Creates a . + + + + + Creates a + with the specified options. + + + The created + by this instance and accessible through its property + will be instantiated using the specified . + + The options to use when creating the underlying + . + + The represent options invalid for use + with a . + + + + + Creates a + with the specified state. + + The state to use as the underlying + 's AsyncState. + + + + Creates a with + the specified state and options. + + The options to use when creating the underlying + . + The state to use as the underlying + 's AsyncState. + + The represent options invalid for use + with a . + + + + + Attempts to transition the underlying + into the + Faulted + state. + + The exception to bind to this . + True if the operation was successful; otherwise, false. + This operation will return false if the + is already in one + of the three final states: + RanToCompletion, + Faulted, or + Canceled. + + The argument is null. + The was disposed. + + + + Attempts to transition the underlying + into the + Faulted + state. + + The collection of exceptions to bind to this . + True if the operation was successful; otherwise, false. + This operation will return false if the + is already in one + of the three final states: + RanToCompletion, + Faulted, or + Canceled. + + The argument is null. + There are one or more null elements in . + The collection is empty. + The was disposed. + + + + Transitions the underlying + into the + Faulted + state. + + The exception to bind to this . + The argument is null. + + The underlying is already in one + of the three final states: + RanToCompletion, + Faulted, or + Canceled. + + The was disposed. + + + + Transitions the underlying + into the + Faulted + state. + + The collection of exceptions to bind to this . + The argument is null. + There are one or more null elements in . + + The underlying is already in one + of the three final states: + RanToCompletion, + Faulted, or + Canceled. + + The was disposed. + + + + Attempts to transition the underlying + into the + RanToCompletion + state. + + The result value to bind to this . + True if the operation was successful; otherwise, false. + This operation will return false if the + is already in one + of the three final states: + RanToCompletion, + Faulted, or + Canceled. + + The was disposed. + + + + Transitions the underlying + into the + RanToCompletion + state. + + The result value to bind to this . + + The underlying is already in one + of the three final states: + RanToCompletion, + Faulted, or + Canceled. + + The was disposed. + + + + Transitions the underlying + into the + Canceled + state. + + + The underlying is already in one + of the three final states: + RanToCompletion, + Faulted, or + Canceled. + + The was disposed. + + + + Attempts to transition the underlying + into the + Canceled + state. + + True if the operation was successful; otherwise, false. + This operation will return false if the + is already in one + of the three final states: + RanToCompletion, + Faulted, or + Canceled. + + The was disposed. + + + + Gets the created + by this . + + + This property enables a consumer access to the that is controlled by this instance. + The , , + , and + methods (and their "Try" variants) on this instance all result in the relevant state + transitions on this underlying Task. + + + + + An exception holder manages a list of exceptions for one particular task. + It offers the ability to aggregate, but more importantly, also offers intrinsic + support for propagating unhandled exceptions that are never observed. It does + this by aggregating and throwing if the holder is ever GC'd without the holder's + contents ever having been requested (e.g. by a Task.Wait, Task.get_Exception, etc). + + + + + Creates a new holder; it will be registered for finalization. + + The task this holder belongs to. + + + + A finalizer that repropagates unhandled exceptions. + + + + + Add an exception to the internal list. This will ensure the holder is + in the proper state (handled/unhandled) depending on the list's contents. + + An exception object (either an Exception or an + IEnumerable{Exception}) to add to the list. + + + + A private helper method that ensures the holder is considered + unhandled, i.e. it is registered for finalization. + + + + + A private helper method that ensures the holder is considered + handled, i.e. it is not registered for finalization. + + Whether this is called from the finalizer thread. + + + + Allocates a new aggregate exception and adds the contents of the list to + it. By calling this method, the holder assumes exceptions to have been + "observed", such that the finalization check will be subsequently skipped. + + Whether this is being called from a finalizer. + An extra exception to be included (optionally). + The aggregate exception to throw. + + + + Provides a set of static (Shared in Visual Basic) methods for working with specific kinds of + instances. + + + + + Creates a proxy Task that represents the + asynchronous operation of a Task{Task}. + + + It is often useful to be able to return a Task from a + Task{TResult}, where the inner Task represents work done as part of the outer Task{TResult}. However, + doing so results in a Task{Task}, which, if not dealt with carefully, could produce unexpected behavior. Unwrap + solves this problem by creating a proxy Task that represents the entire asynchronous operation of such a Task{Task}. + + The Task{Task} to unwrap. + The exception that is thrown if the + argument is null. + A Task that represents the asynchronous operation of the provided Task{Task}. + + + + Creates a proxy Task{TResult} that represents the + asynchronous operation of a Task{Task{TResult}}. + + + It is often useful to be able to return a Task{TResult} from a Task{TResult}, where the inner Task{TResult} + represents work done as part of the outer Task{TResult}. However, doing so results in a Task{Task{TResult}}, + which, if not dealt with carefully, could produce unexpected behavior. Unwrap solves this problem by + creating a proxy Task{TResult} that represents the entire asynchronous operation of such a Task{Task{TResult}}. + + The Task{Task{TResult}} to unwrap. + The exception that is thrown if the + argument is null. + A Task{TResult} that represents the asynchronous operation of the provided Task{Task{TResult}}. /// Unwraps a Task that returns another Task. + + + + Provides support for creating and scheduling + Tasks. + + + + There are many common patterns for which tasks are relevant. The + class encodes some of these patterns into methods that pick up default settings, which are + configurable through its constructors. + + + A default instance of is available through the + Task.Factory property. + + + + + + Initializes a instance with the default configuration. + + + This constructor creates a instance with a default configuration. The + property is initialized to + TaskCreationOptions.None, the + property is initialized to TaskContinuationOptions.None, + and the TaskScheduler property is + initialized to the current scheduler (see TaskScheduler.Current). + + + + + Initializes a instance with the specified configuration. + + The default that will be assigned + to tasks created by this unless another CancellationToken is explicitly specified + while calling the factory methods. + + This constructor creates a instance with a default configuration. The + property is initialized to + TaskCreationOptions.None, the + property is initialized to TaskContinuationOptions.None, + and the TaskScheduler property is + initialized to the current scheduler (see TaskScheduler.Current). + + + + + Initializes a instance with the specified configuration. + + + The + TaskScheduler to use to schedule any tasks created with this TaskFactory. A null value + indicates that the current TaskScheduler should be used. + + + With this constructor, the + property is initialized to + TaskCreationOptions.None, the + property is initialized to TaskContinuationOptions.None, + and the TaskScheduler property is + initialized to , unless it's null, in which case the property is + initialized to the current scheduler (see TaskScheduler.Current). + + + + + Initializes a instance with the specified configuration. + + + The default + TaskCreationOptions to use when creating tasks with this TaskFactory. + + + The default + TaskContinuationOptions to use when creating continuation tasks with this TaskFactory. + + + The exception that is thrown when the + argument or the + argument specifies an invalid value. + + + With this constructor, the + property is initialized to , + the + property is initialized to , and the TaskScheduler property is initialized to the + current scheduler (see TaskScheduler.Current). + + + + + Initializes a instance with the specified configuration. + + The default that will be assigned + to tasks created by this unless another CancellationToken is explicitly specified + while calling the factory methods. + + The default + TaskCreationOptions to use when creating tasks with this TaskFactory. + + + The default + TaskContinuationOptions to use when creating continuation tasks with this TaskFactory. + + + The default + TaskScheduler to use to schedule any Tasks created with this TaskFactory. A null value + indicates that TaskScheduler.Current should be used. + + + The exception that is thrown when the + argument or the + argumentspecifies an invalid value. + + + With this constructor, the + property is initialized to , + the + property is initialized to , and the TaskScheduler property is initialized to + , unless it's null, in which case the property is initialized to the + current scheduler (see TaskScheduler.Current). + + + + + Creates and starts a Task. + + The action delegate to execute asynchronously. + The started Task. + The exception that is thrown when the + argument is null. + + Calling StartNew is functionally equivalent to creating a Task using one of its constructors + and then calling + Start to schedule it for execution. However, + unless creation and scheduling must be separated, StartNew is the recommended + approach for both simplicity and performance. + + + + + Creates and starts a Task. + + The action delegate to execute asynchronously. + The that will be assigned to the new task. + The started Task. + The exception that is thrown when the + argument is null. + The provided CancellationToken + has already been disposed. + + + Calling StartNew is functionally equivalent to creating a Task using one of its constructors + and then calling + Start to schedule it for execution. However, + unless creation and scheduling must be separated, StartNew is the recommended + approach for both simplicity and performance. + + + + + Creates and starts a Task. + + The action delegate to execute asynchronously. + A TaskCreationOptions value that controls the behavior of the + created + Task. + The started Task. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + + Calling StartNew is functionally equivalent to creating a Task using one of its constructors and + then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a Task. + + The action delegate to execute asynchronously. + The that will be assigned to the new + A TaskCreationOptions value that controls the behavior of the + created + Task. + The TaskScheduler + that is used to schedule the created Task. + The started Task. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The provided CancellationToken + has already been disposed. + + + Calling StartNew is functionally equivalent to creating a Task using one of its constructors and + then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a Task. + + The action delegate to execute asynchronously. + An object containing data to be used by the + delegate. + The started Task. + The exception that is thrown when the + argument is null. + + Calling StartNew is functionally equivalent to creating a Task using one of its constructors and + then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a Task. + + The action delegate to execute asynchronously. + An object containing data to be used by the + delegate. + The that will be assigned to the new + The started Task. + The exception that is thrown when the + argument is null. + The provided CancellationToken + has already been disposed. + + + Calling StartNew is functionally equivalent to creating a Task using one of its constructors and + then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a Task. + + The action delegate to execute asynchronously. + An object containing data to be used by the + delegate. + A TaskCreationOptions value that controls the behavior of the + created + Task. + The started Task. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + + Calling StartNew is functionally equivalent to creating a Task using one of its constructors and + then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a Task. + + The action delegate to execute asynchronously. + An object containing data to be used by the + delegate. + The that will be assigned to the new task. + A TaskCreationOptions value that controls the behavior of the + created + Task. + The TaskScheduler + that is used to schedule the created Task. + The started Task. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The provided CancellationToken + has already been disposed. + + + Calling StartNew is functionally equivalent to creating a Task using one of its constructors and + then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + The type of the result available through the + Task. + + A function delegate that returns the future result to be available through + the . + The started . + The exception that is thrown when the + argument is null. + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + The type of the result available through the + Task. + + A function delegate that returns the future result to be available through + the . + The that will be assigned to the new + The started . + The exception that is thrown when the + argument is null. + The provided CancellationToken + has already been disposed. + + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + The type of the result available through the + Task. + + A function delegate that returns the future result to be available through + the . + A TaskCreationOptions value that controls the behavior of the + created + . + The started . + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + The type of the result available through the + Task. + + A function delegate that returns the future result to be available through + the . + The that will be assigned to the new task. + A TaskCreationOptions value that controls the behavior of the + created + . + The TaskScheduler + that is used to schedule the created + Task{TResult}. + The started . + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The provided CancellationToken + has already been disposed. + + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + The type of the result available through the + Task. + + A function delegate that returns the future result to be available through + the . + An object containing data to be used by the + delegate. + The started . + The exception that is thrown when the + argument is null. + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + The type of the result available through the + Task. + + A function delegate that returns the future result to be available through + the . + An object containing data to be used by the + delegate. + The that will be assigned to the new + The started . + The exception that is thrown when the + argument is null. + The provided CancellationToken + has already been disposed. + + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + The type of the result available through the + Task. + + A function delegate that returns the future result to be available through + the . + An object containing data to be used by the + delegate. + A TaskCreationOptions value that controls the behavior of the + created + . + The started . + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + The type of the result available through the + Task. + + A function delegate that returns the future result to be available through + the . + An object containing data to be used by the + delegate. + The that will be assigned to the new task. + A TaskCreationOptions value that controls the behavior of the + created + . + The TaskScheduler + that is used to schedule the created + Task{TResult}. + The started . + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The provided CancellationToken + has already been disposed. + + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates a Task that executes an end method action + when a specified IAsyncResult completes. + + The IAsyncResult whose completion should trigger the processing of the + . + The action delegate that processes the completed . + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + A Task that represents the asynchronous + operation. + + + + Creates a Task that executes an end method action + when a specified IAsyncResult completes. + + The IAsyncResult whose completion should trigger the processing of the + . + The action delegate that processes the completed . + The TaskCreationOptions value that controls the behavior of the + created Task. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + A Task that represents the asynchronous + operation. + + + + Creates a Task that executes an end method action + when a specified IAsyncResult completes. + + The IAsyncResult whose completion should trigger the processing of the + . + The action delegate that processes the completed . + The TaskScheduler + that is used to schedule the task that executes the end method. + The TaskCreationOptions value that controls the behavior of the + created Task. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + A Task that represents the asynchronous + operation. + + + + Creates a Task that represents a pair of begin + and end methods that conform to the Asynchronous Programming Model pattern. + + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The created Task that represents the + asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of begin + and end methods that conform to the Asynchronous Programming Model pattern. + + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The TaskCreationOptions value that controls the behavior of the + created Task. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The created Task that represents the + asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of begin + and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the + delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The created Task that represents the + asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of begin + and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the + delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The TaskCreationOptions value that controls the behavior of the + created Task. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The created Task that represents the + asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of begin + and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the + delegate. + The type of the second argument passed to + delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The second argument passed to the + delegate. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The created Task that represents the + asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of begin + and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the + delegate. + The type of the second argument passed to + delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The second argument passed to the + delegate. + The TaskCreationOptions value that controls the behavior of the + created Task. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The created Task that represents the + asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of begin + and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the + delegate. + The type of the second argument passed to + delegate. + The type of the third argument passed to + delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The second argument passed to the + delegate. + The third argument passed to the + delegate. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The created Task that represents the + asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of begin + and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the + delegate. + The type of the second argument passed to + delegate. + The type of the third argument passed to + delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The second argument passed to the + delegate. + The third argument passed to the + delegate. + The TaskCreationOptions value that controls the behavior of the + created Task. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The created Task that represents the + asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that executes an end + method function when a specified IAsyncResult completes. + + The type of the result available through the + Task. + + The IAsyncResult whose completion should trigger the processing of the + . + The function delegate that processes the completed . + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + A Task that represents the + asynchronous operation. + + + + Creates a Task that executes an end + method function when a specified IAsyncResult completes. + + The type of the result available through the + Task. + + The IAsyncResult whose completion should trigger the processing of the + . + The function delegate that processes the completed . + The TaskCreationOptions value that controls the behavior of the + created Task. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + A Task that represents the + asynchronous operation. + + + + Creates a Task that executes an end + method function when a specified IAsyncResult completes. + + The type of the result available through the + Task. + + The IAsyncResult whose completion should trigger the processing of the + . + The function delegate that processes the completed . + The TaskScheduler + that is used to schedule the task that executes the end method. + The TaskCreationOptions value that controls the behavior of the + created Task. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + A Task that represents the + asynchronous operation. + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the result available through the + Task. + + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the result available through the + Task. + + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The TaskCreationOptions value that controls the behavior of the + created Task. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the delegate. + The type of the result available through the + Task. + + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the delegate. + The type of the result available through the + Task. + + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The TaskCreationOptions value that controls the behavior of the + created Task. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the delegate. + The type of the second argument passed to + delegate. + The type of the result available through the + Task. + + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The second argument passed to the + delegate. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the delegate. + The type of the second argument passed to + delegate. + The type of the result available through the + Task. + + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The second argument passed to the + delegate. + The TaskCreationOptions value that controls the behavior of the + created Task. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the delegate. + The type of the second argument passed to + delegate. + The type of the third argument passed to + delegate. + The type of the result available through the + Task. + + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The second argument passed to the + delegate. + The third argument passed to the + delegate. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the delegate. + The type of the second argument passed to + delegate. + The type of the third argument passed to + delegate. + The type of the result available through the + Task. + + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The second argument passed to the + delegate. + The third argument passed to the + delegate. + The TaskCreationOptions value that controls the behavior of the + created Task. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Check validity of options passed to FromAsync method + + The options to be validated. + determines type of FromAsync method that called this method + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The array of tasks from which to continue. + The action delegate to execute when all tasks in + the array have completed. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The array of tasks from which to continue. + The action delegate to execute when all tasks in + the array have completed. + The CancellationToken + that will be assigned to the new continuation task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The array of tasks from which to continue. + The action delegate to execute when all tasks in the array have completed. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAll. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The array of tasks from which to continue. + The action delegate to execute when all tasks in the array have completed. + The CancellationToken + that will be assigned to the new continuation task. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The TaskScheduler + that is used to schedule the created continuation Task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAll. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result of the antecedent . + The array of tasks from which to continue. + The action delegate to execute when all tasks in + the array have completed. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result of the antecedent . + The array of tasks from which to continue. + The action delegate to execute when all tasks in + the array have completed. + The CancellationToken + that will be assigned to the new continuation task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result of the antecedent . + The array of tasks from which to continue. + The action delegate to execute when all tasks in the array have completed. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAll. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result of the antecedent . + The array of tasks from which to continue. + The action delegate to execute when all tasks in the array have completed. + The CancellationToken + that will be assigned to the new continuation task. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The TaskScheduler + that is used to schedule the created continuation Task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAll. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result that is returned by the + delegate and associated with the created . + The array of tasks from which to continue. + The function delegate to execute when all tasks in the + array have completed. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result that is returned by the + delegate and associated with the created . + The array of tasks from which to continue. + The function delegate to execute when all tasks in the + array have completed. + The CancellationToken + that will be assigned to the new continuation task. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result that is returned by the + delegate and associated with the created . + The array of tasks from which to continue. + The function delegate to execute when all tasks in the + array have completed. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAll. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result that is returned by the + delegate and associated with the created . + The array of tasks from which to continue. + The function delegate to execute when all tasks in the + array have completed. + The CancellationToken + that will be assigned to the new continuation task. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The TaskScheduler + that is used to schedule the created continuation . + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAll. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result that is returned by the + delegate and associated with the created . + The type of the result of the antecedent . + The array of tasks from which to continue. + The function delegate to execute when all tasks in the + array have completed. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result that is returned by the + delegate and associated with the created . + The type of the result of the antecedent . + The array of tasks from which to continue. + The function delegate to execute when all tasks in the + array have completed. + The CancellationToken + that will be assigned to the new continuation task. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result that is returned by the + delegate and associated with the created . + The type of the result of the antecedent . + The array of tasks from which to continue. + The function delegate to execute when all tasks in the + array have completed. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAll. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result that is returned by the + delegate and associated with the created . + The type of the result of the antecedent . + The array of tasks from which to continue. + The function delegate to execute when all tasks in the + array have completed. + The CancellationToken + that will be assigned to the new continuation task. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The TaskScheduler + that is used to schedule the created continuation . + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAll. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The array of tasks from which to continue when one task completes. + The action delegate to execute when one task in the array completes. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The array of tasks from which to continue when one task completes. + The action delegate to execute when one task in the array completes. + The CancellationToken + that will be assigned to the new continuation task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The array of tasks from which to continue when one task completes. + The action delegate to execute when one task in the array completes. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAny. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The array of tasks from which to continue when one task completes. + The action delegate to execute when one task in the array completes. + The CancellationToken + that will be assigned to the new continuation task. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The TaskScheduler + that is used to schedule the created continuation Task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAny. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result that is returned by the + delegate and associated with the created . + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the + array completes. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result that is returned by the + delegate and associated with the created . + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the + array completes. + The CancellationToken + that will be assigned to the new continuation task. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result that is returned by the + delegate and associated with the created . + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the + array completes. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAny. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result that is returned by the + delegate and associated with the created . + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the + array completes. + The CancellationToken + that will be assigned to the new continuation task. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The TaskScheduler + that is used to schedule the created continuation . + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAny. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result that is returned by the + delegate and associated with the created . + The type of the result of the antecedent . + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the + array completes. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result that is returned by the + delegate and associated with the created . + The type of the result of the antecedent . + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the + array completes. + The CancellationToken + that will be assigned to the new continuation task. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result that is returned by the + delegate and associated with the created . + The type of the result of the antecedent . + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the + array completes. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAny. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result that is returned by the + delegate and associated with the created . + The type of the result of the antecedent . + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the + array completes. + The CancellationToken + that will be assigned to the new continuation task. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The TaskScheduler + that is used to schedule the created continuation . + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAny. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result of the antecedent . + The array of tasks from which to continue when one task completes. + The action delegate to execute when one task in the + array completes. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result of the antecedent . + The array of tasks from which to continue when one task completes. + The action delegate to execute when one task in the + array completes. + The CancellationToken + that will be assigned to the new continuation task. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result of the antecedent . + The array of tasks from which to continue when one task completes. + The action delegate to execute when one task in the + array completes. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAny. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result of the antecedent . + The array of tasks from which to continue when one task completes. + The action delegate to execute when one task in the + array completes. + The CancellationToken + that will be assigned to the new continuation task. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The TaskScheduler + that is used to schedule the created continuation . + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAny. + + + + + Gets the default CancellationToken of this + TaskFactory. + + + This property returns the default that will be assigned to all + tasks created by this factory unless another CancellationToken value is explicitly specified + during the call to the factory methods. + + + + + Gets the TaskScheduler of this + TaskFactory. + + + This property returns the default scheduler for this factory. It will be used to schedule all + tasks unless another scheduler is explicitly specified during calls to this factory's methods. + If null, TaskScheduler.Current + will be used. + + + + + Gets the TaskCreationOptions + value of this TaskFactory. + + + This property returns the default creation options for this factory. They will be used to create all + tasks unless other options are explicitly specified during calls to this factory's methods. + + + + + Gets the TaskContinuationOptions + value of this TaskFactory. + + + This property returns the default continuation options for this factory. They will be used to create + all continuation tasks unless other options are explicitly specified during calls to this factory's methods. + + + + + Represents an abstract scheduler for tasks. + + + + TaskScheduler acts as the extension point for all + pluggable scheduling logic. This includes mechanisms such as how to schedule a task for execution, and + how scheduled tasks should be exposed to debuggers. + + + All members of the abstract type are thread-safe + and may be used from multiple threads concurrently. + + + + + + Queues a Task to the scheduler. + + + + A class derived from TaskScheduler + implements this method to accept tasks being scheduled on the scheduler. + A typical implementation would store the task in an internal data structure, which would + be serviced by threads that would execute those tasks at some time in the future. + + + This method is only meant to be called by the .NET Framework and + should not be called directly by the derived class. This is necessary + for maintaining the consistency of the system. + + + The Task to be queued. + The argument is null. + + + + Determines whether the provided Task + can be executed synchronously in this call, and if it can, executes it. + + + + A class derived from TaskScheduler implements this function to + support inline execution of a task on a thread that initiates a wait on that task object. Inline + execution is optional, and the request may be rejected by returning false. However, better + scalability typically results the more tasks that can be inlined, and in fact a scheduler that + inlines too little may be prone to deadlocks. A proper implementation should ensure that a + request executing under the policies guaranteed by the scheduler can successfully inline. For + example, if a scheduler uses a dedicated thread to execute tasks, any inlining requests from that + thread should succeed. + + + If a scheduler decides to perform the inline execution, it should do so by calling to the base + TaskScheduler's + TryExecuteTask method with the provided task object, propagating + the return value. It may also be appropriate for the scheduler to remove an inlined task from its + internal data structures if it decides to honor the inlining request. Note, however, that under + some circumstances a scheduler may be asked to inline a task that was not previously provided to + it with the method. + + + The derived scheduler is responsible for making sure that the calling thread is suitable for + executing the given task as far as its own scheduling and execution policies are concerned. + + + The Task to be + executed. + A Boolean denoting whether or not task has previously been + queued. If this parameter is True, then the task may have been previously queued (scheduled); if + False, then the task is known not to have been queued, and this call is being made in order to + execute the task inline without queueing it. + A Boolean value indicating whether the task was executed inline. + The argument is + null. + The was already + executed. + + + + Generates an enumerable of Task instances + currently queued to the scheduler waiting to be executed. + + + + A class derived from implements this method in order to support + integration with debuggers. This method will only be invoked by the .NET Framework when the + debugger requests access to the data. The enumerable returned will be traversed by debugging + utilities to access the tasks currently queued to this scheduler, enabling the debugger to + provide a representation of this information in the user interface. + + + It is important to note that, when this method is called, all other threads in the process will + be frozen. Therefore, it's important to avoid synchronization with other threads that may lead to + blocking. If synchronization is necessary, the method should prefer to throw a + than to block, which could cause a debugger to experience delays. Additionally, this method and + the enumerable returned must not modify any globally visible state. + + + The returned enumerable should never be null. If there are currently no queued tasks, an empty + enumerable should be returned instead. + + + For developers implementing a custom debugger, this method shouldn't be called directly, but + rather this functionality should be accessed through the internal wrapper method + GetScheduledTasksForDebugger: + internal Task[] GetScheduledTasksForDebugger(). This method returns an array of tasks, + rather than an enumerable. In order to retrieve a list of active schedulers, a debugger may use + another internal method: internal static TaskScheduler[] GetTaskSchedulersForDebugger(). + This static method returns an array of all active TaskScheduler instances. + GetScheduledTasksForDebugger then may be used on each of these scheduler instances to retrieve + the list of scheduled tasks for each. + + + An enumerable that allows traversal of tasks currently queued to this scheduler. + + + This scheduler is unable to generate a list of queued tasks at this time. + + + + + Retrieves some thread static state that can be cached and passed to multiple + TryRunInline calls, avoiding superflous TLS fetches. + + A bag of TLS state (or null if none exists). + + + + Attempts to execute the target task synchronously. + + The task to run. + True if the task may have been previously queued, + false if the task was absolutely not previously queued. + The state retrieved from GetThreadStatics + True if it ran, false otherwise. + + + + Attempts to dequeue a Task that was previously queued to + this scheduler. + + The Task to be dequeued. + A Boolean denoting whether the argument was successfully dequeued. + The argument is null. + + + + Notifies the scheduler that a work item has made progress. + + + + + Initializes the . + + + + + Frees all resources associated with this scheduler. + + + + + Creates a + associated with the current . + + + All Task instances queued to + the returned scheduler will be executed through a call to the + Post method + on that context. + + + A associated with + the current SynchronizationContext, as + determined by SynchronizationContext.Current. + + + The current SynchronizationContext may not be used as a TaskScheduler. + + + + + Attempts to execute the provided Task + on this scheduler. + + + + Scheduler implementations are provided with Task + instances to be executed through either the method or the + method. When the scheduler deems it appropriate to run the + provided task, should be used to do so. TryExecuteTask handles all + aspects of executing a task, including action invocation, exception handling, state management, + and lifecycle control. + + + must only be used for tasks provided to this scheduler by the .NET + Framework infrastructure. It should not be used to execute arbitrary tasks obtained through + custom mechanisms. + + + + A Task object to be executed. + + The is not associated with this scheduler. + + A Boolean that is true if was successfully executed, false if it + was not. A common reason for execution failure is that the task had previously been executed or + is in the process of being executed by another thread. + + + + Provides an array of all queued Task instances + for the debugger. + + + The returned array is populated through a call to . + Note that this function is only meant to be invoked by a debugger remotely. + It should not be called by any other codepaths. + + An array of Task instances. + + This scheduler is unable to generate a list of queued tasks at this time. + + + + + Provides an array of all active TaskScheduler + instances for the debugger. + + + This function is only meant to be invoked by a debugger remotely. + It should not be called by any other codepaths. + + An array of TaskScheduler instances. + + + + Registers a new TaskScheduler instance in the global collection of schedulers. + + + + + Removes a TaskScheduler instance from the global collection of schedulers. + + + + + Indicates the maximum concurrency level this + is able to support. + + + + + Indicates whether this is a custom scheduler, in which case the safe code paths will be taken upon task entry + using a CAS to transition from queued state to executing. + + + + + Gets the default TaskScheduler instance. + + + + + Gets the TaskScheduler + associated with the currently executing task. + + + When not called from within a task, will return the scheduler. + + + + + Gets the unique ID for this . + + + + + Occurs when a faulted 's unobserved exception is about to trigger exception escalation + policy, which, by default, would terminate the process. + + + This AppDomain-wide event provides a mechanism to prevent exception + escalation policy (which, by default, terminates the process) from triggering. + Each handler is passed a + instance, which may be used to examine the exception and to mark it as observed. + + + + + Nested class that provides debugger view for TaskScheduler + + + + Default thread pool scheduler. + + + + A TaskScheduler implementation that executes all tasks queued to it through a call to + on the + that its associated with. The default constructor for this class binds to the current + + + + + Constructs a SynchronizationContextTaskScheduler associated with + + This constructor expects to be set. + + + + Implemetation of for this scheduler class. + + Simply posts the tasks to be executed on the associated . + + + + + + Implementation of for this scheduler class. + + The task will be executed inline only if the call happens within + the associated . + + + + + + + Implementes the property for + this scheduler class. + + By default it returns 1, because a based + scheduler only supports execution on a single thread. + + + + + Provides data for the event that is raised when a faulted 's + exception goes unobserved. + + + The Exception property is used to examine the exception without marking it + as observed, whereas the method is used to mark the exception + as observed. Marking the exception as observed prevents it from triggering exception escalation policy + which, by default, terminates the process. + + + + + Initializes a new instance of the class + with the unobserved exception. + + The Exception that has gone unobserved. + + + + Marks the as "observed," thus preventing it + from triggering exception escalation policy which, by default, terminates the process. + + + + + Gets whether this exception has been marked as "observed." + + + + + The Exception that went unobserved. + + + + + Represents an exception used to communicate an invalid operation by a + . + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the + class with a specified error message. + + The error message that explains the reason for the exception. + + + + Initializes a new instance of the + class using the default error message and a reference to the inner exception that is the cause of + this exception. + + The exception that is the cause of the current exception. + + + + Initializes a new instance of the + class with a specified error message and a reference to the inner exception that is the cause of + this exception. + + The error message that explains the reason for the exception. + The exception that is the cause of the current exception. + + + diff --git a/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+sl4+win8+wp8+wpa81/ensureRedirect.xml b/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+sl4+win8+wp8+wpa81/ensureRedirect.xml new file mode 100644 index 00000000..e69de29b diff --git a/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+sl4+win8/System.IO.dll b/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+sl4+win8/System.IO.dll new file mode 100644 index 0000000000000000000000000000000000000000..01edf729d6fd3f62b325ada34491065ecf202911 GIT binary patch literal 22704 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 + + + System.IO + + + + + A strongly-typed resource class, for looking up localized strings, etc. + + + + + Returns the cached ResourceManager instance used by this class. + + + + + Overrides the current thread's CurrentUICulture property for all + resource lookups using this strongly typed resource class. + + + + + Looks up a localized string similar to Found invalid data while decoding.. + + + + + The exception that is thrown when a data stream is in an invalid format. + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class with a specified error message. + + The error message that explains the reason for the exception. + + + + Initializes a new instance of the class with a reference to the inner exception that is the cause of this exception. + The error message that explains the reason for the exception. + The exception that is the cause of the current exception. If the parameter is not null, the current exception is raised in a catch block that handles the inner exception. + + + diff --git a/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+sl4+win8/System.Runtime.dll b/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+sl4+win8/System.Runtime.dll new file mode 100644 index 0000000000000000000000000000000000000000..967bb30a0d84f969455800059b74fae5c24271df GIT binary patch literal 22208 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 QU>aprW%>sEYaZx-0jWNPVE_OC literal 0 HcmV?d00001 diff --git a/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+sl4+win8/System.Runtime.xml b/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+sl4+win8/System.Runtime.xml new file mode 100644 index 00000000..93cb00d7 --- /dev/null +++ b/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+sl4+win8/System.Runtime.xml @@ -0,0 +1,56 @@ + + + + System.Runtime + + + + Defines a provider for progress updates. + The type of progress update value. + + + Reports a progress update. + The value of the updated progress. + + + Identities the async state machine type for this method. + + + Identities the state machine type for this method. + + + Initializes the attribute. + The type that implements the state machine. + + + Gets the type that implements the state machine. + + + Initializes the attribute. + The type that implements the state machine. + + + + Allows you to obtain the method or property name of the caller to the method. + + + + + Allows you to obtain the line number in the source file at which the method is called. + + + + + Allows you to obtain the full path of the source file that contains the caller. + This is the file path at the time of compile. + + + + Identities the iterator state machine type for this method. + + + Initializes the attribute. + The type that implements the state machine. + + + diff --git a/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+sl4+win8/System.Threading.Tasks.dll b/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+sl4+win8/System.Threading.Tasks.dll new file mode 100644 index 0000000000000000000000000000000000000000..03d08ad93e7cc6f8ae5664b89516ba2010a4f749 GIT binary patch literal 164576 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
    A;XM&re5ZI=Miv% z@6p}IamS99N6DC8CPqU={A6rJ_-vFYc#7SYVL6cx7 zgTdq+tXZ3Uz#@}>mlxRWgU&tnN7!*zFLUwZAEZq7{>amEy|(g>vvWs^)-o(`ewDQ% z$ZZxkRg+wUhh7`9uJKXQTs|N4$gh4vUDo0m-?Eq2;V!2|x1!@3f6lCOzQ!GUZ^%* ze6@ayj#r;ix)?z2C4>ZF$_8Y$bN8z~6YKTTrFc~#ZQkNNoRZ6sA{W?00fYDLho41v zm;C|Sz~)1xp~8XgO@)#>T-;SCRi8E$`gRwJx%7e3F1I+)zcZJwcA!$ZZsfn0jy@Xmq$T^AP)ZE>$H44$*|th4&g*mcI4i2*n%zbkg{C*E{n>EN;3U-|pD9G(B$cl>sH<@j}%-SDoDY|h^^=fo8}2!{GZI}&}UJu3-_ylrFdvJd<{{26cU5@-m09yp!nc(lWfX6z7_If=39C&ZR^Y4Lg z9|AaMuEr6sdvOd<0oOhpl~cfRaW`Tat$^dXhHylXi_eLAade)GBi@Dp*N^mGAi)p% zOs?oI6mwCq7h`Av=l=HLe3}8|U5Zo*|MdY~LC&V%@1BxY&T^4N}d3Y#dy* z2DJ-oPgSI3sh&$%A1s0P10w4~oE&JAptZM-+Of2L0Z6v20qJCzERmu?u)sXBUqHSu z0HQi1kel$p}e61ulj_*QG#H!jr1v zJW#m-|5WGb$9X~p?GxxfdtOKdW7}dEs<{M+h-{!*A*cYuaMM>`l znj1y2#?n0xeg6Cxf{g8c06nN6jaY&p*mVcAOMvK-$sTm9J_&zMuvS%sn!u7 z+%b8C!Op5m4WR+q+e+xV)Y}21b|H`GRrMw9eW>IG=&!G%m%(QFA{eX3j|1hV$wt7s z4Joa;GK9N?0xEy6JYA1`%5S%JnRHU3_wB`9K(hQ&WDJ6If^Cx8Soc~{XBwK#Qv3kW zjkQe=p!ijjFHTdThK|jkgzZaN592-r+J@!22PBXj4kC|IZvP5;jsq?_A`u-zoQBGz zq*>D1FuKkeFNxr2K0sSQmJgc=E0-SK*QTfWUQIs5bs4uD)#^En)@`1+k*T^fVwa>|h z_S1oOcMWZ@Ry7I-yYm*vXA9Ul1j#9_8t;sd{_*6LwDqWH&;M;j%HEBy>>#ST#II`n z>kC2QfLLPsJ#71ZkUecPrMH zpg->saTdKELcObr&BskVG~aZLzlut8{tI?3HtJ6BMW3H4z^hplAs?mP8W+(9d8(J(H-gQDOi_$a(orLiw>McNedXT=F zzLL@bNQmqN9RNyVul8pY?C}e7NM-FLnFCn?7L*L^0|jegcvM%t1gI{=RBGj9iYc3V z8PHK8hXk3b`Ej7=uAyKHa0iEqJTa< zKO$-ut+(nDzeMqXe4f9!FM#n~qJSt&peNP%9c#5}Z#dL{7{$)?vC`P&DHw>Wlh~w^{~lr46SbBs8}%c)d_I0dP@cKtFdp`!7Wy$A8U%Tn&Ubz=-V` z=jVSGzyX`*yTdj0q~%e*m5=iKC^E-S1pN@2VP%jv;Mc)6PYM zgN0&x?Txz%2ZsB2zaKw)qw?e0nU6Im5kDSbm3sm(SttyqclVbLx+Nl>w!uvgFX?4 zeMA4yzVy(({?hnr8&$ZKXg41k+_lMdhtda&?!iKF=urAV-=Xv%GIkcy!yqiZ2cj4P zWC@V_itb?lVc~|%?{Wu4ED*&mcVM8fi)@yUI}O zL;Zt_GO4&b^aY`!e{grgTn`Q z0v7MQb}ymTRi*vHabHo`9EY^;`o8{wzMTV*-NC+Hh4h}HdjLgAkHfn`0*bt9U69*Ap;S_WQh2+!U|E3z?MoL6d!VV%@U%2VAGqn~8iog;`ay*NKeynr=bgU4&Lpj2#^^Y2*(6XVvesqi7!{`vZ&~QWtH9Nz{%ua{qL0k3@ zVvVE-MN||ijRLK^t1ZH)X7OVKSbg+MLjf;hwnyh@?@MK%;8{At+FQU4^0_G^5f#H(0_I_Z1mFdI3A=gE( zA4I>}#}+E3y-tmuc0(W79Ne3RnH=)z=}xZ(_>KJsh7VBcKwJg$5fCfwms>7En+yFLhLJBj`4V#3jhawRQ1z4~E+GIHr`+Ko*b*pzv2d_hC{Z+hUPJCI4BbF; znqLep*qy#;aA-+S_oaO|iiGRhu0^Z0j6<9b?jUj%C5%HT32JOzCIDi=3V;=yN3q~=sf4Iy|J)sc&H$Z2F5Io z5U7w%q4VtSr{zVuUyaF9g>)YoZk2<=PTZH?Gdw6mXLo2T8oh4_qsGA@q2vG-yM-6n zE{;qz35r;evglm8G{jNhhJEPq{j`tJGH-ARbl}S`0#6*PVe9*)kxEd>{ym4Jf!2^F zV82Y9z*6_-!oZ$Q1vS7>cuIk&T`RU=RUExzWq0V+A+~`+1J_I;LKF564hNCZjO;|i z>`q_e4({DFJUB>vE>2-Zj4zxA6QSN?W z_k!-wWiLqkf_egZvqOuZ*TH36P0zbKwCM#Q+$g@;y1st66!70Bz`6Ma;T+pVCP2ET zO0;xn&mha>MA@`U`v&`{2=Kn^J8x+pjKgk>FrG6?0|GCEjT#eeIqv(w2=5^gVXwy9z1Z){u zr)l)<7L-f*O3NpUC&+-%*d01D*|KCw*%Y{s{`duVY%ltIj-$oCG-#_16IIt#W-u7Q z`>2w>!NTNipNnDR!WUG#*Z4IF1T6R2n<=VT%50ks{_}X37uTG$3C7-C zGG4>_1{m$ zQw2P49x7toC=ufB-~WH?y$e`X)%O2A=3I--1_4F!F3KIb-|>zpppxJf#S01uTg4Cz zwkc*MVpbIOP#^*Pn7MJO`3`M9n@R=w4(=I-)1o*@qOu#kO12^fp zLH4KZAY6{%@&PUZxIByt#loz-j==R9T!!I-k7(gPPqyPDgD~IL6Lm4`4%;f54PIq^ zi}hnxaQ_EP}=qlBb^jZ+O>NzdOp&f zwjb+$UfN)9#Chon{i4WX#FC{Ujx;u&;txw9`~FnYUcE{E`jOs{)f3xh9IFG>2WnAm za7Q-jKUrTHN^w3%^@Im=sLt=_P-<>&Y_1KKkEt1BgDqor~xsrU;*`BeH2RxysYJF<3T z4MS}WW5)FxXM^%_rxnMkSYc>4v`!<>40A|0JetgQ>EC8JqWSc?nB6kz+{HnvXzmGW)@MgE>s zmrNr2gOkYq3~vvdOqN5F$>-C_)V7yd%|fb4Wg(@`VST*tynGV27g8%VvZZ|yr4B11 z&$1%g-&q-atY(u4gbiR<%f35Io-kx~QtMQ-}^hff*vkt#g$F#vP8OelE zU?9y$n+JH~+*m}lOujTz719b=i)pQ46)Zs7$5C4IFFv)x-)8TL=c*s<;G#c7O28pt z7w0?AY27sa!4wKF!vcIb*H=(oA~8QvAX79P<$N(n0T2(39J3En0`!Jc>^WGB5gzy# znp3b2eP<&9?g{?*D@M5+DFx|cup_Nw%7(ANK-z_V9yo{EH|Pm)h|_Z6d!~<=M)7ad zwt}CLJYX#N2+D`E5#XNZLmMW1*%kM0JU&Xd9!t-VRC)n)WE!ifGt+cUT?Ex-AyNu@ z`U|S{GPx1s5YaK(C+Qd!Kv(vBPo9@4_|$lqpgsCUQ#g}{L1~5fE8POq!jU}ikHJ}- zuRo{V1UMlZ#&mF6H54-4#xw_}u;)YUSpyDE+r??Oz;r>!;eDptp#r}%ZUq-`-1fj@ zKASy%=CoRv!%M z)C?wJ+lcMsCI%aHR65wGb=?Hc=8qJ~LXeoww4T#K#0;jROktv&=@L_SQNg52h!nG!R0+|difMcal@KeOOpBP}#LZ0q zV2T%WnY>HMGfCXSq-vHbZevn4>mzEJRL%N{Iwn=K{^AZMRkH!&P9{~e3~@KpD_laB zxQFQ-rorM~Cj2`umYyx{XNqRJK`dj+XBsM&IFHt*m`2{tg%kQWeUGUV0VO=~>OS+Ix9V)(Q7uv}%pd_>_>W!g6s8ykqdTVHZ zBLN?3uQCFmMc5oH@xidRW+1E$>txz&uZMjEV;39`3pd9u_<;2c>({J5vHs2q;pF3n znhIXw!%P8f!`q^EWesPIMh%3X;hos06jQ6hr=va?HWT$;_F0G84n9Nmg|{Z{2}^~Z z-RBsoFp_l&YZdG9(2W>vbN9`d_qpy=)^66Vy$4MSXV+R!&h&8tTCqr_C4qW2vk*aZXzx1je05jgR}v zHgdtpIO;Q{tT(aVf|>yLqGtlEW!;Mw0q@3ja2N1tTsPD|;-XP)@ub1=38*RY$?ge| z6F&oMI6Xei-GF|Hcc6|;{0M?!O5zNx?Tv|@%wU+GI0v`G4XVkm#Ah(?%ZWQt55~~; zJM90@#IG^0Jqdpa2m9nsRKKL1?!J(d)Y{$#Zc7?zAGzT9B&zwVtZ%b^!D=Lvy$x$5 zYbI*}tCRJ9Q~{fkJ7M2=HhH04z>CSz7(YK{hTG@`f22@L`lOOZp$Zs+I3sJ`$l z>+7jsVjX;YkdHrWJZlbX5$heSn_2gDdW;%Y&?s_w45p4BLAS^e|vwPwGW~?-}jh20lbj0YCH{jCQlvFpoActk(>;HgI3> zB2Qlk=yw;Y*?)!`^{Bf%+rZ|5`@C$hYaq4ld#E<}df*|nK*k%W?J_<<4a-Qwd(hq) zpLrQ@jK_!Z(Nq(vg8^eQzV*T%8_%HDtIVL$V{QiZfjiOS3lC;o!Bo{(%QLA5-kI4C z_vqowT`dJ{&-~WQHG0TF^=-#4@MP`AIwXQD(Y&3_I-Ye3D#aY=;mUg3uX)= ztzo?bwJG&cjI&}8=~Jw`SdXxtU_FQ0p?YdN_|P%JV;M8+g8~DWw)xHEfZ06F&RgW6aa2 zE%IJKRrOJ=N3HZ$0N(Dx;tn6XXXDZT#-dy#d!Q?A6n^F!Xwi85%r(NI61?}HY|#uX zyV|1J_~QK{rdllFR{R`#h3OD{?S2=2yAv10CD{LPzZa>eA_%pwK-!`y+P)q?)%6S} z&qI)Ge*$R-QytgZ8}>0Rw?A#)i)p`Wdd0pUNrq6q<@RIt*N{9ly=Om$pCJP@Ne`k_ zO$kgnnnp5B(R3%%Tuob;?$dOfX@e&4q?j*iie`FC(|D%ynwBtK(bT}yI#kvAYo_j+ z{8~`VG)?`P@-#V_W@uW+v_R9}nO11}ooS1v056L9s-{s)?`yi9=^IV!nanU%vt3L$ zH6pj}hfMLB{>3y%lfO5WP@ri5QzUnEh*+wO{q*zXqwElPt$y+w>7P1x}a$% z(;u4NVDjs(>iH#8q$Z;km6xum8`D@#=}hICDwq~(+Q_t0(??8OHQ9YBW`m{_rc;`x zF@2|LC6kT5ti&_tBvThnZCX>5L`?&khG;5gnyhI)lT*_MroS<%(Z&Z>S>z{tV3S3i z@RQ$8iz0aS*$-N!C{NKfN~XgsMRxD5X)*&Ena+xiUB3|-a6!|UuCqlJ{K0hI z$(m_@?knFp6;556r#zi+f+Fi#wzl-rCXXD0tGtlXG|Lck7}9_ zP$jcrlcqZZ<{nrgMSIkdA2b3YsH_0e*?irS}e6AxA(f{`huX-IF%R|^+{wn}{Gg=v}n_n_S}AIf!F``~>@3p9lXzbePU5lzX#_&o-E zr)fa&Q8@|9>2++3nH~HN(gjVUgHI!Uuj#JfvvM*7^i`fKkP2ZH6J04|jUw1@QLa%6 zCz#HA{4I36fj>yrkMf=Os1IEu9gwbRHIqZr6HHZ##PgwP=y|)Qy`kCorNI)W6)-xu z1Y_Q(>4VS`V;U^g^hs!$Q3ela`ZBb_m;v=nYGjxJtC<#It#84!rxih`uv+6r*sm!t z>^`FcPG|}ZTV>3GFD%+<;2(q1Xpa^_T-bJF4s_6zicxNXA)3-K%55;qq65YPSZR4~ zHx|Nvi;fzL;ezG4(YOcv`l}Msu=M*Olc^qthMh9#duRIB;5I63ja&{(Ic*tC4*SGd z4h>ATP!aaMQ4b#J)|0Lx+7bHX-_xvd<=FdPq-m`l=&E((=>|7 zYXIQC#V|EIAJd-HG$TA4Ho}WcsxBMhuu8)cDD4v_RhNx$L8aNZhW{)!LWhAAvzBYN z5egN-f$(Z`Bh)gfm`}jHOe^4<@EY?8*r4gR@I~e(IH$?C`@QB<^oBA1TLBT>mzz(+ z157H)R#>VC4o<2tw!&^r3%jp1x5BArp3g$JOp2m<weta4t|QjGa?(dLyD$W5hpP%TT=`3 zq`3no>3r=XPRkeICQacHX>uoY;1ZUB+vI~`J7E#0slD9^TbP!^+Y!=jC&Uk;(wD*-ZU^9Dopu!S9e^#GPDBpIv=^D` z;B4e+`6?V?s_iW0y9Nxh*?sfdcOhoOn!0mOI%0zwQ z4y1dSR4W~YRhpG_pv30O`5xiL}@46zpSK z475idLW^N4jgItb@Mcnb^bvGW1WTe1xqSqEnU=%u=x^Nq0ppmK!I9|S+&+f&Ob3k< z==m|cz@*ONGq72C^3gm4FEM=zCvaZjGw^0J&$IBI@`S*cVB1-U98NVO&lseUOe*Fl zkj120_Y-o%e}~+j$E#rzQF}H~VoVR)r^*pM(~!J;H~5aJ7Nfjqy8`JWxn?jc z_H`SGwM>VQZpFWp?b0+S_Gcl*`%EkBb+K>Rr1(VB{Ya+xmT57piOmL^@Ek=k>)=JE z7^Yfyi>VKjI_@?xOnKto{$#U>={jFVT$=O{`9=JgFY0KN_Thn5WO|skJLg8 zW>U5G7DY_w#jIFgcOTKH(`X-B;)@LwWf{zmuX1ZCMl&tuW7JBNFxA;t#HYzt0$=&X ze|7ffndWLb5P#BaCF(StiT_#nihG$B+y51xVe=J_=rlUgzG90eI?}$vYmAENk&xx? zE7~!s^TAidGtoGB8uN`%Y0xbp8-Mb3yhW#Rn%(J4s$JR$udy5x!qBsg2x3|esR={f z+lXYHHY{P3yPxQuPoA|5 zW`wA==m+;mu}XWs>;H#)w0Kfe=cJ!SjCf8{SkeLa7_m9gn3loxqyT%O*l4B2+mpp%i~8AnhzpiyKYJfBqL5;$7VIzb6v3*b3HJVC z1Ol20RD)@lDp{#m4pRz*}ot^H#1Ni$tc*7O^u z4G>OEwv?0R0C9{-^~izZghi+2KyksMJM9@Fvl#GSEwoO#)1D=qn*39;VX)YyDJ3OM z4i?E%$a67-hEZBNQ!UbIO#4o!(Py9`!mmVmW@D5gBC&~VLqxho_u8|?0*mVHH;CO9 zJ!;Pp?_2b^Jy+~@P)v2M3>Qb38gN88Er*NrsgzdBXU+&w#Iy{mQ>xrXh_`gwy(xZT zr06=0JeR@aDNox+3z`d)s3GNf`&bdL>HU=5_Hm*{5nm}Mh$T#m?esmv1W~VPL~5Fx zAT}w2sj1m8K@6BqF&6{1!~}5z(+a3eJ!qeR4~0`2(Hr)OVx>i=?2|-v8Ko`9PX)VW zp?Fl&7pdRc3&kcT)w2pk!&TIC2IZq`&KQqEvCg6*4}4bSMw#9`U$IbSZbm-0a~LITr2mm?LVCR9%jE+#>2NI`2^@ zepLjWd;RY5H!;70Jt3}FHY^pVnU+CGuPV2t;#a0x`^~+cziL)$&a~Vs?+Fx=`m5Kse$vYVmj~fDbqHcc8TePCb~90Ccad}=h0&VW~AZ)NDM5SI^`V%_Om+4*`pm*8eVJC+FZ8(?DO0EY z*k?Y{YNlFn@0*P+u~(=0^`$7MHN`T0r)fZ6YTcGMQ$6eKV>vC6X|cVWX^2V#y7PEU zjAJ@z(5Ug4*r(Ix^*t>g7yIXM6u77F61hRlol8^;EBh|=+$hd5)xi_!`GoMRQJ#CS zo==JlMfUfwyeGwYO}{YB(w^S^PGj2Kc`D!Fe)uh)ILlNEW0^YKqSB`Id%$y(IHTz{ zOxr9P=c}}p{Z@Hy7U{PV)xtJRds?hxI%w?fmnNSUk83*8Z>{IkVxOWGr~0jt&xuzw z{nBp<(g96=X=~*3qCrz?8h%C>hct~#8{oEGysoJ_?E%m2V%+Ui`ZBmLZMWwRv5)Dj z*qD|LFNh;db#Nx_70(yM^abQu3twZ}PVp;~x=Yw8LTV|k4t)D(<5PXJk%l1o_kX~1 zmsr4QwGiKbu-k5Nf@v|(m1K`NXVJa(JtANsMd38tiz3RRN9}t>UyB~M?-TV*wUFLF zO};G7Sk&P8vdF9hNXOFi`af>pFE$`i&5HZK;`yrBzev$6tmi>-LDK_Fz3!m2T6mht zsp&A&%Ec<*hy5Ep4~qAZa1@41{onCyz(2#g=&a{!BE+H}JP(T@78xyG7qcwFzk7)- zNL1dX{!uO76d`xHq6}(rLgZL9p~bsmmPI$Ucu&+@bXSWH#6FAGw)jx|ilk!hYw@v| zbvMy+Y>tmwoD-*+>L5J*VvEm39Lg}}uVRy?+3A^Hm&HXSDsOrE zXs_Qzm-}5b(d&vBZP8S(Kg1-9Zt?=T$f9{(Qog9JoA}Mwq$oETyOc}k>$^?%W>WV{ zHaV1uuBk=RCMQ^Q5$Eb&Xwl^so^rJ!{O06GuNHE{GKxw0+`PTzev8_8`^qy&>RKG& z-Bz}Gz(rBs?POnzdU89QpD|2Bl-0RyuQow>3UluJ87EQ`!1-F;hN}v zqDCfbO3zHge5IP`o}otG#8hj4D{~goor>VI%zZ6uyi!gVXLKblSR%}%jH{0G`@7p zy1&&*>0G0tBxY@B^@v<;(e74j3pd&gEI^yF(7L=uY3=auySLKI8k6^jq)pe8=}y+1;Ywd=JY!Ch`nv z{f4|^rRBGNN49>G2 zqbo{VKM$h;iH`fhtPH=F#*Y?F@bfhSo^Yi({rrp^i|+GlZ`_4Mbvc-|)vt@;_oU17 zZNDHR)1n{zLX24!wQU=2thT6U+eqU(Bo(E&ZJcr2CL%f;AMi{u?p4I+U#ju2ChEJX z#*>=p{7W@ z_ki9;p_P^my^S)9jgVSWDafXSme-C(O z8eUr{N&`HLo>_+1GemVTvg;C=W&Fle3%fCGkm0*kr5zc3S`IRzHJu!MsqJ86#IuyP z0xk~zy=}I!VVjFQ+TCDud5&lqTpAqEZm97XlN$MQjopfP>bt_BP#FBR9S#`#Ec&6tLF0@?o*fSv|3XqV3+;H+Xt~ct z86Dp+I$KoQ@wgFV(VZRNHTqceOvh8kaEnfK{Mab8=#P${8M7^l==7CwC)09hKP11? z55`4JF+&PF{b-DPN!5CNR(YqNjJqtlz0)to4vQY_^qX{TW(7BcAL{d?vc5Z8W?RR0G z{mtnXHFORz>n%FdIoRBZM8|!7mh95qJYuDF?-FbNYEgEVcr)aHtAv?dlFShnE$fnM zRw1bOq}u}~Z3DdKRzKtc z&*hpL+#VgWyj#6R+lM^TZH0L+=R4%_+K`{c3bUT+pmBD{8o9z;$y5hF4B3dD;t0hg zTHbAy>C5z*_}7rF-5xRhm<}4A+1aq#Y^SJ2V0M~ZZFXd$=VmA^nMqxNR+~jkEA0ET z8@jDFr)zp5l<04Yppnz+nbfy;tIao<7Qr{!Tha3((=vPL4JW#-F#}$wdM>jMM0(WB zV_IRq18J?fQqy{*b>{m_%ki()XS%I7LyoHb`}l?n-5xicOv~ZQ4c{WYuc_nEpONrU zQvA0Z;*d6&nM~@l#YS@i6J4t!JU5zUiugOnC(N5Qtr_}Aw&su!8Vu{>rKA>rdV~Kpq?8%-g=F{d>CKdB(v!+?h zE#|UjF}IraOo!~$3$~gonU;Y^PLW$ znWH@It3!wTykIWS^khzve8Hq&CsHx-yDqbjMd<-M%`5Sgc9x$N+im_mfytv`{G#C9 z=1D~&1|Ou@ZGNO_6w}ArbMAySa<_SriE4e)+-+uNQWPTmR?N&%1gVqX3)^EJyR~`R z2}R&hyhQFXm)_Zw_M*8`5oBZ9i{|OOn$q@~=M=$B#lwB}nm6M2D6aDMn$?Qnsp75O z_L}eW=V?`!edZZO@CnA;XNIh5%J-5Ptq8oP)C9d`e!Ql6+UJVEF=dH-$>bN4@d{Lf z^s+gZKV_*BUNILaf_ta@9`}lwx2`G5ezQOk?8LPFX3zCaX$Q=7Mes4E9WX;4Yf5|7 zj8+65CBMhLYVP6BK&rfh<^e^}wInd%py|7@DPM!xQ4tKpv<7n~e_m1fUNdJaf|(_+ zCA?<7^kh@ML*@}h@GzzwGH>46ly=zMq6oe(c{lN}d7Gv`N*?e$VjkvuVO7HGCjIag z9u){GZJ+eI`KC&PxY8$E9yL$ky_D;S9WzfWg1)6oo-j}Gby}spYkr~#(jD(6zH2_gS3H$=(%hy9W?~x6b%Ad!=D1YC9^O9E zOes}@vRrTbBK!Z$dWHSHb17y!);@@&fMvPYti1QnUK1w`h`W)|1B zLBIBZ@2fce!iOSMpxuBuoO&m!gnR$%?WQ{58&jCegvYQBZm^XjxN3EEJte$kr8cj> zgrjIT;8e5JudlH*-`}6vv$;0ahgw6m$<^vAvH6}F!^o$_FlsSBR0I6cVnPVp<5|;C zCFGzQ@MnwQ=dT1zVNaz^H8J?9E)!;OY9;HqVXaz8-Mg;drkc!SpW9I-+{yJ(d+oB2 zPt&%c`+&04V=e=8QT?0ex}JRv$KTYf#5LF1RuL%GgdNR%n%iGSyBoZIoz&*JD2}1y zoM8WtS!v%Te2wj6zz=Lu`*p2_JPr0Vwdc?RYMHxP|HXM*4krt#gaA|nB5?8=0dZ_k zVS5kW&KyohM3t!8U)4nI-5B;MV0EyTv);_A_G>h%RDf{VbJpX;-JhrtH^K z71=(5N>QrX=i1S=E&HgkwD~rTy#^>tXZ8tVjbf!EEBN?Ih_fsbk9CuswvGQH)r4%0 zFsYfA;I@S6Y-zq-!S;Emc*b3m+T2ssQ^i#ES1quTbFF4o+q5qdp68eco24or73W>F zOE}G`pR!UN1boT%E4=;ZI3~0hNj@qgO6bem>RLc5VE|i3TIw3f z$#V7fIJ6j0+RU@bV(Rf<<+|3cTBfYTf^Ey5m)TBF+o~~Nf+~?L5>#2#Gx7JaM^T&zRKfjFLNr^* zZbCm)H^}AG36{EQNEQ`AfZC>gF*v5nqWZQV?Z%_nw;v! zsWz^mJHCZW-yKw46X)OgU#~tdn+{TusZTwAAwkZGRx*YA2TZYE- zrkaxv&IN_)&Skl3u8#O7j<%ciNHaap+gDg^qbYJAs=zm{X?p;w0lBCqj6-#Usi-zs zfGYGAws~KDnC)v>RUcE4cdr40mqllR zfWcgrs*l=7>ce<`aZO0Avy8XZS*Gl&CDk_BRf+g;r{(FgsAx0TJ{$G=@&6oCd8)J9 z6-`A@$9)dRyte*ymBd_JmKs|qvcdgRjQ|4FSV7lKb#|M2#CV8vk-Cn8+E!C@}E5gC?8eIzZ)@J=jngzFL=Dd zmciQor+QMkE>Eh-e;Vb~J&ZcCYOL7G$KwC*=iMCMix*i{4_9Y2^#|98L3Y=bi_US^ zh(YZvxV8VA-q<{s>mICm4^*W$xBR<4>83}mgIEWNGeOW1KhE`e*RtT8IM%l7jQF#~ zRja?YyGFmW&ElxD>CYC|neyM*zs6{IMq{rN(A>YtuCBKK^VAKkIi#(QI zTl##0U^x`MbyUD|eyV@;{*igT@x$yYj8pZT-D z>)fZFZ`0#glh3u$uC}PFUX#CTh*S)U#L`m0Z z0nN9Yf38#!)X02=JxL|B8bi5Ms?t!jNKl`){-2F|s-Eg@MBP`bu}f_?rK(ZUbp==B zYLmaquI~Apr>YiEp0w@i=glq6OKI|PU6)m~hqxU`|L^$xSL1Wjc>BL^r2Pet&i{NA zZMs_hPp)yzM|;)B{%rX_tCi>+k;SpQG+f)V+=Ro1pr> zT5aFVrKmbI{SAm_{iFJa6_ctsdzx)4yDFDH>EJA!*Jw%!*_Enq;FYSpElQi>H{bsE zF;#@-k!N$cuJ|TivrL?`&IBJ^{Ba4yC6umYxWwRGnL}_c?IF+}7k~Uw)L`g@OFsy~ zB^sAFoRd5b2Eb4lh)WDE{cxV~68}xY3!el126ZXUs^o{;MbZzdy3zLMI75;j+wqwQ z|0>xFQ|F*ob-NXHxBo)aSe)ai7kl=Chq~U0+e`7O(q6ERx8L<&hTH$}pCj?7IsI3l zK7cb84S?e~QxVP|gzvA_!t?lU+8#mAPaI%<9W@t@vwpyOmh}tP?^!Ri3Q3+GtiG%r zSp!)kSQAi(1PnkuX=bBl0b!ZLx(_CM) zzv=h_JI$+9!|&{Uz!oRZpzP!sl$|`MvJ+??Whc=5WKN#5YzxeZ-Hvf+&Z)EVZ{zm_ zt>!tEx8Mv2`-66Htyc5=$~)MynrB%)E0>P1atjm>j;}EGX*I=BsrGKy! zXg(?@&tkR&_vjmO9CeNy&+qt-$9-8N8+cyN2AyX;CVe8fadjV;JH7)zsE zYf!F^sM(m8=5urMtkq7Qwc5$ERtIwGX`Z9{G|((swX#Kl5gH;s$RF+#!Kn$joej~b z--u+?`JsJLi=;2)7VHYm#IhPf2N>lAM^R_^UkJ^?)Xzn>v8KQ`>@w^t=ops6K9}KG zL44SF<7`1jm=JZbW5bF${$*%6sR}LKCe1^QnY0FHyXZM-1#Z*qN0%XE((14QM*gJ7 zPzz8mL-C|Ec^RrF?FzlgSclsQI(}}!TJ-+~ErG%p=Mu_edmh$jxKAyYwV5pu;=p8E z_RkT0NiR z&lfZ=^?X4y;4Z>w*|134X=a-Ff@Y6dBRsfBJS($P$|8>& zorshqi9OZ}Gcny^_OZ0f- z{-RY;8ZtJ+|Gt%NiE!0QVV;@5AtV=WJzazUrD2GvZPrZljY+@DS;u9 zo^H&PeBF`M!a3+)B=aQAH=HMF9^wMDd@f2kaw*$O*m|*KT`y@??0WQh-kbC*RC=F~w(Hr_=uM;6H?j3xO1-3+ zvw!6FU(I`0FX>&u4U%RH-XLjymMoVS5}8ra^z z_6AAMKQ^-cdpvgaaVI35t@XSwjgn^RrqnlEHcFbWx>3@M-HnoF>~56w9$&qrcQZ*N zeNJ;JjgsE>Yn1fH+Br$HJD-y@m-9JEb2&FkdIOGHHBFwAG}rPuN%Je8<2ukNajfk* zNl#wZ0?iR{PSSIi6fM*DBFDMNaV}c^Z@0ZD>G{i>`1t;ab?^=$|7U!!u>TeIH*xQ> z!8E8Qra?6^4SF)u%lIHaE1vvATKjRTAE$O<|1NCl;Rd6{@Yqdb80lFCbNGs zTavYfp5W|@{%7Lp__pzGl=LQBra?1RXBspobPlF|E;2c9qolXxG7WmRGY>5dp#=sV zN6OXKuM~4R6G}1HjD&K|<>XvWwmaGGH0asSMoI6eEkb+im__Wf$e`ywmvGEQ+&9Rl zxb156u_bQcXj|BG3tP4r^eiaV+0AtUi`syPe^C$apOoym77!2*q(!t>8zn+-C)(~S)WF3w?>0z<33@~ z+0t)iM-(Duo|Luns zoD-ETe%eA$qjq6S7q*13PY7E=w1u8Zjb=+UTawu)nJvlMLQkjmHR%i@&GgMgea1Hj zHKcVO>bBMeT&n`kTfp@!HL3pPXi+`qsE^a6S;n0v%{V@vQx~!SBDODL`y!K`TJ39c z&qQtOM?K`IPhXRIQ6_3}+a>7l6<5!B>-9E0m%0qkxFvXpv&eBWMTn(cPp0&xJI2&x zJW?rv$#RB&VCrgr;f!byI|WTsMK*wZ}4!V+Z^V9DH8H59e>Qhy>p9hwlxmlSc8nuSQCmr> zv!5)(?GCa6wTrAq4UltDL*%Wf-6chi=IwOOn<=UOL*&btIzoPCm-q>9Pyp_``~@vV z@(OCH6dn>BY@aS|9@ql11?nu>3e_pwV(M&8ohv(`Wxni&xXfJviw2yraYSnau+CS6aS{c-;ImW8Cb{NP01?*qM{-x|$&h}ZxQ}a7k0Xg z+Y39jM$d(vl28qijoLyuP}{I}W=k+{Cy5(-X23-8Jx&05qx1_Zfh0WEB@iq(1eW0M zP^Fk$;4j-Yu(u`#msC?ZRp|G+3S(GfOh1Q z&RWYF(2*?o@f39d>pE8GQip9`wjQKUjGxl8U@3C=l)p1+mUXD8#cQMW{enk9=_;2IQ zgwY9G623@CNz6_xPn?&yGVz7P1Bss}8cBVVZcVx~X>HQWNv|h;l4K-DCQnITo%~7i zPsx8Id#5C(3{S~VDM@)VMJH&CnJF|;dw z+bZzyEE2y-%*1aIN8$HjW5EmZp(TvRZxjpg8^y`^jbb4L;4k9^LJ0)n^&%**jSpH1)~T!yv%bRm39Cn2^6AYwg>?z*3#=zu&35Dy!#b3866>w3Ygl)&zQ_6nt7uQT zLRtH>PGFtO`Vi}jte>)ab|C*)*3qmtv(~fjW__FW8&Px}@LTzA6 zbO_n=S!+Y=2EazvVv7ioVL>MTs%=BA-v8m={yX z{xhp;y_!_ApA4rK_*d#B%=<|CVlVu~;Pk(tHl&mP;q;}reLQ^?>U`T;)U)XuP%orY zUbPo$?=G>$X8_qdv8ug@A3)L42hcv24xm<=!@7`to*D2IrZx=NhT1q_C+df6|DF{F zQXPB;Qp{l17}jjoi32H`ll6gtbQC&dQvKCl^vYb>k|M7`Rply+DqYoTzU_JP;XNIf zNu{X0dnb!(rS|I_Z!7?zr8GwKa~d635gQsDAkCKN5exxg}~l^pZHnwn6QHHhcmHN#b8`I-+*Q|0Hz5 zzvxI@x}kQ(aaiJ3Flqq){YTQ36Ez6OVu{u$)DRqxC8ouphCu>qI3%HV$8j0|h6_DV zBcT^+6!bx*zYj^w(;qb!$7pk9iuO$-F@i!Xq?|m>0bs&_XX26Z8 znJ^PI3o20u;Z;Ur4XROx;53N%jttB}y#Z=ahr%tWIdCg#F5Hef4CeumShG6R5pW0U zNSx*kpUQ^2@rab6N|*unpjN`Ys8w)3YBkQdAn`i39CbcChU)Gu&$dkO!1b zJ%n>i;}fSiD>T02DcYdEF503V741nT?t!hoX*=xu|1tzFZ0U_${=A zadI^3csT~ONamv!OZ;9MrpSq?C2|t#a-5A8`BIlrXHfm4Jzr_Q8(H4qCRE2gyVP{98+U(ltT`M z3E^qsv%=?uKNQ{={!aL*@ZQ}sx;J!xulu*%?~7Ow@l3>L5gw7gksBgQqh?0cMQx2b z5cNxxJ=!<=@6o?S`^SXF#KrW8`6%Xm%(pQz_H^u}*iLalaUJ*jV`o=G(q(C0TdJih94-0%SUHE#SLZOVkd9xYtH?w!;Iw|DKvXHG66H(i{t8 z@Jh#C-dIPSh{u{tMlj1+2?VI%aDV_cl6!LM~qInClME@;N&i1X^zE#_|q8)E1VJqCl z>DzR?=e6JS@EqHBX!}lW->K~{YWsd&?yI<_dcLa5YtY<)O!a8cK znhmMS@sO$<56vw!w_rBmBdPl1$9jF1*Z9jMdi|MRf3Da5rs~(-^g2+lgY`O8ufz5F zK~wd+hxB@tUO%GOYxH`pUVmY#e)yGMf34Tw;+opwTT}JN?=^p~`I6>Knt#EYpY zpG?(Hf6?||wEY)tzpU+-wf(ZTySu4=?4j2!^x9jmTk3UZz4q7ZZh9T4*TH)2a8vC! zO|O^h^@Do-kY2CS>qqo@jb5+S>-Bp5oSSN|?RxzJuBn|~a8vEHOY<(xdo=Gsrgqum zrrKq%w(r&Uz1segF6R}!KA_hJ_4+lvKCJT}*8IBW*EJv0d`!nbrtNQN`y1N+hPJ<{ z?Qd%Pn^+$jZ{F1D$94K~oqk-WAJ^$;b$frR*PrS2=X(8xUVo+izt-z-_4<3gzNFVb zp+B|jPnv(x{EOzxnlEeqUGwjn|Ec+(n!RnRAGFkKU%hUl*KPH>y-k(dUUNsy9W{5> z+*z}~W`E7yGW`d!FnC4*Wr2{q1Q3!KSX$h-hfLUE~A7`=rCL+i?+BVYBl#Eh^Ta7o7{4f%HTsl{ci_$n+9Z9~K# zxSkp|5ZCFrJdSyv#Bw&{auT;siGuJ`VoCT+vAg?B@hdK7#7waXmlq<=NGiu8^gOQr zA#aVEDc0h05|{6B$&3y&DSb*zYug`TKcUZ1!y|N};S+kJu{r);V^hTa$k8^B(9O90 zG;U9IJDWJwZBxYaZXTgK-F!k{blV)?2V?XzeM0-2o8vE_{RdpGVA>?K`(fU$HlNTE z-0qIsGsPzU0Q%-umd-ABq`~N#YNumnY~J)LM{#Lc#kAPG;_4f# zV@u1+VZgL$RgP)JPDj?<62~lOS!IRxhSAO{bghPr%8HWNRaK4(XJ%OmITTmb6eYT1 zW>l7!JJ?(u+vEwuDoY*E%(CKX6_wS_vJwu!Y1NQZ zHf_3d_AD4ai?U%o)GoNpBg%`NQ!A@xW@kdyTt~@lsul%y%yqh4vMO#atE#M+iS>4w z^m??T>gKW%hgC>k%`69~wsCnX8tue(fdSPu6(v?4-ISwdS2)XNI&ha~&MGT+R9WfS z?4IjzPOmH-IJ>O8)KR4(P?P_K`6^RJWt9VRD{poT!yUmQDqNYzR+g1s<$0Z$MF}cF z`BIS?#U;}nSDOb`R+c-8E3DM!S+XmfNr_DB(o)KH-Sk0K#nY%nbjT^5SCd_VOGViKG014vwqqSK<-mvz<;i%s8T|5<@!6@I)Csy|~Iziov;O z;CWVtWpLw>f$GcyjCBynT3tA3wsUrsBhxWu_O!8OjyXE}AUyXgaRgDpsB6u}0{$vL zMX_?LqH+A9Vu$lURSno%9aR;@<>cwI(KZbQt}0$-zos)OZ&z1VM_yOW>TyFV`79>a zthr7{MK#u-n(L$Yg||oJc}Amc)%ADAa%r|#JS5W@LE$Y2j8RcC9fz;7dA!4VY`fZL zOhx6CY8=ZPe2!Vw<)e-rR8`RmX{GDqO=GHSAZ!}$%1UVOxl;L6#j~&j;OJ28m^r1q z2FH}*(qd=v04H7;rp(5X(KQx2rs_)o%&ab{tST>?f}^tQYBGGv47@%--cUykhx-Lx_uy-`YY96V1 z#^yfFu2HVgbiE=oaJlL_;Tp@bZo*TbSQU;XRnMxdCc>+;8Z@#k1mJkUgQLqiL)m~T`{#gUbEV^8W^I%G+PjuQYK_87$JAmBnd_*o z#!7M6>$zUNgTrRyz0h?cTW!KMYBt{U)uk|l1|>&MS;dWbBGUDykhMCyI&0=EXAMVf zew9!@YN%2D#!>p$PRgh7YA5S%tf_kx(r7WNveH?ISK!gJXU(dt!t0HSX}LF@4266p z%C5juwF*y7?$*3(*Y(A)ImK1e99b2Wv!_kJe&CGaS;Zw~&YIlW)lSSa5btB~*0Sto zbtG^QyXHo+&@z_PK9e5cm$3CBd=fI%Ksyq(O&UAe(E1|mu91L#8ld)9aQR96+ z9rM4sTTrJG-7;iU;%)Bm+0NlpM-}5e!GFk+S6PYSYUn-#Z$+-}d{uw8s-sR3-R`dY zl|tGWgBSC1?6m5Z%Q}pI;gg5AlTX?8g@l z2c5Y3j#{?>*L+Y_<;(%}@uM&Y_lQ0aTve^631J2NZis6N6~$;Dx{jJ9-Z@|a%8BOF=jD%4c$Upo&ft8%#R#;EW8 zo49n4DY+>m?!4=ssB(67c}<}{Td{*%gB=IF#<6*Y|4lr+-JOXC>EC!z_`f(vT!ZUY zN2NBe!`1tx(rJGO@Tcge@>R+;)l%l`)CKR{D(7TRz3L3(R-u!Uk4oV+O*>!?pRjy5 z{<0go&P?mx(+KtS8e({dEIQ-Mpj0vnJkOC zOaEW&y$5_$#rijXcGH#wLJHj^EYgvLO$beCAtVq@BMD8>C1nGVGFnD!Wi0^{9$=orn`i8 zY)Bd6E-dm81r|0Sii4#v1}by=v3_c~FRR|Vc2x*bO3E<_xoFR=!Jc^epYi6)_gDF2A-Fb%EI)?u0%;ecop6g&k) zS)m*0Y?RCV&`ner6S|hArkNLQWSA3bcv)i|lO043&MoUK(Ub+29}2Qzh;aiWC;=cu z^u+RZBPRhjFxME;!&)#n+KA~WyZA**>|?n4_9Lax%|b*;Y-q#~M~sl#Zyh2!@^5@B zk&%DTV~C3UIvQkZmtXBfLxd6{5|YJ-kAh^Iqlkbe=j3Kh&o6Ul7ZqktFDc0>%%1Ho zKtWz{eqK(AW>jYtXJzM=&DQdKGa9%zfec@ryP~;rfd^X_b?(}R$_4zc!mE3%H2`VCqm*DSUigr18WQedIs4|TU6RIlfUkX=;U7lOe?qEkcE zik%R#Nyy|1d^w9sJayO1(6s{Nn;5U-AewkaY1wlK&b(h%FjQt5v@ zoMffiC6E%~Gj0#Zp#SmEItxRLp+p#4AW*X=ivWjeY%W!VU>%_eeLbx~D6(1v_SnXi zRLree;;AadHmXiW^Zp1p1u)?#S__#!Lc7Dz*FrLm-M->jDI&16Y_ppJ;7hZ%GmMF} zW1+A#yDH;%gjSM5WFzvsmA4r?{6@{#8| zYQ;Euphu$+?UTU|z4k=hBDBXQcZQg?Cq;Gc1&B@R+>6AHcAdMPoUU`vFZa!_ zx5qs5L{*^Ymz#l@w-8V_Rzu%pWFDheBq zRZXg8EGJT#a;b=YC!gkS;u$Bbip5bcJ#1pUpdm2T%JQ%?&q8tIZQ(f<9Bjcy*$kWp zn318$j2AoP)%%*bveAo}v|c37bwTQzJo4aCRwa&C`LH{U4gn?ZM#Q5$x}~{66+N$@ zj&})Ss3R)ISrtvt*zMM)*NdfyHnXOFct)xG!gW={VxPPzEaP`}4qDbM(PmXNEWvS@ z%A(R)2sm}L-Bog}uemGB8@V5?xxLNxxD)6zEYsYcfFos~g={LxAR5VRJ)$)j0mORT z{s*Y)a)jF01;)Iw+>}I+%FWq^C@LzQfxR*;{p8gB`+y_CfC7LZH7d8fE1h717g(?Jx#lBlnOPhU-p86`Yz=FkeN}Jf0VxLBsd1esA_$N2i;Dn{@i}I`r?A4nv#4Us+vYh z-&equF=ZA*{A;SY{SFlZ2}ougzS1eV#>%Tgt=gr~LX}~COMz2VkeWhGGU4fEWqxyo zrLWW-y$@$}7U2YlVaBoLZoS12U|sOBE&;;p5md)@gE%qek8xThGoEBE&-Ar(^2?|B z+>M8CAu+1L`CK023@v6w)#j7|u}Yq)kqls_0w^|_UuIjGQI`(QI321Nf{yGeq*QDW z1$8S$aD)S;u!PFWic@(|2K}Dmt1(@mivqCl;xJhqjBYJ#Z(d<`{`Atk89DB}!m{BR z?t;8REoW9hSr$Eke!>-taAET;1ym=8onIS<1Hg z4GpA8fpEDz${BDEiIIm<*|@Ml-@(iCS;sJ~hd%lwkF3_sj()<6l~fP?*5}rJL4*8; zN?_B!9`804+tA2ph;O4<9+?G-D)*uac&Y+tE^@Lpkw5ZLWw6aRKbuidL!(<|m3W<3 z5A!KeM?DH>1$g_N`qOB$cMo+m1NL8o~k?hD{gJ+kNidZy*Xdlob+rwmwodxh=p3OgYM7#V8Y-wPKAx^}(7KuG4}Zc4Kf{u*o_x z-Fm7Cs3CE}UwTiY0*fecoN|j`T847GDB}lD!Q$MXDAfrgWJVO~1rjv~WvxdZ(T9id zdOR`=uM-YZ^w0Oy&ufy08R=HFQbZqFO*jNpsb^vI2BOmEt|<2+bIbF}CPaRn&Zp`d(;T#6Pp*HI#|cJYT4SZ)Co zSY^PH`w`%+h;86;C}<6J6*#aWCo0&5^*f9vO@h24-wo_Uxp~Jr9X(N_u1&7#Ok z5!p)j*S=h!2itLd{7RbM9)cv-5KDC%en0mgJO9Ey|y)mFDN<6uVvS zoEbSKv)xmRX1WWq3TL~^@(OZF^~&_nmE;D6iB#o-NgQh?jx_44D%=$@A;9A4JgTV$ zH!3bE%FZb*Eh@pz)%3zLcS%kz@nWc!Q!*nf-;H1OWbEpC^{ve zF0Zt>sMNmV51NjZP^RVQSnl@OLe-@@bLZnzhD1?*`RdKPET#{!;49#LSqw@Th( zp{~|-;-st@xwKayfC8MfvsfJB?127c3o+8uj^LtDH2s+?m5gMWxg_TuamF)UqOl&E zARK|&4CF+MFuHJvoWCEBj2bHt8DwQuG6@JDIL`*7qJ{0zS2Wu+WZLmQJC{RH!KG1gFHLEw}BBU|{UeDGq*^DkFxa*qKVh zUV0=U#y22H6@Ys%N_3_K97!@ZR}e~4qV#j(ax#onJfc{J6dcXqcZmlNkyIIs$mPQ~ zxKp^%mx+WN#MS7-1)_0-ht%Xk&?qU#>q^8nzEM)7Kjr2pS3$LtT9CJ-=^%oLef3UX$>rOd}!7#7^9&kdt&f;p0dRaez#bgcmPs(EuBQ_Q9^E(8^C?y zlmkf%40Q-HCf5^wWT+ky!;xY=Z7_ky8AO^wXNqXaDVCPw!9O8%h`Z@=71tOdwObj` z6WJ7ow>2;n?Q{>(f-tBVo~oin9Mg37YgK3(40I~`>0GL$$ z0JTzi5fZ8!=@gKGr!x2#N}HvpX#CfKdJ60%%qnRO+WV_Y&&P6y9R}l#pYWsLz#bbY&{n&owSr+D1g6hS9aa# zC2cx`e!u5=gb5EY-(s0*HQk128)h5(y1L0ej41?F1FdPh_Qg^W!g91@8W0*tjtUv! z8ei@iSyjT!a$18t;gYcb$GFm?9x(Cg4{TeC%4>z0qV;8WQwhW=IE&`VbO@tQGqr2Y zgrR$b{_wfJ_iL=`nTr#tZFMoTTrACyeh?4B3tJ6?q*#i3Z#2uq-+8Gj>`NR58F@iGzFCjCug+aoz;3OaI}X)S84R588(W^3Ld@M;iW-yRsNM zXAOUjA*5Ow-7Qv$#;3+7Jqd`(hn{#6jqAKDpYb4@ey^HIo*G)NFQli}FUIQ{^sy+$ zf?C=0J$zM)|Efn68j`NG0S=}Px!9SIL#Yc!L4Au}Kw#pbgg_4AnJz>OI5{CehkR~9 z4I}s^a06L%O7d0@ub|CJqQy%sx12GnU)lCi5INthH{ah@--c363V~y_xxt`3|EY zqL-PTa=iWq+Tmf2tj@jIdXHz!;Kl)t$&p1u!i~Oi>bh+c_DBzel;HV4A;`H~=&6Y~ zLCOpda=V*Dzbr&6uc~slTj>?&uG_C~ucMh(74X~HuEr}Pc&rS&;!#r7yjguSd%9;JGZ79dG(7!s*XX(k)k$99H=TpR9V-wyu#0W-iD%3$KvC7tJ z{N6nhaO>0HNXqNP&XoB|l}5F$mxsl)%0OFzbfS1Q1!~kme_YB39W);0(_?krk)#PX z)zFBOoAO;@NVS`z)s;6@&X+jj-9Yl9-m_R&7)FqY030J1)HRM&8T*KSp zv?iW5^dYfIZZ^uaYfB;CQvovg^P^;IejLI?!1@-fqOAU|pMXOZP7!3Ag z5xCTdok7?$y+&dK8CDN3A*&74g!(E-LX>=J*Ho)&=1UZ1@F$1Yf^g9oxl%x?#4%E| z*I-Prx$D#I1usRMT*ow_AUBFETdP9mC}w3fJkj2OCJZL&L99=_DnYCahzRj|E{T+o zPC*|`Qm(;O;07&b5MJ8Uf@jI3R!|uQ!Hm@i@IZ*jxAHY;PylR7)QV}qNXmU1IkHT0 z;6M;{%ZJH&s(c8_u=ZhrsT_K2TSF^UC88rqNQ;N@X%*9PnqK86^a!X*tK=$%{#~mm z%gRAg3c5fOCSP%>CkT|LW4!=9H%qYZ)zGP(x$>K8=P+#+Mdz=ELhpNgj=e$T*yetA-Zcs}*43;*9i(Op;{z zKyNWU(Y6N9@gcmC8)#Y+Li}=ST!~DyR3Kif*Xv+L)9Dg2_%R&v%wrN<<)~$q7a}d? zXnu{E_SfJw;2bAeAQ6A$3bCBw6_PmQ6EozsEpoL<O7128cE|-dg>*699JlKs47G&^)0~_xj2rij}cr+6YNF20+yH8 zw%e-Rin5xfTAYeeZ~RkeS~63?mEd@F&Aevm>w>GH=~dWu4X(httIAWy#c$Af`kOz@ zib78_PEPPOm-2OV`FKB7GolT%h0X-a>t*$h+Ljky?@HnQpTp%kn-e!!T*8)GXmb!T*gVdSXw6>DD*h zA>UVy=Zfl^)O%7aufP?JkpjfQG8~oV5m-jz6v;f;CCCT3vZ#h~EN_(z^Asn7`!q=x zREwvN5TIbeUll|~z5u44_SnBtbvF8%R4|st;+Uw9PgBqvGSrgB1p|sV)KQi75+#IU zPR0$|=`+$f&rxw=w!TTeRWS!KYlC+Z!VdACMiYgA3aT|9l@W=y0=)UsjNuUUH)()~gAtST!(?NDwfU&zcr3*;w6Wte+$te%vOz6c zEDtf89skYeRw-K9YA;2e@;4ut!UKZl0BKM(o-&e+@aUC#-DR4*^Z@I0w>&|wTD1qt zI_lW*nQoje|721Zj5@C+9!#Dh9!A@vn6O>&ofFpYgw~U5-Te4AMoV`cL$ix^BREKfIq5;EMia5IN=f%35D^;vo zgcTOgz|0q~Csa?4h2}v)`2vqFE@CE=Td-#2yAiodB5aBD&bnRY3%oh5-bJZ79ztGF zgG4KUiH3PTD@?OJhky|g%K}7OI$80!(VfCZ8O=9&7gFILBnuXKyIPT`bN zc5S)O2bD8AWbm!9^N<-;-hV85H7w3z1a=G^9{)|*-!VP zGP(3&2qp5%Td;gG@s#&sLtLq8X_KdsSm5=gX1lR^1l~@L&L<~{kWM|=hIiUw4agHN zh6+&z#Zp_-U#qS^T%_AYGZ!YsO1vyrf2a=GVUeZfGEH}FrWJ#?sFYI8{GL`&g9Bp- zQiPP4@=@H3M_;nAbwt*dH8hpiTGxA`bb3=|Asz}74aDkjN;aN9Ys3QAhlhIgEeBnb z@J0(PmHa>y)aaQRMM(-af`uiPut!QDcgjrKnq_Knfn*XAzAyuDuIdV-Vey3|QIH^x zYJXwn3tXIkyhUqLfXhplBL_V)-oJ;O}jglIfcprvo> z1`U`#B1D%lp-@X7t%t*&P%)8Wwh=DLs3-_`pl<9Wk^fR-g3CagpmrfptstgB4aWq} zsT!UtxM5Xr!}Q^EL*bZiWtQB16|^6r(PH~xUIQ3!X)`*+D3uo8%dJ`gt|CO!YCmpR z8cTmN6^91!@>QN`P`0MTqc$uc=!VJ$@d6Z)yMQ_q%o}X~1S2wvc$jU#4fAHCg}8w% z6%z}nM`wd;tOv*Z?!g$pdyrqOvh$ffgb@30J&F-RNJn}IK}hHO>PmD#`xxiMf? zi~mR&Nl~_3fKt3E0KZX7+DWSA3%ald8~v6x<~7czVYWG-B>B^#X<0`zMk!!5V;o{K z8Dsd+y8)jZ=V%~U`;!9!5T<7X8t2I|I2$BDF)wTj;XiDJ81r_6J}shU32GZq?#AyD z@w*g#8wFNg+zGsjLP6!&CcJWthBqwWml-*3Ij+giNNdTx!H$CGaQT3IKyTA>mH~euemx8c>5@4hFvSjs zKA;d%tuY$MDF*(Cc`&v%9VI0c{Nnh*1* zMnl^Qjvk8aorPXfhpGUJ)`Rk?OHujJL$gY`?9~L0(Nf|4YeGJ2#ayJW%CTX=jzLb9 zEEd6nshJ1Lt5$mS7+c}Z0Is#b5(&8=9nhvxg3khV{Oyg|N9tiQT2YVc0EP6!mK;85 zU$b#ft;!XjWw071MA|%Q+whAk7@M-?7FUZ^qh zf}_;fd73u74De6jlqEmtF0 z>EX{$<*`U5dSPmaZfi!EW9JIW)?v;*;7c8MgJzP}C7>#!Eu9J{9llpFATi>hHs)gX zHTY(vMy=Gw9lmcV+SQ^jwTqal_)H%;=kUE%t(1HjVc|uX;2$+^GG?RsFGuYm@8<5^a|#xtPE&mkqCO-qs32Ymcj+U zH>c0Z4SJG;DwdfqcrD`sAK=S~#Ojlzg)|}?3*Cq1y&fAw6^} zRT^TxgH@dy5-$0^7`CWdL^*y@wZ(2Ji*8CEZHSC^6g+K=y2^r9nVyH^NKKML+>59dX)AuxEz`}?|*j`NzveuOnVYs zHx*h@D`Hx%E$M0JgWmK8wChNz2F=H`cfobR&=vrew3ETDRrIEvrsz-#8J;i3g- zX(yN9ifb!+8P(F13x8enZ;jR6Y}MmfV4HD4`@J<^`*m)3Drs-Bfw#FP478Xvh)GRN zSC-C$8LO3{e}8S^;l^Z4Pzh=?URNss8AmpWQSjrd&{P@GNtyMhmV!+<^p*6o+H_SK zOh5Ma&y-jrRmKwS<|&Lwf%;>{K1cA^sR|eNBK!(am)R3a3hjf8qNR^BZ9H4Iuboqc zePL|Ic{9?hK?&!7mVj%@JK>OS)DN|SB()hg)A!bkeu36MgvIJgE(PWWw0M>>CZI>) zjI^i)_(qPSkL0Q~zu>>VWncgGwH8At#1;Kxh+7q4Ezz`|GHPU8%VQ{rsab4|sVO^Y!{);f@9O`xaN!Kbd``OD0NUJW|nsU}V9 zEVBkpLWdxWU9Gty(zTJZi;^B(>+Bz=YKcYQ`V2tF69&M5oYIn|2c*<8e&jfW!)OL^ z*F5ScBQTk%lOB$_sVc$UdC1-cuMnl2FkeM~C|jF;eW>QdOngEwxtgqj%xW`_JdRZ} zCGNzNSdxoPT1dFlj||rz3h7HZtiX3A);=MjX8A+)U(0bFW33MfA;zSK);*X`oRbza z8?<4x4x5ekwEm3QwRp7(R8fT1GY|Bfq+`s?spKE}b!H9yfu7mvNnT2MWeiW>qFXh@ z4D>TjVL`YSqIP(3&)CCgu6`9$txhyBY3ref{$a3;DkNJ&N{vs$q>GTtF;T|SU9Vd zN;<1}LT2@>(L*4Plzhr8Z3Oktq_2S)vO!W>6jalikUz>dkd~y4$zRelwEdtJ@~0~8 z8M9Qj5cY$d#vyk=SN^S9r&{PSotTA$rcDU8AGA740Fikq#eM3g6LX=LlQPd0bv?3F z!TqKE@t0cChjftfiq-RI*h66tWp~+Xp5Q%gDXA{CM_M%MkFrMWlzJRp z02M-6S!-VzZz!FTGd1OiR)n^m7KA*~T6b`o=3;~>TPHD9pe2`13_1dZC{US*3j0fi zD#sMnWTn|)C@KvE9UDheleQvWg8mD^XofV>@uX_waYd8u(QM@uOC@}H2%D{QknjWN z5sbM>6w_o&93i-4f|>6LGAdH&WuWB*eooD$X`M)N$uca5M@Tcvbcj-WnWkmYWVRe5aC(HvX;LJ(7e+fO*BgWn8``>|5NOr~BG{popMt@$ z>5a&Kg}022IR~vFc(vtk2GrOpmhc~uM#Mj!Hg&xvAJ-5XvjGGqK{LybQ%3={HpHhTk-C%n=NRk+eo^X0D8CM#$386N*~R5_8V@ zSaCFSJx7MEA`@jqxJq#gY^2%91@7E2@o6@ew-816{gctK$k)7 zGHfFG3z$+YswbC7GzT)2XE4G5S^7vSsDIBi;fk2dP*h2Sb!B3w5O5YlCD@+}vq2Cp ziiz_6(lMEaPFj6Z$X~E2sAeKUt24)u2^i9X&dZB2{?|uqIJVJpf=q}?uW<(c#>g7z zj@QPaHbZ!|z?8I=vUxfsluta;W|E@0;ygXCl!)N;s@D2|s!S8PNh=$UcA#Ja$nyk} zg|tbGEJzG#J7uPW0!!DQCbXI&;J-rjY1T}?QXICU4}xkr`-F~+;`5iH~&bWkJ9AV>OJ4Os)FWSqS}=5Ad*6eB3CYAq+J5o#@K zjpY`L7>$ajychGRRAlm}3id8|HuTd?I#x6=fg+{m(O#HMKc(UdE!~8~_R=u;uP@01 zxvxl!wAM>Zl1N(+Oc=6(rT%P?HXyh)BXKUuWPKibQlc5u&_&Ay*;oP3pZw!B4O?s0 zjl*Er3_}!qf-%a&gy~59m(NbYU+Lpbo(OZ;OG(-8T0R%<{1ED^QCn)P5XY%bK4 z(I;2QNoh{i;)DUV3|bYRG~cn|qT-SEMy2dAqNE`XB!e;L^kCAd_)fJkqY@c=${5&O z?FYlxT5ppZ9h~5ND5bfw%n~7s+TvI8Mm~~AR`QX!(w8Yj7=kfLM+KI~z+Y;ZS~IsP zRlrt{M5OY9!3kMgswadrTh&koU{bNPF(jy1bj2WN6i zZEzC}yfImPN`4%RNugBGjL1+|84zhkNNUz`X-4BBV^iz4vMJSC>n;C#C@cRay{qD< zq?ydoDs+?p$;>=gU5e{UNhuq65eEn<31#a~>q3#HEO7P8E0$O@hT7ovTIK2%Q1#LV zw%5`>Jl0NE5|Jj{h>3xD&MzByP#VZax<%qA$=}`>3Z~Y2qq;nL@J9lwQV?txXznSO z)Ood}m!y|+qu3WndM!q=3)!=U(*YsaQqlzxCdZU2Ypx4s>UCM@Nduu4@6ygI)w1dd zZ90?ZB(|2`{%DkAx*s!%Ey5S$09!U{O@^5w!;$6km+VrrQ*=}8QwPd}Mb6}z3|1B6 zgDI|BTFprySIi?P?ctlIZ}_Nj$OC0Z=o1*Co3mh|f>9a#K|B-sq_83OV_acSRLBni=5Id{9LdMY#zk!)Y~w6{=GYr=@2K9YadPDzQ); zZZFVn;w)z#ZbT*-Xp=b>>C`^vPOXoK3Dr!^b(@-rl~xRw{G*P4n_?kCuVAWE3;f3` zg3CQqr##&*AGk0NI@?;WB#Qpw`H_HFm$Z0W7|14fU}UK8KfDU*k13e%PSH?Lw3x!i zT}2wE0>LT=E0k^NBG8eotAgJUwK8`1}KP;Ay(jx=Mb-T#4k|HnseclKB_n^rxLSD~#g z4>zet-V{wus~hauAWNrM5Ax8Hn5#P~EssB0%ghyDu(sfx1TYJXT;)-!EJ$Y~5;pXe zj4bNKQPW!7^Kcctd1o_VbWNCRvx`qhRM&(tw)oanQITB}3Tz1xVNT5!?zGurBb|0z zY(hi_Tz5_AiJC}UB_~8gvs{)$@zN}shDPB|Eg{0;)FiNI(RsQ(A;QiI2Y|;q2I-Yy zkqNW$cY3&{CCui>=@FXEmT-EQrp1OkScZ?&!yHloFjmq!_irvfGU*}V$-gu=R{PE1klYHW&;fai(^=fa(2YL z#pn@E8@?UlE-uj);|#|wF6@c64$d&qB+=FhqZlYTNU~(~iE(O1p(u;5aggH4Nsd@j zug<`#qccK4vfBX}JV=xX;4{$%dZIao!(*EgQ=nlC3aOphNhClNlB0wJ3h38!Tjh$@nKm~5@(dqOtvR= zM4`d94$g3!BM$#Lz-$L$$AK~=Fp8w`=y((WVZyVsQG83}ATj^2L7D@9b|FgwX9^WA zY~h25z#xo``XmUCBP=pe!=Eh%Vxq(*4&##;;HQ+MPLLjx zcAGsmTmv$|+7=#}oUjb?yNsA6EbHj9h1ug0TH9jdQnYB7&7Pu(yBL()#8ryc$z=~0 z*C|?Tij8-ohqwdZWV6n$un4m_#U2%Bv!!UsNwN4QlarHhm#_>1hQSh+#o9T7KA63e zGaRKHjy2(txUff(HSvQuhe2VHxcCeIs7_kAjURS?U`ASa1V1A2foTmTD~EOjQxb-D zO=w*~ibf{5!a+qlH7rP->+Yt>CS~sXBKzJw(4atE)@c|0218&6xK1miWbMYOcne7N$6bi(CwAo?cL`S?B#w#MP4 zLjl+hPP@FYcNAB^gL2f#8HQs0#vbbox7^tQ1D#fO(Cqx;h#ZTfV*rl09ugGax(R5n zkEe9DuECWmk=<4SpoFt35~7;Wx>%}bAQ+`_4*gIRX z1eaqd=xZcS9Ym94+{h`f7w8eQgw`z_0`nyk#I=LgMxQO<0Em!_Eo40~5zUl5u#iH) z3Bo|>LLf_Zh>#|j9yWt_(>p_KQ4F5pGf|6xkz}LZ_5A2jG zFz+_7pI@L7^w>`H><*Gl3v=Kf%&Gnv?FjDzP#`MFwAyCx2d z-3D`IhjF)KWU4>(A0Kvpg!99}k2rof`7x0nt^9!5#)q9BBBB75655D*TR8FGDFtD> z{CX-H@`V}f1Jbe12wM`q#od1B7>rHp1{4@q`-H6&WoX1G2~*I;U0tF*gx|c|XAunv zJlW|`)j-D>5ctJG@yRl&0SJh>VuhdB=WxK|2_Zrd5B|b@J4DU< zG?kDX6hm@w-MXE!)h3uN_3n@i)rd#yPUAYhb+-`0=V-8L1P;(gp#|&>kbVcI3ek^6 zNju^W22lw1O5MrQpfMmv2VMeYzdPuo&`!M$U1?=03Q37tQmm+y*CdzU?Y?+n<&9eO zO@_AW0|{p6#sjmbto4N2hOSK!Hb6oO(Xp2R8?w5uhUJ`yIMC0WqaeY4ecXN;y#}KR z(Z-4}WJ_-p?xgc!WFZI}Z>pl+w~MKcdI=~JTnKQ%gj_#h;dK@w6ILsFkA z5kWcLhjCc=Kj zKsZ@bg9g@6sgewET-+wKK9FR#O6qN)LQo|J?X8(q3RQo+k_a)QhY>RQ50IiI^;a^{ zeiIDTKTbFJhix^$#T1RuRD3-ik)ox*+*xPDlBB^dJMEt?740^|u!G}{wxwhH1oye| zZ$_Uu#1&=%{&XZqOo3kv#3IF>lZNPCric*OfXF~7DSEIM3P~=rR1Bf66Sclrr|XPTg#vTE zvG7Jm(dNKlQ^wkbBk@j+vl)noL`hOppFp=Dq6(V!45Fzh#>CsLInX~({q{NqgjqH(FM*WD;7Ofa|12#PmR{}o6xTagIGZ8?}KbVdSfl8T-J%Yj!iNFk|j^-rQ3<_R06uYE$*qI)0s z9NFF9k>~*6Zu-I99KHp>^oQG!jRO6E0SF#r5In|_TLGMf>B^m_Xb1$Q{zITaI;_^R zQW)%8gu$;Iga&a`m%#8q633Jxle7{rHSu^PY^6Hc@MWc-XamiH|JQwXO1n(}XaG{Y z5)eIxKcxjIB#(t>*PU<5VVeQq5aeYgK+Z3a<^m*A#B|+o)8W!hryQ{<07q#eB1J}q z^LfQ4{A_}da_I`ePjMk6)vt&;6{_^WaYEb!+e$0jTcg|r)L9HG^pP57`aO;>XRf7y zyY1BhnZs8fU^IW2-V(h*a02Z&vf$anG&^!KGD1nwFaafk{uRLRFm(s|n1(2*pTrHJ zr!E879x#I<>VyR`ClcC{UIyK)K}d?Nugk6@*iHi=dK7ICr5Ku^800??;7G(%RREjP z?ueENh%_uR8!U>|rIIYcAJ#JZ6=n$g+qx6WmVgrU3RQ>&so*|ZtG)()DI#|zX)3|` zQ51Gar>H@9KoJYlKu(Ktz=erwr;4ji-8A?^Gq8c22C`WPYavqa&|FrEVuK|M#bl!% zqaC>kVyBQSwnC8{9vYg%mWCGGxg^JoOrZhI^_H~X?NkBd!`2=^WF4g6I#`3Y13}w% z;agC|HWkHze@LAhQmasw!4=a}oCtEoSgs>-Yu)KU4wfY%!-)%~oOdy)6^G(oNg|sX zE|Od?A|ucRyF8q^xTYaaLRlpCjnNaEbjfgNB73SQ)54k75p6qgzeo(o0bb?DoAAdD zM3P9+Mre#DJL{ufj!yr?+MH?H*jO7km~HWG$*r5Teh5rkHEpei=#*Q8xGyQqN@t8} z!+%k){x&|^@&*Heto{3sqG=j=|9N4$N&to@zyZ^hYIr$y0eEg0L zgHEp)db?+6@^5dAYdXCl_0#XpIpeO*PhB-`K+?qt*`6NGy2q}}EI9SGEBo2B-s0yZ zo#UKK{eQQ}hhGuG&->unF-)=mk+R(KpT=oMfpZabfQ+DJc~6w1Ax|&hE1q9b@N)>X zqd=$xo{)eCjj%^YQP0_rMZ9n%MJZ5v0eC<-4)*Jyg~cYc<-{f@MMj0iI+Bwn+O*;N z&zcy&CzV!)ADr-|;nmytwbI%a{^&uKs+=T$gE1;I&Bgz?K(O1Bl8~28SQg(lJ%TCt z*<2=InAzb`wuIT(Z;y>lI9)Qa++o9(2>*4l;e|mY32CKh(*b)Xc}*U?ObAHJy>3jV ztp?N(i9d1WpzPM62!~0`{c(pn1Az1@GljMuQ8;U$3jJHEgBnrT$c@4VJx(Wp$~;8@ zal~d-Bn3N8zgrK4c$6V(CgBsb@I>_T3tZ#(GFH7eZUFxsdZ3EMU-Dh8b}3XT*6 zwNY)=H-JSkmT$(UR2287x<^Ie(>R}DTy%*FGk_U5L0|PV644-*ekqk26SDC~84v-|LB8-mF)z05 zA<98pefY5C_!=B3NQ{c~n{j+ia?_QU!z#6@aZhK|G-i*n?D9 zQVj)fp*4d4xV4!L&2t!{p)J~`MNH0_G<^zA`#=>Hu8ss~ppLitjt0^6B4|f!Y;1Tm z;_%355kYr|rv2o0CvJ%*FFWW-d7J@=hEd)ClfVTqo3?F`-Ha>A5?R_wwAiS}(J^SF zuDM4}Rwvp!2^JdVV)zvplVkH+j?Jq`_>F{RJeiTO47FI9@*oLRp-1;Pa=WLED+qi- z|E3G9BBI#_`?j`Z7P1O+#iz!BEIU*IGf07(RG;jfPz>`RF2Xq~zDSlRpjlfzrAZHI`=_z;+LjZ#jgk{72J4BI(Jffo^ zro2EO02Ze`1Y};th`ES#I5@^AjMoXRt=J$3$0g8&DwJV}`SOdWH{g9>NO(oUAvrJ_ z-XzZ_e}_~3kRX1A9=|JIC0t_YDmX>aeI?kA!wA?)gE7Zp1DshP<;8)8WRTW8QlYBV z_wiBT>axA>emrs`fd+n?qX~&xBbd2aTyG`<;y4B)rueo!m^_-}8(79hg<(&4mAYk9 zah3ymOR|XTXrXW7G9C64b1jezfy%O2p6`(MiNz^V9rP~x7le-nS3rR% zMA2*ua9e3SqG%B`NNG}B5>DAgg(oH15k4Y9q%mpTD#nmoL5iyyfW23A+Xl@PRXj4Zt&^ZBplus( z)5hqblKcfR{Jc^ce<}x|lK5>vqf`{S`6+%&Xhw}^v8EN;w7fj2235<3I{BkQ%|4Pq zUZF_-Y!r*sPY~%poT+~0%vb5H5x*NO2qu;!%-pHzrut%FxpRXKDKOTMU@ZLjzoHHhfCLi_=ms%i8-Y{5C`8F5Ggt7Eb^?`f z=nKe=b=yWLj6657(GeFFB}$?l&<4spT&Uh1L`ZTt#1wy2Q&bmX0)jxVuu5=#rz4?l zA{GBROfrGid#9i(N(6}}*|c%TqD}HwzYKlCuMTNTZQ7#$HH{kT#1f~uRv4uK^^+Br zpZ$gUac11!lvY&ioolw(BovDs>p0<2ExY18%!`TZy~zB@=uO@jg&>k4D|&sbkQcoZ z4sfG*stA@lah#y?6s?DXA?g^`hz?SycpODW9e-dMCjW6BZ=hUQx%0s!h&kAqm8f-& ziUh-2TSXuM`NwKKi|m)RoIyVNi2!6{LIivvTfeFoi)DQl8x^CGSO&-qTDEI_Kra{4 z-&Q8Wf0XeGF(Xhi6WKWLmM9O2+v8MU*$#0F`pnWR)iqPfodLm`!N#eZM4Sv{G@KZg zprEiPTVwLkdIXK3+vXT8)g2q9*y91zKZ}j?cZm@SY+^W8VsdJPAp2nI)I=HptSxak zn`eheLSCVgM`nQ<0KrD`D@I*&mXiVvD~6E+YR;+CC7uMXloEyT^n90~x) zYQUq&R0#s(`G`;zh}ek?R?Bh(6EM5sP^N(+S`kaee*%_hDdv$BC19um6NG3hFp_2H z3J_ErAgdebd_hPI%+B(y0MX*?wBE+Fn ziAaJ=KrRIT@w2UqUMw5IywX;RT}_D#ji<1CVqpDjo46MKZl_!c2%`r7Na@v88fXef z(+vo2pm3}l z)&va&>A}cVbg#IhJj*m1=xGNsdKpGn6w`a68f_EW)))$;(d4o{J|ToeplvO_C0qSV zvB{^jMo1(YlG-5le(1bEZtJ`F>xdZkIzr#1kFp7!sYqgAQ_v-3R>IVBW{g-=BgC;7 zjgde{WIyw-Of^(W~(~8^itqe*_`4hU$wI1&Y?Z&M}6T{&mL&T@^BFjjqvjvH`p^az8nph zc&60xTds?F1t(|@rJBXc(bR1k(+%pzzlsl#C`45Y;fa?=^km|i>FY9kC;XUg!{P!2 zAvO3}UE3U+c0yWVPFZn-w~4c0>#J#~AGZj}*P-|s+UlBG&p7>iG?w0Fv0ZY# z<#nFL4c-O%%ApXqT?oXfpg2pLEAVsXnKo_M6Sp}FYAU@AzJ}^1XLf_PvB6v3gaOi= zPGI8n*36sVqyUZ zWx7VCA!2jdv=~t_$%|jUp5M8|Q|rO6LC=|#oj)g?4Z5O1DTb@5^l-}IW!`3wrX6R~ zx`mc!WDZ0m6NR+0ryglz8&9y{Ukb@uX74uBTi#gMP;dNdu=q7*pNxK9+B2z?ZJCfx zLXl&ZU2~jh$Ckq6Qv3Xs&wSJGr0i95=P%tmreqjC;$MLCpTo`lOd?G|;w(cjTjkz^MtXHn~@ z^&w~T!Dsn6J>E=!e=g9{ggXOpEx$2=`gA-hJraMT@y9vM(vCxWQqlSfCv#TEGJYB! zmgd`N`0spe7~tk(eEGIu(t*E;!5Q)wI`O&{?KaTo=xLUQ)=s>GN51dIgu{1*$rpL} zy&(zk=Zd)%>0^>!e8-QXIq&#dxMQQSb&kb?hw=?-RT|%J&R_jgP>&5R(7?N5$vb~| zfgB9v-&j7j1*-5B%6y<*y&Ef3zY*Yhx{v^J{{R2?|1<@P?OI0=pmogu(^U9>cJd$N zeV5ot&|J&MzZThH$OTg`_@$FA%D!p&_$N{HsNH5uk8yQ~j5r}S%-$JVnrHih3{Z`E9VEd9c}-1nVlZPDh<-YmYpJ-~RPmgoOvM?$!s>D-O*HB-Tp5jVkNpxc9Xg?~JG_fF}<)A27OBOMo~;&y}!m-?-%ZO4BEvreuUViuDa zUQkqAl0MMYU*4wFXV)~&_jsL?OLLq#rG+PEyK*yAhr33POr4yQJ376;tFN3{``xK2$a%=z|LnredJ%;wmzQq-t8~7 z{FHRhhOAr8>VLvtcP!~N>%_ayDE_c2|KsPo4*BTjFaF$8J?yl&4jl&cd1FGSVRf$^ zTD&H#_QNg-H?8`7WbYp@ylHz@_l8djnyR1p!!Nw_iuLnHh9pt*LE5@=e!RSR-bwAdkepv)8*75eFy#3);ROK zRZ-U@zB8oM4vDtixZKtO6p3&pgQUr^;oZW!JkV*|j)EWG{adel1`e3s$vOF*^?QF5 zGL+mmyoak>YnQ&6hyGcT+Zg@z#NQYFzT<@LPmb8p*;U5=y~7J!r?~PqP1%%lLH7Kn zrp6P84XgClrq!vHXG$wxk z4z}%i|C)zAZ!Y=ym;5mgeem&Hqhc?==E7CJ&lgse{4zf5oo8P3-k+Jd{?q<<#CqQ%&UiSG!2<6JtH$CWBBmlV`#{bt}t$0ZRh<*a0@VG zxD7OXVk%=4;~*AcX!;z#mBEW|Lmd% zj$5<+ryKvgUVE!@y-vEuAGy1bIW~yfA6JV8e;7Hes2H3^It#bne3Q#TEyK&o`p{L;+QMu#8VK27ix+bRw@MpLyouU+xIAnPG zh%qBh$gD1}c2$f@Pc5$+J}Nb{ynJ|S`AFQ38d*{48j&$PGqb$P&j7v>Xa@f(hIN6L>++F&RL}G9(#x&+QtWIy^l!!`9wu=7(V4(@U^fM5uCRCMZ`Th=m^r-d&5h4|_3MdmOfGO-|IHa6oq5_n zT3)taw{y|_>(^|)F6PN|Z&>wR!Gr6@{NCx~J=gwtdcV%ctzOyn#IxVq_R@}BwGWON znzO85eAxh3r%r!O`7$i((|y&a4_&%3`L?*puJGtd@xn_kMAI z&YO4cJ$?L7&Ch;TT{(C6o7bFw;p%>_U%t(Jr84>MN%KyQJ>}68W550Tx)X01y|4cj zj+<9jBW#P<346Ci+PmoT;RAY!Xe~W}ST45+(4sqBG2o&rzaLs<>)9;~&Mmzs<3>wi z2gCQJr@Bs%Caj-n!b%z%kgkQVs;RE2MBdSv)!a0{!CTYRBBC;vYxHo2VPl48z?fy| zw;8Hrqz#KoYsVk=R>STWzWZ{)pI3K_`}m_1o6hU? zk71iK4*d1u6O#)2zUkH88!w1R^Rk+%P9-5of7r#AN@bt*u3)P z+kKPIeY@?wA0GaG!URz!9#|yjMx#`6Z3{2cN(e<)- zaNMBdpB+^=Zd1m%H7{-+9l2so;f&>jhD2oiXg}v}zW&wI zRt+fKf7b0Mf1msEsIjB3zjyJRo4Q}W`i1z*W{iD&YX^7O>&k+i0Sk7jt1~S_qRsYK zc!VnqUl!{X(vmPLPVO8Yj)lVou7t=A`nsg6EgT#7h}jVS8fA7yY=69(UikWei`VU0 zKlh|t(;IFcyYrn?S5Ko+7khZelxSqynvp%h?>P9`ve>Q5=T4k4@aj+dC;n^5p6Jqb zv-fRr6-!%|=bGZm*_6F0>w*bKZ_5mM_d>KQA=$!;l_{$QD>l^yqpa>>#YP{U6_a}# zR2b?Dpa$D7yG@%tX8gGWa_{=8VdC8x_nrAw?6CS<^M3it-TZa_NvUsVZ;Sc!g)dUm zZ|uAK?BeyUeNNvxZdm?DayIg`2K(rv4UF z{M3vWQ$IQRwVjQh-`eShu$yLleE-F#%=~`cr0c%>;oEOMxuAFE*!yQ(bFj4UiXmH; zCtbOBZB+92dkYV(+Wh?f#G5WJeD1i{F7vJ%vas&jUWbwnmcBJ__wj$tNq+H$RSyrm zr=@bnU=GwT1fWnJRFuWCNO?S`R`Ja~44)tio+8g}Y0FW)#X zy6L8oU#AZ1{@iEYQ3*db+&y;Q@?T5tSv|a)Cnfgc58^(o`my1q+&5nD{zc1E;rG7& z`_PYiUwr-6=-(3uPTaQd*FCqLoBL4I+$o;96AQObI#Brajzul+L}zxWOKMH;y*IY( zgHJdA{^^vsZB^_4D(;qc_M;Jf&f2>!YhcZjS6;Sm*Xnn!?Q>_RIoBP$;m!-@pV#rs z)Q1)=(2}p(_IBFvh|C5E|-qy~knDXjND|g-Bc?*! zcb9$QnSa$>d)3~!TjTB>RqS}{$#Jgbkx{VU-zxjvZ9en$*c1A1*l*V;Y?i@*j~MP^ zFq)ArZil;g``=scAIW^YrwnOg8fS$K5$V~=U-yO*B`uSckdU5_q%Z8 z_dm`{8v3uLpRY{*^7FzQH$UFD^!e4l<-FYCl{4;oW&5P?8-BgH_R4v04|+ehbo&Lb zd^#vMZQ#}mil&!z+!r?V_cPb5an)b=!)({a-_CjK>K*(0Tz$@=*Ajnl{G+t4v(%95<~#k;Tl=%n+m++1$IFS*m*|N7k_< zZ#kUx4!IEav)*xr5r*}KJ=a`q>uFp2hPSP8wXJUL63YB;uG~`o9}h2<$F*$hw)x~u zH*L%J&H6DaG0pRTjnzM@r8{UHclE_j&Iy}5@`Eq#-M09>ms+M3*zQhiT6kJr$HY5c zdSvNk_ouy)aKoy)iu-5UUnq1Y7H|0AtciPPK6KZtYm)XP+b-Dp(30;jdF8-Kwr}=6 za#?i5bE~KBJy_cHgQ7dG*!TJBGv91|{Ij*+M-E#N_QmBx`W@f+`_KQ{w`4 zHty_Exbe~j(cX3UZys~qyws+bZE7p0Fo!5j13myP58 zS`nT2(G$_-mmYlk{_bBDUUKf!BThKu#z()}xh!VV(l<)IeZFx$|IiZ8oYQRGqr1eu z_HLK;KaG8$de)BAVW0oH;)31NX6)bCxVCodnEW?>Zh7?f9%oey{`Q7z2WLhu?p3jC zTuNQ<(}?>EpI+EEVZfr8u_db(o|>E8W#^6^+Y9DB z_qR!ZwYKzWy}qlfdjF(^GkQID{qcQX$^PPmFCO}F>h7U$ypz$IKVZnze(qDhobm0= zA8y$A{D}<@w+(EHjQ?g)pGU7<{`kPMzu$f4xQjL~D!;dWbK=d9-ah4ELc<>yXVl*F z=SS0?Th(`0^}`#JFHESik4wF4_GS0)>+|V-+n=wzcS%{q8(C?^Ti0&CX~`WsHeJ=+ z>z`L#nAm*$u#8(B^_xyx)&J2=-=6<`pSQkBDcW_-H+dibV)Hay6tnEPn&&>N|MHfr zUrHbRSM1ZL&3UKbxXthUHthNdY16wc*p+zWAL+{nz3o~)=yl|JT~N3GUS2|Ge*@Dd zX7YJc+fxkJ^dxnMu=I|W)N?rUyJl)SCOy_=t?kNSP<0GXM=-ekvpbew5dYZ5g^wP1 z`uM~v&rP%!ec-CHfasV$!&SCvWNYRz?Y-*zf}4A__Gm9$vwB!$Tf>*zw6$BVnefa- zRgD2L<1XP5l&+bz$Z^x%WHxk`R5UcU0NU9-B)eZc+Au3vhm zymacS!e2iM?{NOSwwR1>ANz36*ORwy{b6m-oI~DMweQB{FP+>Y{+sKkb-8@!Ne90@ za7q3H&-S^i{^MlZ#3$dpJfnY0`a2IbOdY+b`-C4B-8;(h?oS=|tX|ZVS9#-}y4$}0 z^1gHX=T9HgwbS3vdveQy@}Hl-vi`zlkB-bZZom&aYaZuKOu&K*K*`AD{Qi zyMOJ^t~&Te&a#IGtr@>3-P!Qo{;iJNH!mMh=2~v=XYwdAeYw3WisFS-Uix2)0z&Ud zSY+~aR}T~Gu=E(?CdvkhG-NI!y|c`+xkjar8a`^oh*N_ka{B0s-0xpn_{*G&|7!gE z=>0vmKXzcRRaTH{rK}|M%8R_=nMXd}Hsr}p=bYPf)^9(we)7)s?)lfAl=1U}g@fL{ zb$aEB`yX{**5R!=x4(aOZ|9wFPrdN5ioW(=GvDjKD7DA+7q6*#dztI^TcZa?W~aV> zYk%*D_l#M*e(%t*{JlpH}y%QcAzOVo4e?D;c1qt_^@$%1YpMJRFo!b*{jJf@z zS^XTp`=%|w;ENHLUa-1h%P)6rnp}Rl_W8imN($bX+8XKHIV^T%;boogoxWjL=5<|L z?{OR|es%xY^H!gml+x|?=k^|2wC}lrXTB15^2(bxSDpOu{PErs@3{EojN`v{E$=tT zRMT)<`tp7~P}aquHFvN2MWDzA*-7tA63)F~s?8G?Zil+L=9rzagT+))yE|ASnPKT0 z?mT7Dk6%yvIO@XPH$D-+qDS?l@!dAWe;T%=;)a7u-?z{FGJVtXPFEnbjzegD$dU@~ zwfLc?9Z|1#yI;iEy{ue~0ZQlmN7Ai>Tmuk8VMnXCnMVms1v`;HOP3p4t}z*z>7z2! zGsVVMCekVD_WzQ6@TX@FOYL~ufwOMS{5XHYxp}dj{@!(4&%_T)E*`L<>%!YA21bp# z={(o+irSbP|A_3=y-Vb0A8*^e?y6|#sW)7;=i`~Kv8PvD`}FA-b$liBqkq2h+lX)D z`(E9Y?^)i#g%?%C%)e=TLf$wR(> zCO^6HZ)ZO_f6}F6zi#VQ^2zv&wd2m|@!hriPMH(G@2w|Sq|}DFd^>mDYFoB(+p9nM z4xZL)>9F3HWIVFt()&*O=P!T#;NFpVcH)&Y@85LBi1p`f&dmJ&>F~cj@MmuKj+cM* zZRhDfAJ{!+SGi~N;BOv@A9dV6>L*R#wR^;?B|E|zuUnsa{os+eb?@npc~r&Y=OP|o zDw7xexf7*Q2w`D{iL`L$h|H?gipq3P>hO%p5#?1?>7zVjTz>hKsr6N#7Dv3k{PymnMjd}& z-L20z+t;C0 zbNd6R{jtLg(S%S#rLOEaEN0nFg?5K6M~ofsog4H0)&YMHkEnis^sKkvsC~EZ?Q>JJ z2Hn44!dmZN<140lW_M4Y7Bk_E4zZ(0o;UdOCF{%Twsdht`&FDh!Scy{KdymPL9vd3e`=kDKL_nGsV!Mz>VoL~2R zYwURsKiuuZb02a1@M3Gr<*y%le}8uV&(-#XGksEF=?bWuVuYbHJ{^>Qt z%C22KH>zKswz|w0uGo0#?GqCxZFNrg_~$s!W2Zgedh5HFetW^GS8w?#{*((=G*sMi zaoVP$L7ftQefq`Ar-Vg6HF8(w+aLV0;;dPJoOa=X>c`jrYxOs?&bs0HSCf}sly_;$ z@8h4m=i+aknm6^P=DYuRsrKd_n?CL`b7jNXQ@@+Ks_2T8J8Jt?b$sydJ6C>j`s!g5 zVy4;WoVj&t&-^#?&vHL-+3?p$#9qwkzLXxr51yO!R6$-P5YefiXu#C=!yoHpP) zXYX^iJo(9;&n~^_*UHU*zcq5sqz?{NE&et#{ifbu#JgYEvZ?F*jXk~_wDhdRJH5Hi zM~`3T$alWxx+=ZXRc{RZF*j#!>gBuNKKNi+OK!pSuKn*hPjLO++x70OTh@Mj!`l8) z|2ow2^?)Z1R*$>vygz^YWNp^)jf-<1?!VQ(<&LReURZb9#D@ob`%{nZW0L;0>w|wD zc;xjh5ml}Czx~iz_w{+k(RXRvJ=d)oJLmV9y`_5}|Kh>U?qb*SsI!nVuTbfh*fp;S zR}dB;EUvbd{}Eq+l(_T-gH2!1eoo!=3h7AAjLvY47$XxiBgJjHi?{!EueIDBd~m_e zg9~;XT!7Bqaqu^9TvFP$cj|9n9#@e0;P-!@)#q=MjvKPzi&Kklzdv$xukgGF&wa9E z$_JwsJd^NF%)!x5Y>3?c+?Y3QUD7B0f7M-eSQP92r&C(GOG08;q`Nx=1VOq(Kwyy; z77#&DLb?PbM3f~Jlujk26cMCb;E*c_h`#}Zqn^0u`Q3Y;bI*S>v%Bx?Gdu5o;`{l| zI}m~AV}0vJygAENc&1AFqP=PVc$#h*4p%e$ec}0HUu^ihM8ghqD)dF$>kAN_bHu#! zMOfNBOQTE{BD6xO zHnMpQXJW*-i}^3NK9f9v43wivl$OEcgm3g`1aToW^#>t!V5iQv2t#9(= zc%cc~E<4@~m$^tx%o9>2wfIAaOTx*=GBvjnOKKFet|s?S42DOY`coidL|z1bYcc&A z<@jAN`jf)I58l;p$`*$?qLU1WJGUqbUyNM!S#-_Gj|J^~easOT0Heb<(4&D!1ZZVx zWT}Oz{PnT{IDNr+3p)E?0qhj)%m98f2;>OtOi#cK1Unr-8_+!22fI_Jq4uAq&po1{bewQ6KJIYTVt^{laCWsH0**jcv>v#dDoExipxgo^p<>anwG@m;Ygd4pw4?!N$V9a zGPP*^N?yX-mwA&UAU_5ga%Zda9Eu`m(`~{RxrOLw(pKzu?RgTiIHfq9E~{A4V>`GQ zB`3~=Y&Ar0DxM$P7wfGRSao47o`tim^p0-g!&BIkk~Q!pa5u0b2I-q26jN)h+^?@> zR;Y;JwBa|odp|-Neo^7FFvN|GDzJ2mZD)*2l))jn%rL^<#kJrWv{@P*BOjTQ zT{2jTM8g)hpDhGp&_iQrP(L=FSFLb}HLscV1HO zFD6zp(^oLlZ%JZ!Vf0~?deWb*v#_XK`_M*>RyQuwj?ezfm<{i8(x+_W#37`?Y{go` z&7?eRHD$t-Ao^Y;j@Ht&JShb)I)S$SoSgfT*4f$dm5v7qp09Q{Uoa^G z2qs-W@)8pMZs0n$6n;k%ey23EVAEi%5$D9QqD12ZU2)|9zx%~|s*bVI_?XZbSkebg zGQ9)Lk%P1}BnGpHsz@t{?&9^764HDLT~dJN{cTQ|r1&BNDa5t8$>l?eUh(2ZZ}Bg& zlG||HbB>m)m|j=6qiqE7OSc@w;&f2@%}TqaWuqbUyc>w&vOOqNfQwSJLTCoj(%U7S zXUgWGD*q@IDQ``yz5S8pm={g2hdxeW;tTBXCd9Pm5GOFvo5+wbJ3mTT0aG%PfQvC? zDHd+t^Qa7d1bK4dfRL$r#19+Ge%nDcrzO%%KB_?cspy*nobjj?XyQGO^C{jlpAOF7 zupjCoh1Fbn928Q1xyXaGEvf<;JJKcLv8!u=PgJ2Yk85>>scm#GU9pO4NuUidl0aAO zjKG$wuQ&DX*fDfqQc65P~L0FfteD9I=Bq$O7I)--Zq~#6d*{(=$KXBWMic zQ~N5d-4XM~-a?Y`dkp2vk69V8)DzJ2)-1w&WRlqRH&f&|2$qb|2&LyJdH z03?N&;0c0Ikhij6)w!^z|IA2iRxo}yXyUkmnLfi4!j28&JR_g9Am}iHl~e(cu!Fl74tD|n|BAFY2e2GV3))|$#gD=1LpcF}H{WmR`u92GLR!2U zFQVI`49oi@Nr>G*hj=Hb9^u_DPM=wK7 zl|cI%o8+#)1z=bT$P=uahllFPoq4BGC5%-rJ9_W&pa)=ZF8F~0UhhYQ60EzP#T;_k zTyf*FQWzwZ4r*Z+YX;LR?YXBO*VvM8(q}>9!rn&pIV|YKxW&F=BO5J?9kDwV<88Q_ zb%eHMsmT{FdWkgy&&Rd5Wi_NP_7S9GNZJJ=Y#UG$pP3p}G zP5mideG4{a-sX$hl=Jgfq;BQ6H@fM3>CbX3f1R$r{iNR+y^v#UY2POiA9Lm1>r{%C ze>bsrN+%C}8GsuQ9<#!?Y>Uz+p3J-P-oGF3wrdHcmj^l{=HSgN?hncL?pKDf}^bD}hUksKf-mBJ) z>e@0VzJ0w*T3ROUgE9G6=@+!gYxg0lY+o+Hc@Lh>-sOK` zX_h)-AicQ$I>k07>Z_w=;ApEVZtS@!k!4C%H>(UkM(5`A2RY)qfdPq*G2Z#k{gdgR zY4?SP;WP$H8Gea(DaH4e zhZxpeGWW+j6Z|~H9Eb*9JvPSemyb1v*{ezmM-s~lWOH8iP|9dbgni~reL!Rj47`9s z)W)s+5Gl8LslmFMVP)|LdGRD|w|Ck7t(T@9#ta(!#(;(|U2__Hc=aY)iy3s3!n`#- zm(h7v@v^i9hF7uKXx^6J5TL_)J}fvgU=}?F4Obxs0cRMj95j7bIbe^mt41pkcdcD{08Z>6}0?_krmL>_fG#SY7;-V=j~D5BR+r)#$-PDo*4cfFQ>pvz;r ziV?IY13GzIP|=5_5^}~2Gl==qEGGZ6oL*FMjLDVapkaQ+w2E-kp4_|i$ z*k|Zmn!6Tw7BeT)t|Ux;lV8fiq>X)t+)M|VTb_4t#T%>FHnHcXter0;8 zvg#-VTR)px&1m4!Ikq#za^|g$?}nxE%#$NzUflB-tv_gqy7GGW5?hCcMyhK7(bZBV z<`Q-PtAQBV&|rEUZ;C|>Dl+ZVX3T3Mu0 zvs-V}eED37ZpIIu|L@|~znKRInFiPibC?G|Miv&Uwr|8@hViZedx^1PIp{n>RbdL z5#bqyJR{|l8^d)9Veg)6%)q`5T*kR>gJH<~sY$j6?Nt%=u0;l7Gg;+YsYaTpDwEG%gl6h44!bAYW|?vHM8oNW(+8I3*43%?b`~HX8cCZU zbGks$$wH>(lkaz~E&x7(aGg9+`f;1~I|pn-N|bR}6_FS2IxY9Oxc-!r0fj3uAc5z zHVhgT;L}Up8RV|IS~-1>IA8(+TvK>(*-8{(q96b#+@bsv1bc`CAP}R|147>p08l{m zSFH&a>bU?;0O#8Ppg(`86~We1T*q%4qzlKdu2eifd{ywf&!X^w#q85S&yjM?!U3=j zKaWZ_ZJvFyjhW5x)Av1U)Yr9cNg)lSILum-mBG88qWb3t&O*(C(Db{BIq{gi{9kb$<$y;bc|nvx9aJ($vjz@wv?WEiM5m)#{DEUZV9O@ zTIi-TD+5cA+1^uhOvKslg85I-xwr|Ikv8~_Nm&!_gJwlEeg9-f_+lYh7SVQE4v9Cp zFnzg+v{}v*p>v8De(Q0VV3r2-zfg|-uX}&54m@_heuvh4?|ua%LjbB%y8}#m;r(D} z06*JV7#_6Yb^-Mw1>DgU>T#Ayi&L%!ulT8IF9LblTI$j20Bq{J0Z`8H!TJGM4*=@| zV5Mkhe{b%B0aO4MlzZcU@nV7LwT`b63d(j!#+yZHrF%w6zo@#XOMZXngP3!e6}o8~ z!fJ|wPh^1QY*B7Ln?IXc!PWlK!xj~e`7o)b{$M;@+sB-R6>n>a!&7d{;_EQd&dLky zd3^NZTs12R17p*dOhf8{K?FisK~rsUa?vIpUkQuOW5%%;MpdPsy-sObRTh>m5g9=z zj{X7rVBD`c=`2sdFP`Qu2X|ghlDBNRPaAT`vF2$d+|&ynVxk*nyI|kvzogXf?XBMK zy!~cv^1>uRuKg{oI=$(Vb@JQrT=eL@11UtVt4c)+1~>J1X6Dpj(EVKM2Ud)e0|7IP zGk4=f$nnk(5RvZ?NiS2dB^A2W`zPRaP`(~kv$@!pRwy-}7rg!MURC)>41tZ`B_yQ( E10+ctx&QzG literal 0 HcmV?d00001 diff --git a/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+sl4+win8/System.Threading.Tasks.xml b/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+sl4+win8/System.Threading.Tasks.xml new file mode 100644 index 00000000..6c770122 --- /dev/null +++ b/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+sl4+win8/System.Threading.Tasks.xml @@ -0,0 +1,8969 @@ + + + + System.Threading.Tasks + + + + Represents one or more errors that occur during application execution. + + is used to consolidate multiple failures into a single, throwable + exception object. + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class with + a specified error message. + + The error message that explains the reason for the exception. + + + + Initializes a new instance of the class with a specified error + message and a reference to the inner exception that is the cause of this exception. + + The error message that explains the reason for the exception. + The exception that is the cause of the current exception. + The argument + is null. + + + + Initializes a new instance of the class with + references to the inner exceptions that are the cause of this exception. + + The exceptions that are the cause of the current exception. + The argument + is null. + An element of is + null. + + + + Initializes a new instance of the class with + references to the inner exceptions that are the cause of this exception. + + The exceptions that are the cause of the current exception. + The argument + is null. + An element of is + null. + + + + Initializes a new instance of the class with a specified error + message and references to the inner exceptions that are the cause of this exception. + + The error message that explains the reason for the exception. + The exceptions that are the cause of the current exception. + The argument + is null. + An element of is + null. + + + + Initializes a new instance of the class with a specified error + message and references to the inner exceptions that are the cause of this exception. + + The error message that explains the reason for the exception. + The exceptions that are the cause of the current exception. + The argument + is null. + An element of is + null. + + + + Allocates a new aggregate exception with the specified message and list of inner exceptions. + + The error message that explains the reason for the exception. + The exceptions that are the cause of the current exception. + The argument + is null. + An element of is + null. + + + + Returns the that is the root cause of this exception. + + + + + Invokes a handler on each contained by this . + + The predicate to execute for each exception. The predicate accepts as an + argument the to be processed and returns a Boolean to indicate + whether the exception was handled. + + Each invocation of the returns true or false to indicate whether the + was handled. After all invocations, if any exceptions went + unhandled, all unhandled exceptions will be put into a new + which will be thrown. Otherwise, the method simply returns. If any + invocations of the throws an exception, it will halt the processing + of any more exceptions and immediately propagate the thrown exception as-is. + + An exception contained by this was not handled. + The argument is + null. + + + + Flattens an instances into a single, new instance. + + A new, flattened . + + If any inner exceptions are themselves instances of + , this method will recursively flatten all of them. The + inner exceptions returned in the new + will be the union of all of the the inner exceptions from exception tree rooted at the provided + instance. + + + + + Creates and returns a string representation of the current . + + A string representation of the current exception. + + + + Gets a read-only collection of the instances that caused the + current exception. + + + + + A strongly-typed resource class, for looking up localized strings, etc. + + + + + Returns the cached ResourceManager instance used by this class. + + + + + Overrides the current thread's CurrentUICulture property for all + resource lookups using this strongly typed resource class. + + + + + Looks up a localized string similar to One or more errors occurred.. + + + + + Looks up a localized string similar to An element of innerExceptions was null.. + + + + + Looks up a localized string similar to {0}{1}---> (Inner Exception #{2}) {3}{4}{5}. + + + + + Looks up a localized string similar to No tokens were supplied.. + + + + + Looks up a localized string similar to The CancellationTokenSource associated with this CancellationToken has been disposed.. + + + + + Looks up a localized string similar to The CancellationTokenSource has been disposed.. + + + + + Looks up a localized string similar to The SyncRoot property may not be used for the synchronization of concurrent collections.. + + + + + Looks up a localized string similar to The array is multidimensional, or the type parameter for the set cannot be cast automatically to the type of the destination array.. + + + + + Looks up a localized string similar to The index is equal to or greater than the length of the array, or the number of elements in the dictionary is greater than the available space from index to the end of the destination array.. + + + + + Looks up a localized string similar to The capacity argument must be greater than or equal to zero.. + + + + + Looks up a localized string similar to The concurrencyLevel argument must be positive.. + + + + + Looks up a localized string similar to The index argument is less than zero.. + + + + + Looks up a localized string similar to TKey is a reference type and item.Key is null.. + + + + + Looks up a localized string similar to The key already existed in the dictionary.. + + + + + Looks up a localized string similar to The source argument contains duplicate keys.. + + + + + Looks up a localized string similar to The key was of an incorrect type for this dictionary.. + + + + + Looks up a localized string similar to The value was of an incorrect type for this dictionary.. + + + + + Looks up a localized string similar to The lazily-initialized type does not have a public, parameterless constructor.. + + + + + Looks up a localized string similar to ValueFactory returned null.. + + + + + Looks up a localized string similar to The spinCount argument must be in the range 0 to {0}, inclusive.. + + + + + Looks up a localized string similar to There are too many threads currently waiting on the event. A maximum of {0} waiting threads are supported.. + + + + + Looks up a localized string similar to The event has been disposed.. + + + + + Looks up a localized string similar to The operation was canceled.. + + + + + Looks up a localized string similar to The condition argument is null.. + + + + + Looks up a localized string similar to The timeout must represent a value between -1 and Int32.MaxValue, inclusive.. + + + + + Looks up a localized string similar to The specified TaskContinuationOptions combined LongRunning and ExecuteSynchronously. Synchronous continuations should not be long running.. + + + + + Looks up a localized string similar to The specified TaskContinuationOptions excluded all continuation kinds.. + + + + + Looks up a localized string similar to (Internal)An attempt was made to create a LongRunning SelfReplicating task.. + + + + + Looks up a localized string similar to The value needs to translate in milliseconds to -1 (signifying an infinite timeout), 0 or a positive integer less than or equal to Int32.MaxValue.. + + + + + Looks up a localized string similar to The value needs to be either -1 (signifying an infinite timeout), 0 or a positive integer.. + + + + + Looks up a localized string similar to A task may only be disposed if it is in a completion state (RanToCompletion, Faulted or Canceled).. + + + + + Looks up a localized string similar to It is invalid to specify TaskCreationOptions.LongRunning in calls to FromAsync.. + + + + + Looks up a localized string similar to It is invalid to specify TaskCreationOptions.PreferFairness in calls to FromAsync.. + + + + + Looks up a localized string similar to It is invalid to specify TaskCreationOptions.SelfReplicating in calls to FromAsync.. + + + + + Looks up a localized string similar to FromAsync was called with a TaskManager that had already shut down.. + + + + + Looks up a localized string similar to The tasks argument contains no tasks.. + + + + + Looks up a localized string similar to It is invalid to exclude specific continuation kinds for continuations off of multiple tasks.. + + + + + Looks up a localized string similar to The tasks argument included a null value.. + + + + + Looks up a localized string similar to RunSynchronously may not be called on a task that was already started.. + + + + + Looks up a localized string similar to RunSynchronously may not be called on a continuation task.. + + + + + Looks up a localized string similar to RunSynchronously may not be called on a task not bound to a delegate, such as the task returned from an asynchronous method.. + + + + + Looks up a localized string similar to RunSynchronously may not be called on a task that has already completed.. + + + + + Looks up a localized string similar to Start may not be called on a task that was already started.. + + + + + Looks up a localized string similar to Start may not be called on a continuation task.. + + + + + Looks up a localized string similar to Start may not be called on a task with null action.. + + + + + Looks up a localized string similar to Start may not be called on a promise-style task.. + + + + + Looks up a localized string similar to Start may not be called on a task that has completed.. + + + + + Looks up a localized string similar to The task has been disposed.. + + + + + Looks up a localized string similar to The tasks array included at least one null element.. + + + + + Looks up a localized string similar to The awaited task has not yet completed.. + + + + + Looks up a localized string similar to A task was canceled.. + + + + + Looks up a localized string similar to The exceptions collection was empty.. + + + + + Looks up a localized string similar to The exceptions collection included at least one null element.. + + + + + Looks up a localized string similar to A Task's exception(s) were not observed either by Waiting on the Task or accessing its Exception property. As a result, the unobserved exception was rethrown by the finalizer thread.. + + + + + Looks up a localized string similar to (Internal)Expected an Exception or an IEnumerable<Exception>. + + + + + Looks up a localized string similar to ExecuteTask may not be called for a task which was already executed.. + + + + + Looks up a localized string similar to ExecuteTask may not be called for a task which was previously queued to a different TaskScheduler.. + + + + + Looks up a localized string similar to The current SynchronizationContext may not be used as a TaskScheduler.. + + + + + Looks up a localized string similar to The TryExecuteTaskInline call to the underlying scheduler succeeded, but the task body was not invoked.. + + + + + Looks up a localized string similar to An exception was thrown by a TaskScheduler.. + + + + + Looks up a localized string similar to It is invalid to specify TaskCreationOptions.SelfReplicating for a Task<TResult>.. + + + + + Looks up a localized string similar to {Not yet computed}. + + + + + Looks up a localized string similar to A task's Exception may only be set directly if the task was created without a function.. + + + + + Looks up a localized string similar to An attempt was made to transition a task to a final state when it had already completed.. + + + + + Represents a thread-safe collection of keys and values. + + The type of the keys in the dictionary. + The type of the values in the dictionary. + + All public and protected members of are thread-safe and may be used + concurrently from multiple threads. + + + + + Initializes a new instance of the + class that is empty, has the default concurrency level, has the default initial capacity, and + uses the default comparer for the key type. + + + + + Initializes a new instance of the + class that is empty, has the specified concurrency level and capacity, and uses the default + comparer for the key type. + + The estimated number of threads that will update the + concurrently. + The initial number of elements that the + can contain. + is + less than 1. + is less than + 0. + + + + Initializes a new instance of the + class that contains elements copied from the specified , has the default concurrency + level, has the default initial capacity, and uses the default comparer for the key type. + + The whose elements are copied to + the new + . + is a null reference + (Nothing in Visual Basic). + contains one or more + duplicate keys. + + + + Initializes a new instance of the + class that is empty, has the specified concurrency level and capacity, and uses the specified + . + + The + implementation to use when comparing keys. + is a null reference + (Nothing in Visual Basic). + + + + Initializes a new instance of the + class that contains elements copied from the specified , has the default concurrency level, has the default + initial capacity, and uses the specified + . + + The whose elements are copied to + the new + . + The + implementation to use when comparing keys. + is a null reference + (Nothing in Visual Basic). -or- + is a null reference (Nothing in Visual Basic). + + + + + Initializes a new instance of the + class that contains elements copied from the specified , + has the specified concurrency level, has the specified initial capacity, and uses the specified + . + + The estimated number of threads that will update the + concurrently. + The whose elements are copied to the new + . + The implementation to use + when comparing keys. + + is a null reference (Nothing in Visual Basic). + -or- + is a null reference (Nothing in Visual Basic). + + + is less than 1. + + contains one or more duplicate keys. + + + + Initializes a new instance of the + class that is empty, has the specified concurrency level, has the specified initial capacity, and + uses the specified . + + The estimated number of threads that will update the + concurrently. + The initial number of elements that the + can contain. + The + implementation to use when comparing keys. + + is less than 1. -or- + is less than 0. + + is a null reference + (Nothing in Visual Basic). + + + + Attempts to add the specified key and value to the . + + The key of the element to add. + The value of the element to add. The value can be a null reference (Nothing + in Visual Basic) for reference types. + true if the key/value pair was added to the + successfully; otherwise, false. + is null reference + (Nothing in Visual Basic). + The + contains too many elements. + + + + Determines whether the contains the specified + key. + + The key to locate in the . + true if the contains an element with + the specified key; otherwise, false. + is a null reference + (Nothing in Visual Basic). + + + + Attempts to remove and return the the value with the specified key from the + . + + The key of the element to remove and return. + When this method returns, contains the object removed from the + or the default value of + if the operation failed. + true if an object was removed successfully; otherwise, false. + is a null reference + (Nothing in Visual Basic). + + + + Removes the specified key from the dictionary if it exists and returns its associated value. + If matchValue flag is set, the key will be removed only if is associated with a particular + value. + + The key to search for and remove if it exists. + The variable into which the removed value, if found, is stored. + Whether removal of the key is conditional on its value. + The conditional value to compare against if is true + + + + + Attempts to get the value associated with the specified key from the . + + The key of the value to get. + When this method returns, contains the object from + the + with the spedified key or the default value of + , if the operation failed. + true if the key was found in the ; + otherwise, false. + is a null reference + (Nothing in Visual Basic). + + + + Compares the existing value for the specified key with a specified value, and if they’re equal, + updates the key with a third value. + + The key whose value is compared with and + possibly replaced. + The value that replaces the value of the element with if the comparison results in equality. + The value that is compared to the value of the element with + . + true if the value with was equal to and replaced with ; otherwise, + false. + is a null + reference. + + + + Removes all keys and values from the . + + + + + Copies the elements of the to an array of + type , starting at the + specified array index. + + The one-dimensional array of type + that is the destination of the elements copied from the . The array must have zero-based indexing. + The zero-based index in at which copying + begins. + is a null reference + (Nothing in Visual Basic). + is less than + 0. + is equal to or greater than + the length of the . -or- The number of elements in the source + is greater than the available space from to the end of the destination + . + + + + Copies the key and value pairs stored in the to a + new array. + + A new array containing a snapshot of key and value pairs copied from the . + + + + Copy dictionary contents to an array - shared implementation between ToArray and CopyTo. + + Important: the caller must hold all locks in m_locks before calling CopyToPairs. + + + + + Copy dictionary contents to an array - shared implementation between ToArray and CopyTo. + + Important: the caller must hold all locks in m_locks before calling CopyToEntries. + + + + + Copy dictionary contents to an array - shared implementation between ToArray and CopyTo. + + Important: the caller must hold all locks in m_locks before calling CopyToObjects. + + + + Returns an enumerator that iterates through the . + An enumerator for the . + + The enumerator returned from the dictionary is safe to use concurrently with + reads and writes to the dictionary, however it does not represent a moment-in-time snapshot + of the dictionary. The contents exposed through the enumerator may contain modifications + made to the dictionary after was called. + + + + + Shared internal implementation for inserts and updates. + If key exists, we always return false; and if updateIfExists == true we force update with value; + If key doesn't exist, we always add value and return true; + + + + + Adds a key/value pair to the + if the key does not already exist. + + The key of the element to add. + The function used to generate a value for the key + is a null reference + (Nothing in Visual Basic). + is a null reference + (Nothing in Visual Basic). + The dictionary contains too many + elements. + The value for the key. This will be either the existing value for the key if the + key is already in the dictionary, or the new value for the key as returned by valueFactory + if the key was not in the dictionary. + + + + Adds a key/value pair to the + if the key does not already exist. + + The key of the element to add. + the value to be added, if the key does not already exist + is a null reference + (Nothing in Visual Basic). + The dictionary contains too many + elements. + The value for the key. This will be either the existing value for the key if the + key is already in the dictionary, or the new value if the key was not in the dictionary. + + + + Adds a key/value pair to the if the key does not already + exist, or updates a key/value pair in the if the key + already exists. + + The key to be added or whose value should be updated + The function used to generate a value for an absent key + The function used to generate a new value for an existing key + based on the key's existing value + is a null reference + (Nothing in Visual Basic). + is a null reference + (Nothing in Visual Basic). + is a null reference + (Nothing in Visual Basic). + The dictionary contains too many + elements. + The new value for the key. This will be either be the result of addValueFactory (if the key was + absent) or the result of updateValueFactory (if the key was present). + + + + Adds a key/value pair to the if the key does not already + exist, or updates a key/value pair in the if the key + already exists. + + The key to be added or whose value should be updated + The value to be added for an absent key + The function used to generate a new value for an existing key based on + the key's existing value + is a null reference + (Nothing in Visual Basic). + is a null reference + (Nothing in Visual Basic). + The dictionary contains too many + elements. + The new value for the key. This will be either be the result of addValueFactory (if the key was + absent) or the result of updateValueFactory (if the key was present). + + + + Adds the specified key and value to the . + + The object to use as the key of the element to add. + The object to use as the value of the element to add. + is a null reference + (Nothing in Visual Basic). + The dictionary contains too many + elements. + + An element with the same key already exists in the . + + + + Removes the element with the specified key from the . + + The key of the element to remove. + true if the element is successfully remove; otherwise false. This method also returns + false if + was not found in the original . + + is a null reference + (Nothing in Visual Basic). + + + + Adds the specified value to the + with the specified key. + + The + structure representing the key and value to add to the . + The of is null. + The + contains too many elements. + An element with the same key already exists in the + + + + + Determines whether the + contains a specific key and value. + + The + structure to locate in the . + true if the is found in the ; otherwise, false. + + + + Removes a key and value from the dictionary. + + The + structure representing the key and value to remove from the . + true if the key and value represented by is successfully + found and removed; otherwise, false. + The Key property of is a null reference (Nothing in Visual Basic). + + + Returns an enumerator that iterates through the . + An enumerator for the . + + The enumerator returned from the dictionary is safe to use concurrently with + reads and writes to the dictionary, however it does not represent a moment-in-time snapshot + of the dictionary. The contents exposed through the enumerator may contain modifications + made to the dictionary after was called. + + + + + Adds the specified key and value to the dictionary. + + The object to use as the key. + The object to use as the value. + is a null reference + (Nothing in Visual Basic). + The dictionary contains too many + elements. + + is of a type that is not assignable to the key type of the . -or- + is of a type that is not assignable to , + the type of values in the . + -or- A value with the same key already exists in the . + + + + + Gets whether the contains an + element with the specified key. + + The key to locate in the . + true if the contains + an element with the specified key; otherwise, false. + is a null reference + (Nothing in Visual Basic). + + + Provides an for the + . + An for the . + + + + Removes the element with the specified key from the . + + The key of the element to remove. + is a null reference + (Nothing in Visual Basic). + + + + Copies the elements of the to an array, starting + at the specified array index. + + The one-dimensional array that is the destination of the elements copied from + the . The array must have zero-based + indexing. + The zero-based index in at which copying + begins. + is a null reference + (Nothing in Visual Basic). + is less than + 0. + is equal to or greater than + the length of the . -or- The number of elements in the source + is greater than the available space from to the end of the destination + . + + + + Replaces the internal table with a larger one. To prevent multiple threads from resizing the + table as a result of races, the table of buckets that was deemed too small is passed in as + an argument to GrowTable(). GrowTable() obtains a lock, and then checks whether the bucket + table has been replaced in the meantime or not. + + Reference to the bucket table that was deemed too small. + + + + Computes the bucket and lock number for a particular key. + + + + + Acquires all locks for this hash table, and increments locksAcquired by the number + of locks that were successfully acquired. The locks are acquired in an increasing + order. + + + + + Acquires a contiguous range of locks for this hash table, and increments locksAcquired + by the number of locks that were successfully acquired. The locks are acquired in an + increasing order. + + + + + Releases a contiguous range of locks. + + + + + Gets a collection containing the keys in the dictionary. + + + + + Gets a collection containing the values in the dictionary. + + + + + A helper method for asserts. + + + + + Get the data array to be serialized + + + + + Construct the dictionary from a previously seiralized one + + + + + Gets or sets the value associated with the specified key. + + The key of the value to get or set. + The value associated with the specified key. If the specified key is not found, a get + operation throws a + , and a set operation creates a new + element with the specified key. + is a null reference + (Nothing in Visual Basic). + The property is retrieved and + + does not exist in the collection. + + + + Gets the number of key/value pairs contained in the . + + The dictionary contains too many + elements. + The number of key/value paris contained in the . + Count has snapshot semantics and represents the number of items in the + at the moment when Count was accessed. + + + + Gets a value that indicates whether the is empty. + + true if the is empty; otherwise, + false. + + + + Gets a collection containing the keys in the . + + An containing the keys in the + . + + + + Gets a collection containing the values in the . + + An containing the values in + the + . + + + + Gets a value indicating whether the dictionary is read-only. + + true if the is + read-only; otherwise, false. For , this property always returns + false. + + + + Gets a value indicating whether the has a fixed size. + + true if the has a + fixed size; otherwise, false. For , this property always + returns false. + + + + Gets a value indicating whether the is read-only. + + true if the is + read-only; otherwise, false. For , this property always + returns false. + + + + Gets an containing the keys of the . + + An containing the keys of the . + + + + Gets an containing the values in the . + + An containing the values in the . + + + + Gets or sets the value associated with the specified key. + + The key of the value to get or set. + The value associated with the specified key, or a null reference (Nothing in Visual Basic) + if is not in the dictionary or is of a type that is + not assignable to the key type of the . + is a null reference + (Nothing in Visual Basic). + + A value is being assigned, and is of a type that is not assignable to the + key type of the . -or- A value is being + assigned, and is of a type that is not assignable to the value type + of the + + + + + Gets a value indicating whether access to the is + synchronized with the SyncRoot. + + true if access to the is synchronized + (thread safe); otherwise, false. For , this property always + returns false. + + + + Gets an object that can be used to synchronize access to the . This property is not supported. + + The SyncRoot property is not supported. + + + + The number of concurrent writes for which to optimize by default. + + + + + A node in a singly-linked list representing a particular hash table bucket. + + + + + A private class to represent enumeration over the dictionary that implements the + IDictionaryEnumerator interface. + + + + Throws the exception on the ThreadPool. + The exception to propagate. + The target context on which to propagate the exception. Null to use the ThreadPool. + + + Copies the exception's stack trace so its stack trace isn't overwritten. + The exception to prepare. + + + + Provides a builder for asynchronous methods that return . + This type is intended for compiler use only. + + + AsyncTaskMethodBuilder is a value type, and thus it is copied by value. + Prior to being copied, one of its Task, SetResult, or SetException members must be accessed, + or else the copies may end up building distinct Task instances. + + + + Represents an asynchronous method builder. + + + A cached VoidTaskResult task used for builders that complete synchronously. + + + The generic builder object to which this non-generic instance delegates. + + + Initializes a new . + The initialized . + + + Initiates the builder's execution with the associated state machine. + Specifies the type of the state machine. + The state machine instance, passed by reference. + + + Associates the builder with the state machine it represents. + The heap-allocated state machine object. + The argument was null (Nothing in Visual Basic). + The builder is incorrectly initialized. + + + Perform any initialization necessary prior to lifting the builder to the heap. + + + + Schedules the specified state machine to be pushed forward when the specified awaiter completes. + + Specifies the type of the awaiter. + Specifies the type of the state machine. + The awaiter. + The state machine. + + + + Schedules the specified state machine to be pushed forward when the specified awaiter completes. + + Specifies the type of the awaiter. + Specifies the type of the state machine. + The awaiter. + The state machine. + + + + Completes the in the + RanToCompletion state. + + The builder is not initialized. + The task has already completed. + + + + Completes the in the + Faulted state with the specified exception. + + The to use to fault the task. + The argument is null (Nothing in Visual Basic). + The builder is not initialized. + The task has already completed. + + + + Called by the debugger to request notification when the first wait operation + (await, Wait, Result, etc.) on this builder's task completes. + + + true to enable notification; false to disable a previously set notification. + + + + Gets the for this builder. + The representing the builder's asynchronous operation. + The builder is not initialized. + + + + Gets an object that may be used to uniquely identify this builder to the debugger. + + + This property lazily instantiates the ID in a non-thread-safe manner. + It must only be used by the debugger, and only in a single-threaded manner + when no other threads are in the middle of accessing this property or this.Task. + + + + Holds state related to the builder's IAsyncStateMachine. + This is a mutable struct. Be very delicate with it. + + + A reference to the heap-allocated state machine object associated with this builder. + + + Initiates the builder's execution with the associated state machine. + Specifies the type of the state machine. + The state machine instance, passed by reference. + The argument is null (Nothing in Visual Basic). + + + Associates the builder with the state machine it represents. + The heap-allocated state machine object. + The argument was null (Nothing in Visual Basic). + The builder is incorrectly initialized. + + + + Gets the Action to use with an awaiter's OnCompleted or UnsafeOnCompleted method. + On first invocation, the supplied state machine will be boxed. + + Specifies the type of the method builder used. + Specifies the type of the state machine used. + The builder. + The state machine. + An Action to provide to the awaiter. + + + Provides the ability to invoke a state machine's MoveNext method under a supplied ExecutionContext. + + + The context with which to run MoveNext. + + + The state machine whose MoveNext method should be invoked. + + + Initializes the runner. + The context with which to run MoveNext. + + + Invokes MoveNext under the provided context. + + + Cached delegate used with ExecutionContext.Run. + + + Invokes the MoveNext method on the supplied IAsyncStateMachine. + The IAsyncStateMachine machine instance. + + + + Provides a builder for asynchronous methods that return void. + This type is intended for compiler use only. + + + + The synchronization context associated with this operation. + + + State related to the IAsyncStateMachine. + + + An object used by the debugger to uniquely identify this builder. Lazily initialized. + + + Temporary support for disabling crashing if tasks go unobserved. + + + Registers with UnobservedTaskException to suppress exception crashing. + + + Non-zero if PreventUnobservedTaskExceptions has already been invoked. + + + Initializes a new . + The initialized . + + + Initializes the . + The synchronizationContext associated with this operation. This may be null. + + + Initiates the builder's execution with the associated state machine. + Specifies the type of the state machine. + The state machine instance, passed by reference. + The argument was null (Nothing in Visual Basic). + + + Associates the builder with the state machine it represents. + The heap-allocated state machine object. + The argument was null (Nothing in Visual Basic). + The builder is incorrectly initialized. + + + Perform any initialization necessary prior to lifting the builder to the heap. + + + + Schedules the specified state machine to be pushed forward when the specified awaiter completes. + + Specifies the type of the awaiter. + Specifies the type of the state machine. + The awaiter. + The state machine. + + + + Schedules the specified state machine to be pushed forward when the specified awaiter completes. + + Specifies the type of the awaiter. + Specifies the type of the state machine. + The awaiter. + The state machine. + + + Completes the method builder successfully. + + + Faults the method builder with an exception. + The exception that is the cause of this fault. + The argument is null (Nothing in Visual Basic). + The builder is not initialized. + + + Notifies the current synchronization context that the operation completed. + + + + Gets an object that may be used to uniquely identify this builder to the debugger. + + + This property lazily instantiates the ID in a non-thread-safe manner. + It must only be used by the debugger and only in a single-threaded manner. + + + + + Provides a builder for asynchronous methods that return . + This type is intended for compiler use only. + + + AsyncTaskMethodBuilder{TResult} is a value type, and thus it is copied by value. + Prior to being copied, one of its Task, SetResult, or SetException members must be accessed, + or else the copies may end up building distinct Task instances. + + + + A cached task for default(TResult). + + + State related to the IAsyncStateMachine. + + + The lazily-initialized task. + Must be named m_task for debugger step-over to work correctly. + + + The lazily-initialized task completion source. + + + Temporary support for disabling crashing if tasks go unobserved. + + + Initializes a new . + The initialized . + + + Initiates the builder's execution with the associated state machine. + Specifies the type of the state machine. + The state machine instance, passed by reference. + + + Associates the builder with the state machine it represents. + The heap-allocated state machine object. + The argument was null (Nothing in Visual Basic). + The builder is incorrectly initialized. + + + Perform any initialization necessary prior to lifting the builder to the heap. + + + + Schedules the specified state machine to be pushed forward when the specified awaiter completes. + + Specifies the type of the awaiter. + Specifies the type of the state machine. + The awaiter. + The state machine. + + + + Schedules the specified state machine to be pushed forward when the specified awaiter completes. + + Specifies the type of the awaiter. + Specifies the type of the state machine. + The awaiter. + The state machine. + + + + Completes the in the + RanToCompletion state with the specified result. + + The result to use to complete the task. + The task has already completed. + + + + Completes the builder by using either the supplied completed task, or by completing + the builder's previously accessed task using default(TResult). + + A task already completed with the value default(TResult). + The task has already completed. + + + + Completes the in the + Faulted state with the specified exception. + + The to use to fault the task. + The argument is null (Nothing in Visual Basic). + The task has already completed. + + + + Called by the debugger to request notification when the first wait operation + (await, Wait, Result, etc.) on this builder's task completes. + + + true to enable notification; false to disable a previously set notification. + + + This should only be invoked from within an asynchronous method, + and only by the debugger. + + + + + Gets a task for the specified result. This will either + be a cached or new task, never null. + + The result for which we need a task. + The completed task containing the result. + + + Gets the lazily-initialized TaskCompletionSource. + + + Gets the for this builder. + The representing the builder's asynchronous operation. + + + + Gets an object that may be used to uniquely identify this builder to the debugger. + + + This property lazily instantiates the ID in a non-thread-safe manner. + It must only be used by the debugger, and only in a single-threaded manner + when no other threads are in the middle of accessing this property or this.Task. + + + + Provides a base class used to cache tasks of a specific return type. + Specifies the type of results the cached tasks return. + + + + A singleton cache for this result type. + This may be null if there are no cached tasks for this TResult. + + + + Creates a non-disposable task. + The result for the task. + The cacheable task. + + + Creates a cache. + A task cache for this result type. + + + Gets a cached task if one exists. + The result for which we want a cached task. + A cached task if one exists; otherwise, null. + + + Provides a cache for Boolean tasks. + + + A true task. + + + A false task. + + + Gets a cached task for the Boolean result. + true or false + A cached task for the Boolean result. + + + Provides a cache for zero Int32 tasks. + + + The minimum value, inclusive, for which we want a cached task. + + + The maximum value, exclusive, for which we want a cached task. + + + The cache of Task{Int32}. + + + Creates an array of cached tasks for the values in the range [INCLUSIVE_MIN,EXCLUSIVE_MAX). + + + Gets a cached task for the zero Int32 result. + The integer value + A cached task for the Int32 result or null if not cached. + + + + Represents state machines generated for asynchronous methods. + This type is intended for compiler use only. + + + + Moves the state machine to its next state. + + + Configures the state machine with a heap-allocated replica. + The heap-allocated replica. + + + + Represents an awaiter used to schedule continuations when an await operation completes. + + + + + Represents an operation that will schedule continuations when the operation completes. + + + + Schedules the continuation action to be invoked when the instance completes. + The action to invoke when the operation completes. + The argument is null (Nothing in Visual Basic). + + + Schedules the continuation action to be invoked when the instance completes. + The action to invoke when the operation completes. + The argument is null (Nothing in Visual Basic). + Unlike OnCompleted, UnsafeOnCompleted need not propagate ExecutionContext information. + + + Used with Task(of void) + + + + An interface similar to the one added in .NET 4.0. + + + + The exception that is thrown in a thread upon cancellation of an operation that the thread was executing. + + + Initializes the exception. + + + Initializes the exception. + The error message that explains the reason for the exception. + + + Initializes the exception. + The error message that explains the reason for the exception. + The exception that is the cause of the current exception. + + + Initializes the exception. + A cancellation token associated with the operation that was canceled. + + + Initializes the exception. + The error message that explains the reason for the exception. + A cancellation token associated with the operation that was canceled. + + + Initializes the exception. + The error message that explains the reason for the exception. + The exception that is the cause of the current exception. + A cancellation token associated with the operation that was canceled. + + + Gets a token associated with the operation that was canceled. + + + + A dummy replacement for the .NET internal class StackCrawlMark. + + + + + Propogates notification that operations should be canceled. + + + + A may be created directly in an unchangeable canceled or non-canceled state + using the CancellationToken's constructors. However, to have a CancellationToken that can change + from a non-canceled to a canceled state, + CancellationTokenSource must be used. + CancellationTokenSource exposes the associated CancellationToken that may be canceled by the source through its + Token property. + + + Once canceled, a token may not transition to a non-canceled state, and a token whose + is false will never change to one that can be canceled. + + + All members of this struct are thread-safe and may be used concurrently from multiple threads. + + + + + + Internal constructor only a CancellationTokenSource should create a CancellationToken + + + + + Initializes the CancellationToken. + + + The canceled state for the token. + + + Tokens created with this constructor will remain in the canceled state specified + by the parameter. If is false, + both and will be false. + If is true, + both and will be true. + + + + + Registers a delegate that will be called when this CancellationToken is canceled. + + + + If this token is already in the canceled state, the + delegate will be run immediately and synchronously. Any exception the delegate generates will be + propogated out of this method call. + + + The delegate to be executed when the CancellationToken is canceled. + The instance that can + be used to deregister the callback. + is null. + The associated CancellationTokenSource has been disposed. + + + + Registers a delegate that will be called when this + CancellationToken is canceled. + + + + If this token is already in the canceled state, the + delegate will be run immediately and synchronously. Any exception the delegate generates will be + propogated out of this method call. + + + The delegate to be executed when the CancellationToken is canceled. + A Boolean value that indicates whether to capture + the current SynchronizationContext and use it + when invoking the . + The instance that can + be used to deregister the callback. + is null. + The associated CancellationTokenSource has been disposed. + + + + Registers a delegate that will be called when this + CancellationToken is canceled. + + + + If this token is already in the canceled state, the + delegate will be run immediately and synchronously. Any exception the delegate generates will be + propogated out of this method call. + + + The delegate to be executed when the CancellationToken is canceled. + The state to pass to the when the delegate is invoked. This may be null. + The instance that can + be used to deregister the callback. + is null. + The associated CancellationTokenSource has been disposed. + + + + Registers a delegate that will be called when this + CancellationToken is canceled. + + + + If this token is already in the canceled state, the + delegate will be run immediately and synchronously. Any exception the delegate generates will be + propogated out of this method call. + + + The delegate to be executed when the CancellationToken is canceled. + The state to pass to the when the delegate is invoked. This may be null. + A Boolean value that indicates whether to capture + the current SynchronizationContext and use it + when invoking the . + The instance that can + be used to deregister the callback. + is null. + The associated CancellationTokenSource has been disposed. + + + + Determines whether the current CancellationToken instance is equal to the + specified token. + + The other CancellationToken to which to compare this + instance. + True if the instances are equal; otherwise, false. Two tokens are equal if they are associated + with the same CancellationTokenSource or if they were both constructed + from public CancellationToken constructors and their values are equal. + + + + Determines whether the current CancellationToken instance is equal to the + specified . + + The other object to which to compare this instance. + True if is a CancellationToken + and if the two instances are equal; otherwise, false. Two tokens are equal if they are associated + with the same CancellationTokenSource or if they were both constructed + from public CancellationToken constructors and their values are equal. + An associated CancellationTokenSource has been disposed. + + + + Serves as a hash function for a CancellationToken. + + A hash code for the current CancellationToken instance. + + + + Determines whether two CancellationToken instances are equal. + + The first instance. + The second instance. + True if the instances are equal; otherwise, false. + An associated CancellationTokenSource has been disposed. + + + + Determines whether two CancellationToken instances are not equal. + + The first instance. + The second instance. + True if the instances are not equal; otherwise, false. + An associated CancellationTokenSource has been disposed. + + + + Throws a OperationCanceledException if + this token has had cancellation requested. + + + This method provides functionality equivalent to: + + if (token.IsCancellationRequested) + throw new OperationCanceledException(token); + + + The token has had cancellation requested. + The associated CancellationTokenSource has been disposed. + + + + Returns an empty CancellationToken value. + + + The value returned by this property will be non-cancelable by default. + + + + + Gets whether cancellation has been requested for this token. + + Whether cancellation has been requested for this token. + + + This property indicates whether cancellation has been requested for this token, + either through the token initially being construted in a canceled state, or through + calling Cancel + on the token's associated . + + + If this property is true, it only guarantees that cancellation has been requested. + It does not guarantee that every registered handler + has finished executing, nor that cancellation requests have finished propagating + to all registered handlers. Additional synchronization may be required, + particularly in situations where related objects are being canceled concurrently. + + + + + + Gets whether this token is capable of being in the canceled state. + + + If CanBeCanceled returns false, it is guaranteed that the token will never transition + into a canceled state, meaning that will never + return true. + + + + + Gets a that is signaled when the token is canceled. + + Accessing this property causes a WaitHandle + to be instantiated. It is preferable to only use this property when necessary, and to then + dispose the associated instance at the earliest opportunity (disposing + the source will dispose of this allocated handle). The handle should not be closed or disposed directly. + + The associated CancellationTokenSource has been disposed. + + + + Represents a callback delegate that has been registered with a CancellationToken. + + + To unregister a callback, dispose the corresponding Registration instance. + + + + + Attempts to deregister the item. If it's already being run, this may fail. + Entails a full memory fence. + + True if the callback was found and deregistered, false otherwise. + + + + Disposes of the registration and unregisters the target callback from the associated + CancellationToken. + If the target callback is currently executing this method will wait until it completes, except + in the degenerate cases where a callback method deregisters itself. + + + + + Determines whether two CancellationTokenRegistration + instances are equal. + + The first instance. + The second instance. + True if the instances are equal; otherwise, false. + + + + Determines whether two CancellationTokenRegistration instances are not equal. + + The first instance. + The second instance. + True if the instances are not equal; otherwise, false. + + + + Determines whether the current CancellationTokenRegistration instance is equal to the + specified . + + The other object to which to compare this instance. + True, if both this and are equal. False, otherwise. + Two CancellationTokenRegistration instances are equal if + they both refer to the output of a single call to the same Register method of a + CancellationToken. + + + + + Determines whether the current CancellationToken instance is equal to the + specified . + + The other CancellationTokenRegistration to which to compare this instance. + True, if both this and are equal. False, otherwise. + Two CancellationTokenRegistration instances are equal if + they both refer to the output of a single call to the same Register method of a + CancellationToken. + + + + + Serves as a hash function for a CancellationTokenRegistration.. + + A hash code for the current CancellationTokenRegistration instance. + + + + Signals to a that it should be canceled. + + + + is used to instantiate a + (via the source's Token property) + that can be handed to operations that wish to be notified of cancellation or that can be used to + register asynchronous operations for cancellation. That token may have cancellation requested by + calling to the source's Cancel + method. + + + All members of this class, except Dispose, are thread-safe and may be used + concurrently from multiple threads. + + + + + The ID of the thread currently executing the main body of CTS.Cancel() + this helps us to know if a call to ctr.Dispose() is running 'within' a cancellation callback. + This is updated as we move between the main thread calling cts.Cancel() and any syncContexts that are used to + actually run the callbacks. + + + + Initializes the . + + + + + Communicates a request for cancellation. + + + + The associated will be + notified of the cancellation and will transition to a state where + IsCancellationRequested returns true. + Any callbacks or cancelable operations + registered with the will be executed. + + + Cancelable operations and callbacks registered with the token should not throw exceptions. + However, this overload of Cancel will aggregate any exceptions thrown into a , + such that one callback throwing an exception will not prevent other registered callbacks from being executed. + + + The that was captured when each callback was registered + will be reestablished when the callback is invoked. + + + An aggregate exception containing all the exceptions thrown + by the registered callbacks on the associated . + This has been disposed. + + + + Communicates a request for cancellation. + + + + The associated will be + notified of the cancellation and will transition to a state where + IsCancellationRequested returns true. + Any callbacks or cancelable operations + registered with the will be executed. + + + Cancelable operations and callbacks registered with the token should not throw exceptions. + If is true, an exception will immediately propagate out of the + call to Cancel, preventing the remaining callbacks and cancelable operations from being processed. + If is false, this overload will aggregate any + exceptions thrown into a , + such that one callback throwing an exception will not prevent other registered callbacks from being executed. + + + The that was captured when each callback was registered + will be reestablished when the callback is invoked. + + + Specifies whether exceptions should immediately propagate. + An aggregate exception containing all the exceptions thrown + by the registered callbacks on the associated . + This has been disposed. + + + + Releases the resources used by this . + + + This method is not thread-safe for any other concurrent calls. + + + + + Throws an exception if the source has been disposed. + + + + + InternalGetStaticSource() + + Whether the source should be set. + A static source to be shared among multiple tokens. + + + + Registers a callback object. If cancellation has already occurred, the + callback will have been run by the time this method returns. + + + + + + + + + + Invoke the Canceled event. + + + The handlers are invoked synchronously in LIFO order. + + + + + Creates a CancellationTokenSource that will be in the canceled state + when any of the source tokens are in the canceled state. + + The first CancellationToken to observe. + The second CancellationToken to observe. + A CancellationTokenSource that is linked + to the source tokens. + A CancellationTokenSource associated with + one of the source tokens has been disposed. + + + + Creates a CancellationTokenSource that will be in the canceled state + when any of the source tokens are in the canceled state. + + The CancellationToken instances to observe. + A CancellationTokenSource that is linked + to the source tokens. + is null. + A CancellationTokenSource associated with + one of the source tokens has been disposed. + + + + Gets whether cancellation has been requested for this CancellationTokenSource. + + Whether cancellation has been requested for this CancellationTokenSource. + + + This property indicates whether cancellation has been requested for this token source, such as + due to a call to its + Cancel method. + + + If this property returns true, it only guarantees that cancellation has been requested. It does not + guarantee that every handler registered with the corresponding token has finished executing, nor + that cancellation requests have finished propagating to all registered handlers. Additional + synchronization may be required, particularly in situations where related objects are being + canceled concurrently. + + + + + + A simple helper to determine whether cancellation has finished. + + + + + A simple helper to determine whether disposal has occured. + + + + + The ID of the thread that is running callbacks. + + + + + Gets the CancellationToken + associated with this . + + The CancellationToken + associated with this . + The token source has been + disposed. + + + + + + + + + + + + + + The currently executing callback + + + + + A helper class for collating the various bits of information required to execute + cancellation callbacks. + + + + + InternalExecuteCallbackSynchronously_GeneralPath + This will be called on the target synchronization context, however, we still need to restore the required execution context + + + + + A sparsely populated array. Elements can be sparse and some null, but this allows for + lock-free additions and growth, and also for constant time removal (by nulling out). + + The kind of elements contained within. + + + + Allocates a new array with the given initial size. + + How many array slots to pre-allocate. + + + + Adds an element in the first available slot, beginning the search from the tail-to-head. + If no slots are available, the array is grown. The method doesn't return until successful. + + The element to add. + Information about where the add happened, to enable O(1) deregistration. + + + + The tail of the doubly linked list. + + + + + A struct to hold a link to the exact spot in an array an element was inserted, enabling + constant time removal later on. + + + + + A fragment of a sparsely populated array, doubly linked. + + The kind of elements contained within. + + + + Provides lazy initialization routines. + + + These routines avoid needing to allocate a dedicated, lazy-initialization instance, instead using + references to ensure targets have been initialized as they are accessed. + + + + + Initializes a target reference type with the type's default constructor if the target has not + already been initialized. + + The refence type of the reference to be initialized. + A reference of type to initialize if it has not + already been initialized. + The initialized reference of type . + Type does not have a default + constructor. + + Permissions to access the constructor of type were missing. + + + + This method may only be used on reference types. To ensure initialization of value + types, see other overloads of EnsureInitialized. + + + This method may be used concurrently by multiple threads to initialize . + In the event that multiple threads access this method concurrently, multiple instances of + may be created, but only one will be stored into . In such an occurrence, this method will not dispose of the + objects that were not stored. If such objects must be disposed, it is up to the caller to determine + if an object was not used and to then dispose of the object appropriately. + + + + + + Initializes a target reference type using the specified function if it has not already been + initialized. + + The reference type of the reference to be initialized. + The reference of type to initialize if it has not + already been initialized. + The invoked to initialize the + reference. + The initialized reference of type . + Type does not have a + default constructor. + returned + null. + + + This method may only be used on reference types, and may + not return a null reference (Nothing in Visual Basic). To ensure initialization of value types or + to allow null reference types, see other overloads of EnsureInitialized. + + + This method may be used concurrently by multiple threads to initialize . + In the event that multiple threads access this method concurrently, multiple instances of + may be created, but only one will be stored into . In such an occurrence, this method will not dispose of the + objects that were not stored. If such objects must be disposed, it is up to the caller to determine + if an object was not used and to then dispose of the object appropriately. + + + + + + Initialize the target using the given delegate (slow path). + + The reference type of the reference to be initialized. + The variable that need to be initialized + The delegate that will be executed to initialize the target + The initialized variable + + + + Initializes a target reference or value type with its default constructor if it has not already + been initialized. + + The type of the reference to be initialized. + A reference or value of type to initialize if it + has not already been initialized. + A reference to a boolean that determines whether the target has already + been initialized. + A reference to an object used as the mutually exclusive lock for initializing + . + The initialized value of type . + + + + Initializes a target reference or value type with a specified function if it has not already been + initialized. + + The type of the reference to be initialized. + A reference or value of type to initialize if it + has not already been initialized. + A reference to a boolean that determines whether the target has already + been initialized. + A reference to an object used as the mutually exclusive lock for initializing + . + The invoked to initialize the + reference or value. + The initialized value of type . + + + + Ensure the target is initialized and return the value (slow path). This overload permits nulls + and also works for value type targets. Uses the supplied function to create the value. + + The type of target. + A reference to the target to be initialized. + A reference to a location tracking whether the target has been initialized. + A reference to a location containing a mutual exclusive lock. + + The to invoke in order to produce the lazily-initialized value. + + The initialized object. + + + + Provides a slimmed down version of . + + + All public and protected members of are thread-safe and may be used + concurrently from multiple threads, with the exception of Dispose, which + must only be used when all other operations on the have + completed, and Reset, which should only be used when no other threads are + accessing the event. + + + + + Initializes a new instance of the + class with an initial state of nonsignaled. + + + + + Initializes a new instance of the + class with a Boolen value indicating whether to set the intial state to signaled. + + true to set the initial state signaled; false to set the initial state + to nonsignaled. + + + + Initializes a new instance of the + class with a Boolen value indicating whether to set the intial state to signaled and a specified + spin count. + + true to set the initial state to signaled; false to set the initial state + to nonsignaled. + The number of spin waits that will occur before falling back to a true + wait. + is less than + 0 or greater than the maximum allowed value. + + + + Initializes the internal state of the event. + + Whether the event is set initially or not. + The spin count that decides when the event will block. + + + + Helper to ensure the lock object is created before first use. + + + + + This method lazily initializes the event object. It uses CAS to guarantee that + many threads racing to call this at once don't result in more than one event + being stored and used. The event will be signaled or unsignaled depending on + the state of the thin-event itself, with synchronization taken into account. + + True if a new event was created and stored, false otherwise. + + + + Sets the state of the event to signaled, which allows one or more threads waiting on the event to + proceed. + + + + + Private helper to actually perform the Set. + + Indicates whether we are calling Set() during cancellation. + The object has been canceled. + + + + Sets the state of the event to nonsignaled, which causes threads to block. + + + Unlike most of the members of , is not + thread-safe and may not be used concurrently with other members of this instance. + + + + + Blocks the current thread until the current is set. + + + The maximum number of waiters has been exceeded. + + + The caller of this method blocks indefinitely until the current instance is set. The caller will + return immediately if the event is currently in a set state. + + + + + Blocks the current thread until the current receives a signal, + while observing a . + + The to + observe. + + The maximum number of waiters has been exceeded. + + was + canceled. + + The caller of this method blocks indefinitely until the current instance is set. The caller will + return immediately if the event is currently in a set state. + + + + + Blocks the current thread until the current is set, using a + to measure the time interval. + + A that represents the number of milliseconds + to wait, or a that represents -1 milliseconds to wait indefinitely. + + true if the was set; otherwise, + false. + is a negative + number other than -1 milliseconds, which represents an infinite time-out -or- timeout is greater + than . + + The maximum number of waiters has been exceeded. + + + + + Blocks the current thread until the current is set, using a + to measure the time interval, while observing a . + + A that represents the number of milliseconds + to wait, or a that represents -1 milliseconds to wait indefinitely. + + The to + observe. + true if the was set; otherwise, + false. + is a negative + number other than -1 milliseconds, which represents an infinite time-out -or- timeout is greater + than . + was canceled. + + The maximum number of waiters has been exceeded. + + + + + Blocks the current thread until the current is set, using a + 32-bit signed integer to measure the time interval. + + The number of milliseconds to wait, or (-1) to wait indefinitely. + true if the was set; otherwise, + false. + is a + negative number other than -1, which represents an infinite time-out. + + The maximum number of waiters has been exceeded. + + + + + Blocks the current thread until the current is set, using a + 32-bit signed integer to measure the time interval, while observing a . + + The number of milliseconds to wait, or (-1) to wait indefinitely. + The to + observe. + true if the was set; otherwise, + false. + is a + negative number other than -1, which represents an infinite time-out. + + The maximum number of waiters has been exceeded. + + was canceled. + + + + Releases all resources used by the current instance of . + + + Unlike most of the members of , is not + thread-safe and may not be used concurrently with other members of this instance. + + + + + When overridden in a derived class, releases the unmanaged resources used by the + , and optionally releases the managed resources. + + true to release both managed and unmanaged resources; + false to release only unmanaged resources. + + Unlike most of the members of , is not + thread-safe and may not be used concurrently with other members of this instance. + + + + + Throw ObjectDisposedException if the MRES is disposed + + + + + Private helper method to wake up waiters when a cancellationToken gets canceled. + + + + + Private helper method for updating parts of a bit-string state value. + Mainly called from the IsSet and Waiters properties setters + + + Note: the parameter types must be int as CompareExchange cannot take a Uint + + The new value + The mask used to set the bits + + + + Private helper method - performs Mask and shift, particular helpful to extract a field from a packed word. + eg ExtractStatePortionAndShiftRight(0x12345678, 0xFF000000, 24) => 0x12, ie extracting the top 8-bits as a simple integer + + ?? is there a common place to put this rather than being private to MRES? + + + + + + + + + Performs a Mask operation, but does not perform the shift. + This is acceptable for boolean values for which the shift is unnecessary + eg (val & Mask) != 0 is an appropriate way to extract a boolean rather than using + ((val & Mask) >> shiftAmount) == 1 + + ?? is there a common place to put this rather than being private to MRES? + + + + + + + Helper function to measure and update the wait time + + The first time (in Ticks) observed when the wait started. + The orginal wait timeoutout in milliseconds. + The new wait time in milliseconds, -1 if the time expired, -2 if overflow in counters + has occurred. + + + + Gets the underlying object for this . + + The underlying event object fore this . + + Accessing this property forces initialization of an underlying event object if one hasn't + already been created. To simply wait on this , + the public Wait methods should be preferred. + + + + + Gets whether the event is set. + + true if the event has is set; otherwise, false. + + + + Gets the number of spin waits that will be occur before falling back to a true wait. + + + + + How many threads are waiting. + + + + + Provides support for spin-based waiting. + + + + encapsulates common spinning logic. On single-processor machines, yields are + always used instead of busy waits, and on computers with Intel™ processors employing Hyper-Threading™ + technology, it helps to prevent hardware thread starvation. SpinWait encapsulates a good mixture of + spinning and true yielding. + + + is a value type, which means that low-level code can utilize SpinWait without + fear of unnecessary allocation overheads. SpinWait is not generally useful for ordinary applications. + In most cases, you should use the synchronization classes provided by the .NET Framework, such as + . For most purposes where spin waiting is required, however, + the type should be preferred over the System.Threading.Thread.SpinWait method. + + + While SpinWait is designed to be used in concurrent applications, it is not designed to be + used from multiple threads concurrently. SpinWait's members are not thread-safe. If multiple + threads must spin, each should use its own instance of SpinWait. + + + + + + Performs a single spin. + + + This is typically called in a loop, and may change in behavior based on the number of times a + has been called thus far on this instance. + + + + + Resets the spin counter. + + + This makes and behave as though no calls + to had been issued on this instance. If a instance + is reused many times, it may be useful to reset it to avoid yielding too soon. + + + + + Spins until the specified condition is satisfied. + + A delegate to be executed over and over until it returns true. + The argument is null. + + + + Spins until the specified condition is satisfied or until the specified timeout is expired. + + A delegate to be executed over and over until it returns true. + + A that represents the number of milliseconds to wait, + or a TimeSpan that represents -1 milliseconds to wait indefinitely. + True if the condition is satisfied within the timeout; otherwise, false + The argument is null. + is a negative number + other than -1 milliseconds, which represents an infinite time-out -or- timeout is greater than + . + + + + Spins until the specified condition is satisfied or until the specified timeout is expired. + + A delegate to be executed over and over until it returns true. + The number of milliseconds to wait, or (-1) to wait indefinitely. + True if the condition is satisfied within the timeout; otherwise, false + The argument is null. + is a + negative number other than -1, which represents an infinite time-out. + + + + Gets the number of times has been called on this instance. + + + + + Gets whether the next call to will yield the processor, triggering a + forced context switch. + + Whether the next call to will yield the processor, triggering a + forced context switch. + + On a single-CPU machine, always yields the processor. On machines with + multiple CPUs, may yield after an unspecified number of calls. + + + + + A helper class to get the number of preocessors, it updates the numbers of processors every sampling interval + + + + + Gets the number of available processors + + + + + Gets whether the current machine has only a single processor. + + + + + Represents an asynchronous operation that produces a result at some time in the future. + + + The type of the result produced by this . + + + + instances may be created in a variety of ways. The most common approach is by + using the task's property to retrieve a instance that can be used to create tasks for several + purposes. For example, to create a that runs a function, the factory's StartNew + method may be used: + + // C# + var t = Task<int>.Factory.StartNew(() => GenerateResult()); + - or - + var t = Task.Factory.StartNew(() => GenerateResult()); + + ' Visual Basic + Dim t = Task<int>.Factory.StartNew(Function() GenerateResult()) + - or - + Dim t = Task.Factory.StartNew(Function() GenerateResult()) + + + + The class also provides constructors that initialize the task but that do not + schedule it for execution. For performance reasons, the StartNew method should be the + preferred mechanism for creating and scheduling computational tasks, but for scenarios where creation + and scheduling must be separated, the constructors may be used, and the task's + Start + method may then be used to schedule the task for execution at a later time. + + + All members of , except for + Dispose, are thread-safe + and may be used from multiple threads concurrently. + + + + + + Represents an asynchronous operation. + + + + instances may be created in a variety of ways. The most common approach is by + using the Task type's property to retrieve a instance that can be used to create tasks for several + purposes. For example, to create a that runs an action, the factory's StartNew + method may be used: + + // C# + var t = Task.Factory.StartNew(() => DoAction()); + + ' Visual Basic + Dim t = Task.Factory.StartNew(Function() DoAction()) + + + + The class also provides constructors that initialize the Task but that do not + schedule it for execution. For performance reasons, TaskFactory's StartNew method should be the + preferred mechanism for creating and scheduling computational tasks, but for scenarios where creation + and scheduling must be separated, the constructors may be used, and the task's + method may then be used to schedule the task for execution at a later time. + + + All members of , except for , are thread-safe + and may be used from multiple threads concurrently. + + + For operations that return values, the class + should be used. + + + For developers implementing custom debuggers, several internal and private members of Task may be + useful (these may change from release to release). The Int32 m_taskId field serves as the backing + store for the property, however accessing this field directly from a debugger may be + more efficient than accessing the same value through the property's getter method (the + s_taskIdCounter Int32 counter is used to retrieve the next available ID for a Task). Similarly, the + Int32 m_stateFlags field stores information about the current lifecycle stage of the Task, + information also accessible through the property. The m_action System.Object + field stores a reference to the Task's delegate, and the m_stateObject System.Object field stores the + async state passed to the Task by the developer. Finally, for debuggers that parse stack frames, the + InternalWait method serves a potential marker for when a Task is entering a wait operation. + + + + + + A type initializer that runs with the appropriate permissions. + + + + + Initializes a new with the specified action. + + The delegate that represents the code to execute in the Task. + The argument is null. + + + + Initializes a new with the specified action and CancellationToken. + + The delegate that represents the code to execute in the Task. + The CancellationToken + that will be assigned to the new Task. + The argument is null. + The provided CancellationToken + has already been disposed. + + + + + Initializes a new with the specified action and creation options. + + The delegate that represents the code to execute in the task. + + The TaskCreationOptions used to + customize the Task's behavior. + + + The argument is null. + + + The argument specifies an invalid value for . + + + + + Initializes a new with the specified action and creation options. + + The delegate that represents the code to execute in the task. + The that will be assigned to the new task. + + The TaskCreationOptions used to + customize the Task's behavior. + + + The argument is null. + + + The argument specifies an invalid value for . + + The provided CancellationToken + has already been disposed. + + + + + Initializes a new with the specified action and state. + + The delegate that represents the code to execute in the task. + An object representing data to be used by the action. + + The argument is null. + + + + + Initializes a new with the specified action, state, snd options. + + The delegate that represents the code to execute in the task. + An object representing data to be used by the action. + The that will be assigned to the new task. + + The argument is null. + + The provided CancellationToken + has already been disposed. + + + + + Initializes a new with the specified action, state, snd options. + + The delegate that represents the code to execute in the task. + An object representing data to be used by the action. + + The TaskCreationOptions used to + customize the Task's behavior. + + + The argument is null. + + + The argument specifies an invalid value for . + + + + + Initializes a new with the specified action, state, snd options. + + The delegate that represents the code to execute in the task. + An object representing data to be used by the action. + The that will be assigned to the new task. + + The TaskCreationOptions used to + customize the Task's behavior. + + + The argument is null. + + + The argument specifies an invalid value for . + + The provided CancellationToken + has already been disposed. + + + + + An internal constructor used by the factory methods on task and its descendent(s). + This variant does not capture the ExecutionContext; it is up to the caller to do that. + + An action to execute. + Optional state to pass to the action. + Parent of Task. + A CancellationToken for the task. + A task scheduler under which the task will run. + Options to control its execution. + Internal options to control its execution + + + + Common logic used by the following internal ctors: + Task() + Task(object action, object state, Task parent, TaskCreationOptions options, TaskScheduler taskScheduler) + + ASSUMES THAT m_creatingTask IS ALREADY SET. + + + Action for task to execute. + Object to which to pass to action (may be null) + Task scheduler on which to run thread (only used by continuation tasks). + A CancellationToken for the Task. + Options to customize behavior of Task. + Internal options to customize behavior of Task. + + + + Checks if we registered a CT callback during construction, and deregisters it. + This should be called when we know the registration isn't useful anymore. Specifically from Finish() if the task has completed + successfully or with an exception. + + + + + Captures the ExecutionContext so long as flow isn't suppressed. + + A stack crawl mark pointing to the frame of the caller. + + + + Internal function that will be called by a new child task to add itself to + the children list of the parent (this). + + Since a child task can only be created from the thread executing the action delegate + of this task, reentrancy is neither required nor supported. This should not be called from + anywhere other than the task construction/initialization codepaths. + + + + + Starts the , scheduling it for execution to the current TaskScheduler. + + + A task may only be started and run only once. Any attempts to schedule a task a second time + will result in an exception. + + + The is not in a valid state to be started. It may have already been started, + executed, or canceled, or it may have been created in a manner that doesn't support direct + scheduling. + + + The instance has been disposed. + + + + + Starts the , scheduling it for execution to the specified TaskScheduler. + + + A task may only be started and run only once. Any attempts to schedule a task a second time will + result in an exception. + + + The TaskScheduler with which to associate + and execute this task. + + + The argument is null. + + + The is not in a valid state to be started. It may have already been started, + executed, or canceled, or it may have been created in a manner that doesn't support direct + scheduling. + + + The instance has been disposed. + + + + + Runs the synchronously on the current TaskScheduler. + + + + A task may only be started and run only once. Any attempts to schedule a task a second time will + result in an exception. + + + Tasks executed with will be associated with the current TaskScheduler. + + + If the target scheduler does not support running this Task on the current thread, the Task will + be scheduled for execution on the scheduler, and the current thread will block until the + Task has completed execution. + + + + The is not in a valid state to be started. It may have already been started, + executed, or canceled, or it may have been created in a manner that doesn't support direct + scheduling. + + + The instance has been disposed. + + + + + Runs the synchronously on the scheduler provided. + + + + A task may only be started and run only once. Any attempts to schedule a task a second time will + result in an exception. + + + If the target scheduler does not support running this Task on the current thread, the Task will + be scheduled for execution on the scheduler, and the current thread will block until the + Task has completed execution. + + + + The is not in a valid state to be started. It may have already been started, + executed, or canceled, or it may have been created in a manner that doesn't support direct + scheduling. + + + The instance has been disposed. + + The parameter + is null. + The scheduler on which to attempt to run this task inline. + + + + Throws an exception if the task has been disposed, and hence can no longer be accessed. + + The task has been disposed. + + + + Sets the internal completion event. + + + + + Disposes the , releasing all of its unmanaged resources. + + + Unlike most of the members of , this method is not thread-safe. + Also, may only be called on a that is in one of + the final states: RanToCompletion, + Faulted, or + Canceled. + + + The exception that is thrown if the is not in + one of the final states: RanToCompletion, + Faulted, or + Canceled. + + + + + Disposes the , releasing all of its unmanaged resources. + + + A Boolean value that indicates whether this method is being called due to a call to . + + + Unlike most of the members of , this method is not thread-safe. + + + + + Schedules the task for execution. + + If true, TASK_STATE_STARTED bit is turned on in + an atomic fashion, making sure that TASK_STATE_CANCELED does not get set + underneath us. If false, TASK_STATE_STARTED bit is OR-ed right in. This + allows us to streamline things a bit for StartNew(), where competing cancellations + are not a problem. + + + + Adds an exception to the list of exceptions this task has thrown. + + An object representing either an Exception or a collection of Exceptions. + + + + Returns a list of exceptions by aggregating the holder's contents. Or null if + no exceptions have been thrown. + + Whether to include a TCE if cancelled. + An aggregate exception, or null if no exceptions have been caught. + + + + Throws an aggregate exception if the task contains exceptions. + + + + + Checks whether this is an attached task, and whether we are being called by the parent task. + And sets the TASK_STATE_EXCEPTIONOBSERVEDBYPARENT status flag based on that. + + This is meant to be used internally when throwing an exception, and when WaitAll is gathering + exceptions for tasks it waited on. If this flag gets set, the implicit wait on children + will skip exceptions to prevent duplication. + + This should only be called when this task has completed with an exception + + + + + + Signals completion of this particular task. + + The bUserDelegateExecuted parameter indicates whether this Finish() call comes following the + full execution of the user delegate. + + If bUserDelegateExecuted is false, it mean user delegate wasn't invoked at all (either due to + a cancellation request, or because this task is a promise style Task). In this case, the steps + involving child tasks (i.e. WaitForChildren) will be skipped. + + + + + + FinishStageTwo is to be executed as soon as we known there are no more children to complete. + It can happen i) either on the thread that originally executed this task (if no children were spawned, or they all completed by the time this task's delegate quit) + ii) or on the thread that executed the last child. + + + + + Final stage of the task completion code path. Notifies the parent (if any) that another of its childre are done, and runs continuations. + This function is only separated out from FinishStageTwo because these two operations are also needed to be called from CancellationCleanupLogic() + + + + + This is called by children of this task when they are completed. + + + + + This is to be called just before the task does its final state transition. + It traverses the list of exceptional children, and appends their aggregate exceptions into this one's exception list + + + + + Special purpose Finish() entry point to be used when the task delegate throws a ThreadAbortedException + This makes a note in the state flags so that we avoid any costly synchronous operations in the finish codepath + such as inlined continuations + + + Indicates whether the ThreadAbortException was added to this task's exception holder. + This should always be true except for the case of non-root self replicating task copies. + + Whether the delegate was executed. + + + + Executes the task. This method will only be called once, and handles bookeeping associated with + self-replicating tasks, in addition to performing necessary exception marshaling. + + The task has already been disposed. + + + + IThreadPoolWorkItem override, which is the entry function for this task when the TP scheduler decides to run it. + + + + + + Outermost entry function to execute this task. Handles all aspects of executing a task on the caller thread. + Currently this is called by IThreadPoolWorkItem.ExecuteWorkItem(), and TaskManager.TryExecuteInline. + + + Performs atomic updates to prevent double execution. Should only be set to true + in codepaths servicing user provided TaskSchedulers. The ConcRT or ThreadPool schedulers don't need this. + + + + The actual code which invokes the body of the task. This can be overriden in derived types. + + + + + Alternate InnerInvoke prototype to be called from ExecuteSelfReplicating() so that + the Parallel Debugger can discover the actual task being invoked. + Details: Here, InnerInvoke is actually being called on the rootTask object while we are actually executing the + childTask. And the debugger needs to discover the childTask, so we pass that down as an argument. + The NoOptimization and NoInlining flags ensure that the childTask pointer is retained, and that this + function appears on the callstack. + + + + + + Performs whatever handling is necessary for an unhandled exception. Normally + this just entails adding the exception to the holder object. + + The exception that went unhandled. + + + + Waits for the to complete execution. + + + The was canceled -or- an exception was thrown during + the execution of the . + + + The has been disposed. + + + + + Waits for the to complete execution. + + + A that represents the number of milliseconds to wait, or a that represents -1 milliseconds to wait indefinitely. + + + true if the completed execution within the allotted time; otherwise, false. + + + The was canceled -or- an exception was thrown during the execution of the . + + + is a negative number other than -1 milliseconds, which represents an + infinite time-out -or- timeout is greater than + . + + + The has been disposed. + + + + + Waits for the to complete execution. + + + A to observe while waiting for the task to complete. + + + The was canceled. + + + The was canceled -or- an exception was thrown during the execution of the . + + + The + has been disposed. + + + + + Waits for the to complete execution. + + + The number of milliseconds to wait, or (-1) to + wait indefinitely. + true if the completed execution within the allotted time; otherwise, + false. + + + is a negative number other than -1, which represents an + infinite time-out. + + + The was canceled -or- an exception was thrown during the execution of the . + + + The + has been disposed. + + + + + Waits for the to complete execution. + + + The number of milliseconds to wait, or (-1) to + wait indefinitely. + + + A to observe while waiting for the task to complete. + + + true if the completed execution within the allotted time; otherwise, false. + + + The was canceled -or- an exception was thrown during the execution of the . + + + The + has been disposed. + + + is a negative number other than -1, which represents an + infinite time-out. + + + The was canceled. + + + + + The core wait function, which is only accesible internally. It's meant to be used in places in TPL code where + the current context is known or cached. + + + + + Cancels the . + + Indiactes whether we should only cancel non-invoked tasks. + For the default scheduler this option will only be serviced through TryDequeue. + For custom schedulers we also attempt an atomic state transition. + true if the task was successfully canceled; otherwise, false. + The + has been disposed. + + + + Sets the task's cancellation acknowledged flag. + + + + + Runs all of the continuations, as appropriate. + + + + + Helper function to determine whether the current task is in the state desired by the + continuation kind under evaluation. Three possibilities exist: the task failed with + an unhandled exception (OnFailed), the task was canceled before running (OnAborted), + or the task completed successfully (OnCompletedSuccessfully). Note that the last + one includes completing due to cancellation. + + The continuation options under evaluation. + True if the continuation should be run given the task's current state. + + + + Creates a continuation that executes when the target completes. + + + An action to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed, whether it completes due to running to completion successfully, faulting due to an + unhandled exception, or exiting out early due to being canceled. + + + The argument is null. + + + The has been disposed. + + + + + Creates a continuation that executes when the target completes. + + + An action to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + The that will be assigned to the new continuation task. + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed, whether it completes due to running to completion successfully, faulting due to an + unhandled exception, or exiting out early due to being canceled. + + + The argument is null. + + + The has been disposed. + + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation that executes when the target completes. + + + An action to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + + The to associate with the continuation task and to use for its execution. + + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed, whether it completes due to running to completion successfully, faulting due to an + unhandled exception, or exiting out early due to being canceled. + + + The argument is null. + + + The argument is null. + + + The has been disposed. + + + + + Creates a continuation that executes when the target completes. + + + An action to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + + Options for when the continuation is scheduled and how it behaves. This includes criteria, such + as OnlyOnCanceled, as + well as execution options, such as ExecuteSynchronously. + + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed. If the continuation criteria specified through the parameter are not met, the continuation task will be canceled + instead of scheduled. + + + The argument is null. + + + The argument specifies an invalid value for TaskContinuationOptions. + + + The has been disposed. + + + + + Creates a continuation that executes when the target completes. + + + An action to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + + Options for when the continuation is scheduled and how it behaves. This includes criteria, such + as OnlyOnCanceled, as + well as execution options, such as ExecuteSynchronously. + + The that will be assigned to the new continuation task. + + The to associate with the continuation task and to use for its + execution. + + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed. If the criteria specified through the parameter + are not met, the continuation task will be canceled instead of scheduled. + + + The argument is null. + + + The argument specifies an invalid value for TaskContinuationOptions. + + + The argument is null. + + + The has been disposed. + + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation that executes when the target completes. + + + The type of the result produced by the continuation. + + + A function to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed, whether it completes due to running to completion successfully, faulting due to an + unhandled exception, or exiting out early due to being canceled. + + + The argument is null. + + + The has been disposed. + + + + + Creates a continuation that executes when the target completes. + + + The type of the result produced by the continuation. + + + A function to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + The that will be assigned to the new continuation task. + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed, whether it completes due to running to completion successfully, faulting due to an + unhandled exception, or exiting out early due to being canceled. + + + The argument is null. + + + The has been disposed. + + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation that executes when the target completes. + + + The type of the result produced by the continuation. + + + A function to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + + The to associate with the continuation task and to use for its execution. + + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed, whether it completes due to running to completion successfully, faulting due to an + unhandled exception, or exiting out early due to being canceled. + + + The argument is null. + + + The argument is null. + + + The has been disposed. + + + + + Creates a continuation that executes when the target completes. + + + The type of the result produced by the continuation. + + + A function to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + + Options for when the continuation is scheduled and how it behaves. This includes criteria, such + as OnlyOnCanceled, as + well as execution options, such as ExecuteSynchronously. + + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed. If the continuation criteria specified through the parameter are not met, the continuation task will be canceled + instead of scheduled. + + + The argument is null. + + + The argument specifies an invalid value for TaskContinuationOptions. + + + The has been disposed. + + + + + Creates a continuation that executes when the target completes. + + + The type of the result produced by the continuation. + + + A function to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + The that will be assigned to the new continuation task. + + Options for when the continuation is scheduled and how it behaves. This includes criteria, such + as OnlyOnCanceled, as + well as execution options, such as ExecuteSynchronously. + + + The to associate with the continuation task and to use for its + execution. + + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed. If the criteria specified through the parameter + are not met, the continuation task will be canceled instead of scheduled. + + + The argument is null. + + + The argument specifies an invalid value for TaskContinuationOptions. + + + The argument is null. + + + The has been disposed. + + The provided CancellationToken + has already been disposed. + + + + + Converts TaskContinuationOptions to TaskCreationOptions, and also does + some validity checking along the way. + + Incoming TaskContinuationOptions + Outgoing TaskCreationOptions + Outgoing InternalTaskOptions + + + + Registers the continuation and possibly runs it (if the task is already finished). + + The continuation task itself. + TaskScheduler with which to associate continuation task. + Restrictions on when the continuation becomes active. + + + + Waits for all of the provided objects to complete execution. + + + An array of instances on which to wait. + + + The argument is null. + + + The argument contains a null element. + + + At least one of the instances was canceled -or- an exception was thrown during + the execution of at least one of the instances. + + + The has been disposed. + + + + + Waits for all of the provided objects to complete execution. + + + true if all of the instances completed execution within the allotted time; + otherwise, false. + + + An array of instances on which to wait. + + + A that represents the number of milliseconds to wait, or a that represents -1 milliseconds to wait indefinitely. + + + The argument is null. + + + The argument contains a null element. + + + At least one of the instances was canceled -or- an exception was thrown during + the execution of at least one of the instances. + + + is a negative number other than -1 milliseconds, which represents an + infinite time-out -or- timeout is greater than + . + + + The has been disposed. + + + + + Waits for all of the provided objects to complete execution. + + + true if all of the instances completed execution within the allotted time; + otherwise, false. + + + The number of milliseconds to wait, or (-1) to + wait indefinitely. + An array of instances on which to wait. + + + The argument is null. + + + The argument contains a null element. + + + At least one of the instances was canceled -or- an exception was thrown during + the execution of at least one of the instances. + + + The has been disposed. + + + is a negative number other than -1, which represents an + infinite time-out. + + + + + Waits for all of the provided objects to complete execution. + + + true if all of the instances completed execution within the allotted time; + otherwise, false. + + + An array of instances on which to wait. + + + A to observe while waiting for the tasks to complete. + + + The argument is null. + + + The argument contains a null element. + + + At least one of the instances was canceled -or- an exception was thrown during + the execution of at least one of the instances. + + + The was canceled. + + + The has been disposed. + + + + + Waits for all of the provided objects to complete execution. + + + true if all of the instances completed execution within the allotted time; + otherwise, false. + + + An array of instances on which to wait. + + + The number of milliseconds to wait, or (-1) to + wait indefinitely. + + + A to observe while waiting for the tasks to complete. + + + The argument is null. + + + The argument contains a null element. + + + At least one of the instances was canceled -or- an exception was thrown during + the execution of at least one of the instances. + + + The has been disposed. + + + is a negative number other than -1, which represents an + infinite time-out. + + + The was canceled. + + + + + Waits for a set of handles in a STA-aware way. In other words, it will wait for each + of the events individually if we're on a STA thread, because MsgWaitForMultipleObjectsEx + can't do a true wait-all due to its hidden message queue event. This is not atomic, + of course, but we only wait on one-way (MRE) events anyway so this is OK. + + An array of wait handles to wait on. + The timeout to use during waits. + The cancellationToken that enables a wait to be canceled. + True if all waits succeeded, false if a timeout occurred. + + + + Internal WaitAll implementation which is meant to be used with small number of tasks, + optimized for Parallel.Invoke and other structured primitives. + + + + + This internal function is only meant to be called by WaitAll() + If the completed task is canceled or it has other exceptions, here we will add those + into the passed in exception list (which will be lazily initialized here). + + + + + Waits for any of the provided objects to complete execution. + + + An array of instances on which to wait. + + The index of the completed task in the array argument. + + The argument is null. + + + The argument contains a null element. + + + The has been disposed. + + + + + Waits for any of the provided objects to complete execution. + + + An array of instances on which to wait. + + + A that represents the number of milliseconds to wait, or a that represents -1 milliseconds to wait indefinitely. + + + The index of the completed task in the array argument, or -1 if the + timeout occurred. + + + The argument is null. + + + The argument contains a null element. + + + The has been disposed. + + + is a negative number other than -1 milliseconds, which represents an + infinite time-out -or- timeout is greater than + . + + + + + Waits for any of the provided objects to complete execution. + + + An array of instances on which to wait. + + + A to observe while waiting for a task to complete. + + + The index of the completed task in the array argument. + + + The argument is null. + + + The argument contains a null element. + + + The has been disposed. + + + The was canceled. + + + + + Waits for any of the provided objects to complete execution. + + + An array of instances on which to wait. + + + The number of milliseconds to wait, or (-1) to + wait indefinitely. + + + The index of the completed task in the array argument, or -1 if the + timeout occurred. + + + The argument is null. + + + The argument contains a null element. + + + The has been disposed. + + + is a negative number other than -1, which represents an + infinite time-out. + + + + + Waits for any of the provided objects to complete execution. + + + An array of instances on which to wait. + + + The number of milliseconds to wait, or (-1) to + wait indefinitely. + + + A to observe while waiting for a task to complete. + + + The index of the completed task in the array argument, or -1 if the + timeout occurred. + + + The argument is null. + + + The argument contains a null element. + + + The has been disposed. + + + is a negative number other than -1, which represents an + infinite time-out. + + + The was canceled. + + + + + Gets a unique ID for this Task instance. + + + Task IDs are assigned on-demand and do not necessarily represent the order in the which Task + instances were created. + + + + + Returns the unique ID of the currently executing Task. + + + + + Gets the Task instance currently executing, or + null if none exists. + + + + + Gets the Exception that caused the Task to end prematurely. If the Task completed successfully or has not yet thrown any + exceptions, this will return null. + + + Tasks that throw unhandled exceptions store the resulting exception and propagate it wrapped in a + in calls to Wait + or in accesses to the property. Any exceptions not observed by the time + the Task instance is garbage collected will be propagated on the finalizer thread. + + + The Task + has been disposed. + + + + + Gets the TaskStatus of this Task. + + + + + Gets whether this Task instance has completed + execution due to being canceled. + + + A Task will complete in Canceled state either if its CancellationToken + was marked for cancellation before the task started executing, or if the task acknowledged the cancellation request on + its already signaled CancellationToken by throwing an + OperationCanceledException2 that bears the same + CancellationToken. + + + + + Returns true if this task has a cancellation token and it was signaled. + To be used internally in execute entry codepaths. + + + + + This internal property provides access to the CancellationToken that was set on the task + when it was constructed. + + + + + Gets whether this threw an OperationCanceledException2 while its CancellationToken was signaled. + + + + + Gets whether this Task has completed. + + + will return true when the Task is in one of the three + final states: RanToCompletion, + Faulted, or + Canceled. + + + + + Checks whether this task has been disposed. + + + + + Gets the TaskCreationOptions used + to create this task. + + + + + Gets a that can be used to wait for the task to + complete. + + + Using the wait functionality provided by + should be preferred over using for similar + functionality. + + + The has been disposed. + + + + + Gets the state object supplied when the Task was created, + or null if none was supplied. + + + + + Gets an indication of whether the asynchronous operation completed synchronously. + + true if the asynchronous operation completed synchronously; otherwise, false. + + + + Provides access to the TaskScheduler responsible for executing this Task. + + + + + Provides access to factory methods for creating and instances. + + + The factory returned from is a default instance + of , as would result from using + the default constructor on TaskFactory. + + + + + Provides an event that can be used to wait for completion. + Only called by Wait*(), which means that we really do need to instantiate a completion event. + + + + + Determines whether this is the root task of a self replicating group. + + + + + Determines whether the task is a replica itself. + + + + + The property formerly known as IsFaulted. + + + + + Gets whether the completed due to an unhandled exception. + + + If is true, the Task's will be equal to + TaskStatus.Faulted, and its + property will be non-null. + + + + + Checks whether the TASK_STATE_EXCEPTIONOBSERVEDBYPARENT status flag is set, + This will only be used by the implicit wait to prevent double throws + + + + + + Checks whether the body was ever invoked. Used by task scheduler code to verify custom schedulers actually ran the task. + + + + + A structure to hold continuation information. + + + + + Constructs a new continuation structure. + + The task to be activated. + The continuation options. + The scheduler to use for the continuation. + + + + Invokes the continuation for the target completion task. + + The completed task. + Whether the continuation can be inlined. + + + + Initializes a new with the specified function. + + + The delegate that represents the code to execute in the task. When the function has completed, + the task's property will be set to return the result value of the function. + + + The argument is null. + + + + + Initializes a new with the specified function. + + + The delegate that represents the code to execute in the task. When the function has completed, + the task's property will be set to return the result value of the function. + + The to be assigned to this task. + + The argument is null. + + The provided CancellationToken + has already been disposed. + + + + + Initializes a new with the specified function and creation options. + + + The delegate that represents the code to execute in the task. When the function has completed, + the task's property will be set to return the result value of the function. + + + The TaskCreationOptions used to + customize the task's behavior. + + + The argument is null. + + + The argument specifies an invalid value for . + + + + + Initializes a new with the specified function and creation options. + + + The delegate that represents the code to execute in the task. When the function has completed, + the task's property will be set to return the result value of the function. + + The that will be assigned to the new task. + + The TaskCreationOptions used to + customize the task's behavior. + + + The argument is null. + + + The argument specifies an invalid value for . + + The provided CancellationToken + has already been disposed. + + + + + Initializes a new with the specified function and state. + + + The delegate that represents the code to execute in the task. When the function has completed, + the task's property will be set to return the result value of the function. + + An object representing data to be used by the action. + + The argument is null. + + + + + Initializes a new with the specified action, state, and options. + + + The delegate that represents the code to execute in the task. When the function has completed, + the task's property will be set to return the result value of the function. + + An object representing data to be used by the function. + The to be assigned to the new task. + + The argument is null. + + The provided CancellationToken + has already been disposed. + + + + + Initializes a new with the specified action, state, and options. + + + The delegate that represents the code to execute in the task. When the function has completed, + the task's property will be set to return the result value of the function. + + An object representing data to be used by the function. + + The TaskCreationOptions used to + customize the task's behavior. + + + The argument is null. + + + The argument specifies an invalid value for . + + + + + Initializes a new with the specified action, state, and options. + + + The delegate that represents the code to execute in the task. When the function has completed, + the task's property will be set to return the result value of the function. + + An object representing data to be used by the function. + The to be assigned to the new task. + + The TaskCreationOptions used to + customize the task's behavior. + + + The argument is null. + + + The argument specifies an invalid value for . + + The provided CancellationToken + has already been disposed. + + + + + Creates a new future object. + + The parent task for this future. + A function that yields the future value. + The task scheduler which will be used to execute the future. + The CancellationToken for the task. + Options to control the future's behavior. + Internal options to control the future's behavior. + The argument specifies + a SelfReplicating , which is illegal."/>. + + + + Creates a new future object. + + The parent task for this future. + An object containing data to be used by the action; may be null. + A function that yields the future value. + The CancellationToken for the task. + The task scheduler which will be used to execute the future. + Options to control the future's behavior. + Internal options to control the future's behavior. + The argument specifies + a SelfReplicating , which is illegal."/>. + + + + Evaluates the value selector of the Task which is passed in as an object and stores the result. + + + + + Creates a continuation that executes when the target completes. + + + An action to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed, whether it completes due to running to completion successfully, faulting due to an + unhandled exception, or exiting out early due to being canceled. + + + The argument is null. + + + The has been disposed. + + + + + Creates a continuation that executes when the target completes. + + + An action to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + The that will be assigned to the new continuation task. + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed, whether it completes due to running to completion successfully, faulting due to an + unhandled exception, or exiting out early due to being canceled. + + + The argument is null. + + + The has been disposed. + + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation that executes when the target completes. + + + An action to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + + The to associate with the continuation task and to use for its execution. + + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed, whether it completes due to running to completion successfully, faulting due to an + unhandled exception, or exiting out early due to being canceled. + + + The argument is null. + + + The argument is null. + + + The has been disposed. + + + + + Creates a continuation that executes when the target completes. + + + An action to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + + Options for when the continuation is scheduled and how it behaves. This includes criteria, such + as OnlyOnCanceled, as + well as execution options, such as ExecuteSynchronously. + + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed. If the continuation criteria specified through the parameter are not met, the continuation task will be canceled + instead of scheduled. + + + The argument is null. + + + The argument specifies an invalid value for TaskContinuationOptions. + + + The has been disposed. + + + + + Creates a continuation that executes when the target completes. + + + An action to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + The that will be assigned to the new continuation task. + + Options for when the continuation is scheduled and how it behaves. This includes criteria, such + as OnlyOnCanceled, as + well as execution options, such as ExecuteSynchronously. + + + The to associate with the continuation task and to use for its + execution. + + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed. If the criteria specified through the parameter + are not met, the continuation task will be canceled instead of scheduled. + + + The argument is null. + + + The argument specifies an invalid value for TaskContinuationOptions. + + + The argument is null. + + + The has been disposed. + + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation that executes when the target completes. + + + The type of the result produced by the continuation. + + + A function to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + A new continuation . + + The returned will not be scheduled for execution until the current + task has completed, whether it completes due to running to completion successfully, faulting due + to an unhandled exception, or exiting out early due to being canceled. + + + The argument is null. + + + The has been disposed. + + + + + Creates a continuation that executes when the target completes. + + + The type of the result produced by the continuation. + + + A function to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + The that will be assigned to the new task. + A new continuation . + + The returned will not be scheduled for execution until the current + task has completed, whether it completes due to running to completion successfully, faulting due + to an unhandled exception, or exiting out early due to being canceled. + + + The argument is null. + + + The has been disposed. + + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation that executes when the target completes. + + + The type of the result produced by the continuation. + + + A function to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + + The to associate with the continuation task and to use for its execution. + + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed, whether it completes due to running to completion successfully, faulting due to an + unhandled exception, or exiting out early due to being canceled. + + + The argument is null. + + + The argument is null. + + + The has been disposed. + + + + + Creates a continuation that executes when the target completes. + + + The type of the result produced by the continuation. + + + A function to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + + Options for when the continuation is scheduled and how it behaves. This includes criteria, such + as OnlyOnCanceled, as + well as execution options, such as ExecuteSynchronously. + + A new continuation . + + + The returned will not be scheduled for execution until the current + task has completed, whether it completes due to running to completion successfully, faulting due + to an unhandled exception, or exiting out early due to being canceled. + + + The , when executed, should return a . This task's completion state will be transferred to the task returned + from the ContinueWith call. + + + + The argument is null. + + + The argument specifies an invalid value for TaskContinuationOptions. + + + The has been disposed. + + + + + Creates a continuation that executes when the target completes. + + + The type of the result produced by the continuation. + + + A function to run when the completes. When run, the delegate will be passed as + an argument this completed task. + + The that will be assigned to the new task. + + Options for when the continuation is scheduled and how it behaves. This includes criteria, such + as OnlyOnCanceled, as + well as execution options, such as ExecuteSynchronously. + + + The to associate with the continuation task and to use for its + execution. + + A new continuation . + + + The returned will not be scheduled for execution until the current task has + completed, whether it completes due to running to completion successfully, faulting due to an + unhandled exception, or exiting out early due to being canceled. + + + The , when executed, should return a . + This task's completion state will be transferred to the task returned from the + ContinueWith call. + + + + The argument is null. + + + The argument specifies an invalid value for TaskContinuationOptions. + + + The argument is null. + + + The has been disposed. + + The provided CancellationToken + has already been disposed. + + + + + Gets the result value of this . + + + The get accessor for this property ensures that the asynchronous operation is complete before + returning. Once the result of the computation is available, it is stored and will be returned + immediately on later calls to . + + + + + Provides access to factory methods for creating instances. + + + The factory returned from is a default instance + of , as would result from using + the default constructor on the factory type. + + + + + Provides support for creating and scheduling + Task{TResult} objects. + + The type of the results that are available though + the Task{TResult} objects that are associated with + the methods in this class. + + + There are many common patterns for which tasks are relevant. The + class encodes some of these patterns into methods that pick up default settings, which are + configurable through its constructors. + + + A default instance of is available through the + Task{TResult}.Factory property. + + + + + + Initializes a instance with the default configuration. + + + This constructor creates a instance with a default configuration. The + property is initialized to + TaskCreationOptions.None, the + property is initialized to TaskContinuationOptions.None, + and the TaskScheduler property is + initialized to the current scheduler (see TaskScheduler.Current). + + + + + Initializes a instance with the default configuration. + + The default that will be assigned + to tasks created by this unless another CancellationToken is explicitly specified + while calling the factory methods. + + This constructor creates a instance with a default configuration. The + property is initialized to + TaskCreationOptions.None, the + property is initialized to TaskContinuationOptions.None, + and the TaskScheduler property is + initialized to the current scheduler (see TaskScheduler.Current). + + + + + Initializes a instance with the specified configuration. + + + The + TaskScheduler to use to schedule any tasks created with this TaskFactory{TResult}. A null value + indicates that the current TaskScheduler should be used. + + + With this constructor, the + property is initialized to + TaskCreationOptions.None, the + property is initialized to TaskContinuationOptions.None, + and the TaskScheduler property is + initialized to , unless it's null, in which case the property is + initialized to the current scheduler (see TaskScheduler.Current). + + + + + Initializes a instance with the specified configuration. + + + The default + TaskCreationOptions to use when creating tasks with this TaskFactory{TResult}. + + + The default + TaskContinuationOptions to use when creating continuation tasks with this TaskFactory{TResult}. + + + The exception that is thrown when the + argument or the + argument specifies an invalid value. + + + With this constructor, the + property is initialized to , + the + property is initialized to , and the TaskScheduler property is initialized to the + current scheduler (see TaskScheduler.Current). + + + + + Initializes a instance with the specified configuration. + + The default that will be assigned + to tasks created by this unless another CancellationToken is explicitly specified + while calling the factory methods. + + The default + TaskCreationOptions to use when creating tasks with this TaskFactory{TResult}. + + + The default + TaskContinuationOptions to use when creating continuation tasks with this TaskFactory{TResult}. + + + The default + TaskScheduler to use to schedule any Tasks created with this TaskFactory{TResult}. A null value + indicates that TaskScheduler.Current should be used. + + + The exception that is thrown when the + argument or the + argumentspecifies an invalid value. + + + With this constructor, the + property is initialized to , + the + property is initialized to , and the TaskScheduler property is initialized to + , unless it's null, in which case the property is initialized to the + current scheduler (see TaskScheduler.Current). + + + + + Creates and starts a . + + A function delegate that returns the future result to be available through + the . + The started . + The exception that is thrown when the + argument is null. + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + A function delegate that returns the future result to be available through + the . + The that will be assigned to the new task. + The started . + The exception that is thrown when the + argument is null. + The provided CancellationToken + has already been disposed. + + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + A function delegate that returns the future result to be available through + the . + A TaskCreationOptions value that controls the behavior of the + created + . + The started . + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + A function delegate that returns the future result to be available through + the . + A TaskCreationOptions value that controls the behavior of the + created + . + The that will be assigned to the new task. + The TaskScheduler + that is used to schedule the created + Task{TResult}. + The started . + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The provided CancellationToken + has already been disposed. + + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + A function delegate that returns the future result to be available through + the . + An object containing data to be used by the + delegate. + The started . + The exception that is thrown when the + argument is null. + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + A function delegate that returns the future result to be available through + the . + An object containing data to be used by the + delegate. + The that will be assigned to the new task. + The started . + The exception that is thrown when the + argument is null. + The provided CancellationToken + has already been disposed. + + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + A function delegate that returns the future result to be available through + the . + An object containing data to be used by the + delegate. + A TaskCreationOptions value that controls the behavior of the + created + . + The started . + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + A function delegate that returns the future result to be available through + the . + An object containing data to be used by the + delegate. + The that will be assigned to the new task. + A TaskCreationOptions value that controls the behavior of the + created + . + The TaskScheduler + that is used to schedule the created + Task{TResult}. + The started . + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The provided CancellationToken + has already been disposed. + + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates a Task that executes an end + method function when a specified IAsyncResult completes. + + The IAsyncResult whose completion should trigger the processing of the + . + The function delegate that processes the completed . + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + A Task that represents the + asynchronous operation. + + + + Creates a Task that executes an end + method function when a specified IAsyncResult completes. + + The IAsyncResult whose completion should trigger the processing of the + . + The function delegate that processes the completed . + The TaskCreationOptions value that controls the behavior of the + created Task. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + A Task that represents the + asynchronous operation. + + + + Creates a Task that executes an end + method function when a specified IAsyncResult completes. + + The IAsyncResult whose completion should trigger the processing of the + . + The function delegate that processes the completed . + The TaskScheduler + that is used to schedule the task that executes the end method. + The TaskCreationOptions value that controls the behavior of the + created Task. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + A Task that represents the + asynchronous operation. + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The TaskCreationOptions value that controls the behavior of the + created Task. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The TaskCreationOptions value that controls the behavior of the + created Task. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the delegate. + The type of the second argument passed to + delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The second argument passed to the + delegate. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the delegate. + The type of the second argument passed to + delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The second argument passed to the + delegate. + The TaskCreationOptions value that controls the behavior of the + created Task. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the delegate. + The type of the second argument passed to + delegate. + The type of the third argument passed to + delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The second argument passed to the + delegate. + The third argument passed to the + delegate. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the delegate. + The type of the second argument passed to + delegate. + The type of the third argument passed to + delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The second argument passed to the + delegate. + The third argument passed to the + delegate. + The TaskCreationOptions value that controls the behavior of the + created Task. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The array of tasks from which to continue. + The function delegate to execute when all tasks in + the array have completed. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The array of tasks from which to continue. + The function delegate to execute when all tasks in + the array have completed. + The CancellationToken + that will be assigned to the new continuation task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The array of tasks from which to continue. + The function delegate to execute when all tasks in the array have completed. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAll. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The array of tasks from which to continue. + The function delegate to execute when all tasks in the array have completed. + The CancellationToken + that will be assigned to the new continuation task. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The TaskScheduler + that is used to schedule the created continuation Task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAll. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result of the antecedent . + The array of tasks from which to continue. + The function delegate to execute when all tasks in the + array have completed. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result of the antecedent . + The array of tasks from which to continue. + The function delegate to execute when all tasks in the + array have completed. + The CancellationToken + that will be assigned to the new continuation task. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result of the antecedent . + The array of tasks from which to continue. + The function delegate to execute when all tasks in the + array have completed. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAll. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result of the antecedent . + The array of tasks from which to continue. + The function delegate to execute when all tasks in the + array have completed. + The CancellationToken + that will be assigned to the new continuation task. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The TaskScheduler + that is used to schedule the created continuation . + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAll. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the array completes. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the array completes. + The CancellationToken + that will be assigned to the new continuation task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the array completes. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAny. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the array completes. + The CancellationToken + that will be assigned to the new continuation task. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The TaskScheduler + that is used to schedule the created continuation Task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAny. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result of the antecedent . + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the + array completes. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result of the antecedent . + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the + array completes. + The CancellationToken + that will be assigned to the new continuation task. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result of the antecedent . + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the + array completes. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAny. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result of the antecedent . + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the + array completes. + The CancellationToken + that will be assigned to the new continuation task. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The TaskScheduler + that is used to schedule the created continuation . + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAny. + + + + + Gets the default CancellationToken of this + TaskFactory. + + + This property returns the default that will be assigned to all + tasks created by this factory unless another CancellationToken value is explicitly specified + during the call to the factory methods. + + + + + Gets the TaskScheduler of this + TaskFactory{TResult}. + + + This property returns the default scheduler for this factory. It will be used to schedule all + tasks unless another scheduler is explicitly specified during calls to this factory's methods. + If null, TaskScheduler.Current + will be used. + + + + + Gets the TaskCreationOptions + value of this TaskFactory{TResult}. + + + This property returns the default creation options for this factory. They will be used to create all + tasks unless other options are explicitly specified during calls to this factory's methods. + + + + + Gets the TaskContinuationOptions + value of this TaskFactory{TResult}. + + + This property returns the default continuation options for this factory. They will be used to create + all continuation tasks unless other options are explicitly specified during calls to this factory's methods. + + + + + Represents the current stage in the lifecycle of a . + + + + + The task has been initialized but has not yet been scheduled. + + + + + The task is waiting to be activated and scheduled internally by the .NET Framework infrastructure. + + + + + The task has been scheduled for execution but has not yet begun executing. + + + + + The task is running but has not yet completed. + + + + + The task has finished executing and is implicitly waiting for + attached child tasks to complete. + + + + + The task completed execution successfully. + + + + + The task acknowledged cancellation by throwing an OperationCanceledException2 with its own CancellationToken + while the token was in signaled state, or the task's CancellationToken was already signaled before the + task started executing. + + + + + The task completed due to an unhandled exception. + + + + + Specifies flags that control optional behavior for the creation and execution of tasks. + + + + + Specifies that the default behavior should be used. + + + + + A hint to a TaskScheduler to schedule a + task in as fair a manner as possible, meaning that tasks scheduled sooner will be more likely to + be run sooner, and tasks scheduled later will be more likely to be run later. + + + + + Specifies that a task will be a long-running, course-grained operation. It provides a hint to the + TaskScheduler that oversubscription may be + warranted. + + + + + Specifies that a task is attached to a parent in the task hierarchy. + + + + + Task creation flags which are only used internally. + + + + Specifies "No internal task options" + + + Used to filter out internal vs. public task creation options. + + + Specifies that the task will be queued by the runtime before handing it over to the user. + This flag will be used to skip the cancellationtoken registration step, which is only meant for unstarted tasks. + + + + Specifies flags that control optional behavior for the creation and execution of continuation tasks. + + + + + Default = "Continue on any, no task options, run asynchronously" + Specifies that the default behavior should be used. Continuations, by default, will + be scheduled when the antecedent task completes, regardless of the task's final TaskStatus. + + + + + A hint to a TaskScheduler to schedule a + task in as fair a manner as possible, meaning that tasks scheduled sooner will be more likely to + be run sooner, and tasks scheduled later will be more likely to be run later. + + + + + Specifies that a task will be a long-running, course-grained operation. It provides + a hint to the TaskScheduler that + oversubscription may be warranted. + + + + + Specifies that a task is attached to a parent in the task hierarchy. + + + + + Specifies that the continuation task should not be scheduled if its antecedent ran to completion. + This option is not valid for multi-task continuations. + + + + + Specifies that the continuation task should not be scheduled if its antecedent threw an unhandled + exception. This option is not valid for multi-task continuations. + + + + + Specifies that the continuation task should not be scheduled if its antecedent was canceled. This + option is not valid for multi-task continuations. + + + + + Specifies that the continuation task should be scheduled only if its antecedent ran to + completion. This option is not valid for multi-task continuations. + + + + + Specifies that the continuation task should be scheduled only if its antecedent threw an + unhandled exception. This option is not valid for multi-task continuations. + + + + + Specifies that the continuation task should be scheduled only if its antecedent was canceled. + This option is not valid for multi-task continuations. + + + + + Specifies that the continuation task should be executed synchronously. With this option + specified, the continuation will be run on the same thread that causes the antecedent task to + transition into its final state. If the antecedent is already complete when the continuation is + created, the continuation will run on the thread creating the continuation. Only very + short-running continuations should be executed synchronously. + + + + + Represents an exception used to communicate task cancellation. + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the + class with a specified error message. + + The error message that explains the reason for the exception. + + + + Initializes a new instance of the + class with a specified error message and a reference to the inner exception that is the cause of + this exception. + + The error message that explains the reason for the exception. + The exception that is the cause of the current exception. + + + + Initializes a new instance of the class + with a reference to the that has been canceled. + + A task that has been canceled. + + + + Gets the task associated with this exception. + + + It is permissible for no Task to be associated with a + , in which case + this property will return null. + + + + + Represents the producer side of a unbound to a + delegate, providing access to the consumer side through the property. + + + + It is often the case that a is desired to + represent another asynchronous operation. + TaskCompletionSource is provided for this purpose. It enables + the creation of a task that can be handed out to consumers, and those consumers can use the members + of the task as they would any other. However, unlike most tasks, the state of a task created by a + TaskCompletionSource is controlled explicitly by the methods on TaskCompletionSource. This enables the + completion of the external asynchronous operation to be propagated to the underlying Task. The + separation also ensures that consumers are not able to transition the state without access to the + corresponding TaskCompletionSource. + + + All members of are thread-safe + and may be used from multiple threads concurrently. + + + The type of the result value assocatied with this . + + + + Creates a . + + + + + Creates a + with the specified options. + + + The created + by this instance and accessible through its property + will be instantiated using the specified . + + The options to use when creating the underlying + . + + The represent options invalid for use + with a . + + + + + Creates a + with the specified state. + + The state to use as the underlying + 's AsyncState. + + + + Creates a with + the specified state and options. + + The options to use when creating the underlying + . + The state to use as the underlying + 's AsyncState. + + The represent options invalid for use + with a . + + + + + Attempts to transition the underlying + into the + Faulted + state. + + The exception to bind to this . + True if the operation was successful; otherwise, false. + This operation will return false if the + is already in one + of the three final states: + RanToCompletion, + Faulted, or + Canceled. + + The argument is null. + The was disposed. + + + + Attempts to transition the underlying + into the + Faulted + state. + + The collection of exceptions to bind to this . + True if the operation was successful; otherwise, false. + This operation will return false if the + is already in one + of the three final states: + RanToCompletion, + Faulted, or + Canceled. + + The argument is null. + There are one or more null elements in . + The collection is empty. + The was disposed. + + + + Transitions the underlying + into the + Faulted + state. + + The exception to bind to this . + The argument is null. + + The underlying is already in one + of the three final states: + RanToCompletion, + Faulted, or + Canceled. + + The was disposed. + + + + Transitions the underlying + into the + Faulted + state. + + The collection of exceptions to bind to this . + The argument is null. + There are one or more null elements in . + + The underlying is already in one + of the three final states: + RanToCompletion, + Faulted, or + Canceled. + + The was disposed. + + + + Attempts to transition the underlying + into the + RanToCompletion + state. + + The result value to bind to this . + True if the operation was successful; otherwise, false. + This operation will return false if the + is already in one + of the three final states: + RanToCompletion, + Faulted, or + Canceled. + + The was disposed. + + + + Transitions the underlying + into the + RanToCompletion + state. + + The result value to bind to this . + + The underlying is already in one + of the three final states: + RanToCompletion, + Faulted, or + Canceled. + + The was disposed. + + + + Transitions the underlying + into the + Canceled + state. + + + The underlying is already in one + of the three final states: + RanToCompletion, + Faulted, or + Canceled. + + The was disposed. + + + + Attempts to transition the underlying + into the + Canceled + state. + + True if the operation was successful; otherwise, false. + This operation will return false if the + is already in one + of the three final states: + RanToCompletion, + Faulted, or + Canceled. + + The was disposed. + + + + Gets the created + by this . + + + This property enables a consumer access to the that is controlled by this instance. + The , , + , and + methods (and their "Try" variants) on this instance all result in the relevant state + transitions on this underlying Task. + + + + + An exception holder manages a list of exceptions for one particular task. + It offers the ability to aggregate, but more importantly, also offers intrinsic + support for propagating unhandled exceptions that are never observed. It does + this by aggregating and throwing if the holder is ever GC'd without the holder's + contents ever having been requested (e.g. by a Task.Wait, Task.get_Exception, etc). + + + + + Creates a new holder; it will be registered for finalization. + + The task this holder belongs to. + + + + A finalizer that repropagates unhandled exceptions. + + + + + Add an exception to the internal list. This will ensure the holder is + in the proper state (handled/unhandled) depending on the list's contents. + + An exception object (either an Exception or an + IEnumerable{Exception}) to add to the list. + + + + A private helper method that ensures the holder is considered + unhandled, i.e. it is registered for finalization. + + + + + A private helper method that ensures the holder is considered + handled, i.e. it is not registered for finalization. + + Whether this is called from the finalizer thread. + + + + Allocates a new aggregate exception and adds the contents of the list to + it. By calling this method, the holder assumes exceptions to have been + "observed", such that the finalization check will be subsequently skipped. + + Whether this is being called from a finalizer. + An extra exception to be included (optionally). + The aggregate exception to throw. + + + + Provides a set of static (Shared in Visual Basic) methods for working with specific kinds of + instances. + + + + + Creates a proxy Task that represents the + asynchronous operation of a Task{Task}. + + + It is often useful to be able to return a Task from a + Task{TResult}, where the inner Task represents work done as part of the outer Task{TResult}. However, + doing so results in a Task{Task}, which, if not dealt with carefully, could produce unexpected behavior. Unwrap + solves this problem by creating a proxy Task that represents the entire asynchronous operation of such a Task{Task}. + + The Task{Task} to unwrap. + The exception that is thrown if the + argument is null. + A Task that represents the asynchronous operation of the provided Task{Task}. + + + + Creates a proxy Task{TResult} that represents the + asynchronous operation of a Task{Task{TResult}}. + + + It is often useful to be able to return a Task{TResult} from a Task{TResult}, where the inner Task{TResult} + represents work done as part of the outer Task{TResult}. However, doing so results in a Task{Task{TResult}}, + which, if not dealt with carefully, could produce unexpected behavior. Unwrap solves this problem by + creating a proxy Task{TResult} that represents the entire asynchronous operation of such a Task{Task{TResult}}. + + The Task{Task{TResult}} to unwrap. + The exception that is thrown if the + argument is null. + A Task{TResult} that represents the asynchronous operation of the provided Task{Task{TResult}}. /// Unwraps a Task that returns another Task. + + + + Provides support for creating and scheduling + Tasks. + + + + There are many common patterns for which tasks are relevant. The + class encodes some of these patterns into methods that pick up default settings, which are + configurable through its constructors. + + + A default instance of is available through the + Task.Factory property. + + + + + + Initializes a instance with the default configuration. + + + This constructor creates a instance with a default configuration. The + property is initialized to + TaskCreationOptions.None, the + property is initialized to TaskContinuationOptions.None, + and the TaskScheduler property is + initialized to the current scheduler (see TaskScheduler.Current). + + + + + Initializes a instance with the specified configuration. + + The default that will be assigned + to tasks created by this unless another CancellationToken is explicitly specified + while calling the factory methods. + + This constructor creates a instance with a default configuration. The + property is initialized to + TaskCreationOptions.None, the + property is initialized to TaskContinuationOptions.None, + and the TaskScheduler property is + initialized to the current scheduler (see TaskScheduler.Current). + + + + + Initializes a instance with the specified configuration. + + + The + TaskScheduler to use to schedule any tasks created with this TaskFactory. A null value + indicates that the current TaskScheduler should be used. + + + With this constructor, the + property is initialized to + TaskCreationOptions.None, the + property is initialized to TaskContinuationOptions.None, + and the TaskScheduler property is + initialized to , unless it's null, in which case the property is + initialized to the current scheduler (see TaskScheduler.Current). + + + + + Initializes a instance with the specified configuration. + + + The default + TaskCreationOptions to use when creating tasks with this TaskFactory. + + + The default + TaskContinuationOptions to use when creating continuation tasks with this TaskFactory. + + + The exception that is thrown when the + argument or the + argument specifies an invalid value. + + + With this constructor, the + property is initialized to , + the + property is initialized to , and the TaskScheduler property is initialized to the + current scheduler (see TaskScheduler.Current). + + + + + Initializes a instance with the specified configuration. + + The default that will be assigned + to tasks created by this unless another CancellationToken is explicitly specified + while calling the factory methods. + + The default + TaskCreationOptions to use when creating tasks with this TaskFactory. + + + The default + TaskContinuationOptions to use when creating continuation tasks with this TaskFactory. + + + The default + TaskScheduler to use to schedule any Tasks created with this TaskFactory. A null value + indicates that TaskScheduler.Current should be used. + + + The exception that is thrown when the + argument or the + argumentspecifies an invalid value. + + + With this constructor, the + property is initialized to , + the + property is initialized to , and the TaskScheduler property is initialized to + , unless it's null, in which case the property is initialized to the + current scheduler (see TaskScheduler.Current). + + + + + Creates and starts a Task. + + The action delegate to execute asynchronously. + The started Task. + The exception that is thrown when the + argument is null. + + Calling StartNew is functionally equivalent to creating a Task using one of its constructors + and then calling + Start to schedule it for execution. However, + unless creation and scheduling must be separated, StartNew is the recommended + approach for both simplicity and performance. + + + + + Creates and starts a Task. + + The action delegate to execute asynchronously. + The that will be assigned to the new task. + The started Task. + The exception that is thrown when the + argument is null. + The provided CancellationToken + has already been disposed. + + + Calling StartNew is functionally equivalent to creating a Task using one of its constructors + and then calling + Start to schedule it for execution. However, + unless creation and scheduling must be separated, StartNew is the recommended + approach for both simplicity and performance. + + + + + Creates and starts a Task. + + The action delegate to execute asynchronously. + A TaskCreationOptions value that controls the behavior of the + created + Task. + The started Task. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + + Calling StartNew is functionally equivalent to creating a Task using one of its constructors and + then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a Task. + + The action delegate to execute asynchronously. + The that will be assigned to the new + A TaskCreationOptions value that controls the behavior of the + created + Task. + The TaskScheduler + that is used to schedule the created Task. + The started Task. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The provided CancellationToken + has already been disposed. + + + Calling StartNew is functionally equivalent to creating a Task using one of its constructors and + then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a Task. + + The action delegate to execute asynchronously. + An object containing data to be used by the + delegate. + The started Task. + The exception that is thrown when the + argument is null. + + Calling StartNew is functionally equivalent to creating a Task using one of its constructors and + then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a Task. + + The action delegate to execute asynchronously. + An object containing data to be used by the + delegate. + The that will be assigned to the new + The started Task. + The exception that is thrown when the + argument is null. + The provided CancellationToken + has already been disposed. + + + Calling StartNew is functionally equivalent to creating a Task using one of its constructors and + then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a Task. + + The action delegate to execute asynchronously. + An object containing data to be used by the + delegate. + A TaskCreationOptions value that controls the behavior of the + created + Task. + The started Task. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + + Calling StartNew is functionally equivalent to creating a Task using one of its constructors and + then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a Task. + + The action delegate to execute asynchronously. + An object containing data to be used by the + delegate. + The that will be assigned to the new task. + A TaskCreationOptions value that controls the behavior of the + created + Task. + The TaskScheduler + that is used to schedule the created Task. + The started Task. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The provided CancellationToken + has already been disposed. + + + Calling StartNew is functionally equivalent to creating a Task using one of its constructors and + then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + The type of the result available through the + Task. + + A function delegate that returns the future result to be available through + the . + The started . + The exception that is thrown when the + argument is null. + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + The type of the result available through the + Task. + + A function delegate that returns the future result to be available through + the . + The that will be assigned to the new + The started . + The exception that is thrown when the + argument is null. + The provided CancellationToken + has already been disposed. + + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + The type of the result available through the + Task. + + A function delegate that returns the future result to be available through + the . + A TaskCreationOptions value that controls the behavior of the + created + . + The started . + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + The type of the result available through the + Task. + + A function delegate that returns the future result to be available through + the . + The that will be assigned to the new task. + A TaskCreationOptions value that controls the behavior of the + created + . + The TaskScheduler + that is used to schedule the created + Task{TResult}. + The started . + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The provided CancellationToken + has already been disposed. + + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + The type of the result available through the + Task. + + A function delegate that returns the future result to be available through + the . + An object containing data to be used by the + delegate. + The started . + The exception that is thrown when the + argument is null. + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + The type of the result available through the + Task. + + A function delegate that returns the future result to be available through + the . + An object containing data to be used by the + delegate. + The that will be assigned to the new + The started . + The exception that is thrown when the + argument is null. + The provided CancellationToken + has already been disposed. + + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + The type of the result available through the + Task. + + A function delegate that returns the future result to be available through + the . + An object containing data to be used by the + delegate. + A TaskCreationOptions value that controls the behavior of the + created + . + The started . + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + The type of the result available through the + Task. + + A function delegate that returns the future result to be available through + the . + An object containing data to be used by the + delegate. + The that will be assigned to the new task. + A TaskCreationOptions value that controls the behavior of the + created + . + The TaskScheduler + that is used to schedule the created + Task{TResult}. + The started . + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The provided CancellationToken + has already been disposed. + + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates a Task that executes an end method action + when a specified IAsyncResult completes. + + The IAsyncResult whose completion should trigger the processing of the + . + The action delegate that processes the completed . + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + A Task that represents the asynchronous + operation. + + + + Creates a Task that executes an end method action + when a specified IAsyncResult completes. + + The IAsyncResult whose completion should trigger the processing of the + . + The action delegate that processes the completed . + The TaskCreationOptions value that controls the behavior of the + created Task. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + A Task that represents the asynchronous + operation. + + + + Creates a Task that executes an end method action + when a specified IAsyncResult completes. + + The IAsyncResult whose completion should trigger the processing of the + . + The action delegate that processes the completed . + The TaskScheduler + that is used to schedule the task that executes the end method. + The TaskCreationOptions value that controls the behavior of the + created Task. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + A Task that represents the asynchronous + operation. + + + + Creates a Task that represents a pair of begin + and end methods that conform to the Asynchronous Programming Model pattern. + + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The created Task that represents the + asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of begin + and end methods that conform to the Asynchronous Programming Model pattern. + + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The TaskCreationOptions value that controls the behavior of the + created Task. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The created Task that represents the + asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of begin + and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the + delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The created Task that represents the + asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of begin + and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the + delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The TaskCreationOptions value that controls the behavior of the + created Task. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The created Task that represents the + asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of begin + and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the + delegate. + The type of the second argument passed to + delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The second argument passed to the + delegate. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The created Task that represents the + asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of begin + and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the + delegate. + The type of the second argument passed to + delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The second argument passed to the + delegate. + The TaskCreationOptions value that controls the behavior of the + created Task. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The created Task that represents the + asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of begin + and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the + delegate. + The type of the second argument passed to + delegate. + The type of the third argument passed to + delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The second argument passed to the + delegate. + The third argument passed to the + delegate. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The created Task that represents the + asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of begin + and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the + delegate. + The type of the second argument passed to + delegate. + The type of the third argument passed to + delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The second argument passed to the + delegate. + The third argument passed to the + delegate. + The TaskCreationOptions value that controls the behavior of the + created Task. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The created Task that represents the + asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that executes an end + method function when a specified IAsyncResult completes. + + The type of the result available through the + Task. + + The IAsyncResult whose completion should trigger the processing of the + . + The function delegate that processes the completed . + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + A Task that represents the + asynchronous operation. + + + + Creates a Task that executes an end + method function when a specified IAsyncResult completes. + + The type of the result available through the + Task. + + The IAsyncResult whose completion should trigger the processing of the + . + The function delegate that processes the completed . + The TaskCreationOptions value that controls the behavior of the + created Task. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + A Task that represents the + asynchronous operation. + + + + Creates a Task that executes an end + method function when a specified IAsyncResult completes. + + The type of the result available through the + Task. + + The IAsyncResult whose completion should trigger the processing of the + . + The function delegate that processes the completed . + The TaskScheduler + that is used to schedule the task that executes the end method. + The TaskCreationOptions value that controls the behavior of the + created Task. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + A Task that represents the + asynchronous operation. + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the result available through the + Task. + + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the result available through the + Task. + + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The TaskCreationOptions value that controls the behavior of the + created Task. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the delegate. + The type of the result available through the + Task. + + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the delegate. + The type of the result available through the + Task. + + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The TaskCreationOptions value that controls the behavior of the + created Task. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the delegate. + The type of the second argument passed to + delegate. + The type of the result available through the + Task. + + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The second argument passed to the + delegate. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the delegate. + The type of the second argument passed to + delegate. + The type of the result available through the + Task. + + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The second argument passed to the + delegate. + The TaskCreationOptions value that controls the behavior of the + created Task. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the delegate. + The type of the second argument passed to + delegate. + The type of the third argument passed to + delegate. + The type of the result available through the + Task. + + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The second argument passed to the + delegate. + The third argument passed to the + delegate. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the delegate. + The type of the second argument passed to + delegate. + The type of the third argument passed to + delegate. + The type of the result available through the + Task. + + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The second argument passed to the + delegate. + The third argument passed to the + delegate. + The TaskCreationOptions value that controls the behavior of the + created Task. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Check validity of options passed to FromAsync method + + The options to be validated. + determines type of FromAsync method that called this method + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The array of tasks from which to continue. + The action delegate to execute when all tasks in + the array have completed. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The array of tasks from which to continue. + The action delegate to execute when all tasks in + the array have completed. + The CancellationToken + that will be assigned to the new continuation task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The array of tasks from which to continue. + The action delegate to execute when all tasks in the array have completed. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAll. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The array of tasks from which to continue. + The action delegate to execute when all tasks in the array have completed. + The CancellationToken + that will be assigned to the new continuation task. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The TaskScheduler + that is used to schedule the created continuation Task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAll. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result of the antecedent . + The array of tasks from which to continue. + The action delegate to execute when all tasks in + the array have completed. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result of the antecedent . + The array of tasks from which to continue. + The action delegate to execute when all tasks in + the array have completed. + The CancellationToken + that will be assigned to the new continuation task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result of the antecedent . + The array of tasks from which to continue. + The action delegate to execute when all tasks in the array have completed. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAll. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result of the antecedent . + The array of tasks from which to continue. + The action delegate to execute when all tasks in the array have completed. + The CancellationToken + that will be assigned to the new continuation task. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The TaskScheduler + that is used to schedule the created continuation Task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAll. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result that is returned by the + delegate and associated with the created . + The array of tasks from which to continue. + The function delegate to execute when all tasks in the + array have completed. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result that is returned by the + delegate and associated with the created . + The array of tasks from which to continue. + The function delegate to execute when all tasks in the + array have completed. + The CancellationToken + that will be assigned to the new continuation task. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result that is returned by the + delegate and associated with the created . + The array of tasks from which to continue. + The function delegate to execute when all tasks in the + array have completed. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAll. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result that is returned by the + delegate and associated with the created . + The array of tasks from which to continue. + The function delegate to execute when all tasks in the + array have completed. + The CancellationToken + that will be assigned to the new continuation task. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The TaskScheduler + that is used to schedule the created continuation . + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAll. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result that is returned by the + delegate and associated with the created . + The type of the result of the antecedent . + The array of tasks from which to continue. + The function delegate to execute when all tasks in the + array have completed. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result that is returned by the + delegate and associated with the created . + The type of the result of the antecedent . + The array of tasks from which to continue. + The function delegate to execute when all tasks in the + array have completed. + The CancellationToken + that will be assigned to the new continuation task. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result that is returned by the + delegate and associated with the created . + The type of the result of the antecedent . + The array of tasks from which to continue. + The function delegate to execute when all tasks in the + array have completed. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAll. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result that is returned by the + delegate and associated with the created . + The type of the result of the antecedent . + The array of tasks from which to continue. + The function delegate to execute when all tasks in the + array have completed. + The CancellationToken + that will be assigned to the new continuation task. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The TaskScheduler + that is used to schedule the created continuation . + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAll. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The array of tasks from which to continue when one task completes. + The action delegate to execute when one task in the array completes. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The array of tasks from which to continue when one task completes. + The action delegate to execute when one task in the array completes. + The CancellationToken + that will be assigned to the new continuation task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The array of tasks from which to continue when one task completes. + The action delegate to execute when one task in the array completes. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAny. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The array of tasks from which to continue when one task completes. + The action delegate to execute when one task in the array completes. + The CancellationToken + that will be assigned to the new continuation task. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The TaskScheduler + that is used to schedule the created continuation Task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAny. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result that is returned by the + delegate and associated with the created . + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the + array completes. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result that is returned by the + delegate and associated with the created . + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the + array completes. + The CancellationToken + that will be assigned to the new continuation task. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result that is returned by the + delegate and associated with the created . + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the + array completes. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAny. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result that is returned by the + delegate and associated with the created . + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the + array completes. + The CancellationToken + that will be assigned to the new continuation task. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The TaskScheduler + that is used to schedule the created continuation . + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAny. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result that is returned by the + delegate and associated with the created . + The type of the result of the antecedent . + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the + array completes. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result that is returned by the + delegate and associated with the created . + The type of the result of the antecedent . + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the + array completes. + The CancellationToken + that will be assigned to the new continuation task. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result that is returned by the + delegate and associated with the created . + The type of the result of the antecedent . + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the + array completes. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAny. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result that is returned by the + delegate and associated with the created . + The type of the result of the antecedent . + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the + array completes. + The CancellationToken + that will be assigned to the new continuation task. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The TaskScheduler + that is used to schedule the created continuation . + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAny. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result of the antecedent . + The array of tasks from which to continue when one task completes. + The action delegate to execute when one task in the + array completes. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result of the antecedent . + The array of tasks from which to continue when one task completes. + The action delegate to execute when one task in the + array completes. + The CancellationToken + that will be assigned to the new continuation task. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result of the antecedent . + The array of tasks from which to continue when one task completes. + The action delegate to execute when one task in the + array completes. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAny. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result of the antecedent . + The array of tasks from which to continue when one task completes. + The action delegate to execute when one task in the + array completes. + The CancellationToken + that will be assigned to the new continuation task. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The TaskScheduler + that is used to schedule the created continuation . + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAny. + + + + + Gets the default CancellationToken of this + TaskFactory. + + + This property returns the default that will be assigned to all + tasks created by this factory unless another CancellationToken value is explicitly specified + during the call to the factory methods. + + + + + Gets the TaskScheduler of this + TaskFactory. + + + This property returns the default scheduler for this factory. It will be used to schedule all + tasks unless another scheduler is explicitly specified during calls to this factory's methods. + If null, TaskScheduler.Current + will be used. + + + + + Gets the TaskCreationOptions + value of this TaskFactory. + + + This property returns the default creation options for this factory. They will be used to create all + tasks unless other options are explicitly specified during calls to this factory's methods. + + + + + Gets the TaskContinuationOptions + value of this TaskFactory. + + + This property returns the default continuation options for this factory. They will be used to create + all continuation tasks unless other options are explicitly specified during calls to this factory's methods. + + + + + Represents an abstract scheduler for tasks. + + + + TaskScheduler acts as the extension point for all + pluggable scheduling logic. This includes mechanisms such as how to schedule a task for execution, and + how scheduled tasks should be exposed to debuggers. + + + All members of the abstract type are thread-safe + and may be used from multiple threads concurrently. + + + + + + Queues a Task to the scheduler. + + + + A class derived from TaskScheduler + implements this method to accept tasks being scheduled on the scheduler. + A typical implementation would store the task in an internal data structure, which would + be serviced by threads that would execute those tasks at some time in the future. + + + This method is only meant to be called by the .NET Framework and + should not be called directly by the derived class. This is necessary + for maintaining the consistency of the system. + + + The Task to be queued. + The argument is null. + + + + Determines whether the provided Task + can be executed synchronously in this call, and if it can, executes it. + + + + A class derived from TaskScheduler implements this function to + support inline execution of a task on a thread that initiates a wait on that task object. Inline + execution is optional, and the request may be rejected by returning false. However, better + scalability typically results the more tasks that can be inlined, and in fact a scheduler that + inlines too little may be prone to deadlocks. A proper implementation should ensure that a + request executing under the policies guaranteed by the scheduler can successfully inline. For + example, if a scheduler uses a dedicated thread to execute tasks, any inlining requests from that + thread should succeed. + + + If a scheduler decides to perform the inline execution, it should do so by calling to the base + TaskScheduler's + TryExecuteTask method with the provided task object, propagating + the return value. It may also be appropriate for the scheduler to remove an inlined task from its + internal data structures if it decides to honor the inlining request. Note, however, that under + some circumstances a scheduler may be asked to inline a task that was not previously provided to + it with the method. + + + The derived scheduler is responsible for making sure that the calling thread is suitable for + executing the given task as far as its own scheduling and execution policies are concerned. + + + The Task to be + executed. + A Boolean denoting whether or not task has previously been + queued. If this parameter is True, then the task may have been previously queued (scheduled); if + False, then the task is known not to have been queued, and this call is being made in order to + execute the task inline without queueing it. + A Boolean value indicating whether the task was executed inline. + The argument is + null. + The was already + executed. + + + + Generates an enumerable of Task instances + currently queued to the scheduler waiting to be executed. + + + + A class derived from implements this method in order to support + integration with debuggers. This method will only be invoked by the .NET Framework when the + debugger requests access to the data. The enumerable returned will be traversed by debugging + utilities to access the tasks currently queued to this scheduler, enabling the debugger to + provide a representation of this information in the user interface. + + + It is important to note that, when this method is called, all other threads in the process will + be frozen. Therefore, it's important to avoid synchronization with other threads that may lead to + blocking. If synchronization is necessary, the method should prefer to throw a + than to block, which could cause a debugger to experience delays. Additionally, this method and + the enumerable returned must not modify any globally visible state. + + + The returned enumerable should never be null. If there are currently no queued tasks, an empty + enumerable should be returned instead. + + + For developers implementing a custom debugger, this method shouldn't be called directly, but + rather this functionality should be accessed through the internal wrapper method + GetScheduledTasksForDebugger: + internal Task[] GetScheduledTasksForDebugger(). This method returns an array of tasks, + rather than an enumerable. In order to retrieve a list of active schedulers, a debugger may use + another internal method: internal static TaskScheduler[] GetTaskSchedulersForDebugger(). + This static method returns an array of all active TaskScheduler instances. + GetScheduledTasksForDebugger then may be used on each of these scheduler instances to retrieve + the list of scheduled tasks for each. + + + An enumerable that allows traversal of tasks currently queued to this scheduler. + + + This scheduler is unable to generate a list of queued tasks at this time. + + + + + Retrieves some thread static state that can be cached and passed to multiple + TryRunInline calls, avoiding superflous TLS fetches. + + A bag of TLS state (or null if none exists). + + + + Attempts to execute the target task synchronously. + + The task to run. + True if the task may have been previously queued, + false if the task was absolutely not previously queued. + The state retrieved from GetThreadStatics + True if it ran, false otherwise. + + + + Attempts to dequeue a Task that was previously queued to + this scheduler. + + The Task to be dequeued. + A Boolean denoting whether the argument was successfully dequeued. + The argument is null. + + + + Notifies the scheduler that a work item has made progress. + + + + + Initializes the . + + + + + Frees all resources associated with this scheduler. + + + + + Creates a + associated with the current . + + + All Task instances queued to + the returned scheduler will be executed through a call to the + Post method + on that context. + + + A associated with + the current SynchronizationContext, as + determined by SynchronizationContext.Current. + + + The current SynchronizationContext may not be used as a TaskScheduler. + + + + + Attempts to execute the provided Task + on this scheduler. + + + + Scheduler implementations are provided with Task + instances to be executed through either the method or the + method. When the scheduler deems it appropriate to run the + provided task, should be used to do so. TryExecuteTask handles all + aspects of executing a task, including action invocation, exception handling, state management, + and lifecycle control. + + + must only be used for tasks provided to this scheduler by the .NET + Framework infrastructure. It should not be used to execute arbitrary tasks obtained through + custom mechanisms. + + + + A Task object to be executed. + + The is not associated with this scheduler. + + A Boolean that is true if was successfully executed, false if it + was not. A common reason for execution failure is that the task had previously been executed or + is in the process of being executed by another thread. + + + + Provides an array of all queued Task instances + for the debugger. + + + The returned array is populated through a call to . + Note that this function is only meant to be invoked by a debugger remotely. + It should not be called by any other codepaths. + + An array of Task instances. + + This scheduler is unable to generate a list of queued tasks at this time. + + + + + Provides an array of all active TaskScheduler + instances for the debugger. + + + This function is only meant to be invoked by a debugger remotely. + It should not be called by any other codepaths. + + An array of TaskScheduler instances. + + + + Registers a new TaskScheduler instance in the global collection of schedulers. + + + + + Removes a TaskScheduler instance from the global collection of schedulers. + + + + + Indicates the maximum concurrency level this + is able to support. + + + + + Indicates whether this is a custom scheduler, in which case the safe code paths will be taken upon task entry + using a CAS to transition from queued state to executing. + + + + + Gets the default TaskScheduler instance. + + + + + Gets the TaskScheduler + associated with the currently executing task. + + + When not called from within a task, will return the scheduler. + + + + + Gets the unique ID for this . + + + + + Occurs when a faulted 's unobserved exception is about to trigger exception escalation + policy, which, by default, would terminate the process. + + + This AppDomain-wide event provides a mechanism to prevent exception + escalation policy (which, by default, terminates the process) from triggering. + Each handler is passed a + instance, which may be used to examine the exception and to mark it as observed. + + + + + Nested class that provides debugger view for TaskScheduler + + + + Default thread pool scheduler. + + + + A TaskScheduler implementation that executes all tasks queued to it through a call to + on the + that its associated with. The default constructor for this class binds to the current + + + + + Constructs a SynchronizationContextTaskScheduler associated with + + This constructor expects to be set. + + + + Implemetation of for this scheduler class. + + Simply posts the tasks to be executed on the associated . + + + + + + Implementation of for this scheduler class. + + The task will be executed inline only if the call happens within + the associated . + + + + + + + Implementes the property for + this scheduler class. + + By default it returns 1, because a based + scheduler only supports execution on a single thread. + + + + + Provides data for the event that is raised when a faulted 's + exception goes unobserved. + + + The Exception property is used to examine the exception without marking it + as observed, whereas the method is used to mark the exception + as observed. Marking the exception as observed prevents it from triggering exception escalation policy + which, by default, terminates the process. + + + + + Initializes a new instance of the class + with the unobserved exception. + + The Exception that has gone unobserved. + + + + Marks the as "observed," thus preventing it + from triggering exception escalation policy which, by default, terminates the process. + + + + + Gets whether this exception has been marked as "observed." + + + + + The Exception that went unobserved. + + + + + Represents an exception used to communicate an invalid operation by a + . + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the + class with a specified error message. + + The error message that explains the reason for the exception. + + + + Initializes a new instance of the + class using the default error message and a reference to the inner exception that is the cause of + this exception. + + The exception that is the cause of the current exception. + + + + Initializes a new instance of the + class with a specified error message and a reference to the inner exception that is the cause of + this exception. + + The error message that explains the reason for the exception. + The exception that is the cause of the current exception. + + + diff --git a/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+sl4+win8/ensureRedirect.xml b/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+sl4+win8/ensureRedirect.xml new file mode 100644 index 00000000..e69de29b diff --git a/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+sl5+win8+wp8+wpa81/System.IO.dll b/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+sl5+win8+wp8+wpa81/System.IO.dll new file mode 100644 index 0000000000000000000000000000000000000000..01edf729d6fd3f62b325ada34491065ecf202911 GIT binary patch literal 22704 zcmeHv2_ThSxA1cY^E@Ww5t%YP$E?g#=6OhngJZ~WbR2U7CrL$vOc5cHNV9h zXc84kqKHCC)7{T8HoWim-v8eBfA9DI_o=g|o-7rVd?oo2ctUW>B2BkmL!6oCsTlLE+uP@FFzER00K`4DmB$S_<` z7|z(%5f@7GBPz17F-y)?ZD#^ORwxW~^SPnpTx-1$TAT&N0zup$hJGei7Y1(}`00Zm z1aZ>B=$U>a5lH`OPXd4-zLyUL#^t>Y$%_16c+a9p6nMszAjlF4=tEErLWsFX5Q0wW z0>m4FSi!4S5rTy0(*DXD2SJRB@-YJ3Y!R+VA;wSuZjAH|q|wF-`n~wUfz}nt5oBKw zN$Z8IisseMV>i34q_CM<0R=7ooHu4xuY}kiMZIIw)ot zs0>uXM2m%>Kye6SLqU)o4uTS9^Xx~z}-c!l!z$t@l6@4r06zZYWdjbP@bZdjKomB7hG z930)xO|fmQrE?Ott<{nEB1@k*W@8zA@3KMtz)gDM1LgNOyVSDwzm!T?X(T=%swRq- z0n}lZSMTYr-^&UkC3G&1F5hw&)bYM^j5$8wrCHVz~1%Ral89G`R zqGlUJcs2?doC>Uh*Fq|x0~JHi6$}JPY=$6t!1JBpC*epTgW?fL4lH0$gl8q39U&_a zMwXGpYG-p}@b&28k9gI@!B-#NQ2=txQ7Oh(qJPEK0zaOa$&xqZK36$OZ1QvMioO3Q2=Cyj$zV4 zxB;ZnL(gdOOjx8>>@=v1^#=V7#5!P^p+o@bp)6YbNdS=tH4Bk9ClDJrFayZ!pirEU zG^7nEg8_9RX{JE9umOw-;)2eBI=P^Jh#hLfAr)*Dm;ho71$EM}{fyIq$S7!uIFh!X zksT!jFwt2|5QPJn)GQ{2k^+>~reVpnTF{XBJf;cK9Of|{(7MMwW(<0Y^nVQsf$QcW z8uF)wBLPH%R6H~RX+l~wXh4JJG-ywQZZt@s!5|vkK!dR~m`H;=XmB459stk+DhJRG zssfN3IuD>R)IbY2(;(9<{Djd#wL>_p5rC_(7ASELZwsIq)*Uqj!agW205t(6Cm{DaR4o8(2*A7P74P^RUkfsR)0Kn9&H5ehcr<}&@SjBD3b@m=CszgLT{iLlnV+C zs0%@55F*TUP(W!yCMZ=vSu~gpCIRhS=Sv$yVAyFtG zNRS5&ehYCpB#QPRr7j~26M3|)Nq&(bL|tfBj+xsk`h|o*bK+no7BZiaIL1KWn8f%J z!zn;!E|h=_A|i;PJ|VHzL<#{BN(K}lO?)CL#JM~UME?+?FRj#^?1gN7)`KW$p}yag znib&CoG`T}gb@OWWQaT~+5tY-#A+arfK-el&{~-l5eg+nM1cN6L1Ccm!a#$Gv2(q4m{Asr zvw8@KV91F;2JM*wGmjWeA_p%}Wsb^5r0`gBP(UE%cS)h)gs|9O6HI}Um~G?NM1)G@ zP#WO~A%B?b4-=e%C?UjOYc(cD_>zNYtnzE35h=_+C?JwdYxLJ-J2K!(-`@<-i3~J& zDB-tcnbF(}mD$Xw@VQBjup)#7M1tv9$T7?F#zBODFj531$TtEqCi+AM1Q2`{k7yd5J9UH1T!U*LT6*hr&rHcPo7JC|8aI=GHx~l2g6Bg%_RKh&Xkk`!LP+q|xl<64%El<-b&BccE<^vZr!>$M&G^-++@ zEMv|uCq*X`DI`J>(4G_)5E6^9iQinJVPsGUu(TOw&1x_>MCkw(h87m4hfv%>T%lMT z#JypLA{(#_C~htgW@iT!MCcOBh@z=4Kn(;$gZktqmk$OEKZ%-x27hjft`0=xEcpVgohAfZGf!hMJmC~ z)q-=3^Z^<`6$L3>Eyr00`I1QyB!3Fdh(r!2%}6ap91ipZN0Y=6IKX;f{S*Cw0WOGw z_Co)hr5IYKDnw=zbTR?4uJKa zPH28tG9erYjd`u)6o@QNS{YDm&S!w|qA-ZO55{#LYy=z}jUDf=(F|v?uCdA@J7|(+ z*Plho_^$Nu@le%JQ}Iy7E30{cjkQNm7==g)DIf>*P3Ezd0=SnpDN@7 z!oXii+t(U_`a+>_S{t!oL6LYA)sa);MyN&2`Q%ret7V2 zW|n9}{l5nQV<7%FeS|^&_xb;h0<<#@G#Y}bx&`!1a>-`NAK6e0=t8RQ9uTz)jY8pB zU?zIH73>(aARPo-(KD~0M`2M^4KxZ{s0(YuOBTg&z)TnvRERA`CqS_HqHLNu*M7-uX!58Bxg&jWMO1B8)>*_99x2sXeJQW%~SW=A3!co-arexal=KfEX` zjKnbW{NC)vi^F0_I)+DJ!7O$HE^-C1+Y1fH*%=wYqD$EDDtPcHE8{_6EkM;^5S&Hf z#G1dQXKXMF(lZtwthKG316~?lK7)#e83lz063IAYM-!Zhqs>Yq*i=>W=16Z+Y!y$<}ektY%zsVbP$G$;s6YRVn$O@D5$D)T8Mr{^wItd&y5@daYxeM z?sO6<`IHp7ExYBmM^@XTNQK9YpWQp&DlEUQp*wkev!LTk*ZSbW%eS(apP0T|E2@j` zsP2{84f(~_Yww?0qa3@vL(o&=(n0%c9GuhGHD~yv!iFzhe_8*f;zWZ%_p!UNlfu;p z49en`ulRmEhHcHts&#hH{H%I!@yYcZ8TwY@ujJ0j#3UttUyn^Gv|}oIFDB#}FL!C` zD|NAn?WLy-mXKapQ~a-fE#6?NX5SLL#NKzBFC#tI%TngT0KbX(ko=i%yS7(;DGfDx zas-~1l^M-rllR#Aj5}@p>Fy1q9=vPiBxJrPhP%E?Wys~}lygJ_jz%4(qL=_h=wJ~* zQW176KbH4ATSblaMAsp~YH2BFHk@&1PTvHLheRZ>0x*99uY~H7Tz=8zq0ycF!ZRjfpN2skL44WUxl}WNFROY%%Zpqld>YO4e=)mXO zx7V7^BFEz3=jUaifzH(Pvaf^6s~@~z?P`A*w_GD8K$!J&x9nQMY)v^W7t_ybiRb%u zOxN!2{}QRO#?5?}O}92*euRVNn|RihR}~s+@*EU;)tb&XxYi8n6loj3m*5v=KIWz& z-InRF?&uahr?JH6Pjc&s4`M!iw9>lxwD+L~`@Y=msS&R>_&I#k#dKc3L#|a-&2dk? zH_3S9P0V%sLN<2NM6kBLpf|sKIlV)^Fwfq*B(&)3_=7bcrn0@?6WiOxwy$i695YOd z8%ZTs$A6aJd3xV!r#{7?7Jer|Hz3A_ff&2LNQ|B0s$|~Pw(8JRUit>e0RqEb%DkGXl2zj^*hHnLx6n{?jzltO`l`U)2P&-JS=ocD;_&+lM) zOQlKU)cBjtM<)&VJQ#^0;u>S}7nZSbR&nM>FWZ*1(e}L1-cyr@zwMe}&9y0Yb$udcvRv&+hHL(3%lquqZp}U1-(Eb7qonvf_qn!QQSM~EfEc^z*{hY3 zr`hc;JrmyVVSXg`%-Qa{pTgs1P)W6NvaOfP>FA#Ka%`~vTHztFRrbw|CX1Vc(nfqpUBDv?_qmnadTmT zyeKh+jqyLtj|z-OSc#5DP6e-~rM5!VpWqMsXy6qHekvLYssw_H0zn<18tOj2u$r=p zsw%sAWRw4t00g`YI2p)2 zFIZDS1+SnC<6)WzTstS9fC#jKfe@U-fe6(7Ya;Lu>Zbg(a%u7o|0qn3+f^m;LH_kO zpH|*Cwq`7NyRK)w`?=Uw^ubF}fdzYu4ze_EDNcQ7eIZlpGh6TTya`W94xzLZzLguh zEAG}bhg{H-H`ye~1DRw#p|eN1Fc$(GDjJ4rB93(U z-m&P@?H{-K`n{<4BAREFC+?ZE-rQ-}Q z-f`uBv-ts81d%W(wdP%c~$&<_dw`8>ya)lod@i1wvU1$gOvCSEj_Rg@Wc03yL|-3T)HL6)(fpnB`ONN2xX z&htg?IkRJ?TYm{`HzUi;;nlE7p;4hhvff{pW%K+_2CVH1IGZNLoaUq!kYZ*q5Xy5n zkYbvDO^VGN0w4+Db%rtoGG^+s&d$ul1!fdH$kt;i{{>M8$S8t1^WOC*Z~U*qxrfEc*O%HD`ri&UZV0#f_Kg#N+xh4Wxq__wUJUPV3AQ zKgs5CaIE-ba^P0h^$HiGf+3Ntiue5SANaRQo=<6Ae{?loDfh{X4LXmY%|5H!@1``@ z3QV(;(;5!zRHF6Qe-Fyb>f=1hd0NAc@nNG5Or>W4@_Tene)9(+{#tO3@=wTbSOc6Y z0RgV20wcz#GM;x6-CfTAA9`Rkocn#1?-#60$$wk<1fQ$5Y8|FJ(*>rB5W= zIy z@6jh(6n{!8<66zjL_L%=;vDl0l`CS$xDDcjO-If>lQ6w_O~L6hFcb8c@eg8z)cooMoC%umY>0S0`()+g?;UAr||Q>%ENyErw}r`8pH+XlyDci?H9exK{b z$~C#d&qYwlCoaak-_okkBxY@t$638)j&q zoaD0b&mX?@#~e^(`^eB2eo4S4e|Io5IkUD%>tKLFlRf)u9}hkLoLxA*J_bSMPc3+h zD7?-JGRw`^;X2>9G4u3XWhU$%dsMsRjm@qtO=>IF9lreL(k2$e`1_7z@wf1;i!nqG zchnMQUiOYI-keG8^ZsjU6qH_l+Lqj6?=qMlo)L0F%j*7z*vrQR;(TOBi}Pev>7xaG znsr1&#i(N}H{>t28r8h~G`#7|i;|-hwOX5|4HDc^Q7qaHsTvSgaSU;f6$P7o#4%aW#Vl{Lo0?ZPMEdG-|tjTu#%E9lk{5q+GX^}vjh3JR+8!x zr784WZ==L7=TRG^oz7OR*V$1NMK~Q+#B=2GvDIVTq^~=bL#n^^*xyW*X!ftm7unA3 zht^T3blX$gFaGk(saw9MW1Q&j8z|bH$T(FRbG)W7D^l=r`gWekWlG9N8N&+QQ zIs6q*l{pMkWex#fFASF3Kj)X2@&5koHd$~!7bYG<%(Yo3H4_HUy2$m61^(Ry*E9>B z9bTNuhZuu%1+jQw406d2+EzBdK7RK7<4cWSJ<-pj5`@5}aiI!Uyf(bDP&h&GH)le# z=VC>I2?Bp)lr7eyz^96(qM%gy5U~QfB>kRq=i|((of)tf^`Cqth~$k<-`_aM!))9% zRTi)*ts>RlmvYnKWzvXy)}xo3+H6-YzZ8qr5q@IzT@lMsU)3`f+T{4zP&)mHM_QWJ z!#7se=?y(K$;1(7)&up?Lnmy_wWHX+4`ZXI2p@-cme^NkDl)b?%UC;HWwz+rfD;KPy%dL0ktE3IROanX2h_dllVe}C?!C6xO$ z+gS*H&X;<`YxzIC3s_N>$(B*gWOeKu&l`KiJsQ-Z<>*bdr;Q zqT)%8Pc1I3Cvcf@sVPQ`Mi^GU{?T#)H+I5wh$c&f&4cZdQ2~x6-Ktx+-I2Z@ch0yj z_>(H}gJ4~sbcT)Y-WrY_YmTkkETg-wWSz+B>uLr)O#`f4_G`bftd1F)Y`MU&W`Ol< z*o3~ml~cS4OqFC`Sd3T{o+|MTrbR(p&ngS((&oR#sVW0Y0ZR#-TZt`rOMZ6v;((V7 zKXZHqYbmSZHB|AcwBsvP;53;-|4qEUFE=VFu$B+U9aZhM(%WLr&UTisVkyrvhn-Rf z_%@XLNHb`ZZiT5nAuNZ#(z7k$r61_6XvxfC#;q;Rdfw{_YkT_SHF@q}ZBy-e+&Qf_ z$|bSu%BMFL6IxwL8#v!^)yQic4j)WjqB|;Q+P3?~c{8X;wW8`Yk=U`X4rK6Ai(@5to{eqBiAMv`FFJH3Mi{jO z{#k^by%3-PYbd~)G|vfPjsU=O;tV^2kti}{Zmm^%gglO`y@pqO(|p~01) zMW@nWbz`W&lI9|Nv%EhcbrwtK|3q`mqx&IU634t13}kA9^)krcb$#rKZcFg?EPD5u z*frI+%D#%paSAQrZ%{P8a?`$0x5Lh4+rZUJv0?7+s?YiFuYu<5s|D$$V7?Wf{H28Os^IOvR2!T^;k+*|YWA z^otAwmHcSay5%R(CCANPZx40Xuag>`6j-7q{H6Kn6I1>cT>u>4GrB-_K^Oe7 z=X^mc;DG~1QyEs%nsL9V(@;E&p#QkmqN0Djo`6QKC!oRg1hD3gk4=*~g%vA0!;Voo ztyM3)Kf6Z!kfD%V@X%VjW3}{}f>`qlTN+tKpK1hO=k8<~)4Y0s{?tva2Pj^=;k_Mf zv3}b(XLw77R2G;Y912|5(Ua#`%`D$o`M7+=$vCFUM_F#Syanlo{G$ey9i+IGUL9w& zYppRp=h=Bp5fgblaQt@Y_)3o={t43yy_$X}!u-@?juiTGDBRQEKlS1n1KR_S*iv)Z zS8Vl#Jkj+TI-{RotXRt_X6+(V97pcuUU|-ZUFXP%(Y~#Z&Lzju|wNtHEC=XAd*->bpsR8?1|Yi{nyPmrIqaoH!Xw!Bd*%x{b1g@YUwOC^$S zPh7wxr+xGqYje1qnz8-T6>-XPF9DgeEz&ZY%X73W)LS=JrJod*C@c3LCWx(nE@PhW zmD0D|^Pae+uEVu6u6mM~vGzE3r3Vr(!aX_cO`~h3py!uPps8NnSNLk`gzh_AzS1h< z7?Lo*Bv5O-(WJkjksQ}cekIv++4Mlu=v86Y?yYIV*5+{8@!dVc?uRPBJU!*#*N~kU zKk{(I@|C%48IR17vP}UA13P_UysDLw9=RU$xEw7b^KK-xQD%?)9(@hlhUeRicU)t# zYPw%)q(sU57&aAyTO-fo>7ALYYpasfbt+}avjUrmtW%dv3qx``dLO2w&U>LofIb|8 ze|01+T-f-nGWrwu{|_FjUk)db+d^|UJ;(|x(fGYa=XvRDp1&@;fp3@Cp$e}>GKgV; zCW37XtqU!a&Hwu009d|Y-2(qTIOdvHc3!ZGm$EWV*{z#XZa~>Nz;>|B91fJ7;UDct zXD*b?X}UkDp8_WyLOPGbCT7El8F1phdH0+m2AGMk-duBN6u-)!HHRo~Kay_*xWf_z zK8T9-4UbR^q=dry^A(_BRZ(S}$fBF2UbI`X$cM$g;KrmExIc+}T0HZO4Dtyw1yaO` z{3K9m+Be{Ra%oPlQ>>uky-rHNvOJb7uIIk#2Mn_|b;PpnZ6JCn%Ii)wlG{VKeyi6T zWWKfP^6K)#<3ZiNmzSxPW_uEo_HNo`YUkX^n!d3^&{B9@+i;gd+o`X?FLW6cW%CAf zgi7z95sA*w>KpQFHr9!WlNjgObYw4OYudzZDYU8F)t#IdOUmh3^F{)v0~Iq1<@Dr& z*O>c?F$IOK&B^NDI&o#sxao>#Usko%sf~s$Kl!p!dZg{?ID6#*nd}^Eb{&@Yj5{8R zH7X1AjWsFUbuTz=uEl(v`RetGlP{|uck`v#o2=1P-XJZwrD{TY>Y4mXTu@H6+m666 zQrS65qdpz|5tN*aE>(}m+Mnf0jrHX7JzIoHe49+lqF(CD5f3+dI`||viukH$C--!X zPrc_a%9Vb8r!>3mt*5WS3wMTt+jZ%q>D%e6BE@*?34}9aPp%7L>w64tu*X}4~s$K6WEoy@`ww9Dc2FAXdQg`@H4e?&*mP_1&k_ zp6_B~dpW^%Sy2p^vUuF60dtk!=c6qpo()AQd9E8=Y|Koq7&hlcxicr21%Hh_)KC{1 zy1v;Vf`={6?hc;H*9}wo9?^UWng6unnsF)oW=pter&*ZT3@$G+&-ta6V)4NDjru?L zaVgF3j+wCdWmp{9Ooc`BTv_ztYk6i{^*Ub^kTp8$&pnJdP`ne~87ZCeH~YJ~1`@}= zVUq3FYZ;!NY+rF{`xK#sEjT5t$d#=&JSSMLO#DvghZSyB8it3YE>^k8b?(1#gM7H` zaOrSx2J8^C&NVdaO9g2lBbAWS({sw?YpXUf`$~KeDynp#FTQg4^(NHS?vxedM^`Eg zi95(W2x7bGA*R9ft_;(9hizYAM=SGpjj@eaKSW<6xP2&p+@0FAhfnp2p)Gc_(MaNB z&g$l|nui?S$LJ2G$4!VXt$NLF_CY#z6{@r2Z8x8*^&n;In&%U5OZqQ#Wv4rH+{erD z=k6a9P=PAy9`oi2A609t)60K_(cPK-&B)!^P>30&@Qw9YtK!g*gqZKh@g!cMEk#rw z3z*7dI=>;qV1OTkM;*i|&(9R%$Ka6wQDSHm=2t%k6{SPZGRGjCz?DHo$pin84A6Fx zfLCU#PI6<$pukO-ADtjr97QZE2P)eo$(9}Cm)8=ot4-vn|Gw@o@A;0u471?6xdlz{ zsJ>2kYm)#E&@!}7yJp;0it1|WYheb^Kmr;yQJ8qXB=PLO=k?Y?D*GMas@VYU=ef<9 z%yNLLA}GA^Z`nXd!ICo@2$6*i z#E+Mtkxc^(nD1AkeDR&(auK#m(Of%M;)cKQWKT|S3CakjIB`BGWrnERK96h+w3PR1 zYJ5q!8g)+Be}(%PpQAJuFJ>Slm??6XiD&ml0_;`=8*{w#PDyeyVtr&?tI1en_;mk? zhY_%=6!owPTiff&)rog5OL{A>@iu+GW_7Z1k|>1`u+J;esj79qReHmZ%N82pFhP}+aRdw`zoE$TLtjmUe-`NyKwZRzSQ$q*tXunc2zEC#t#ILRd)qrE# zA9Lr+r7O+Gp6mDzqUdawS}6xPA8rbpvCx zkY<7^6mZj!J$+e**YA_b*tZcHm2) z1#1-fM*A;WqYMKn_H2FEdvo*>H(+$~4;P7(YTg`anZ(z(()E>pn|2Ld3fEk1@^4<> zGx=&PrtZekg5@thT^b2?a%Eg$Pc`QLeBLp&Wx|_#XH<*6zCqp-k0swdKCN4#mLut6 zNf|Zdyjgj9%k?eqH8!o)6Mlan)?%LnRH@0aWKtjDkf=B(tBx&pzISi`Ng zXA<(3Y2wZ-f9W^;apLl3U$^BPaf({5QNTaS=D8R#m%it4Xk^UKgs1D=JJQ{U8E>m_V~t69@wcQbVIz-?aaw1 z#@g9-8y*#PG&#Qrdgj{D{tUkIwPnEiGuvfP+o62XrJ72YTG!AijL!OwaXp7i@pwVdB^?S@d@t26gL zkDP49e;fBdWsK=M5Wu+hawPpSt{rUw4lUEI=^7@3)9>n3?zKd`s1*lJ$W6DEu3_l9 z^s*xExxLJ>W^qYY%3t07&?|r6(2bETEWW9`dTN>|P|S~i|rrF8GenS)hk7EhI#T#AG& z*WNoOCC$ohs-<%u8^wL5~r*-hHRlP zqEN*gVg!ch1^MlA8&^I}O#GN9O%~r0Ij5+E0Hu~JIxKjS!Z_W8 zQ;zvRc=ms*xBiQFyMd(vzG^}4cF$-R;M>RlcWIYDsQYK9{=d32L-X{bP!M(5_&FWF z&D@q>q`vg_pKH6uYs2*IxJz#P+MFZxsRp7Mr(J?TC)rE4 z`fqc`UwL<*{SaP7h)XYS)zhcwV*j}F4ITPht&SBmuzZ=`*b?p(bzo$>T8)!jkT8iME#`)V?meP=Y2`&LB7 zL;)AR{Q8xjjguqoD?dY6Swq1{-BeQnZ>*__UjfU`nC#1bG}&>Ew7)Be zvnGJQGf2i6fxiwJyjbIadj@Da=;5&MN_d$72Uu{(_D>yr52U87ymmf9V>SY&z$+K_ zn&3EI9+rcdXDa|+cx0~#{%{J*`q=>A;7sbs=?h4z`l7OEJUFtRznnwcxfU|Rj7WJ5 z{|oP;xiCW!?x+6JKD@xTeqt)UC)DyvU|R_NCc$F$y-Od7Nb@lc$nSL>CcJ}qQeD_b z&19mFJc%%j-(~g~bMIPvU5WMmVXZf{OFYY7?it@FaptqF%cisZ*pwu0_L1}KQ?kna z-NPPs8wB;XN=S%NggLM~=(@fcUbdBx4ch)ST&;td zYEKDtFghNSW4uyiQuMvp@%yFq2A3FhZuNv$HaR(7H>enV;iKPwlkrVSvO+~}`WvWv zkH)spS4`>Eqv}Gk_a2lVIh&qpiIC|Li_+#>e#=vu3f6i;7Z)1?Sxz;MNw~ z4-O6ZXQvf!(wO2V-};SWdOAzKzrL3AGoY=Rh0yHZ=u>($Q zg%exg#40TB@76B3ObRC^lx+T=NGxy@?bdf46SDxwWBhnt)#tU@Z!N;CbQg0z&^gGB zAOoW(le@C5)-}o>NyFzFUV1AzXxxz%_vO~NV{X@6SObkyMxyJZ&DoZJdduG-xb=tkkQGvOyILs#_H6HmvLI%e`YoqM=vXk)Ny(tGxz-t9F7pN18W zr`7XWnbj@3QC)5$_aOL=8UMIu_O(i}ODPpQBwqU~`NyugNhLP;jbkjFJs-3+L>+v3 zwPoX0C;dB436}8mDuWYop>d~Pjxny`V(7wIY_5N~luxjlVM|2;AKE631IzY3V}FcI zgeQB*=l$n~P>(-zx~Qiq3m + + + System.IO + + + + + A strongly-typed resource class, for looking up localized strings, etc. + + + + + Returns the cached ResourceManager instance used by this class. + + + + + Overrides the current thread's CurrentUICulture property for all + resource lookups using this strongly typed resource class. + + + + + Looks up a localized string similar to Found invalid data while decoding.. + + + + + The exception that is thrown when a data stream is in an invalid format. + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class with a specified error message. + + The error message that explains the reason for the exception. + + + + Initializes a new instance of the class with a reference to the inner exception that is the cause of this exception. + The error message that explains the reason for the exception. + The exception that is the cause of the current exception. If the parameter is not null, the current exception is raised in a catch block that handles the inner exception. + + + diff --git a/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+sl5+win8+wp8+wpa81/System.Runtime.dll b/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+sl5+win8+wp8+wpa81/System.Runtime.dll new file mode 100644 index 0000000000000000000000000000000000000000..967bb30a0d84f969455800059b74fae5c24271df GIT binary patch literal 22208 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 QU>aprW%>sEYaZx-0jWNPVE_OC literal 0 HcmV?d00001 diff --git a/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+sl5+win8+wp8+wpa81/System.Runtime.xml b/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+sl5+win8+wp8+wpa81/System.Runtime.xml new file mode 100644 index 00000000..93cb00d7 --- /dev/null +++ b/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+sl5+win8+wp8+wpa81/System.Runtime.xml @@ -0,0 +1,56 @@ + + + + System.Runtime + + + + Defines a provider for progress updates. + The type of progress update value. + + + Reports a progress update. + The value of the updated progress. + + + Identities the async state machine type for this method. + + + Identities the state machine type for this method. + + + Initializes the attribute. + The type that implements the state machine. + + + Gets the type that implements the state machine. + + + Initializes the attribute. + The type that implements the state machine. + + + + Allows you to obtain the method or property name of the caller to the method. + + + + + Allows you to obtain the line number in the source file at which the method is called. + + + + + Allows you to obtain the full path of the source file that contains the caller. + This is the file path at the time of compile. + + + + Identities the iterator state machine type for this method. + + + Initializes the attribute. + The type that implements the state machine. + + + diff --git a/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+sl5+win8+wp8+wpa81/System.Threading.Tasks.dll b/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+sl5+win8+wp8+wpa81/System.Threading.Tasks.dll new file mode 100644 index 0000000000000000000000000000000000000000..b8f78dafd6ddbae13acf85b07ecf545afb460b32 GIT binary patch literal 34528 zcmeIb1z4L)(=fcbV-Vbnhe9b%f)pxHyrpP?LInx|f)oi&LV+4qccE_3Lft5JclY+x z-Q8Wk*}W5>cAoRT-}hY4`(FQ_p6tCdJ3Bi&J3BkO_l6VEa{^)_gjn$X{vDx>@WdZK zlKy>C2F03|n>Eo|)nis08R5sQ;Ljroa~=ZIY*GxiJFE zPd?R<0{-g@1pP`Gib?T*O-}`gQSeCwzEL=n0^dd^knfDp4PSVcA*2ouo8AbS!Sf$~ z_z0;qBUS+zST=rKJ%o4^a}X$#Y;F0v56XwLl{}P}9f`Y}b*; zaaLu2GXQ?3h7N3w!~oZ&rZ@QwJx68;MEz-62SoT{IuMlR%cc1?(is7HGdkc7 zbZkRAFhJZsW$3_RX|g0OfXqlihiw@;L({=vH>1;JONgn6EIP0pa&J{Q2O6Epk+rHG{&<73wE^AAhqo@;i1N* zBz#<_=Si$KJ1fXjb}b>T!!YR&g<1hGP>W7;8f&1z-Pd=32DESkFgiRnE-fz;wS_vM zA{}Y~wiQgrWZPMSOgtLH;z)okRG^ETnfi_#N&<{HTr360A%kKzwZ~#(%i}17!n$(= z{-9bNX0)?D#bSf`=wRkdj=mjuBu86j^k67v*?}H-&P-;sgT8~C;aC_IMj4n83+!|- zD1(KKmIDS2qOw4N1IQEe2N@8kS%;zqg4$V9Fs%Yzgd1^m;&Gg~92pn}2e<+q);El* zk{(pWl0xSS>~w*er=TQsY&0I8FdjOjbtmp%7z~y(M`j1L`?CmSXMsC%(iTJ|<6%ss z)=)JhRpzT25vuvBElz^$G|7Bbi9Ik-17TszSzKv*Xx)gYOkKrzET+?A>97o$q<`~u zSVkO3TCgFJKnHlX4qc!sD2F8t#Bzh?I1X<5q>E)>2%s(|B>|Q5D2WrKcFvH{cIF2C z0Y&Oi5^!!j9@ANaLmF0?8D+-@UQQIpfx{V>ZPWwLb-D=JWeO-12lerXk_e%`lL{pP zjy!EdodhB1-nn>ECqbtQz>Yczx>W$CRFj@uG^vx|T_%aZe1%1*JFc5ec1mmhh*?9sDSPPFMX@gq_HRwCMlfq(LU z(k+c3wn(WSLs^P#Lz>+P!h~fxOl9_k0Wlqe6K6H)GANb7T;ug;elx^4i5QRFLgo); z)Bu=REGISTK1|*YlY`A;9Qa8JrGdP_TxT#aU}68n0i(5thZ^@A2l_1QMk^vN4IzI?z4ok(MX$gT@iuGj*b4>>AgD~JLFw!Y`Fw7ek zI2S!oH5eU71}*Vg@yalorg7HfPy;YWNe3u$G$NAIMalwGsCdm%!BUNWV*kjwqNqs} zg&5Ez1)eG_7J+FZW@a z!KTg7T}=it2u}{ZGj-sc^lFCpYsBk2STODU0d#P&3xG#iAkJIRi>*Tl(-~A4gi+Lh zVEhhs!nSZr2%T=5vj@ zt8rmQx;^GN^kEvfv6+^tZd@iQbQl~8Bus-IGeMv(kS)V77AOoqK|^4+3_EYoW&a-l zJm0dQT^J`Frjs9YFqjfOVZcH;vT)1_qX?doL;!rvm)Bw}W~atAq(Cape6B1K@Y)Eb zC9G<6b+A~DEDBf0D1xW#q5-ybz~hHkQCoXtg8A?$+<)35o$W4lOCHd5$gECr!k%gGubz3W^hQ_js$C$Df|^V_2uDaCX$TfU4(?+jl-WAKoMR$baIl}!p$1|Sie(1_;|R;A z!i!|$reSr~w*#ByTtf;yBV=w4>kNqV4|sqn{5=o6ZngqB@Z6#XB!L_->5VBe&06sW zVFbmIz~+EA2qI}7c12`t!B^3B>{3V_LIQ=DA56_3`B_pF(@unW5Poz!O-vm)OfsFp zUm8Vi2-Tn8`#hsJYI1G|9n zA)n?3MB5L-gCXRVVHCmJW#bwy zc75O>0}JIiOoC;^3W}Ld(0&e}sevs4{AK`Q2u0}+0x!hE(*h%#jFN_kQIawJ(Ux#2 z*dxsJ|Gqu`mdC%eM_+0H?u-+M!h^^GUD7symHE>c(u4*~x&}Q-H0f$rnDnG^P^>M6 zNYe&~&oDuOA09vG8rT$WN|FmYy9VR<%RJN2pyyd1Y5-QEvl=CXDb6DrrBT={@&V<5 z0%E%aFmSj69|$2(KMxmyi@U&G2=<0|4bTX(0ViWU81|&_^oA9|I#w>t&d-!#ii0r1 z1r*@A#UgKT4A`Ywcj^`jYYOTNupFef4#<^&Qpg8L842^|tBu6Y>r*Rt>_~9y{_w?% zD6m6dDo74r7JNZUycZ!cHKv39<9!doVLZ;`dbkXDQtMY)$LCGq( zv{E%&m4jxh;<_71dXl71Nvg-gcqftuk~D>+r6iqB(gu=Vt~@h z&OcGZc?}($Zv`p-;PJvK1C@czv_j5cYqT9|BM*R7U=)o|8MvNsQl<*49flGKqz19M z3P4$?6e4sjWDAZ-8_ffbY~W@OPi?dk%Gj`uJCU+|fa8Fr2nlo(ARd^WJK_16P#PmI zR1J7lMk%DGs6FJgkvTxB0CfNeArAtX!>J60A_!!K5>O4)NGJ7dk(fY53Mi96BNb2< zk$M5CXG`o{8?9j+WoSSTvOzX2$`CBwgfc~KPy@9FG_sXi59vOV9w+G;NUhLyYBR`h z%v=wV8dqx!3C)Ylb_DXSp)0(K=QhL7cxJKaq14(pt_9_nKwcqFlHVKD1?ednkZZWMF1CFG*AI`11<)rwh>AJOFG&}84GLRn?@)LPEyQT z((QGlLQqT8xe;m)qf$(uDwIkU5xc^ad)e7kDRMx2N!dg+kg5de1A)rX7-|xnF!+Gy z#eJxuW+4~Uy%AanqbyO>`>5W)^hC=PP=Adg7{Bp^a$<|!oQDiAG@C%>ptEgYovR77 z7va{u(MAFdLocb_06kDZ9|@#wgIgblG?)jVY?%VmVV(i2-cBI8h4$zOfu^FC%=1uo zLjk!kZy+DU$Ici{MZwI6s3XE_Ifjy$&ygQGP9T~~AUaAz=#%C{Mj(2lfYviVqCjM5 zi|f&pK`4$umFOCi$p}LI2{a77VyZEMQLUm(m8HW7L3*&rBUA}}H)nK4HZ%l1I)g&d zS^`Z(omdWxP_&molhHVq7o!Whp(vZn3SfjGdsu@I+QVGR3IoW8K*NCN8SpDY0@0F% zqhJEvMoU>qjBu3Dj4}ch)0F5vYXBnxEo!730?_ehl#ysRO-aTt61^bMWYms5mJx~M z*fF8WD40Ek5sl8#lxUfj1EVXtt$^ME1ltPo+0Ra4pFy#xnADpJHn^M-i^dUX7|~!X znyrAa2IJ6D0^MXxgnHdjgQDybyPnYv?N&f<07^ioXh=nyvz5^UT~m}9bIzb1=!F8Z z=Iny9Zv?7D0?q+OPo$0mX;iM#l~am(A##MJ7~5WmPs(V0_CkpS!csqF^g>bs(Ngz9 zWeNyOoruN}h?Y7DO;?m*sguwZ1%#zeMtn!ydZo%C&O3$(#Sv&2^x-=|1vG?=IVzM0 zZKWvz(xg(+7eyKFQ5p)t!2zOsl#V(Ri0+XXMbi+v#tCDHk(@wuk1|j#fhHqY?n6cf zI!7SfKNl(k-J8RY176IcT*4 z!lROhb}As;hdiY1g6ox|V(uA;k%DN5j7mP5O-qdiYAh76VH{76b|(m=pYxT#~`K9Ut9{-lUqMvnwR1zta+)v3dZ~e^sIk` zH&?;@@kzO|Me{%8Y0kKmg*=+kG{^e_o{d8PP};l}=EGF*i6itflH$HoVE5YEOf;++ zpIP9}A6N}*avnP>&UG!V=>lHU!jP>Q;=&gs_a9-SdHmq>cM zS^5I<6rwR7n&I&gCW9Pg{+MzBPaz#rYDrRB5;|?p*_u$&nC5xRfq@)J`cLR-N!$s2 z^SU(N{~z&}O*2Ivq{hN9Qq2?shAL!JUl(?9}<69f<=3LruVLL~_M{&JFzgfyI* zNYWW3ts&_WlGc-S6G?ZG^bko;k@O--Z<6#ONnb+Rm0~dXR05?6=^5x2PIVX?)xS|T zXuo!T;Fgrl1LbX-Yvewwl41&4`nEs3$jbo5XHJ&oVfku^O zg_dhruzD~KYS=>lzJ?1coKRY!cN)R0Y=*jKJj))LX=btd5^h!~L~{^e;x>nyy(2 zQH(@$2ITQNZiV`5&Sm*C#%b0{kW=v}n7u_glN z!>k&@e+i`F6z*3zl}IQPNng?-e+H$a30kjMa*`iH(t%`^9*FSjJdnhoauR*YNhGRH zO4SLaKFJRuk?0Vz^6C@(E@Y$hufXB8n>FRjUy8 zrd0^95>;e9s6yC>R*@C0io~+B6)BErXA{cVB%)1MRh*`%;j~O0ml98e^pFFyEi;ih zhPjlf&GKSJvI#evCk32SkUrLf}GWK*-cQ#AE2Zk zAbb|lM2XKNnxI11dpAM&9HR*u{X^M;AD}$|feTg0dHRR4Yd=7Eci+VG(+`jioB}kJ z;WGg?i~|QoK?O98b%*uU2CEJ5^ix&wR6~BSm&EVU0!g`s0@hH#S_(RC^nvIZ_O*mg zR{`rQo(76~28wz{3fKtsgn5QfX?v4;#tOW#f(~}m1aGF`W3GU$6wg+Qr@i9osCY)8 zJ51c4uE?B)1?#GS2PmH9=rJ4P%N1~?0DC!0Pu@|#}fF4Lp~bG*wN?)+Z6f1EgS*trTyTX#t&JdAjF5K6`Yi`gr_xp zZ2;E_p0+ND2o-(Sh2KUcA8kGtQJ>NAV&VOlKiv? zu{=wX9#EK_n=Y0HN~B_CqcMf~^6WgZOQ0mLAUjtqZDbK4=_ihaCV(JcEN#vOOBX0g z%Mzyuo1+6Hl3cMUzp=D=S!ll8-R-B6#+E{Vm5{EBEBqk%AJ9rU;w9PXKho2zW91^b zI07Wj&KIN5NQpcnAr>M=EGx{FL+dheUTSU$v>{3t z$wmHhI2}$cls73;oRKR|BTVyTX%cB}b}EWW?E@$jFUl4(vmNmoJO4DWAQ>Q`-cOiDHp%JPvI2=rjFQtt z1@b~Lr)0Qc2M}p7P*PBWlEpvSD#%8Y(v1-!EP*5+#t*Cv1u1yKFoZ}7^V3m`xFA=Q zCQitfXEhT>npv19&X?1w3YF0;hze~`C@lv?6^NxGIZR4=l43c6i-A!-5R}Ac%d%5*>0!-F1{F7%8O=Tp9?fuK z`42EHI%e5qjS5^G-514#MS00-^n^#U>AAa_g)2&S=ea& zv64b*8lK3?K_Rn3oUVlNG)Ey)NuI)J^OEJ#LNUmbA`tAlb}6d)-M&4;-y%2jXx^`+r1r7IK;9nDKlrM;q3VSn<7F2C_p zF28NWzetoVj{+a9RAwB(U@wYGy5-A68R8$x!N;IXu{;?M4xZc!Z9}fHXBbT!6nHAE z4CrYBFl(|L!hrTRq3KW>Bu*{N%!EdNhm$3zi!(&v)aaH-yV%I2Vq&4hO28^$xUod^ zqp2y{YQRGg7lj4?r3{Q3GbQ6eoaZkTFkyZ_ym`qI;xm8j1!%e-O#5#6l2jQib1;p8 zeWP|{FtP=IPeD(VbVPgk-IBOYrQBkHC!OdfE81j-xa5tzQ z_W3`X6$D$h$_bmYZcSMkA}-Hg zDixJ9u^0W|JM*!OsoDAIjc)xHmko;|?FMDokHIE4U9lVye=8#1J4%Wd6@s9pMpz?6 zbW%&X@G7U7(vwN)MOEB5{lOuFDJdK<0z4Ao=>irk&KH53O-E_U8Aa^%59WjUXXh7^ zNrH03B|i^9yjUuO`2&6utQ@x(f^}LXk>)fhO1aYGMM{c8u-_Hs6^QbiDOXu11i~mq z8^6}Vi<2~u$R^7DBh?=Z;xQRZNoqYjLy`qR_P8 zbTCdTN*CveeybL69I)s&F;jSMa3*9uk)cR&p+zGn@V(`Bv%o2%UlSP z>@*bGL=y0a)h9a>Tdf&(E1rm=Ek zKm*PWN7$equtJzo5-Ev9p=vV}=0t~fI3^NH;TID*INHJ*Ct*w$OcXJa6eI`tEd-6q zOHecn7yreBPN8QvgSOS=y4N4;*4w@R6&TT7*Y>JGY$|zNC<5uhstmi0mBdh`z5iI z-cdBk+<^`pXafk0wdvs7HaVH>DAWD(CHWJp&Hv&@x4TpX`y4q`RP&8 zXqb788-;(=54WFL2@wh6l*{ZtV&aZ)!#E0t11JlXjjE4`jGB|sc0GtcdsR$+f>vn=sF>p--Ipt7C0i;Y^rF ziG^cwbXs60ZE+r6ZeUS?6UfX5nK1>);9|^155W%v6@5^#Q&QjzVZhN9VhK8s7KJ2j z#fIV4)FkKS43LMx(8PG1K{%^YRt<;8h*gGA6<8jJf&}20Sbre`M)=ks_td9^y(=%i zSl}{bsn*J`8V?_Q?ek>(@XySCxs~BFCRwa$e}Cr1zpm`MI`ecJJu7O0nzX~mvMHr| zZx(5f-_I?IvVY*FIq4Dm$(;vQJL{f5c$uCUu0DC!vKe+ssZLA9PUfG^`N)$b&Uar9 z?!8KD?^GXKvr)Q%;uie8os&HxdY+yPZ+^${7B6LSuj+2pn$TmfB=xI$bzCl zH(X^2(CfBhaUoG7)Klo1KuqVb&4XpYMQ>b##%U1B8DP*B3=2vP@XEX@m@cN)qcjM; z60d@5m}AN4hYBtwFw7TS9b)%7AfYj3hUY28Fl%9~O;NzPj$wfth6fCtF%gceWnYoz;myKtvt^r`oN%ySS zeC!c);rCmO{UM^Ou(=E=4Q^x)Tdz!0}cCLfPS(HRQ{{8CD{m98_73;m99_JGc)wmo_fmE&_yFz^{ME@p8B*Rh+9L^bmLmyj+Cv z9u$5WK?(w-u%XG)f}Nrm0{g^(!0<#NCNKa3#qkyHGAjZ{xb%xGc=5>q zM~1izM8U=#E(Vjg$0S3)7`4FqjiU?`q@sezW}8P6cFRa*)cE^+>=exa=hqv)e%Lz( z#g0nxyk2#)Pvi=}z>~U{0^MjfcA+$&d!47|4af?TAQ#Lm>^J|LOwT#(Mq@udN(nl`4(Tj)V)oYe(N~ zP=MqS1Stc!;#fa~#INu!1Y*_c7&y3qg2=b!7$1*rMRpR~Yl#s}|P@Gb-IDW!13MzOB|{wbtyQ3_f-+PH7Z@x~C|SHiXk z%4DEw)_kfA39OpcW9j$p zV*hdWB>}f*i$(QkbEbbkyk$mRb%jBNpn?T0F_%>{DF#L9xq~?FcUuozpxMQtjEsW2 zK%-GG2HaE=6cLG--B=tws#~m3PoTpAKt+$2AdMDv)}ee5kv|q7%iJ?n88NO3I<$bu7KaES1=gp@U_FnT9#AeE0Qk+ zxSdtWTR&&#?xzF2mvwhvky9SMafB5wY1K662|W+&aaj|7Hcj6B>-Bvj<4&p_{W^Py zPRa5GRxR_~Z>+r5$}f0Qq(+*G<7ls|QQSUP98PHW9G{Rh$LEt#8nwT`cT3Bsz3Sh) zZNAfYYsvQyM;<10ln=P~YS6%h?yk#EYc9Sx;-a5ryO#d9RBfs1qjy^!ACp;mJ>Glg+6W8E>}x(dr?ko$lRLMLSR^?Z|(8n zVoXQ@@2TJCexDm0SMTv`&=SPq`j)H+L6{)4x>I%Vu)r+2yr7+{Ynn9IB~Q86a7mNo zxfbMPW2`F#!}uMc%(ZbCv0W0g1gmrb5@pdwa6uPAXC*A4hILRhP*ha( zy9VHW`JXw<1$tQCRxEV^Psx(0(%f8NLV~%#p5puMG0aEL2YYYYG;m(~n9ABu*4}5C z8~gNF_vnUX1oMrgYo96Y3Wq*0yTaWUImdMIahp#1Hc_5M^|QCO9xy&B>I-M|v}qsh zXTA3`k0~G5uQPM-t64@HR$lDYa$;J0w`9-H`zLld`do8HnJ;Iew_bns@a^uGcRXF; zzki^q%|N{?yf0y+_-u34krUf;BdsE@)+=uDKDOW~Uoe*!IIzg*?_K>HE z>jwH)i=4LwW{OQ5D$Xt%)#JU}?FIMuja}1n%OtxCtH;ES&+62v<^p5&OOe4|qZ;Si z?Q)|et9+havtJ!_WY46`&FHw+IGyLGs0v|d)$}=CI~T7oKj*g|+}IOvV`rPWvDG@O zc%x6YpLZ1&bA(p^q%}dwzr|Tt3#{l#Z_;QjuyIWn^JB9!@mu$1j!fw0;pXP70({`TW%NIvE60AK@H>F z?uTT;S9fCV=p`K&d);)7e(Gr$`8=ZkWxakQRy)1uk+|gX&GYt!cT9)2p7r{J z^IZQnj%t3Nx3}NCDY0;}VNBRz_kCWgUq2qa_^rP|qKequ%Ik&G=9X&O_1bfaS`HmD zFlv+Ogw<~sd>j2neP(3!+e197TT5><+I0HrTG6MR`F4rtm8yg}pTo{-R$TTTulw!x zx&HDI={HmNwsLV;Ij4oCrp5Z*t8CV4MsK}lHaRhLVadAnmydre7+}X3veCi*#EvCw z_RSkweIvfENVKlBe|%tHmxB*l4>>b-STgv%WC5&oLT5LDP(WN@Po;kX7Z@o3C#ZzM1^WIo z7x)L>@}Fid@pr=W`3|}X?&W{Y+5h-syR$(NDs!LpzTT(ThLRK1?5+K>=1!=Yt+uCh z{+O2$o2Rt>ta0P!tT#zETBc)17_=LBdByRDL%EyVIt351(TTGaXlQ)z^oYs5dnY5w zX}}!wCEB0NR?A;SW#`OYVl(8@)2Y?hWwp=ym@E%Vo%?d&PW{r($0F7QeSFbja$dlN z2LtaJRnN-GQnmX?O?$4x+?*M+V%Nh4*}~Il$GY6|z4JQq>-U-)TPVHuN&IWwIxbi_ z!B6O2XxE#yBqZxs3tt8*Kg$M3sq@^7FYvz#QV{HWQpL?84Gp`TG z?4lXAqn+mS^;6m{^1jn*lFGsn84$Lyw}QW`rTraG?g={d>K zBQGE2e4A#dedBsNd8Nq)*J`&X->>Zsh_wDoiY|L5@J1e9$q#+=B5Qd>*x0&lC1HJM zb>d$7+Uok8!VxEy%7RMImtTIp?NyuFLy5sxR;}>4VV5<{WKo?|7XQ+y>dsfsDrxn( ze#sU^!IeY34NuB?vB6}<)~(5Qy=1KRZIaynRzKIctNMZ-A5M=={d(k3a)>Z`Q)|6D zeu5KHdu_Xx2fQMEs@;4h9INr>3{8xTuds7qyKM+NAC-3hv~%jqV4wTTRnWVTnz^TX zjj@e=(0^%{S0N|7I(W}rTa;L5GJqpZl^#dzXS~r-5Y?FBYftTHwVx3&1HWVen$!|ICZgr`34E;Q0bv zfAwGRdzT(!y7_mO|;;hXA4*+=ST^PNAbMemJ2=6t)$>8%C# z7i-LC*2Ul0I4UgR)s%qQFJC`@c6*qmM~98^Ghf774|S-mFq?dP7ktwC_Aydg^uV z;ayJ(79>nc7*sX3+O#vX=lc^2GI{d4Hcy>hjSk+Edg;EA)OX0N_!zThth=GuLUYtr z?Q7|8B*#O}o-uk@vX`~?%x9V2HI^vgl!Q&+q)9PrMt(q_|$6MYtU61vX3a=Wk3c{Dh+)2ZVl4sC4l zNmDv@*8-nalwY6k*|VnJ(q62+)+<`&+#Vl61&0g%`?=D88)o72S~%PPPxx}Skbtn&2Jk<(-TznKdtOa${q@V8CpiqvaWTHR?bhvmGrC$wuQ-0SMWl_^ zvr~&sg|Cnc_&Sfdf5lBP2(2;=n6z?wqQLeN%6Twg+mn%8t@oO&=`ThewLIc(Gkngg zH<@NmUk2PCVgBfTR~7E+J(5Z zUOp_UTa5Z0rqky>6DA1qhrjM2nDc4yxoHg#tfmeAa9Z!R%7)myn6<$Z=5U7j+?j2qS#+p zbadAB_LY-sMASNSjruR|XRTozZy6T%{UdwNZoZn*doKg;z3A_}_is1CKX`BLMkfs3 z8~iyEluyUL)tXg4K~O%nO#gT8w;8tT=OX@JK={`@#-V1g--a1Gv zV8Gc}sns*V;Vs4D#9j;|p1$VkOZwB_cG#5By}{Y_{>P!ij&_ZIFsGm@cX`|Jv+qiF zEN#(0)&BYXS@s^BB9qiZJ{EbF6))5dIBhu**l_pblR@il*DjWOZj9X5*IL)MpIV2Q zF@1Z61nO^XXjmPQd2n99_p%bJvbhF=j0XX_y-g0zZE1Bf@S)?wEpIv>bvk>&tt{Nu zp|eeL&qwjk7han&=Wsj8w({0;j?S}wRy$@@>}nmizP^vo$eMnlwfQxA3wJE-^g>ti zb(CA~ns3*;9vowRC}Z0k^WnPbl#lbO9^*IOvAVl%_2IO&#c}Mj{w~qWt5(+)FKeit zT4-`{(r~@PmacA#Rr0HQjcK)``uUK-#>EcC{EhFCIEZP3B&gZJ_uEt+;* zX#ZVvU$4Xq5vDa4KDo~A=+ezF=aAllufhtu^MVSyGjP@`fa&(1JC~qOe}6tUX*zta zF5ip8HN_#dDpRQ5?C6;V=etcu(`rIZLGw}r91JQevV;%}j@j`bY2DYGnXbsUX11@+ z75%WFbU}JE7V5%yL0om4GLQexd!ZVWvKD^|*P5@eaN5eMV4(Dg^Iw*AR5|nb^TS=2 zjXgfcPdnJv_d#)LlF^XYX2TDz$f@iezNVs!JnpN5*{QS~_N{H+Z8dR8mj})Z zF>%)DG~6Q9dd#tzj|_J0wHTRf@an0MeeuiXhns{ci>BtSb6S)##+y2tLOJDZK088p zd;fZ|N>RbwhKqYQSuu;ROw*h30Y%I_G-d;DfS0Gt+vcOH{|ejmTBp=*0h6>WzFdn} zyOlIL|M**0Qfb)K*L7~1D<+%tj-Fuc_O_4Vz=)UQJTCOP-N4?I6);jGMm5IIoAXrs zzN7ZuK^unlt+Se|Ihp_B!kZW8=kOyRUrwK_Ww=XaT&EqC3j=!%md)>1czs$;g>9Um zg0g8EBaX0wG60kgvC47(u_)m8ZzP)8WRjpolhjP1S|h+^fJHXi99yVGUKhYM522U4 zm#25nUo28IeZ#A6M&5TmKcCdiaPg+0fdfiQn%fE-wPIV*w9e1{tJgY{usNSkM<1Hu zy>Vc9uT`aHI}yqR{)7Q@dK;%WPHqV5;w!piLQ` z{q%M^3MQGgc91jr##VQ4k!lqt*!gT(?So497R#Lu&UvCS|H6{vD#fFG(>PUay!W-7 zl2dD((PQ7~v?FuRFB`c+#;$3a zvKYb&n-+l6Z`3t@du7806a#EWsD)LSGORO0%w$n8-2{nEmEjE*J}Ua-8!U2|(X1|u zzf!onZdHo@V*{_(dHV|Ts)pY54_-L?qNm2DyD|H(9_m(Ip)m0P3I^-9|iN_{7k5LvDMbiL+Irp^bnHs zU^qWfg8xg-gYOP>byi>Ur2k@%8{r*GLp3$l8>}$ayB0Ibc7{RUC8@2sUUij%iqu@S z1z$NDM*5t4H&z^-GL^^gIe+TS8wr9ANvX5;C5==+>2dwyg-@Q(b*xA4{P?)bo3@u+ z`)WVdX>jsdQ1D=wk?(VdkdxyMZ0d|^yj~tSc>lCTP8Ww)`@_u(<_+AF6)>*D({huT z+rDm9K7(7loOLHGQRmLNJwq*WnF86?LyH-M=BzmNR`#No$pBZ&(Qext#;t3A@%{JL z$qjk~^(H55tnTeOy|Tu`&l<*u&E!-8nT)D0X&tOY?+Z zDhR#AZ3RD^r*zIwzZ=ayQ?b;@%d6$Oyv2tLsVRScIriIkSCRr5c|Qi$-FR|~%{dt- z&H^uIfj2o*5h)b_XDZzUvCuQc%Q84qQ64`3xdG+-vA=0T4xxtf=!$~NLe1V+!|Y~O zK#Z*;O;LNb+;%;SopHsx`}woEm#mkjIQ!de%;{Jq{qCFERouf!*j26LSyfH%HkJ1G zi>Jrs)f(<{3EFwEYqjs`=-{FEc5f}o@72rWrr}v(+kMtOHgNBU*N==UOFfWK9XfdK zo)$Y>hCEoEcaOi{-cn`eki5fXnw8tO8D1;huJZa=S;@pRAFezI41bqF>GpY3HZF{F zDsO~(uT$k_Pv5N3**C#8Zr0cou8mcBp2v|%bH*+8(+gP6?|9>#ws>c+!)1#vje9<< z=d{|lI$^_xN>Z1Na;c88)6o66@7TmnOy1r$htkepeLu8+_piN%KgrlN{ma;A-TTj< zd&+#k$k1^XpMCeN8TD*$X6L%X`me`x7dBMi&`%g48QA${=P^-}ESBZkq^obPUpeAo z(pcAyYF(+sKFgOIho24apS;O*U8LvAocbLXdfKh%eApm%*cr2_W9cuMs3Z$9J+e($@Vj~?DVpY=eP7< zXSH9&dO-P_*<(5+epb5`du!Lj&05LPf(mYbI5JOF9=B*tI8BxU=1;~VC?D}}SqtDu zoL&p;o7RFqpQ$&k3PL!V@pcnb;L(apV(MvaSyiHi4n@jhoTU_p|c-m^*()lR_q#{)1FlqmpHEMue$2|)ElJOU@_GLGwqs9i%ZPZp`TeCgblYtR?S0|t)4++97YD2v zFwFF#Z~d602P30~n7pcS?Qv&9d*_wz-S=(q{pNP2f$3AfX4NF`!KdexIlYaHpJ?UT zYERqz^wQYPv$a+jTMs$%W;1ix*!RgVPR8sQQ#E|+PAhq<^oi78`>G2H)AWN80~}^uEpY9U(LJJ>PAXaJh2q zlZa5kqGjW*Kj}4Z)t9TQGj8pgRzBeAxu;?GL+uyo*)3c&D6{O|sMO-*HLgR>C(KUV zQDkTL@@d{4yYWur{k)=f-5eS;a<6LmzO!|KuJS4G^FI{xyF2M6rA(RW8|6Oa(&`aL z*XBmPnYwywNOkV?(>KnI7}Iz@^%T~_hk{>^n3}F~{B|+=n->E=oL&9$+5+DrQr-cP zI=7>Q69PBsvm6G^zYm7{Z0HUJr});%B7y0h!di>lh*dYFDF$fvl!^=rLB3n$1c z$G$mYONBV>9;Lmdb_rX3*3+y{SuRtm9XdMXbPr9lRL#!sIeqG#$~Qa5zYcM{_ND#F zZJy8bTdlmis`b;8S6^$cnqfC>dW5Er+AEcj=PdWQwYc?SpY!ovbJvEpt0;hZ_3(!-T#25-Lq?A*C*57)g(^6fX>x~Z0qrQTAgZG zXYCnfmM4+@zWP~p9fON3JolfTKYw2T{w+Uso?^M|b0_Pvw{t)2$k`A!?bhSMVv{G2 zyk?ZN2>X7n!8)t(-l|VuMn6_7dz9UN)fd52R`|H<*9-H~Ci zFnBAdFnCGM5~lp87cTlp;Wt~tW;@O5^4oB&k*7SdGG+e6deizIga*aloEeU3d58##Wi~M9$G4A163EUi^=pgk8Sj9(bZpNhIsVqcQQN zTKPlEE=NVKPkN_Orn_ylZW4+pOY1|_UVZmYbE2-emAAVWKD0iv&U`_S zpqX>O*jJnm_X}HWbAE>?x%BL&XZ0_$#`j+^yzj~d1J3#PdHk{G((srrZTKF0)M_g9 zx(F)tLK?SfOeUOg=(PcyTjLnw6AnFVKv_}@=C3Cl6$~Gan$mQ%;gF+(;RGi~cCZfG zfE6iN59z^UGT`>ikH;e{et^@(TQh>#`CsA}zsXO$=F!zX$Mwqj3vbE`F0JU*?`$2# ziS?W{*KyeesOCWR;y0`K4#BWkPAz%m41A~Hr|CX(Vt-yxfT9`L& zEq=T>jkgm5Fuq^I_2&1CmzZm8Ez%j)j{oF~-n6%$O0%nSU=s22ojy-XP~BrZ_>e8fg?m4<+; zlb4^92@-5876faYeDt0?)NxSwgOgbgf z%eUKa@^M(%mg}M~A-h_e+hpoWO{_+(3QHduom!vtwaC)vMMB~7ZKDDr{JNgfn$7Xe zEPb1?lQ}hL@bi;lU-R$IJY2u{ReuMb@WrJ_&cyX2R6HLPo2`C0<5-9Lu0fj@y}6RU zt(LKiuR6K-*q5z44+SOlHk{31N41Pl9^c#pP2Kw2aP=?vaos54gx7%s28NjKbIy%H`gkI;5&up>x|MtdSV>pS=WdzQGHqLJDBvk!> zaAWTeydg}jCSfYROjJHaP(DdeKK_SDwOruS7-%vKg@24xqr*b!Ff}kb)>ZLG+x|hE z8V$b$YKl|oze|CCSM@LARPMbIT{Uj)zcIaId0(c_oCP&jl7`0%kG>UdKf%7WUjy8UtM)10^j700d>LAswe#f~}pCPjBtzoUMB{X%eiyl z_`AdXkt9qIWYe<4iKooEspEUtZ(aYDb+cfeTbI^fyRCBlw*Kxo_bsW(GcPCjJ$!k5 zM#h9O-}|JNUftJ4ZKCb1woi<^^i7*Hz$$Og>;>~Xd@3C@waw?qT3fw8xIFTb-NyPQm#3~-6fpnL31k0=8^b<2%v_+8 zAvm)|?iO}EZNS?Zqg+i7Sgq=@ZsnDr4%4Fhp07E*uiNeHYYDqfT@&p5dh}kzXN?_6 zQ4i->7<;>JJ<*-*@?4`j+Vj$L)z)TzH4OH&P}zK`&E+%6~8kv zz;cN=)g!rAd- z{J&0nVq{Vuf9u05=Qk~Mj!!tcD7o(O#*LZnZSS2rWPGfYclp3_>vi)dNJcsz=%rTn zTG;JD+T{~#ov&}pySnk}{ZFyCM{nq9J>ly$&2{tJZ}BX-*6B^J$9=6>S@Cn1dNaz- ze^~x9!Oq1Zb4)CETmHi-(<|S)jrlmeKsDvdn1UIdoE{oT3x_W$;n#%3cjAE&l2 z%Kfsy!FTb|<*%!rj@21*WT|40(>pA#SgiZhhCs zYxpeju=;K)oz=J>ddxVkIcDL|=`J>RRXVV%{Ms%o(CBFSSap-A%^}IRt>4|XXZsI% zwKeVCoQ1p!L?rUz3Ow^mkyrqJ48Qw)r7w5 ziqs|#@sHt;TP|+c)?I(VihfJFeaUaX>d`(Gy8u=Hv0w6PDwzG?aJDzuh2O6EU%Ww> z---vD@uo`vOamm}eIa*C+*_xd?5#ZA(tyG5c%w&Em+uyo@2D-`Dk$IdZwbAB`oYGp zzYL6wizUAd3=p_^IR~~0@pcvld3y^T1@?5v-txzgolpOrMt+0{{v^7TABg`xUh@?P zZXm$lB|7&cUq#Teg_d&rClJ7&c<}Doi11b*1ad*UroAS-sCN=L2zUwxa6XUsity9Z zmVYTS2FK~rr#nXA(l*WNQbKr{-FTsg>|CpP0u@}JX?Q!OMw#c<@PCq*{8(dky2ji( zpGt3D>4ws5N7IeFR(RX*YW+#4ckaSb#j5&SYXi$R{#6&!Mdfrucu}_%5O$uG@))u7&GgSo*?GC*(;9MI##8Cbk#1{`#fb{dk{kt8FsAgs?K^ z1ZWs89l!DpcYS^L3iSaS^hPYdII^nRb8UV0pzaMe50V~!+O)8Df#&9-fVIWpS8p9G zNv|0@V%ON22M^eK@A>+mv(Jp4I|IM2@bCFHt9G7zno);=r~TIV9(mHWIH-mGloOJN z?X20IE8#8;oPSaD`PbzC>^_h_{rXK<)BNo%LHVs_3@CMB`DsD<2|@W$L3uq(|95j2 zE}#m^%W4PzPgEA%Ufb;|lN}ZpmaTeL-Kyp8;U!DT*9AAXd{}evT_MKPY0IizR&VN^ z$a`kiY4dAq&&j)kZtV@ZhchR=Jaxrvr^)NrXA?CpE-Ldp{#eJ$OJ)hw%r1c9^W3_n`7%Dp~h{Q Hh0y;2j36FU literal 0 HcmV?d00001 diff --git a/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+sl5+win8+wp8+wpa81/System.Threading.Tasks.xml b/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+sl5+win8+wp8+wpa81/System.Threading.Tasks.xml new file mode 100644 index 00000000..b47921e5 --- /dev/null +++ b/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+sl5+win8+wp8+wpa81/System.Threading.Tasks.xml @@ -0,0 +1,475 @@ + + + + System.Threading.Tasks + + + + Holds state related to the builder's IAsyncStateMachine. + This is a mutable struct. Be very delicate with it. + + + A reference to the heap-allocated state machine object associated with this builder. + + + Initiates the builder's execution with the associated state machine. + Specifies the type of the state machine. + The state machine instance, passed by reference. + The argument is null (Nothing in Visual Basic). + + + Associates the builder with the state machine it represents. + The heap-allocated state machine object. + The argument was null (Nothing in Visual Basic). + The builder is incorrectly initialized. + + + + Gets the Action to use with an awaiter's OnCompleted or UnsafeOnCompleted method. + On first invocation, the supplied state machine will be boxed. + + Specifies the type of the method builder used. + Specifies the type of the state machine used. + The builder. + The state machine. + An Action to provide to the awaiter. + + + Provides the ability to invoke a state machine's MoveNext method under a supplied ExecutionContext. + + + The context with which to run MoveNext. + + + The state machine whose MoveNext method should be invoked. + + + Initializes the runner. + The context with which to run MoveNext. + + + Invokes MoveNext under the provided context. + + + Cached delegate used with ExecutionContext.Run. + + + Invokes the MoveNext method on the supplied IAsyncStateMachine. + The IAsyncStateMachine machine instance. + + + Provides a base class used to cache tasks of a specific return type. + Specifies the type of results the cached tasks return. + + + + A singleton cache for this result type. + This may be null if there are no cached tasks for this TResult. + + + + Creates a non-disposable task. + The result for the task. + The cacheable task. + + + Creates a cache. + A task cache for this result type. + + + Gets a cached task if one exists. + The result for which we want a cached task. + A cached task if one exists; otherwise, null. + + + Provides a cache for Boolean tasks. + + + A true task. + + + A false task. + + + Gets a cached task for the Boolean result. + true or false + A cached task for the Boolean result. + + + Provides a cache for zero Int32 tasks. + + + The minimum value, inclusive, for which we want a cached task. + + + The maximum value, exclusive, for which we want a cached task. + + + The cache of Task{Int32}. + + + Creates an array of cached tasks for the values in the range [INCLUSIVE_MIN,EXCLUSIVE_MAX). + + + Gets a cached task for the zero Int32 result. + The integer value + A cached task for the Int32 result or null if not cached. + + + Throws the exception on the ThreadPool. + The exception to propagate. + The target context on which to propagate the exception. Null to use the ThreadPool. + + + Copies the exception's stack trace so its stack trace isn't overwritten. + The exception to prepare. + + + + Provides a builder for asynchronous methods that return . + This type is intended for compiler use only. + + + AsyncTaskMethodBuilder is a value type, and thus it is copied by value. + Prior to being copied, one of its Task, SetResult, or SetException members must be accessed, + or else the copies may end up building distinct Task instances. + + + + Represents an asynchronous method builder. + + + A cached VoidTaskResult task used for builders that complete synchronously. + + + The generic builder object to which this non-generic instance delegates. + + + Initializes a new . + The initialized . + + + Initiates the builder's execution with the associated state machine. + Specifies the type of the state machine. + The state machine instance, passed by reference. + + + Associates the builder with the state machine it represents. + The heap-allocated state machine object. + The argument was null (Nothing in Visual Basic). + The builder is incorrectly initialized. + + + Perform any initialization necessary prior to lifting the builder to the heap. + + + + Schedules the specified state machine to be pushed forward when the specified awaiter completes. + + Specifies the type of the awaiter. + Specifies the type of the state machine. + The awaiter. + The state machine. + + + + Schedules the specified state machine to be pushed forward when the specified awaiter completes. + + Specifies the type of the awaiter. + Specifies the type of the state machine. + The awaiter. + The state machine. + + + + Completes the in the + RanToCompletion state. + + The builder is not initialized. + The task has already completed. + + + + Completes the in the + Faulted state with the specified exception. + + The to use to fault the task. + The argument is null (Nothing in Visual Basic). + The builder is not initialized. + The task has already completed. + + + + Called by the debugger to request notification when the first wait operation + (await, Wait, Result, etc.) on this builder's task completes. + + + true to enable notification; false to disable a previously set notification. + + + + Gets the for this builder. + The representing the builder's asynchronous operation. + The builder is not initialized. + + + + Gets an object that may be used to uniquely identify this builder to the debugger. + + + This property lazily instantiates the ID in a non-thread-safe manner. + It must only be used by the debugger, and only in a single-threaded manner + when no other threads are in the middle of accessing this property or this.Task. + + + + + Provides a builder for asynchronous methods that return . + This type is intended for compiler use only. + + + AsyncTaskMethodBuilder{TResult} is a value type, and thus it is copied by value. + Prior to being copied, one of its Task, SetResult, or SetException members must be accessed, + or else the copies may end up building distinct Task instances. + + + + A cached task for default(TResult). + + + State related to the IAsyncStateMachine. + + + The lazily-initialized task. + Must be named m_task for debugger step-over to work correctly. + + + The lazily-initialized task completion source. + + + Temporary support for disabling crashing if tasks go unobserved. + + + Initializes a new . + The initialized . + + + Initiates the builder's execution with the associated state machine. + Specifies the type of the state machine. + The state machine instance, passed by reference. + + + Associates the builder with the state machine it represents. + The heap-allocated state machine object. + The argument was null (Nothing in Visual Basic). + The builder is incorrectly initialized. + + + Perform any initialization necessary prior to lifting the builder to the heap. + + + + Schedules the specified state machine to be pushed forward when the specified awaiter completes. + + Specifies the type of the awaiter. + Specifies the type of the state machine. + The awaiter. + The state machine. + + + + Schedules the specified state machine to be pushed forward when the specified awaiter completes. + + Specifies the type of the awaiter. + Specifies the type of the state machine. + The awaiter. + The state machine. + + + + Completes the in the + RanToCompletion state with the specified result. + + The result to use to complete the task. + The task has already completed. + + + + Completes the builder by using either the supplied completed task, or by completing + the builder's previously accessed task using default(TResult). + + A task already completed with the value default(TResult). + The task has already completed. + + + + Completes the in the + Faulted state with the specified exception. + + The to use to fault the task. + The argument is null (Nothing in Visual Basic). + The task has already completed. + + + + Called by the debugger to request notification when the first wait operation + (await, Wait, Result, etc.) on this builder's task completes. + + + true to enable notification; false to disable a previously set notification. + + + This should only be invoked from within an asynchronous method, + and only by the debugger. + + + + + Gets a task for the specified result. This will either + be a cached or new task, never null. + + The result for which we need a task. + The completed task containing the result. + + + Gets the lazily-initialized TaskCompletionSource. + + + Gets the for this builder. + The representing the builder's asynchronous operation. + + + + Gets an object that may be used to uniquely identify this builder to the debugger. + + + This property lazily instantiates the ID in a non-thread-safe manner. + It must only be used by the debugger, and only in a single-threaded manner + when no other threads are in the middle of accessing this property or this.Task. + + + + + Provides a builder for asynchronous methods that return void. + This type is intended for compiler use only. + + + + The synchronization context associated with this operation. + + + State related to the IAsyncStateMachine. + + + An object used by the debugger to uniquely identify this builder. Lazily initialized. + + + Temporary support for disabling crashing if tasks go unobserved. + + + Registers with UnobservedTaskException to suppress exception crashing. + + + Non-zero if PreventUnobservedTaskExceptions has already been invoked. + + + Initializes a new . + The initialized . + + + Initializes the . + The synchronizationContext associated with this operation. This may be null. + + + Initiates the builder's execution with the associated state machine. + Specifies the type of the state machine. + The state machine instance, passed by reference. + The argument was null (Nothing in Visual Basic). + + + Associates the builder with the state machine it represents. + The heap-allocated state machine object. + The argument was null (Nothing in Visual Basic). + The builder is incorrectly initialized. + + + Perform any initialization necessary prior to lifting the builder to the heap. + + + + Schedules the specified state machine to be pushed forward when the specified awaiter completes. + + Specifies the type of the awaiter. + Specifies the type of the state machine. + The awaiter. + The state machine. + + + + Schedules the specified state machine to be pushed forward when the specified awaiter completes. + + Specifies the type of the awaiter. + Specifies the type of the state machine. + The awaiter. + The state machine. + + + Completes the method builder successfully. + + + Faults the method builder with an exception. + The exception that is the cause of this fault. + The argument is null (Nothing in Visual Basic). + The builder is not initialized. + + + Notifies the current synchronization context that the operation completed. + + + + Gets an object that may be used to uniquely identify this builder to the debugger. + + + This property lazily instantiates the ID in a non-thread-safe manner. + It must only be used by the debugger and only in a single-threaded manner. + + + + + Represents state machines generated for asynchronous methods. + This type is intended for compiler use only. + + + + Moves the state machine to its next state. + + + Configures the state machine with a heap-allocated replica. + The heap-allocated replica. + + + + Represents an awaiter used to schedule continuations when an await operation completes. + + + + + Represents an operation that will schedule continuations when the operation completes. + + + + Schedules the continuation action to be invoked when the instance completes. + The action to invoke when the operation completes. + The argument is null (Nothing in Visual Basic). + + + Schedules the continuation action to be invoked when the instance completes. + The action to invoke when the operation completes. + The argument is null (Nothing in Visual Basic). + Unlike OnCompleted, UnsafeOnCompleted need not propagate ExecutionContext information. + + + Used with Task(of void) + + + diff --git a/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+sl5+win8+wp8+wpa81/ensureRedirect.xml b/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+sl5+win8+wp8+wpa81/ensureRedirect.xml new file mode 100644 index 00000000..e69de29b diff --git a/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+win8+wp8+wpa81/System.IO.dll b/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+win8+wp8+wpa81/System.IO.dll new file mode 100644 index 0000000000000000000000000000000000000000..01edf729d6fd3f62b325ada34491065ecf202911 GIT binary patch literal 22704 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 + + + System.IO + + + + + A strongly-typed resource class, for looking up localized strings, etc. + + + + + Returns the cached ResourceManager instance used by this class. + + + + + Overrides the current thread's CurrentUICulture property for all + resource lookups using this strongly typed resource class. + + + + + Looks up a localized string similar to Found invalid data while decoding.. + + + + + The exception that is thrown when a data stream is in an invalid format. + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class with a specified error message. + + The error message that explains the reason for the exception. + + + + Initializes a new instance of the class with a reference to the inner exception that is the cause of this exception. + The error message that explains the reason for the exception. + The exception that is the cause of the current exception. If the parameter is not null, the current exception is raised in a catch block that handles the inner exception. + + + diff --git a/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+win8+wp8+wpa81/System.Runtime.dll b/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+win8+wp8+wpa81/System.Runtime.dll new file mode 100644 index 0000000000000000000000000000000000000000..967bb30a0d84f969455800059b74fae5c24271df GIT binary patch literal 22208 zcmeHv2Urx#(&%g;XHh`n5+q5OT{4oBAW=Y2g0L)0kg%{U8Ob6dDk><7=#mtaD59vK zB4Sp+oRDNd1wjQx1bsbA5Iml9&;R~+-u>_Q-tcWrSBL8E>gww1>K<&}av%%@L0Itn z@dJVy!5evu81Sz_GDzl@IKvH{V7n#Rh_bmQ=^PLkfeWKj{Heqc9ElhjN}=I=$T(_b zC@wG*XJ+q&3!(UuRk*m=WoAe_m_v{a3InzDnmEnY)&rp>IZzxB#0z4Wr(+MQfHw~O zjKB{`!2yV#ZZ{Hvw4d=L0|??1Em5Ff-kTUi5IP7k#(VCCL_%hOt}7BSf}jfsBW52V zfExhB8-h5&i&GhbL}%0f&Kn0otn>1*0^D*Qu0kWn&;VY_4FE`Ev<hI0#DqiT-J5*uTWy`A~5=ZFQMyq=<$PY^;9xi|8>+*NEtx&wQpE zdE?eUxf2}NOxUWSQ6O~M_k0(CbUwwa-x67AB{7JiVS|r7mMeh1x zMYbX9#aStI=#F&nl4CMB*OA}ayrKAVLF2Quygs!J@2cz7Unuo`U&>WDve|EwE?ORN zhaHWP2aIA?6i3IS0M8Vq(3p+00eQe0B!!Xj4{wljVFti7r&T5>2owho!rv%$6<9?L zR>SKcF-%Y}fHI&u=|l+10dG1IcA`-OL;WL=957%eA`8-MoFHuwM#NBh#%>|7XW zD-ws~o_;e!QYZy5rPLU(19cL`481`y0fca}8PJ;nV;L}q0jn7BCIh}?KnR1B zQp7C9Fhg%K4>6|DcMLLRxv&-hDl?!P7O9cSfN3BGd8S)~@U#eEVvqtO4#9aL7_tC7 zMS-56P`r>Iz&Jq|!~iUXk%k8J5UgMZV_{$oGZ-rayERh|;TJFT4q`$v0V)U|0#FFQ zkmoX!5(pEMyWuO45+|>cm~vAKw}29 zV!+i5xQ+pd3>e6O;S3ndfGGf~K|2A|f%X9?1I9ud)dM693D+^8B;YX@s8bpm25>n8 zra{SQ6^H{e0Wtj0Apk|7djOh3-XJ~#3I)&+nglV9&=N*i6TlUa4S?}bG=SEOoKB1w zcSbk}@LNi~p;u5cBb>$vmjJj3)yjbV42VG?d87f92P+3)4wQwG035=AKNN%o z5Sxr}jF~a(kaPpc8q6hRZZLr#QUnDpMH0Y+V?Y~>0wZl2b6S9{TYwQ4V1Wy;@C8`x z0xV?#wq*gfa{;ywQ-eX;Io+0vGZ-55OmMo*dbSkb$Y8PojYuQg5=jApp=4tk&`Um%H1e-yO(`K^fx%>|6PX$nNFql- z#u2fhq~8}cB?g0>w&V~WGS!Y4GLPtViVdj9E)q%oS>1Gs1*pP-NDKHGZ$%?hi8KoJ z_ca+uM1Wd?V{OSaqA!s~{8?_c>tw%RGKm&Q35A@YkO&fm8XV{Y{mkY_4x>8^`{BWfwbUxgFf3#Gjarp8W@I9{bQA;lu*Aw|41;_zfA^G z>l;b>O$VK+L|<|U@waS=45md==QU(bCL$=2R78gD$dNQEG1!qj6JbLP^^YX_&nsdP z8A|fjgq$P8g2~em%o_&gO_+JB&AioT-WoISnNr?bGq^Tn1r~kK3DC)4WI7S4L?1wP zrd6gCFliW)8Zkekd3Yp{>v{Ri0*U^iln7cNDFQMh`$YQtBdI?bIvoe(1}Fj0#p!v= z;Ho1zm>9zdMf}V@qZ=6Qp#}N`1_#pSNy{w9rWMG~d9x;B0hi{;O^fPmtz_y-awsx= z$-Z+r5N(Q?)?AU!&ka6!Q!I*d-t_Mq-Z~DkCJb(Rcqk zgMd5|z(FV`92&*VjRmRPNESYGB*>afhh%^$mkdF<5U?>2We#vhCu2NNj6k2GAePPv z*GtupM@m%EkMdMcalILs+Az3d^EXUXaGK4&UE;@Ayx#x#{&zUk@A3-7UxV$$R=J9VIJ?O+3)2c~X>L zen?zj!*gkmzN~20B2%&uF66>)bz8SPyBUpLBa4EJK-rs?Ito&~Sb?(*BvC056h9iy zltKl{lOa$lI2>p`j-iAiaA0`>s|48>>>Y$r(30Pl0H!h+5rT@Qina<2K|&~q-6S$F z*w=>WLk?!etHbKBmI@w%a43j_kzhh4hLQq!fDn_35o8Y&QyULFk^%6DV`fo8x{P(E z0u2lCqaf~IgcsO&fNKy7FdfOEfUk%Ni98^HSl>U|x7EY@I)eF8A*Am{=)L0$lwgS~(gWChtn zb^x~m&;o>!rx`o^9Z_}6jLFJ6_cmmtPP;p%r}0b#c$tA83Q#3NR6r*X?7zu?W+>Pz zQW%+JkOcvlgH(_s6zoWX!J7v1Q2;jm)MBp!qA1WN8pst0;{AU^sg#iihGzfNAs-M1 z{wlB&M}hqg1qy+}7_e>kQ;&XTVo0F09v!X zFas1K7-a)N-uZ2If?`1m4Wx%a$j&Mfv>8dCtrG@1?k61=kdF%T|LijXl+px0ZSX_- zUA4~7k^cs3gip&B3=&&N{3Vd9UDNypFsiXXBcQJ!c~7L0JIT; zDnS4LK2KCYZX9IHr~x;RP6UXhf_fqt?TrG^7xV>r92kAEpUI1iCeoK#o+8*Zm;P>_ zj2L6$0O(Ob9g$!>X!AG&0jc@xu~27>#lrHxj>xa$q0J~`40?z3F9b+hFsKCwq z{#uT~fd3A_P5ZRyh_CbiKmX5hfZ^jtqaireppKbMF~c(B3m1w7O;0r_22lsmC={Lp zW@Bbr&W%9}GeNKoGy8I86c&}Lg+^iN2CyD1I4_0=X2YO>|FamK48fA~%3&8j->IDz zSnJ4gAthgIjh&pK<#Ez6dg_u?I2GFpr(%xLF=!MT&94SVK<%YmMhW*S#bm~4sKH!w z4MQ=3CPXt@gjs`S=0~q_!t=v?%m88KXLlt=02hZpjS`CIg}ISP7Je2-vTq0_)E6%f ziy|@X{J%F>@sh9vl8)gQ`f1KO1E-2IZ~}yc;T%kjVR1n&JaGFGv(8$*<&oIqlIr!ygm8~F zA z-+1F{NQ-~gO;SK6dQ`u%c~ zOU1ac0@%gSS`mYxwhzp^&*AkoPgHVv5=K%OG9)IA6@mql7fY*;KX$YTV;?g57WJ)u zd2OpkJrC@Rl$XHT!q%`AeI?yI!!&?K3)59qB~gP_LT0yKDkMsXYFJPp5~~U}3y5nZ zLUnE!5xHcDC6G!LkOf}L%nD{D6B7#xg|&fK!IrZ)jLy)TsUSK!`gawOseeJ42J<8B zU54d^*=I>&Sm%oin2UdraH96<(+P)GIHr|ONNeB2G;Ube@V1ANi5aD= z-jJsoxoJT38B3d8p-A~{nU#xW>@}k64m8Qd@9?yrWZt@W?^lI_FGgaHDchqgF^L}w z1W#2zc9+^oT0!vA_;z`x-pyg|eaQyQJGJ@aIBm|UJv~2EWqdh7L?(g%8T+Jl7LG}b zZOcv_7CTA1=fMeKXODfrZ6D8%@qV^7x1D@$PYw_LK>CnJLxM4#sN8JoPZm~8y>}#Q z-4{ZC$?LXl$ED8hl7Cd2?X)9c<;tQ*sM-(2C6@$?l>2pq?I|_-@1HBwn%!vK<$ngc z&9j|vxD%a_4I` zq+!YFNiRGnEnpw-OU5|``XkQ9d5R2AP$v-7)YNpQ6`A@R3a6y~BW?RdkOM8vSifEEm8)Ud>Lu#VW$h=nRv4CR^(s3I zX$aU2+r~ZRkIJl78d>L2@virwLgWjPO>zaF#+45mYcA(7`gU%`nbRJTy9FGrudB6b z)qZ-HSUzUF#DkSACaE=|bViDUw~n_kT53~zg8gZcoZ7LH?^{PX_uJ9OuCYt@9qmVH zuAEX$-H?JAtI&9s>st8D`W|=cQ|%p#zV|#qf$ z(NQwrD8uJ03v+S(Sos#i^74hBr&4^OSOxEdXf5rdePGbR3YqjLLwo4m5v9W$ge$Fm z4t_|uusF%`mhEw~uOoW9LrfkGB)k%&7X$>b$$v%f9p=NF@pr6hc~c*8_zvmTsy>4k zpX{c76!n}%^RMv4Jzry3Qk`Rj*N&85kFBr>c{LUnYt$@pYry<|b)TofSmc#gekAXk z_xGo7-X;To8CLHgiPf3-ui~~ougg7rGEeu2_KRh^SPy6V0ke&%3Fy1hX?@2|RFf5E zSZnxSm<4+=3^aDOU9wwte^l~CEfv6k#SOm{u^Z<_vdyi1cx8C`v}fvVkdo{3O&_uW#4kW z8fP^+5>RPty{)V{);hdkCCihkW!;65ne9g-%#t3aJpI)CQM2@#hxxObD*Yb$fW5*; z%BT@89|Ut>Oljm&=?|j3#G}pAHfalVM7T2nk=a&uJW%z?QjYJtXbOE%s?J@D;dSG8 zw)srmxaMVncQ`G_|H24vrz-HuOI^{j)29>kb8Z!BGjH;+b4is~WFnlherQj6eMi~n zgSr0eN>=EzMbW`d_iS0Gfw-fqK3cSE>1iK45$#bXcyQYdz8x-lEtPCun7gwYY(3Cm zZZHp`8Te7CA6Odti0ZQ?-k{E%3-~xN6PThxlD`ESWa-ntj1u*0-2vw~N`=5$lKafadF*JX3^P6eV(0+P+pV$QQ#3urM*7%1gg9B47^ zzo*5fo%hIuLFNmf`bYhRMnUUz43cCmYTi+d>Ie-R-f^pjmRo&!=M_0*vqJfyX%)x! z8*h~HCDJz&9P*PTJuCH9ZO#;zyBz2bJKK0-Jhs7#`o-X_anki(PQkz%We0G|6C4hg zTy81%ue#F|_PU&_7*pob)0k!L`Z3Ssz=u!6@B1?()b$!&_K!G8Z&EBx72VyJ%Odu% z&u%=s==uPE*-pEwB6oIB^Ay8F3WUc+N1Pt`-<0~{A$F@cyIJmdEXl>Jc=fHXZ%Wp> zbQPe@%~ZWcpH$yVC4^3v=JCIH7x=oOSn1r=<-FYF?fagN6;CXZWg~0neu$G;b+)tD zWuPNwkC4YT4FRvN-C|bTmCseFn~A>XT_Oy5c4@dv-p;?m_I?w0wtWaUzny-9g5?2f z=cnN7ErVetuDe_}=5C{lSYq71w3qm^)5bz>XyhlSjqm4U(TrN#n;}7B#W~w-Yd!8Ms~F(gLXsp zQL&HM)!9NslkpOL+|FGui@v>F$y?={|HDB*CE+}iWL#gKv0Py5?j3p8wmmA4tmg7K zFj8Ed5s=2YLHTS{5G1yz>Z3sXXMr@C)0yoX%2(o5_dn|o*MA5l`mF4{oq4TMXo8!% zt))c225q$AM_|F8KHhTP6Iu?e4_fu%RAv^SzlUe_w?F{muLWlw{|@~PYk|`sps_X7 zV8j?D;29{`Y6JA&x846&+WSyZa9#IP%Uy~IK`KjooBR6P_N|t7sJh)HWGBP(zVk?@ zO%)Bs@x5cY@0_>9Dp$m0S9QJzEc*ls8i;Qm+`_{1g&UhcvgM}44KVYxS z?0R#eD*EZ|*wwbEIu%;Ddk820vD@e3cQmTpTU4AK;?wAgzF~*sci7hzXVm97DjlTd%D8`s=2Qo2y+03d3@PD|Kw{eU3eUR4C3zVYs+JL7h2T*yozQ zc!)&m2*(wrv+bt!FTW0MZ0Ij7r)f0WwS`MBl8xffbIcBRvoKxUR9|0f>woo-$&ch% z$>f7eV7~#AMeBvH9+Z;oFnzQ9&Dl}Qn@aZ{5t40W6)k1F+}^qjAAY{C@VYLgIYo}f z%=bP@@_a#Ri=6Yxx()hUilT@oLW}qhpFg^CWD#X5ix7PLd-v+A+0xhinhV7?FY-m} zE7z>s(fC60Wkc3brDAMe`CA1S3uC}$0&yJs&uPajUd zF8Sb{xc#;L@2z^ipvaUh92>6&UVRn%_Q>Abc!eL_ZSEeAY(3pWAoIuRA87DOx2G2Rq^^67n-Jh;$4m>wJ zKXnOW49*tB;(;+}-&dL3UXtoDCCOz@`g-8#m7I;Hz&rPo1ScMtUv$}InZG>mnK=t9 z5>6KSGxKcziVD1|*i;l`QqR=3;iKyQGlgbJj~;$o^LBl!zoTu`tzhLmo4oCmM-F#m zp$$#GE$?=`@LRri-=i(Cdv?h%8;ny#XWNbkJEm0gj3??w zi#(>PHx2KNII9aERiAV}ol|bj+R(|m|NUOG-KOE+-g#AWjyq_#$%u z?#VdK7lIWIqV_w@L&Vp;>mWOwPnW@ z*TaMhs#>B;SH(>lYACJoTXff}C{@-JPDRW791~`IDtZZs;$ukR_J7-||N9e&c{1n; z3;k?02G22vu%Lhh&dC@Po`-Qf0B*V9wbZmUwB7z7fyU3M?Bpktqua7->mGl9{Hdt> zefxY_0j^a5m0U&D zSBG$tTkDf9PvL8k?uJb;HeU0r$zrV|59$s^Ex#eK_?xT5QOmSjLhRS?zRluvKdyXQ z<~06F)GFif+Nt%`>aTBX*O0{Dy4TQETOiXPUdV)5%Q=YyEs}O4UfQ?Uu*IRM29iDC zbwk?sV9zIkjh0SdPB(9eE-vvhP4?)K%1;mK3IQ%Bo$#Ov*seL%;ZIo@PPdGC&rAoh7gcb~T68eN|r#jm2>R`GOQ zV^(!2GmR8TwDKPytjqvUb@6ygHuY{{{Y%S@b`||NAmQRhhG5Fs@v^$Hp+piks`?lB%Wr z&mFU5_bmyp@R4KDDocY?eS$ekrkJ?|7c;-=sk)iBhaKluyr;Lv71s0gDQNTD!r7tT z{rJ&@#xS4s)(cQ-9nIaXZJAAn$Lqbb*>S~ zMGEiF@o9;i3N=}C?WRVjV?8G9K)(7x1)iu<8 zm3>Hfva%Y1q(Suc#cPpu;068@%TV8!4or7bj|ysONi~F&UynrR{rO?oZ_lbIVG)e; zFd*G?o?1kly%3-bYbnFp3?B+{mI1(rvIcenJ)1ck13r{lXY-#|Fnb>M7gf-JX))`n zLW9de^UkNi?8c-5o0^a6&GE5P_9T|c@0s@6hxdY?NFVi9HkNM;GR&p^Fz{JTUMGlO z&0%;aK#Pjmg{!OS26r6HH@&*p6dUU9uHGwf53kcEz3vptYn!?) z_Q^h1TSonIo40Nl4Ez?9e*}pYV+9- zy=cQ|@^)+H&X7z__s$g2q0!@fZ8@sW1>3w?WF%8U)Nkx6+}*z=i}e8K&C za`}_(!x?USOUL-EGd59tj%BIP?d7=^eQmq7b0voTlIAti!>%uz;?_>NZyxk($)DWz zer;Uw!A`OGEmqsbzZtY1&w78!-?A*SZt8aM;d*+{V%JPcg5?LxZ2Mi}$AV>iInUHp zXTI^=rfSHs8tt*6vT~`-J)1bM(;^La8r4B{=O4MrS6NRFm0fj;za^HLjG zZE$zsJ$SA?_vA(`%)OO&-h4Q6#yQr)_8>g)6t^5cNnKKBd?dH0ICmM#)GRwZCM2jMI(e<@@!+|;rA)rbjStVpHAr4& zm5xt2ejr=V;~PhxQ(w!QGdx}na4Jh2aFP4Wx>vY!?l9adm|uhiPRaa7)&k%HpI!?T zey#<7?nD2%D&T=DMw#lnXGrjSP8X!2z zE>eAcjMbsN-t3g;qf087$YTMYZiIZ&^(Yb;wK&tG?OPe@s}XaUPU2C%YqWd3|2YfS zeUI2OD}~ow=ji;==W_Ljzx6M7#WjjPpI2fEh>Ga!f%i$ zv7uMqs?aO5Z<*&^NoxbgOAW4uGMJIhICs_i(*0qcJgY6D>&Kzqrb=|G*V7A2>YGLG zt+9TsQ^fN|+Nw#Y(JaCIMN2C+u7~(|$^Hzj`P!I1T9D}^Kc@`sOX^iO`3j97R(em;ihC*89cPQ;J(z0*q z-DI}q5}Qriy)si(THcq?@fh4%C4Nuuy!{6DYUxjEGXV-1+hjox&cD<1ATxW; zA2kHl!#D6BT}nT%Zv1vJ`ip~r1-`0398)0ohGy@4P?dGj_#D&Ii<#_t-yXSw@08x6 z4!a>4B(Pv5g6-+Hbn6VOzkf^srZ1Scz>^OSyyg}=FIdfsKwvC(>t`1?u-G}m4zS%U z4i-C;KiiQ`UoDwk>HdN~4Nf_PG#-ad*$b!S!YMoF9Ca!fU?#$bv(=$d0&0I%9kO`) zQb-ZtHcKG*nkSYN7NHVA3xSR12%uqgaRN?k-d$2J#(mjf#%#H7K#_Mc+ZwrFmVH)I+`_xLzh**tdSe)==#K6vrm3+zAd*t z$4AyJ4!3pjO255t#`_wQb~rdT>a3X5BD)mlMCe$VL!dd-O%!#x^jMmr-~twvVWdWI*2ozG4B zzvlVs)iT|ddZ_pocB6F9ZP{Lf4@tvewxS6~JU%DheLdRGv8LwJkluy8#d5bUs;p%W zxWoEozvSc7o9zp#S7LOtLn=vO*W8%Ck9Cvm$1wh91vlk~SCF$0YfI?vSsHoi!s1)O zEHdjG%W`+zF3#ybeQ=a`GXAjS39NA+$D_nLeolY;bcI_DJ;Vw_ro`o%Tx$yS>VCXYt&wY#BvdZs0z7+h~$Cm4A17>RC z&e4~JXGOD$Qu(dmRDSchtr-RbJR1BOAPzq_W{5|FUkXHtqfwYYdNfi|ddwWNqQZ;9 z(o<2(fu~3gtb5WxYGz2MuVcrc!0niY?hq{Q`s0t7he|i^_H%z&n!c??v}KL+=1GCL zNkUlj)k39|n`mYyje^|@zCw$@dc*iki{Zf1Q9&+KumJkWXw)b@<#cJv$^Xn7uk=*z zTfk=%4zBF2o3+o`QWP2XIr^97=yqczl269lU0qk>tsv{_z@Q>^y zWMP@(a7!r2D0}@>wNw-;tDaYrf9w_UEJU#|K72Qq`=%DnltbHGIl6+ z)3>370Ba?$w$_)#i&3Wx{Fb|qEOC;<;w6klg!9C1v+-|FAj0eFU^AW%-kIsnrkoFL z8?{;MO}chhK8S!_Wm8McxjNpCtxUOfUdEfS*4yIa+LalEba5Kdf2UW9b6xvxn_VrJ z4tsVI`9tL|3xCZ>KHE*4v}lnNlks0f6_(7ZvG(2K;8W*06)mAZ;u=}moMmEbw7Qe$ z0JDLA(wN@`%pSAE;STGm(3ktK*Oh;aQ)I`FJh5Zmc`}n#V<1Mf_RYRqdaqT@&Kwzi z=G$C~YQeGXj=442bm5wr=X!wyC?U~M&Rm6|#@srr)rh~Vqo zzhRa-fDeOynx)7`WPi&nWqFmknyc?}PrhMFI7Yv)q)3ud|L*Y3G5oo9roM{r6Rsgk z;rfehe%Cg1kG&p=X}(f^a9RJ?rlBBbSJvgLQ_U8AJMENxbJTlLR@6-+BjbW+9)dqS zzOEP4$d_@krVX3$UadKwbUEpx)T2}n!|i>3IoUrp z_#}0;t>V}z+ov9DbBJi)V|#8R8MX8~Yz|uiT&9 z)^Y1d$MD9qk=_;IY~7x;d?{AqlUfIHO7n+asQWdZrF6IM7xK!Of$?(7V_%+A6Ny2T z=!%pZN7yQL&JJF_@hJ5K^_JLZ<0h1N@;8w!iq1O6-Je|LTC*>1bHobPSNY0sxAmy0 zEK(S|pz16q`Q>V*-4pr7x{9ZJjvp~8zSh3f*tRF*tK$9=K0o;GSsKB*n-o8`FH2SA zie$~YhU#Z#dV3wh9~RwdThkx-+_k0iIecO2<}2H8T<1OQ-xP{3)mCk4U(2L2%td$5 zcrwf;Cwjj=QA3>d%oEM0cfEEzr)63#0t?O)a8Ph@-a&!FUb}?U8#n=D#_FT+>+19G zRq6A-cfqUS)fvYG)8D%=(ErTU|6eXt1BNf_*}d=wT(XU)_6`aP*SYkKe^ee7;=7%5 z^N3g3yT(TU6|%27uPwcm#QyY3rF27a4rPn-6?cy0Pxv(hq^IpCl)IZlx*EG)PdN2& zJ>@2yGxeOip?Jkvjo9ZaN8R6rOJW0D4j$D;B|jXm{NO6DBJQ8<#L^u4CNDp2jF9~` zKa9=OMj1~_3mj0_w)+qcF@IGd&WJ=SC~kG8-6&A>Ib^M%u+m_KPuC?+QS|0e6AQ2 zD+se#*`h?OZTF;$5?ThFuadPiN{#DohtDolB7jqZ^G*#^OH$Lj2)>Il$Cy?}*>BC# zUmt*7;Nt)7y7k|@?hPyr@SzKG-Ftd<0ZxAW|EbmGPiX(@-TznDXc#Vk@C6L@AkT5d zS3}k6$0I2@7n+urM`xT2tkjac_n0+v!XnM8>D=(yfQ_L`jj@g2PwmV0PT8|whbujH zf5pq=qU%!!cTpX!3=%(u^cj8Kvm!cpvP99K{AT5++@WoJ={Jswty?3p>01c5{%0{h z|Dw@dYtpKBLQ5l2wl>*GT7Z z7?+{MJGRqA&1;nJO+VCl4;ZI^Y$APrnz8!CrIUKJhewvyFCX7gna6DqU$I11W#gif z=kByioP}yf6N?Sf7YEklgf~QU>`pg!#BHx6*Eg?S9A6bxv1T%KMa|nbR(TUP<86~6 zMX8u5;EP?)*mU<7{ReLlikGp2z4y;Ef6NkycJWd0S?4jOpui^fMM)-!pV_x&(NiwM zDd$U5n&6bv|A^`R%l8<6{P54t*@^Mtp9xIRQa07J&{oEqX=~$`!wSUUkBKWUSRGcaJhk-%!R~&HR0L=tF7z|~FrG$89cYiPp{P9+5{7iny%(pG4Zo8Vg?d^jtHZE;hn zX>#NJG6y}MF4G53PQA8b90CJFjU!tQvW8M8W`k8A0=Ojn1ss z@mN8Yo0_Dn-QLh#E8{n5f%Pji;SxByqxuEQ$-1?vobjjlGb` zJ8()noN^ORslzV*-P{HDOW~B{(!~FX%mSCwE~-XETqj2+*Sx1Mle)M$wj!m$e7@v^ zH3zvGB*}71au}zprgBH|iojik0rsbFe`x#Ug=N()SvllenGoT8LO6emcjUTp{Bzlw zhDfr6#{twg)G_xy5%zB{u21ZYuW#yS*3LK)73EsFyDgm55jz%?5`OV%r_t88eWvNd zQ)Lg%#N9j}v-0r7(eK$7Xl2`@rOpem+#% zn^-6vU6O?Nb+?T;c63=`boZRu QU>aprW%>sEYaZx-0jWNPVE_OC literal 0 HcmV?d00001 diff --git a/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+win8+wp8+wpa81/System.Runtime.xml b/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+win8+wp8+wpa81/System.Runtime.xml new file mode 100644 index 00000000..93cb00d7 --- /dev/null +++ b/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+win8+wp8+wpa81/System.Runtime.xml @@ -0,0 +1,56 @@ + + + + System.Runtime + + + + Defines a provider for progress updates. + The type of progress update value. + + + Reports a progress update. + The value of the updated progress. + + + Identities the async state machine type for this method. + + + Identities the state machine type for this method. + + + Initializes the attribute. + The type that implements the state machine. + + + Gets the type that implements the state machine. + + + Initializes the attribute. + The type that implements the state machine. + + + + Allows you to obtain the method or property name of the caller to the method. + + + + + Allows you to obtain the line number in the source file at which the method is called. + + + + + Allows you to obtain the full path of the source file that contains the caller. + This is the file path at the time of compile. + + + + Identities the iterator state machine type for this method. + + + Initializes the attribute. + The type that implements the state machine. + + + diff --git a/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+win8+wp8+wpa81/System.Threading.Tasks.dll b/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+win8+wp8+wpa81/System.Threading.Tasks.dll new file mode 100644 index 0000000000000000000000000000000000000000..b8f78dafd6ddbae13acf85b07ecf545afb460b32 GIT binary patch literal 34528 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 Hh0y;2j36FU literal 0 HcmV?d00001 diff --git a/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+win8+wp8+wpa81/System.Threading.Tasks.xml b/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+win8+wp8+wpa81/System.Threading.Tasks.xml new file mode 100644 index 00000000..b47921e5 --- /dev/null +++ b/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+win8+wp8+wpa81/System.Threading.Tasks.xml @@ -0,0 +1,475 @@ + + + + System.Threading.Tasks + + + + Holds state related to the builder's IAsyncStateMachine. + This is a mutable struct. Be very delicate with it. + + + A reference to the heap-allocated state machine object associated with this builder. + + + Initiates the builder's execution with the associated state machine. + Specifies the type of the state machine. + The state machine instance, passed by reference. + The argument is null (Nothing in Visual Basic). + + + Associates the builder with the state machine it represents. + The heap-allocated state machine object. + The argument was null (Nothing in Visual Basic). + The builder is incorrectly initialized. + + + + Gets the Action to use with an awaiter's OnCompleted or UnsafeOnCompleted method. + On first invocation, the supplied state machine will be boxed. + + Specifies the type of the method builder used. + Specifies the type of the state machine used. + The builder. + The state machine. + An Action to provide to the awaiter. + + + Provides the ability to invoke a state machine's MoveNext method under a supplied ExecutionContext. + + + The context with which to run MoveNext. + + + The state machine whose MoveNext method should be invoked. + + + Initializes the runner. + The context with which to run MoveNext. + + + Invokes MoveNext under the provided context. + + + Cached delegate used with ExecutionContext.Run. + + + Invokes the MoveNext method on the supplied IAsyncStateMachine. + The IAsyncStateMachine machine instance. + + + Provides a base class used to cache tasks of a specific return type. + Specifies the type of results the cached tasks return. + + + + A singleton cache for this result type. + This may be null if there are no cached tasks for this TResult. + + + + Creates a non-disposable task. + The result for the task. + The cacheable task. + + + Creates a cache. + A task cache for this result type. + + + Gets a cached task if one exists. + The result for which we want a cached task. + A cached task if one exists; otherwise, null. + + + Provides a cache for Boolean tasks. + + + A true task. + + + A false task. + + + Gets a cached task for the Boolean result. + true or false + A cached task for the Boolean result. + + + Provides a cache for zero Int32 tasks. + + + The minimum value, inclusive, for which we want a cached task. + + + The maximum value, exclusive, for which we want a cached task. + + + The cache of Task{Int32}. + + + Creates an array of cached tasks for the values in the range [INCLUSIVE_MIN,EXCLUSIVE_MAX). + + + Gets a cached task for the zero Int32 result. + The integer value + A cached task for the Int32 result or null if not cached. + + + Throws the exception on the ThreadPool. + The exception to propagate. + The target context on which to propagate the exception. Null to use the ThreadPool. + + + Copies the exception's stack trace so its stack trace isn't overwritten. + The exception to prepare. + + + + Provides a builder for asynchronous methods that return . + This type is intended for compiler use only. + + + AsyncTaskMethodBuilder is a value type, and thus it is copied by value. + Prior to being copied, one of its Task, SetResult, or SetException members must be accessed, + or else the copies may end up building distinct Task instances. + + + + Represents an asynchronous method builder. + + + A cached VoidTaskResult task used for builders that complete synchronously. + + + The generic builder object to which this non-generic instance delegates. + + + Initializes a new . + The initialized . + + + Initiates the builder's execution with the associated state machine. + Specifies the type of the state machine. + The state machine instance, passed by reference. + + + Associates the builder with the state machine it represents. + The heap-allocated state machine object. + The argument was null (Nothing in Visual Basic). + The builder is incorrectly initialized. + + + Perform any initialization necessary prior to lifting the builder to the heap. + + + + Schedules the specified state machine to be pushed forward when the specified awaiter completes. + + Specifies the type of the awaiter. + Specifies the type of the state machine. + The awaiter. + The state machine. + + + + Schedules the specified state machine to be pushed forward when the specified awaiter completes. + + Specifies the type of the awaiter. + Specifies the type of the state machine. + The awaiter. + The state machine. + + + + Completes the in the + RanToCompletion state. + + The builder is not initialized. + The task has already completed. + + + + Completes the in the + Faulted state with the specified exception. + + The to use to fault the task. + The argument is null (Nothing in Visual Basic). + The builder is not initialized. + The task has already completed. + + + + Called by the debugger to request notification when the first wait operation + (await, Wait, Result, etc.) on this builder's task completes. + + + true to enable notification; false to disable a previously set notification. + + + + Gets the for this builder. + The representing the builder's asynchronous operation. + The builder is not initialized. + + + + Gets an object that may be used to uniquely identify this builder to the debugger. + + + This property lazily instantiates the ID in a non-thread-safe manner. + It must only be used by the debugger, and only in a single-threaded manner + when no other threads are in the middle of accessing this property or this.Task. + + + + + Provides a builder for asynchronous methods that return . + This type is intended for compiler use only. + + + AsyncTaskMethodBuilder{TResult} is a value type, and thus it is copied by value. + Prior to being copied, one of its Task, SetResult, or SetException members must be accessed, + or else the copies may end up building distinct Task instances. + + + + A cached task for default(TResult). + + + State related to the IAsyncStateMachine. + + + The lazily-initialized task. + Must be named m_task for debugger step-over to work correctly. + + + The lazily-initialized task completion source. + + + Temporary support for disabling crashing if tasks go unobserved. + + + Initializes a new . + The initialized . + + + Initiates the builder's execution with the associated state machine. + Specifies the type of the state machine. + The state machine instance, passed by reference. + + + Associates the builder with the state machine it represents. + The heap-allocated state machine object. + The argument was null (Nothing in Visual Basic). + The builder is incorrectly initialized. + + + Perform any initialization necessary prior to lifting the builder to the heap. + + + + Schedules the specified state machine to be pushed forward when the specified awaiter completes. + + Specifies the type of the awaiter. + Specifies the type of the state machine. + The awaiter. + The state machine. + + + + Schedules the specified state machine to be pushed forward when the specified awaiter completes. + + Specifies the type of the awaiter. + Specifies the type of the state machine. + The awaiter. + The state machine. + + + + Completes the in the + RanToCompletion state with the specified result. + + The result to use to complete the task. + The task has already completed. + + + + Completes the builder by using either the supplied completed task, or by completing + the builder's previously accessed task using default(TResult). + + A task already completed with the value default(TResult). + The task has already completed. + + + + Completes the in the + Faulted state with the specified exception. + + The to use to fault the task. + The argument is null (Nothing in Visual Basic). + The task has already completed. + + + + Called by the debugger to request notification when the first wait operation + (await, Wait, Result, etc.) on this builder's task completes. + + + true to enable notification; false to disable a previously set notification. + + + This should only be invoked from within an asynchronous method, + and only by the debugger. + + + + + Gets a task for the specified result. This will either + be a cached or new task, never null. + + The result for which we need a task. + The completed task containing the result. + + + Gets the lazily-initialized TaskCompletionSource. + + + Gets the for this builder. + The representing the builder's asynchronous operation. + + + + Gets an object that may be used to uniquely identify this builder to the debugger. + + + This property lazily instantiates the ID in a non-thread-safe manner. + It must only be used by the debugger, and only in a single-threaded manner + when no other threads are in the middle of accessing this property or this.Task. + + + + + Provides a builder for asynchronous methods that return void. + This type is intended for compiler use only. + + + + The synchronization context associated with this operation. + + + State related to the IAsyncStateMachine. + + + An object used by the debugger to uniquely identify this builder. Lazily initialized. + + + Temporary support for disabling crashing if tasks go unobserved. + + + Registers with UnobservedTaskException to suppress exception crashing. + + + Non-zero if PreventUnobservedTaskExceptions has already been invoked. + + + Initializes a new . + The initialized . + + + Initializes the . + The synchronizationContext associated with this operation. This may be null. + + + Initiates the builder's execution with the associated state machine. + Specifies the type of the state machine. + The state machine instance, passed by reference. + The argument was null (Nothing in Visual Basic). + + + Associates the builder with the state machine it represents. + The heap-allocated state machine object. + The argument was null (Nothing in Visual Basic). + The builder is incorrectly initialized. + + + Perform any initialization necessary prior to lifting the builder to the heap. + + + + Schedules the specified state machine to be pushed forward when the specified awaiter completes. + + Specifies the type of the awaiter. + Specifies the type of the state machine. + The awaiter. + The state machine. + + + + Schedules the specified state machine to be pushed forward when the specified awaiter completes. + + Specifies the type of the awaiter. + Specifies the type of the state machine. + The awaiter. + The state machine. + + + Completes the method builder successfully. + + + Faults the method builder with an exception. + The exception that is the cause of this fault. + The argument is null (Nothing in Visual Basic). + The builder is not initialized. + + + Notifies the current synchronization context that the operation completed. + + + + Gets an object that may be used to uniquely identify this builder to the debugger. + + + This property lazily instantiates the ID in a non-thread-safe manner. + It must only be used by the debugger and only in a single-threaded manner. + + + + + Represents state machines generated for asynchronous methods. + This type is intended for compiler use only. + + + + Moves the state machine to its next state. + + + Configures the state machine with a heap-allocated replica. + The heap-allocated replica. + + + + Represents an awaiter used to schedule continuations when an await operation completes. + + + + + Represents an operation that will schedule continuations when the operation completes. + + + + Schedules the continuation action to be invoked when the instance completes. + The action to invoke when the operation completes. + The argument is null (Nothing in Visual Basic). + + + Schedules the continuation action to be invoked when the instance completes. + The action to invoke when the operation completes. + The argument is null (Nothing in Visual Basic). + Unlike OnCompleted, UnsafeOnCompleted need not propagate ExecutionContext information. + + + Used with Task(of void) + + + diff --git a/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+win8+wp8+wpa81/ensureRedirect.xml b/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+win8+wp8+wpa81/ensureRedirect.xml new file mode 100644 index 00000000..e69de29b diff --git a/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+win8/System.IO.dll b/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+win8/System.IO.dll new file mode 100644 index 0000000000000000000000000000000000000000..34975c7cc3ae0655a38c51d24ff14af1077c62f2 GIT binary patch literal 21168 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�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 literal 0 HcmV?d00001 diff --git a/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+win8/System.IO.xml b/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+win8/System.IO.xml new file mode 100644 index 00000000..865aa1a4 --- /dev/null +++ b/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+win8/System.IO.xml @@ -0,0 +1,8 @@ + + + + System.IO + + + + diff --git a/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+win8/System.Runtime.dll b/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+win8/System.Runtime.dll new file mode 100644 index 0000000000000000000000000000000000000000..967bb30a0d84f969455800059b74fae5c24271df GIT binary patch literal 22208 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 QU>aprW%>sEYaZx-0jWNPVE_OC literal 0 HcmV?d00001 diff --git a/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+win8/System.Runtime.xml b/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+win8/System.Runtime.xml new file mode 100644 index 00000000..93cb00d7 --- /dev/null +++ b/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+win8/System.Runtime.xml @@ -0,0 +1,56 @@ + + + + System.Runtime + + + + Defines a provider for progress updates. + The type of progress update value. + + + Reports a progress update. + The value of the updated progress. + + + Identities the async state machine type for this method. + + + Identities the state machine type for this method. + + + Initializes the attribute. + The type that implements the state machine. + + + Gets the type that implements the state machine. + + + Initializes the attribute. + The type that implements the state machine. + + + + Allows you to obtain the method or property name of the caller to the method. + + + + + Allows you to obtain the line number in the source file at which the method is called. + + + + + Allows you to obtain the full path of the source file that contains the caller. + This is the file path at the time of compile. + + + + Identities the iterator state machine type for this method. + + + Initializes the attribute. + The type that implements the state machine. + + + diff --git a/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+win8/System.Threading.Tasks.dll b/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+win8/System.Threading.Tasks.dll new file mode 100644 index 0000000000000000000000000000000000000000..b8f78dafd6ddbae13acf85b07ecf545afb460b32 GIT binary patch literal 34528 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 Hh0y;2j36FU literal 0 HcmV?d00001 diff --git a/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+win8/System.Threading.Tasks.xml b/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+win8/System.Threading.Tasks.xml new file mode 100644 index 00000000..b47921e5 --- /dev/null +++ b/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+win8/System.Threading.Tasks.xml @@ -0,0 +1,475 @@ + + + + System.Threading.Tasks + + + + Holds state related to the builder's IAsyncStateMachine. + This is a mutable struct. Be very delicate with it. + + + A reference to the heap-allocated state machine object associated with this builder. + + + Initiates the builder's execution with the associated state machine. + Specifies the type of the state machine. + The state machine instance, passed by reference. + The argument is null (Nothing in Visual Basic). + + + Associates the builder with the state machine it represents. + The heap-allocated state machine object. + The argument was null (Nothing in Visual Basic). + The builder is incorrectly initialized. + + + + Gets the Action to use with an awaiter's OnCompleted or UnsafeOnCompleted method. + On first invocation, the supplied state machine will be boxed. + + Specifies the type of the method builder used. + Specifies the type of the state machine used. + The builder. + The state machine. + An Action to provide to the awaiter. + + + Provides the ability to invoke a state machine's MoveNext method under a supplied ExecutionContext. + + + The context with which to run MoveNext. + + + The state machine whose MoveNext method should be invoked. + + + Initializes the runner. + The context with which to run MoveNext. + + + Invokes MoveNext under the provided context. + + + Cached delegate used with ExecutionContext.Run. + + + Invokes the MoveNext method on the supplied IAsyncStateMachine. + The IAsyncStateMachine machine instance. + + + Provides a base class used to cache tasks of a specific return type. + Specifies the type of results the cached tasks return. + + + + A singleton cache for this result type. + This may be null if there are no cached tasks for this TResult. + + + + Creates a non-disposable task. + The result for the task. + The cacheable task. + + + Creates a cache. + A task cache for this result type. + + + Gets a cached task if one exists. + The result for which we want a cached task. + A cached task if one exists; otherwise, null. + + + Provides a cache for Boolean tasks. + + + A true task. + + + A false task. + + + Gets a cached task for the Boolean result. + true or false + A cached task for the Boolean result. + + + Provides a cache for zero Int32 tasks. + + + The minimum value, inclusive, for which we want a cached task. + + + The maximum value, exclusive, for which we want a cached task. + + + The cache of Task{Int32}. + + + Creates an array of cached tasks for the values in the range [INCLUSIVE_MIN,EXCLUSIVE_MAX). + + + Gets a cached task for the zero Int32 result. + The integer value + A cached task for the Int32 result or null if not cached. + + + Throws the exception on the ThreadPool. + The exception to propagate. + The target context on which to propagate the exception. Null to use the ThreadPool. + + + Copies the exception's stack trace so its stack trace isn't overwritten. + The exception to prepare. + + + + Provides a builder for asynchronous methods that return . + This type is intended for compiler use only. + + + AsyncTaskMethodBuilder is a value type, and thus it is copied by value. + Prior to being copied, one of its Task, SetResult, or SetException members must be accessed, + or else the copies may end up building distinct Task instances. + + + + Represents an asynchronous method builder. + + + A cached VoidTaskResult task used for builders that complete synchronously. + + + The generic builder object to which this non-generic instance delegates. + + + Initializes a new . + The initialized . + + + Initiates the builder's execution with the associated state machine. + Specifies the type of the state machine. + The state machine instance, passed by reference. + + + Associates the builder with the state machine it represents. + The heap-allocated state machine object. + The argument was null (Nothing in Visual Basic). + The builder is incorrectly initialized. + + + Perform any initialization necessary prior to lifting the builder to the heap. + + + + Schedules the specified state machine to be pushed forward when the specified awaiter completes. + + Specifies the type of the awaiter. + Specifies the type of the state machine. + The awaiter. + The state machine. + + + + Schedules the specified state machine to be pushed forward when the specified awaiter completes. + + Specifies the type of the awaiter. + Specifies the type of the state machine. + The awaiter. + The state machine. + + + + Completes the in the + RanToCompletion state. + + The builder is not initialized. + The task has already completed. + + + + Completes the in the + Faulted state with the specified exception. + + The to use to fault the task. + The argument is null (Nothing in Visual Basic). + The builder is not initialized. + The task has already completed. + + + + Called by the debugger to request notification when the first wait operation + (await, Wait, Result, etc.) on this builder's task completes. + + + true to enable notification; false to disable a previously set notification. + + + + Gets the for this builder. + The representing the builder's asynchronous operation. + The builder is not initialized. + + + + Gets an object that may be used to uniquely identify this builder to the debugger. + + + This property lazily instantiates the ID in a non-thread-safe manner. + It must only be used by the debugger, and only in a single-threaded manner + when no other threads are in the middle of accessing this property or this.Task. + + + + + Provides a builder for asynchronous methods that return . + This type is intended for compiler use only. + + + AsyncTaskMethodBuilder{TResult} is a value type, and thus it is copied by value. + Prior to being copied, one of its Task, SetResult, or SetException members must be accessed, + or else the copies may end up building distinct Task instances. + + + + A cached task for default(TResult). + + + State related to the IAsyncStateMachine. + + + The lazily-initialized task. + Must be named m_task for debugger step-over to work correctly. + + + The lazily-initialized task completion source. + + + Temporary support for disabling crashing if tasks go unobserved. + + + Initializes a new . + The initialized . + + + Initiates the builder's execution with the associated state machine. + Specifies the type of the state machine. + The state machine instance, passed by reference. + + + Associates the builder with the state machine it represents. + The heap-allocated state machine object. + The argument was null (Nothing in Visual Basic). + The builder is incorrectly initialized. + + + Perform any initialization necessary prior to lifting the builder to the heap. + + + + Schedules the specified state machine to be pushed forward when the specified awaiter completes. + + Specifies the type of the awaiter. + Specifies the type of the state machine. + The awaiter. + The state machine. + + + + Schedules the specified state machine to be pushed forward when the specified awaiter completes. + + Specifies the type of the awaiter. + Specifies the type of the state machine. + The awaiter. + The state machine. + + + + Completes the in the + RanToCompletion state with the specified result. + + The result to use to complete the task. + The task has already completed. + + + + Completes the builder by using either the supplied completed task, or by completing + the builder's previously accessed task using default(TResult). + + A task already completed with the value default(TResult). + The task has already completed. + + + + Completes the in the + Faulted state with the specified exception. + + The to use to fault the task. + The argument is null (Nothing in Visual Basic). + The task has already completed. + + + + Called by the debugger to request notification when the first wait operation + (await, Wait, Result, etc.) on this builder's task completes. + + + true to enable notification; false to disable a previously set notification. + + + This should only be invoked from within an asynchronous method, + and only by the debugger. + + + + + Gets a task for the specified result. This will either + be a cached or new task, never null. + + The result for which we need a task. + The completed task containing the result. + + + Gets the lazily-initialized TaskCompletionSource. + + + Gets the for this builder. + The representing the builder's asynchronous operation. + + + + Gets an object that may be used to uniquely identify this builder to the debugger. + + + This property lazily instantiates the ID in a non-thread-safe manner. + It must only be used by the debugger, and only in a single-threaded manner + when no other threads are in the middle of accessing this property or this.Task. + + + + + Provides a builder for asynchronous methods that return void. + This type is intended for compiler use only. + + + + The synchronization context associated with this operation. + + + State related to the IAsyncStateMachine. + + + An object used by the debugger to uniquely identify this builder. Lazily initialized. + + + Temporary support for disabling crashing if tasks go unobserved. + + + Registers with UnobservedTaskException to suppress exception crashing. + + + Non-zero if PreventUnobservedTaskExceptions has already been invoked. + + + Initializes a new . + The initialized . + + + Initializes the . + The synchronizationContext associated with this operation. This may be null. + + + Initiates the builder's execution with the associated state machine. + Specifies the type of the state machine. + The state machine instance, passed by reference. + The argument was null (Nothing in Visual Basic). + + + Associates the builder with the state machine it represents. + The heap-allocated state machine object. + The argument was null (Nothing in Visual Basic). + The builder is incorrectly initialized. + + + Perform any initialization necessary prior to lifting the builder to the heap. + + + + Schedules the specified state machine to be pushed forward when the specified awaiter completes. + + Specifies the type of the awaiter. + Specifies the type of the state machine. + The awaiter. + The state machine. + + + + Schedules the specified state machine to be pushed forward when the specified awaiter completes. + + Specifies the type of the awaiter. + Specifies the type of the state machine. + The awaiter. + The state machine. + + + Completes the method builder successfully. + + + Faults the method builder with an exception. + The exception that is the cause of this fault. + The argument is null (Nothing in Visual Basic). + The builder is not initialized. + + + Notifies the current synchronization context that the operation completed. + + + + Gets an object that may be used to uniquely identify this builder to the debugger. + + + This property lazily instantiates the ID in a non-thread-safe manner. + It must only be used by the debugger and only in a single-threaded manner. + + + + + Represents state machines generated for asynchronous methods. + This type is intended for compiler use only. + + + + Moves the state machine to its next state. + + + Configures the state machine with a heap-allocated replica. + The heap-allocated replica. + + + + Represents an awaiter used to schedule continuations when an await operation completes. + + + + + Represents an operation that will schedule continuations when the operation completes. + + + + Schedules the continuation action to be invoked when the instance completes. + The action to invoke when the operation completes. + The argument is null (Nothing in Visual Basic). + + + Schedules the continuation action to be invoked when the instance completes. + The action to invoke when the operation completes. + The argument is null (Nothing in Visual Basic). + Unlike OnCompleted, UnsafeOnCompleted need not propagate ExecutionContext information. + + + Used with Task(of void) + + + diff --git a/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+win8/ensureRedirect.xml b/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net40+win8/ensureRedirect.xml new file mode 100644 index 00000000..e69de29b diff --git a/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net45+win8+wp8+wpa81/_._ b/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net45+win8+wp8+wpa81/_._ new file mode 100644 index 00000000..e69de29b diff --git a/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net45+win8+wpa81/_._ b/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net45+win8+wpa81/_._ new file mode 100644 index 00000000..e69de29b diff --git a/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net451+win81+wpa81/_._ b/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net451+win81+wpa81/_._ new file mode 100644 index 00000000..e69de29b diff --git a/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net451+win81/_._ b/src/packages/Microsoft.Bcl.1.1.8/lib/portable-net451+win81/_._ new file mode 100644 index 00000000..e69de29b diff --git a/src/packages/Microsoft.Bcl.1.1.8/lib/portable-win81+wp81+wpa81/_._ b/src/packages/Microsoft.Bcl.1.1.8/lib/portable-win81+wp81+wpa81/_._ new file mode 100644 index 00000000..e69de29b diff --git a/src/packages/Microsoft.Bcl.1.1.8/lib/sl4-windowsphone71/System.IO.dll b/src/packages/Microsoft.Bcl.1.1.8/lib/sl4-windowsphone71/System.IO.dll new file mode 100644 index 0000000000000000000000000000000000000000..01edf729d6fd3f62b325ada34491065ecf202911 GIT binary patch literal 22704 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 + + + System.IO + + + + + A strongly-typed resource class, for looking up localized strings, etc. + + + + + Returns the cached ResourceManager instance used by this class. + + + + + Overrides the current thread's CurrentUICulture property for all + resource lookups using this strongly typed resource class. + + + + + Looks up a localized string similar to Found invalid data while decoding.. + + + + + The exception that is thrown when a data stream is in an invalid format. + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class with a specified error message. + + The error message that explains the reason for the exception. + + + + Initializes a new instance of the class with a reference to the inner exception that is the cause of this exception. + The error message that explains the reason for the exception. + The exception that is the cause of the current exception. If the parameter is not null, the current exception is raised in a catch block that handles the inner exception. + + + diff --git a/src/packages/Microsoft.Bcl.1.1.8/lib/sl4-windowsphone71/System.Runtime.dll b/src/packages/Microsoft.Bcl.1.1.8/lib/sl4-windowsphone71/System.Runtime.dll new file mode 100644 index 0000000000000000000000000000000000000000..57e106328f7453b222fa5cb4b6fed358d70d6927 GIT binary patch literal 39104 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 oq_&^^fK??^Uk1% + + + System.Runtime + + + + + A strongly-typed resource class, for looking up localized strings, etc. + + + + + Returns the cached ResourceManager instance used by this class. + + + + + Overrides the current thread's CurrentUICulture property for all + resource lookups using this strongly typed resource class. + + + + + Looks up a localized string similar to Argument must be of type {0}.. + + + + + Looks up a localized string similar to The last element of an eight element tuple must be a Tuple.. + + + + + Defines methods to support the comparison of objects for structural equality. + + + + + Determines whether an object is structurally equal to the current instance. + + The object to compare with the current instance. + An object that determines whether the current instance and other are equal. + true if the two objects are equal; otherwise, false. + + + + Returns a hash code for the current instance. + + An object that computes the hash code of the current object. + The hash code for the current instance. + + + + Supports the structural comparison of collection objects. + + + + + Determines whether the current collection object precedes, occurs in the same position as, or follows another object in the sort order. + + The object to compare with the current instance. + An object that compares members of the current collection object with the corresponding members of other. + An integer that indicates the relationship of the current collection object to other. + + This instance and other are not the same type. + + + + + Encapsulates a method that has five parameters and returns a value of the type specified by the TResult parameter. + + The type of the first parameter of the method that this delegate encapsulates. + The type of the second parameter of the method that this delegate encapsulates. + The type of the third parameter of the method that this delegate encapsulates. + The type of the fourth parameter of the method that this delegate encapsulates. + The type of the fifth parameter of the method that this delegate encapsulates. + The type of the return value of the method that this delegate encapsulates. + The first parameter of the method that this delegate encapsulates. + The second parameter of the method that this delegate encapsulates. + The third parameter of the method that this delegate encapsulates. + The fourth parameter of the method that this delegate encapsulates. + The fifth parameter of the method that this delegate encapsulates. + The return value of the method that this delegate encapsulates. + + + Defines a provider for progress updates. + The type of progress update value. + + + Reports a progress update. + The value of the updated progress. + + + Identities the async state machine type for this method. + + + Identities the state machine type for this method. + + + Initializes the attribute. + The type that implements the state machine. + + + Gets the type that implements the state machine. + + + Initializes the attribute. + The type that implements the state machine. + + + + Allows you to obtain the method or property name of the caller to the method. + + + + + Allows you to obtain the line number in the source file at which the method is called. + + + + + Allows you to obtain the full path of the source file that contains the caller. + This is the file path at the time of compile. + + + + Identities the iterator state machine type for this method. + + + Initializes the attribute. + The type that implements the state machine. + + + + Helper so we can call some tuple methods recursively without knowing the underlying types. + + + + + Provides static methods for creating tuple objects. + + + + + Creates a new 1-tuple, or singleton. + + The type of the only component of the tuple. + The value of the only component of the tuple. + A tuple whose value is (item1). + + + + Creates a new 3-tuple, or pair. + + The type of the first component of the tuple. + The type of the second component of the tuple. + The value of the first component of the tuple. + The value of the second component of the tuple. + An 2-tuple (pair) whose value is (item1, item2). + + + + Creates a new 3-tuple, or triple. + + The type of the first component of the tuple. + The type of the second component of the tuple. + The type of the third component of the tuple. + The value of the first component of the tuple. + The value of the second component of the tuple. + The value of the third component of the tuple. + An 3-tuple (triple) whose value is (item1, item2, item3). + + + + Creates a new 4-tuple, or quadruple. + + The type of the first component of the tuple. + The type of the second component of the tuple. + The type of the third component of the tuple. + The type of the fourth component of the tuple. + The value of the first component of the tuple. + The value of the second component of the tuple. + The value of the third component of the tuple. + The value of the fourth component of the tuple. + An 4-tuple (quadruple) whose value is (item1, item2, item3, item4). + + + + Creates a new 5-tuple, or quintuple. + + The type of the first component of the tuple. + The type of the second component of the tuple. + The type of the third component of the tuple. + The type of the fourth component of the tuple. + The type of the fifth component of the tuple. + The value of the first component of the tuple. + The value of the second component of the tuple. + The value of the third component of the tuple. + The value of the fourth component of the tuple. + The value of the fifth component of the tuple. + An 5-tuple (quintuple) whose value is (item1, item2, item3, item4, item5). + + + + Creates a new 6-tuple, or sextuple. + + The type of the first component of the tuple. + The type of the second component of the tuple. + The type of the third component of the tuple. + The type of the fourth component of the tuple. + The type of the fifth component of the tuple. + The type of the sixth component of the tuple. + The value of the first component of the tuple. + The value of the second component of the tuple. + The value of the third component of the tuple. + The value of the fourth component of the tuple. + The value of the fifth component of the tuple. + The value of the sixth component of the tuple. + An 6-tuple (sextuple) whose value is (item1, item2, item3, item4, item5, item6). + + + + Creates a new 7-tuple, or septuple. + + The type of the first component of the tuple. + The type of the second component of the tuple. + The type of the third component of the tuple. + The type of the fourth component of the tuple. + The type of the fifth component of the tuple. + The type of the sixth component of the tuple. + The type of the seventh component of the tuple. + The value of the first component of the tuple. + The value of the second component of the tuple. + The value of the third component of the tuple. + The value of the fourth component of the tuple. + The value of the fifth component of the tuple. + The value of the sixth component of the tuple. + The value of the seventh component of the tuple. + An 7-tuple (septuple) whose value is (item1, item2, item3, item4, item5, item6, item7). + + + + Creates a new 8-tuple, or octuple. + + The type of the first component of the tuple. + The type of the second component of the tuple. + The type of the third component of the tuple. + The type of the fourth component of the tuple. + The type of the fifth component of the tuple. + The type of the sixth component of the tuple. + The type of the seventh component of the tuple. + The type of the eighth component of the tuple. + The value of the first component of the tuple. + The value of the second component of the tuple. + The value of the third component of the tuple. + The value of the fourth component of the tuple. + The value of the fifth component of the tuple. + The value of the sixth component of the tuple. + The value of the seventh component of the tuple. + The value of the eighth component of the tuple. + An 8-tuple (octuple) whose value is (item1, item2, item3, item4, item5, item6, item7, item8). + + + + Represents a 1-tuple, or singleton. + + The type of the tuple's only component. + + + + Initializes a new instance of the class. + + The value of the current tuple object's single component. + + + + Returns a value that indicates whether the current tuple object is equal to a specified object. + + The object to compare with this instance. + true if the current instance is equal to the specified object; otherwise, false. + + + + Calculates the hash code for the current tuple object. + + A 32-bit signed integer hash code. + + + + Returns a string that represents the value of this tuple instance. + + The string representation of this tuple object. + + + + Gets the value of the tuple object's single component. + + + The value of the current tuple object's single component. + + + + + Represents an 2-tuple, or pair. + + The type of the first component of the tuple. + The type of the second component of the tuple. + + + + Initializes a new instance of the class. + + The value of the first component of the tuple. + The value of the second component of the tuple. + + + + Returns a value that indicates whether the current tuple object is equal to a specified object. + + The object to compare with this instance. + true if the current instance is equal to the specified object; otherwise, false. + + + + Calculates the hash code for the current tuple object. + + A 32-bit signed integer hash code. + + + + Returns a string that represents the value of this tuple instance. + + The string representation of this tuple object. + + + + Gets the value of the current tuple object's first component. + + + The value of the current tuple object's first component. + + + + + Gets the value of the current tuple object's second component. + + + The value of the current tuple object's second component. + + + + + Represents an 3-tuple, or triple. + + The type of the first component of the tuple. + The type of the second component of the tuple. + The type of the third component of the tuple. + + + + Initializes a new instance of the class. + + The value of the first component of the tuple. + The value of the second component of the tuple. + The value of the third component of the tuple. + + + + Returns a value that indicates whether the current tuple object is equal to a specified object. + + The object to compare with this instance. + true if the current instance is equal to the specified object; otherwise, false. + + + + Calculates the hash code for the current tuple object. + + A 32-bit signed integer hash code. + + + + Returns a string that represents the value of this tuple instance. + + The string representation of this tuple object. + + + + Gets the value of the current tuple object's first component. + + + The value of the current tuple object's first component. + + + + + Gets the value of the current tuple object's second component. + + + The value of the current tuple object's second component. + + + + + Gets the value of the current tuple object's third component. + + + The value of the current tuple object's third component. + + + + + Represents an 4-tuple, or quadruple. + + The type of the first component of the tuple. + The type of the second component of the tuple. + The type of the third component of the tuple. + The type of the fourth component of the tuple. + + + + Initializes a new instance of the class. + + The value of the first component of the tuple. + The value of the second component of the tuple. + The value of the third component of the tuple. + The value of the fourth component of the tuple. + + + + Returns a value that indicates whether the current tuple object is equal to a specified object. + + The object to compare with this instance. + true if the current instance is equal to the specified object; otherwise, false. + + + + Calculates the hash code for the current tuple object. + + A 32-bit signed integer hash code. + + + + Returns a string that represents the value of this tuple instance. + + The string representation of this tuple object. + + + + Gets the value of the current tuple object's first component. + + + The value of the current tuple object's first component. + + + + + Gets the value of the current tuple object's second component. + + + The value of the current tuple object's second component. + + + + + Gets the value of the current tuple object's third component. + + + The value of the current tuple object's third component. + + + + + Gets the value of the current tuple object's fourth component. + + + The value of the current tuple object's fourth component. + + + + + Represents an 5-tuple, or quintuple. + + The type of the first component of the tuple. + The type of the second component of the tuple. + The type of the third component of the tuple. + The type of the fourth component of the tuple. + The type of the fifth component of the tuple. + + + + Initializes a new instance of the class. + + The value of the first component of the tuple. + The value of the second component of the tuple. + The value of the third component of the tuple. + The value of the fourth component of the tuple. + The value of the fifth component of the tuple. + + + + Returns a value that indicates whether the current tuple object is equal to a specified object. + + The object to compare with this instance. + true if the current instance is equal to the specified object; otherwise, false. + + + + Calculates the hash code for the current tuple object. + + A 32-bit signed integer hash code. + + + + Returns a string that represents the value of this tuple instance. + + The string representation of this tuple object. + + + + Gets the value of the current tuple object's first component. + + + The value of the current tuple object's first component. + + + + + Gets the value of the current tuple object's second component. + + + The value of the current tuple object's second component. + + + + + Gets the value of the current tuple object's third component. + + + The value of the current tuple object's third component. + + + + + Gets the value of the current tuple object's fourth component. + + + The value of the current tuple object's fourth component. + + + + + Gets the value of the current tuple object's fifth component. + + + The value of the current tuple object's fifth component. + + + + + Represents an 6-tuple, or sextuple. + + The type of the first component of the tuple. + The type of the second component of the tuple. + The type of the third component of the tuple. + The type of the fourth component of the tuple. + The type of the fifth component of the tuple. + The type of the sixth component of the tuple. + + + + Initializes a new instance of the class. + + The value of the first component of the tuple. + The value of the second component of the tuple. + The value of the third component of the tuple. + The value of the fourth component of the tuple. + The value of the fifth component of the tuple. + The value of the sixth component of the tuple. + + + + Returns a value that indicates whether the current tuple object is equal to a specified object. + + The object to compare with this instance. + true if the current instance is equal to the specified object; otherwise, false. + + + + Calculates the hash code for the current tuple object. + + A 32-bit signed integer hash code. + + + + Returns a string that represents the value of this tuple instance. + + The string representation of this tuple object. + + + + Gets the value of the current tuple object's first component. + + + The value of the current tuple object's first component. + + + + + Gets the value of the current tuple object's second component. + + + The value of the current tuple object's second component. + + + + + Gets the value of the current tuple object's third component. + + + The value of the current tuple object's third component. + + + + + Gets the value of the current tuple object's fourth component. + + + The value of the current tuple object's fourth component. + + + + + Gets the value of the current tuple object's fifth component. + + + The value of the current tuple object's fifth component. + + + + + Gets the value of the current tuple object's sixth component. + + + The value of the current tuple object's sixth component. + + + + + Represents an 7-tuple, or septuple. + + The type of the first component of the tuple. + The type of the second component of the tuple. + The type of the third component of the tuple. + The type of the fourth component of the tuple. + The type of the fifth component of the tuple. + The type of the sixth component of the tuple. + The type of the seventh component of the tuple. + + + + Initializes a new instance of the class. + + The value of the first component of the tuple. + The value of the second component of the tuple. + The value of the third component of the tuple. + The value of the fourth component of the tuple. + The value of the fifth component of the tuple. + The value of the sixth component of the tuple. + The value of the seventh component of the tuple. + + + + Returns a value that indicates whether the current tuple object is equal to a specified object. + + The object to compare with this instance. + true if the current instance is equal to the specified object; otherwise, false. + + + + Calculates the hash code for the current tuple object. + + A 32-bit signed integer hash code. + + + + Returns a string that represents the value of this tuple instance. + + The string representation of this tuple object. + + + + Gets the value of the current tuple object's first component. + + + The value of the current tuple object's first component. + + + + + Gets the value of the current tuple object's second component. + + + The value of the current tuple object's second component. + + + + + Gets the value of the current tuple object's third component. + + + The value of the current tuple object's third component. + + + + + Gets the value of the current tuple object's fourth component. + + + The value of the current tuple object's fourth component. + + + + + Gets the value of the current tuple object's fifth component. + + + The value of the current tuple object's fifth component. + + + + + Gets the value of the current tuple object's sixth component. + + + The value of the current tuple object's sixth component. + + + + + Gets the value of the current tuple object's seventh component. + + + The value of the current tuple object's seventh component. + + + + + Represents an n-tuple, where n is 8 or greater. + + The type of the first component of the tuple. + The type of the second component of the tuple. + The type of the third component of the tuple. + The type of the fourth component of the tuple. + The type of the fifth component of the tuple. + The type of the sixth component of the tuple. + The type of the seventh component of the tuple. + Any generic Tuple object that defines the types of the tuple's remaining components. + + + + Initializes a new instance of the class. + + The value of the first component of the tuple. + The value of the second component of the tuple. + The value of the third component of the tuple. + The value of the fourth component of the tuple. + The value of the fifth component of the tuple. + The value of the sixth component of the tuple. + The value of the seventh component of the tuple. + Any generic Tuple object that contains the values of the tuple's remaining components. + + rest is not a generic Tuple object. + + + + + Returns a value that indicates whether the current tuple object is equal to a specified object. + + The object to compare with this instance. + true if the current instance is equal to the specified object; otherwise, false. + + + + Calculates the hash code for the current tuple object. + + A 32-bit signed integer hash code. + + + + Returns a string that represents the value of this tuple instance. + + The string representation of this tuple object. + + + + Gets the value of the current tuple object's first component. + + + The value of the current tuple object's first component. + + + + + Gets the value of the current tuple object's second component. + + + The value of the current tuple object's second component. + + + + + Gets the value of the current tuple object's third component. + + + The value of the current tuple object's third component. + + + + + Gets the value of the current tuple object's fourth component. + + + The value of the current tuple object's fourth component. + + + + + Gets the value of the current tuple object's fifth component. + + + The value of the current tuple object's fifth component. + + + + + Gets the value of the current tuple object's sixth component. + + + The value of the current tuple object's sixth component. + + + + + Gets the value of the current tuple object's seventh component. + + + The value of the current tuple object's seventh component. + + + + + Gets the current tuple object's remaining components. + + + The value of the current tuple object's remaining components. + + + + diff --git a/src/packages/Microsoft.Bcl.1.1.8/lib/sl4-windowsphone71/System.Threading.Tasks.dll b/src/packages/Microsoft.Bcl.1.1.8/lib/sl4-windowsphone71/System.Threading.Tasks.dll new file mode 100644 index 0000000000000000000000000000000000000000..03d08ad93e7cc6f8ae5664b89516ba2010a4f749 GIT binary patch literal 164576 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
    A;XM&re5ZI=Miv% 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 E10+ctx&QzG literal 0 HcmV?d00001 diff --git a/src/packages/Microsoft.Bcl.1.1.8/lib/sl4-windowsphone71/System.Threading.Tasks.xml b/src/packages/Microsoft.Bcl.1.1.8/lib/sl4-windowsphone71/System.Threading.Tasks.xml new file mode 100644 index 00000000..6c770122 --- /dev/null +++ b/src/packages/Microsoft.Bcl.1.1.8/lib/sl4-windowsphone71/System.Threading.Tasks.xml @@ -0,0 +1,8969 @@ + + + + System.Threading.Tasks + + + + Represents one or more errors that occur during application execution. + + is used to consolidate multiple failures into a single, throwable + exception object. + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class with + a specified error message. + + The error message that explains the reason for the exception. + + + + Initializes a new instance of the class with a specified error + message and a reference to the inner exception that is the cause of this exception. + + The error message that explains the reason for the exception. + The exception that is the cause of the current exception. + The argument + is null. + + + + Initializes a new instance of the class with + references to the inner exceptions that are the cause of this exception. + + The exceptions that are the cause of the current exception. + The argument + is null. + An element of is + null. + + + + Initializes a new instance of the class with + references to the inner exceptions that are the cause of this exception. + + The exceptions that are the cause of the current exception. + The argument + is null. + An element of is + null. + + + + Initializes a new instance of the class with a specified error + message and references to the inner exceptions that are the cause of this exception. + + The error message that explains the reason for the exception. + The exceptions that are the cause of the current exception. + The argument + is null. + An element of is + null. + + + + Initializes a new instance of the class with a specified error + message and references to the inner exceptions that are the cause of this exception. + + The error message that explains the reason for the exception. + The exceptions that are the cause of the current exception. + The argument + is null. + An element of is + null. + + + + Allocates a new aggregate exception with the specified message and list of inner exceptions. + + The error message that explains the reason for the exception. + The exceptions that are the cause of the current exception. + The argument + is null. + An element of is + null. + + + + Returns the that is the root cause of this exception. + + + + + Invokes a handler on each contained by this . + + The predicate to execute for each exception. The predicate accepts as an + argument the to be processed and returns a Boolean to indicate + whether the exception was handled. + + Each invocation of the returns true or false to indicate whether the + was handled. After all invocations, if any exceptions went + unhandled, all unhandled exceptions will be put into a new + which will be thrown. Otherwise, the method simply returns. If any + invocations of the throws an exception, it will halt the processing + of any more exceptions and immediately propagate the thrown exception as-is. + + An exception contained by this was not handled. + The argument is + null. + + + + Flattens an instances into a single, new instance. + + A new, flattened . + + If any inner exceptions are themselves instances of + , this method will recursively flatten all of them. The + inner exceptions returned in the new + will be the union of all of the the inner exceptions from exception tree rooted at the provided + instance. + + + + + Creates and returns a string representation of the current . + + A string representation of the current exception. + + + + Gets a read-only collection of the instances that caused the + current exception. + + + + + A strongly-typed resource class, for looking up localized strings, etc. + + + + + Returns the cached ResourceManager instance used by this class. + + + + + Overrides the current thread's CurrentUICulture property for all + resource lookups using this strongly typed resource class. + + + + + Looks up a localized string similar to One or more errors occurred.. + + + + + Looks up a localized string similar to An element of innerExceptions was null.. + + + + + Looks up a localized string similar to {0}{1}---> (Inner Exception #{2}) {3}{4}{5}. + + + + + Looks up a localized string similar to No tokens were supplied.. + + + + + Looks up a localized string similar to The CancellationTokenSource associated with this CancellationToken has been disposed.. + + + + + Looks up a localized string similar to The CancellationTokenSource has been disposed.. + + + + + Looks up a localized string similar to The SyncRoot property may not be used for the synchronization of concurrent collections.. + + + + + Looks up a localized string similar to The array is multidimensional, or the type parameter for the set cannot be cast automatically to the type of the destination array.. + + + + + Looks up a localized string similar to The index is equal to or greater than the length of the array, or the number of elements in the dictionary is greater than the available space from index to the end of the destination array.. + + + + + Looks up a localized string similar to The capacity argument must be greater than or equal to zero.. + + + + + Looks up a localized string similar to The concurrencyLevel argument must be positive.. + + + + + Looks up a localized string similar to The index argument is less than zero.. + + + + + Looks up a localized string similar to TKey is a reference type and item.Key is null.. + + + + + Looks up a localized string similar to The key already existed in the dictionary.. + + + + + Looks up a localized string similar to The source argument contains duplicate keys.. + + + + + Looks up a localized string similar to The key was of an incorrect type for this dictionary.. + + + + + Looks up a localized string similar to The value was of an incorrect type for this dictionary.. + + + + + Looks up a localized string similar to The lazily-initialized type does not have a public, parameterless constructor.. + + + + + Looks up a localized string similar to ValueFactory returned null.. + + + + + Looks up a localized string similar to The spinCount argument must be in the range 0 to {0}, inclusive.. + + + + + Looks up a localized string similar to There are too many threads currently waiting on the event. A maximum of {0} waiting threads are supported.. + + + + + Looks up a localized string similar to The event has been disposed.. + + + + + Looks up a localized string similar to The operation was canceled.. + + + + + Looks up a localized string similar to The condition argument is null.. + + + + + Looks up a localized string similar to The timeout must represent a value between -1 and Int32.MaxValue, inclusive.. + + + + + Looks up a localized string similar to The specified TaskContinuationOptions combined LongRunning and ExecuteSynchronously. Synchronous continuations should not be long running.. + + + + + Looks up a localized string similar to The specified TaskContinuationOptions excluded all continuation kinds.. + + + + + Looks up a localized string similar to (Internal)An attempt was made to create a LongRunning SelfReplicating task.. + + + + + Looks up a localized string similar to The value needs to translate in milliseconds to -1 (signifying an infinite timeout), 0 or a positive integer less than or equal to Int32.MaxValue.. + + + + + Looks up a localized string similar to The value needs to be either -1 (signifying an infinite timeout), 0 or a positive integer.. + + + + + Looks up a localized string similar to A task may only be disposed if it is in a completion state (RanToCompletion, Faulted or Canceled).. + + + + + Looks up a localized string similar to It is invalid to specify TaskCreationOptions.LongRunning in calls to FromAsync.. + + + + + Looks up a localized string similar to It is invalid to specify TaskCreationOptions.PreferFairness in calls to FromAsync.. + + + + + Looks up a localized string similar to It is invalid to specify TaskCreationOptions.SelfReplicating in calls to FromAsync.. + + + + + Looks up a localized string similar to FromAsync was called with a TaskManager that had already shut down.. + + + + + Looks up a localized string similar to The tasks argument contains no tasks.. + + + + + Looks up a localized string similar to It is invalid to exclude specific continuation kinds for continuations off of multiple tasks.. + + + + + Looks up a localized string similar to The tasks argument included a null value.. + + + + + Looks up a localized string similar to RunSynchronously may not be called on a task that was already started.. + + + + + Looks up a localized string similar to RunSynchronously may not be called on a continuation task.. + + + + + Looks up a localized string similar to RunSynchronously may not be called on a task not bound to a delegate, such as the task returned from an asynchronous method.. + + + + + Looks up a localized string similar to RunSynchronously may not be called on a task that has already completed.. + + + + + Looks up a localized string similar to Start may not be called on a task that was already started.. + + + + + Looks up a localized string similar to Start may not be called on a continuation task.. + + + + + Looks up a localized string similar to Start may not be called on a task with null action.. + + + + + Looks up a localized string similar to Start may not be called on a promise-style task.. + + + + + Looks up a localized string similar to Start may not be called on a task that has completed.. + + + + + Looks up a localized string similar to The task has been disposed.. + + + + + Looks up a localized string similar to The tasks array included at least one null element.. + + + + + Looks up a localized string similar to The awaited task has not yet completed.. + + + + + Looks up a localized string similar to A task was canceled.. + + + + + Looks up a localized string similar to The exceptions collection was empty.. + + + + + Looks up a localized string similar to The exceptions collection included at least one null element.. + + + + + Looks up a localized string similar to A Task's exception(s) were not observed either by Waiting on the Task or accessing its Exception property. As a result, the unobserved exception was rethrown by the finalizer thread.. + + + + + Looks up a localized string similar to (Internal)Expected an Exception or an IEnumerable<Exception>. + + + + + Looks up a localized string similar to ExecuteTask may not be called for a task which was already executed.. + + + + + Looks up a localized string similar to ExecuteTask may not be called for a task which was previously queued to a different TaskScheduler.. + + + + + Looks up a localized string similar to The current SynchronizationContext may not be used as a TaskScheduler.. + + + + + Looks up a localized string similar to The TryExecuteTaskInline call to the underlying scheduler succeeded, but the task body was not invoked.. + + + + + Looks up a localized string similar to An exception was thrown by a TaskScheduler.. + + + + + Looks up a localized string similar to It is invalid to specify TaskCreationOptions.SelfReplicating for a Task<TResult>.. + + + + + Looks up a localized string similar to {Not yet computed}. + + + + + Looks up a localized string similar to A task's Exception may only be set directly if the task was created without a function.. + + + + + Looks up a localized string similar to An attempt was made to transition a task to a final state when it had already completed.. + + + + + Represents a thread-safe collection of keys and values. + + The type of the keys in the dictionary. + The type of the values in the dictionary. + + All public and protected members of are thread-safe and may be used + concurrently from multiple threads. + + + + + Initializes a new instance of the + class that is empty, has the default concurrency level, has the default initial capacity, and + uses the default comparer for the key type. + + + + + Initializes a new instance of the + class that is empty, has the specified concurrency level and capacity, and uses the default + comparer for the key type. + + The estimated number of threads that will update the + concurrently. + The initial number of elements that the + can contain. + is + less than 1. + is less than + 0. + + + + Initializes a new instance of the + class that contains elements copied from the specified , has the default concurrency + level, has the default initial capacity, and uses the default comparer for the key type. + + The whose elements are copied to + the new + . + is a null reference + (Nothing in Visual Basic). + contains one or more + duplicate keys. + + + + Initializes a new instance of the + class that is empty, has the specified concurrency level and capacity, and uses the specified + . + + The + implementation to use when comparing keys. + is a null reference + (Nothing in Visual Basic). + + + + Initializes a new instance of the + class that contains elements copied from the specified , has the default concurrency level, has the default + initial capacity, and uses the specified + . + + The whose elements are copied to + the new + . + The + implementation to use when comparing keys. + is a null reference + (Nothing in Visual Basic). -or- + is a null reference (Nothing in Visual Basic). + + + + + Initializes a new instance of the + class that contains elements copied from the specified , + has the specified concurrency level, has the specified initial capacity, and uses the specified + . + + The estimated number of threads that will update the + concurrently. + The whose elements are copied to the new + . + The implementation to use + when comparing keys. + + is a null reference (Nothing in Visual Basic). + -or- + is a null reference (Nothing in Visual Basic). + + + is less than 1. + + contains one or more duplicate keys. + + + + Initializes a new instance of the + class that is empty, has the specified concurrency level, has the specified initial capacity, and + uses the specified . + + The estimated number of threads that will update the + concurrently. + The initial number of elements that the + can contain. + The + implementation to use when comparing keys. + + is less than 1. -or- + is less than 0. + + is a null reference + (Nothing in Visual Basic). + + + + Attempts to add the specified key and value to the . + + The key of the element to add. + The value of the element to add. The value can be a null reference (Nothing + in Visual Basic) for reference types. + true if the key/value pair was added to the + successfully; otherwise, false. + is null reference + (Nothing in Visual Basic). + The + contains too many elements. + + + + Determines whether the contains the specified + key. + + The key to locate in the . + true if the contains an element with + the specified key; otherwise, false. + is a null reference + (Nothing in Visual Basic). + + + + Attempts to remove and return the the value with the specified key from the + . + + The key of the element to remove and return. + When this method returns, contains the object removed from the + or the default value of + if the operation failed. + true if an object was removed successfully; otherwise, false. + is a null reference + (Nothing in Visual Basic). + + + + Removes the specified key from the dictionary if it exists and returns its associated value. + If matchValue flag is set, the key will be removed only if is associated with a particular + value. + + The key to search for and remove if it exists. + The variable into which the removed value, if found, is stored. + Whether removal of the key is conditional on its value. + The conditional value to compare against if is true + + + + + Attempts to get the value associated with the specified key from the . + + The key of the value to get. + When this method returns, contains the object from + the + with the spedified key or the default value of + , if the operation failed. + true if the key was found in the ; + otherwise, false. + is a null reference + (Nothing in Visual Basic). + + + + Compares the existing value for the specified key with a specified value, and if they’re equal, + updates the key with a third value. + + The key whose value is compared with and + possibly replaced. + The value that replaces the value of the element with if the comparison results in equality. + The value that is compared to the value of the element with + . + true if the value with was equal to and replaced with ; otherwise, + false. + is a null + reference. + + + + Removes all keys and values from the . + + + + + Copies the elements of the to an array of + type , starting at the + specified array index. + + The one-dimensional array of type + that is the destination of the elements copied from the . The array must have zero-based indexing. + The zero-based index in at which copying + begins. + is a null reference + (Nothing in Visual Basic). + is less than + 0. + is equal to or greater than + the length of the . -or- The number of elements in the source + is greater than the available space from to the end of the destination + . + + + + Copies the key and value pairs stored in the to a + new array. + + A new array containing a snapshot of key and value pairs copied from the . + + + + Copy dictionary contents to an array - shared implementation between ToArray and CopyTo. + + Important: the caller must hold all locks in m_locks before calling CopyToPairs. + + + + + Copy dictionary contents to an array - shared implementation between ToArray and CopyTo. + + Important: the caller must hold all locks in m_locks before calling CopyToEntries. + + + + + Copy dictionary contents to an array - shared implementation between ToArray and CopyTo. + + Important: the caller must hold all locks in m_locks before calling CopyToObjects. + + + + Returns an enumerator that iterates through the . + An enumerator for the . + + The enumerator returned from the dictionary is safe to use concurrently with + reads and writes to the dictionary, however it does not represent a moment-in-time snapshot + of the dictionary. The contents exposed through the enumerator may contain modifications + made to the dictionary after was called. + + + + + Shared internal implementation for inserts and updates. + If key exists, we always return false; and if updateIfExists == true we force update with value; + If key doesn't exist, we always add value and return true; + + + + + Adds a key/value pair to the + if the key does not already exist. + + The key of the element to add. + The function used to generate a value for the key + is a null reference + (Nothing in Visual Basic). + is a null reference + (Nothing in Visual Basic). + The dictionary contains too many + elements. + The value for the key. This will be either the existing value for the key if the + key is already in the dictionary, or the new value for the key as returned by valueFactory + if the key was not in the dictionary. + + + + Adds a key/value pair to the + if the key does not already exist. + + The key of the element to add. + the value to be added, if the key does not already exist + is a null reference + (Nothing in Visual Basic). + The dictionary contains too many + elements. + The value for the key. This will be either the existing value for the key if the + key is already in the dictionary, or the new value if the key was not in the dictionary. + + + + Adds a key/value pair to the if the key does not already + exist, or updates a key/value pair in the if the key + already exists. + + The key to be added or whose value should be updated + The function used to generate a value for an absent key + The function used to generate a new value for an existing key + based on the key's existing value + is a null reference + (Nothing in Visual Basic). + is a null reference + (Nothing in Visual Basic). + is a null reference + (Nothing in Visual Basic). + The dictionary contains too many + elements. + The new value for the key. This will be either be the result of addValueFactory (if the key was + absent) or the result of updateValueFactory (if the key was present). + + + + Adds a key/value pair to the if the key does not already + exist, or updates a key/value pair in the if the key + already exists. + + The key to be added or whose value should be updated + The value to be added for an absent key + The function used to generate a new value for an existing key based on + the key's existing value + is a null reference + (Nothing in Visual Basic). + is a null reference + (Nothing in Visual Basic). + The dictionary contains too many + elements. + The new value for the key. This will be either be the result of addValueFactory (if the key was + absent) or the result of updateValueFactory (if the key was present). + + + + Adds the specified key and value to the . + + The object to use as the key of the element to add. + The object to use as the value of the element to add. + is a null reference + (Nothing in Visual Basic). + The dictionary contains too many + elements. + + An element with the same key already exists in the . + + + + Removes the element with the specified key from the . + + The key of the element to remove. + true if the element is successfully remove; otherwise false. This method also returns + false if + was not found in the original . + + is a null reference + (Nothing in Visual Basic). + + + + Adds the specified value to the + with the specified key. + + The + structure representing the key and value to add to the . + The of is null. + The + contains too many elements. + An element with the same key already exists in the + + + + + Determines whether the + contains a specific key and value. + + The + structure to locate in the . + true if the is found in the ; otherwise, false. + + + + Removes a key and value from the dictionary. + + The + structure representing the key and value to remove from the . + true if the key and value represented by is successfully + found and removed; otherwise, false. + The Key property of is a null reference (Nothing in Visual Basic). + + + Returns an enumerator that iterates through the . + An enumerator for the . + + The enumerator returned from the dictionary is safe to use concurrently with + reads and writes to the dictionary, however it does not represent a moment-in-time snapshot + of the dictionary. The contents exposed through the enumerator may contain modifications + made to the dictionary after was called. + + + + + Adds the specified key and value to the dictionary. + + The object to use as the key. + The object to use as the value. + is a null reference + (Nothing in Visual Basic). + The dictionary contains too many + elements. + + is of a type that is not assignable to the key type of the . -or- + is of a type that is not assignable to , + the type of values in the . + -or- A value with the same key already exists in the . + + + + + Gets whether the contains an + element with the specified key. + + The key to locate in the . + true if the contains + an element with the specified key; otherwise, false. + is a null reference + (Nothing in Visual Basic). + + + Provides an for the + . + An for the . + + + + Removes the element with the specified key from the . + + The key of the element to remove. + is a null reference + (Nothing in Visual Basic). + + + + Copies the elements of the to an array, starting + at the specified array index. + + The one-dimensional array that is the destination of the elements copied from + the . The array must have zero-based + indexing. + The zero-based index in at which copying + begins. + is a null reference + (Nothing in Visual Basic). + is less than + 0. + is equal to or greater than + the length of the . -or- The number of elements in the source + is greater than the available space from to the end of the destination + . + + + + Replaces the internal table with a larger one. To prevent multiple threads from resizing the + table as a result of races, the table of buckets that was deemed too small is passed in as + an argument to GrowTable(). GrowTable() obtains a lock, and then checks whether the bucket + table has been replaced in the meantime or not. + + Reference to the bucket table that was deemed too small. + + + + Computes the bucket and lock number for a particular key. + + + + + Acquires all locks for this hash table, and increments locksAcquired by the number + of locks that were successfully acquired. The locks are acquired in an increasing + order. + + + + + Acquires a contiguous range of locks for this hash table, and increments locksAcquired + by the number of locks that were successfully acquired. The locks are acquired in an + increasing order. + + + + + Releases a contiguous range of locks. + + + + + Gets a collection containing the keys in the dictionary. + + + + + Gets a collection containing the values in the dictionary. + + + + + A helper method for asserts. + + + + + Get the data array to be serialized + + + + + Construct the dictionary from a previously seiralized one + + + + + Gets or sets the value associated with the specified key. + + The key of the value to get or set. + The value associated with the specified key. If the specified key is not found, a get + operation throws a + , and a set operation creates a new + element with the specified key. + is a null reference + (Nothing in Visual Basic). + The property is retrieved and + + does not exist in the collection. + + + + Gets the number of key/value pairs contained in the . + + The dictionary contains too many + elements. + The number of key/value paris contained in the . + Count has snapshot semantics and represents the number of items in the + at the moment when Count was accessed. + + + + Gets a value that indicates whether the is empty. + + true if the is empty; otherwise, + false. + + + + Gets a collection containing the keys in the . + + An containing the keys in the + . + + + + Gets a collection containing the values in the . + + An containing the values in + the + . + + + + Gets a value indicating whether the dictionary is read-only. + + true if the is + read-only; otherwise, false. For , this property always returns + false. + + + + Gets a value indicating whether the has a fixed size. + + true if the has a + fixed size; otherwise, false. For , this property always + returns false. + + + + Gets a value indicating whether the is read-only. + + true if the is + read-only; otherwise, false. For , this property always + returns false. + + + + Gets an containing the keys of the . + + An containing the keys of the . + + + + Gets an containing the values in the . + + An containing the values in the . + + + + Gets or sets the value associated with the specified key. + + The key of the value to get or set. + The value associated with the specified key, or a null reference (Nothing in Visual Basic) + if is not in the dictionary or is of a type that is + not assignable to the key type of the . + is a null reference + (Nothing in Visual Basic). + + A value is being assigned, and is of a type that is not assignable to the + key type of the . -or- A value is being + assigned, and is of a type that is not assignable to the value type + of the + + + + + Gets a value indicating whether access to the is + synchronized with the SyncRoot. + + true if access to the is synchronized + (thread safe); otherwise, false. For , this property always + returns false. + + + + Gets an object that can be used to synchronize access to the . This property is not supported. + + The SyncRoot property is not supported. + + + + The number of concurrent writes for which to optimize by default. + + + + + A node in a singly-linked list representing a particular hash table bucket. + + + + + A private class to represent enumeration over the dictionary that implements the + IDictionaryEnumerator interface. + + + + Throws the exception on the ThreadPool. + The exception to propagate. + The target context on which to propagate the exception. Null to use the ThreadPool. + + + Copies the exception's stack trace so its stack trace isn't overwritten. + The exception to prepare. + + + + Provides a builder for asynchronous methods that return . + This type is intended for compiler use only. + + + AsyncTaskMethodBuilder is a value type, and thus it is copied by value. + Prior to being copied, one of its Task, SetResult, or SetException members must be accessed, + or else the copies may end up building distinct Task instances. + + + + Represents an asynchronous method builder. + + + A cached VoidTaskResult task used for builders that complete synchronously. + + + The generic builder object to which this non-generic instance delegates. + + + Initializes a new . + The initialized . + + + Initiates the builder's execution with the associated state machine. + Specifies the type of the state machine. + The state machine instance, passed by reference. + + + Associates the builder with the state machine it represents. + The heap-allocated state machine object. + The argument was null (Nothing in Visual Basic). + The builder is incorrectly initialized. + + + Perform any initialization necessary prior to lifting the builder to the heap. + + + + Schedules the specified state machine to be pushed forward when the specified awaiter completes. + + Specifies the type of the awaiter. + Specifies the type of the state machine. + The awaiter. + The state machine. + + + + Schedules the specified state machine to be pushed forward when the specified awaiter completes. + + Specifies the type of the awaiter. + Specifies the type of the state machine. + The awaiter. + The state machine. + + + + Completes the in the + RanToCompletion state. + + The builder is not initialized. + The task has already completed. + + + + Completes the in the + Faulted state with the specified exception. + + The to use to fault the task. + The argument is null (Nothing in Visual Basic). + The builder is not initialized. + The task has already completed. + + + + Called by the debugger to request notification when the first wait operation + (await, Wait, Result, etc.) on this builder's task completes. + + + true to enable notification; false to disable a previously set notification. + + + + Gets the for this builder. + The representing the builder's asynchronous operation. + The builder is not initialized. + + + + Gets an object that may be used to uniquely identify this builder to the debugger. + + + This property lazily instantiates the ID in a non-thread-safe manner. + It must only be used by the debugger, and only in a single-threaded manner + when no other threads are in the middle of accessing this property or this.Task. + + + + Holds state related to the builder's IAsyncStateMachine. + This is a mutable struct. Be very delicate with it. + + + A reference to the heap-allocated state machine object associated with this builder. + + + Initiates the builder's execution with the associated state machine. + Specifies the type of the state machine. + The state machine instance, passed by reference. + The argument is null (Nothing in Visual Basic). + + + Associates the builder with the state machine it represents. + The heap-allocated state machine object. + The argument was null (Nothing in Visual Basic). + The builder is incorrectly initialized. + + + + Gets the Action to use with an awaiter's OnCompleted or UnsafeOnCompleted method. + On first invocation, the supplied state machine will be boxed. + + Specifies the type of the method builder used. + Specifies the type of the state machine used. + The builder. + The state machine. + An Action to provide to the awaiter. + + + Provides the ability to invoke a state machine's MoveNext method under a supplied ExecutionContext. + + + The context with which to run MoveNext. + + + The state machine whose MoveNext method should be invoked. + + + Initializes the runner. + The context with which to run MoveNext. + + + Invokes MoveNext under the provided context. + + + Cached delegate used with ExecutionContext.Run. + + + Invokes the MoveNext method on the supplied IAsyncStateMachine. + The IAsyncStateMachine machine instance. + + + + Provides a builder for asynchronous methods that return void. + This type is intended for compiler use only. + + + + The synchronization context associated with this operation. + + + State related to the IAsyncStateMachine. + + + An object used by the debugger to uniquely identify this builder. Lazily initialized. + + + Temporary support for disabling crashing if tasks go unobserved. + + + Registers with UnobservedTaskException to suppress exception crashing. + + + Non-zero if PreventUnobservedTaskExceptions has already been invoked. + + + Initializes a new . + The initialized . + + + Initializes the . + The synchronizationContext associated with this operation. This may be null. + + + Initiates the builder's execution with the associated state machine. + Specifies the type of the state machine. + The state machine instance, passed by reference. + The argument was null (Nothing in Visual Basic). + + + Associates the builder with the state machine it represents. + The heap-allocated state machine object. + The argument was null (Nothing in Visual Basic). + The builder is incorrectly initialized. + + + Perform any initialization necessary prior to lifting the builder to the heap. + + + + Schedules the specified state machine to be pushed forward when the specified awaiter completes. + + Specifies the type of the awaiter. + Specifies the type of the state machine. + The awaiter. + The state machine. + + + + Schedules the specified state machine to be pushed forward when the specified awaiter completes. + + Specifies the type of the awaiter. + Specifies the type of the state machine. + The awaiter. + The state machine. + + + Completes the method builder successfully. + + + Faults the method builder with an exception. + The exception that is the cause of this fault. + The argument is null (Nothing in Visual Basic). + The builder is not initialized. + + + Notifies the current synchronization context that the operation completed. + + + + Gets an object that may be used to uniquely identify this builder to the debugger. + + + This property lazily instantiates the ID in a non-thread-safe manner. + It must only be used by the debugger and only in a single-threaded manner. + + + + + Provides a builder for asynchronous methods that return . + This type is intended for compiler use only. + + + AsyncTaskMethodBuilder{TResult} is a value type, and thus it is copied by value. + Prior to being copied, one of its Task, SetResult, or SetException members must be accessed, + or else the copies may end up building distinct Task instances. + + + + A cached task for default(TResult). + + + State related to the IAsyncStateMachine. + + + The lazily-initialized task. + Must be named m_task for debugger step-over to work correctly. + + + The lazily-initialized task completion source. + + + Temporary support for disabling crashing if tasks go unobserved. + + + Initializes a new . + The initialized . + + + Initiates the builder's execution with the associated state machine. + Specifies the type of the state machine. + The state machine instance, passed by reference. + + + Associates the builder with the state machine it represents. + The heap-allocated state machine object. + The argument was null (Nothing in Visual Basic). + The builder is incorrectly initialized. + + + Perform any initialization necessary prior to lifting the builder to the heap. + + + + Schedules the specified state machine to be pushed forward when the specified awaiter completes. + + Specifies the type of the awaiter. + Specifies the type of the state machine. + The awaiter. + The state machine. + + + + Schedules the specified state machine to be pushed forward when the specified awaiter completes. + + Specifies the type of the awaiter. + Specifies the type of the state machine. + The awaiter. + The state machine. + + + + Completes the in the + RanToCompletion state with the specified result. + + The result to use to complete the task. + The task has already completed. + + + + Completes the builder by using either the supplied completed task, or by completing + the builder's previously accessed task using default(TResult). + + A task already completed with the value default(TResult). + The task has already completed. + + + + Completes the in the + Faulted state with the specified exception. + + The to use to fault the task. + The argument is null (Nothing in Visual Basic). + The task has already completed. + + + + Called by the debugger to request notification when the first wait operation + (await, Wait, Result, etc.) on this builder's task completes. + + + true to enable notification; false to disable a previously set notification. + + + This should only be invoked from within an asynchronous method, + and only by the debugger. + + + + + Gets a task for the specified result. This will either + be a cached or new task, never null. + + The result for which we need a task. + The completed task containing the result. + + + Gets the lazily-initialized TaskCompletionSource. + + + Gets the for this builder. + The representing the builder's asynchronous operation. + + + + Gets an object that may be used to uniquely identify this builder to the debugger. + + + This property lazily instantiates the ID in a non-thread-safe manner. + It must only be used by the debugger, and only in a single-threaded manner + when no other threads are in the middle of accessing this property or this.Task. + + + + Provides a base class used to cache tasks of a specific return type. + Specifies the type of results the cached tasks return. + + + + A singleton cache for this result type. + This may be null if there are no cached tasks for this TResult. + + + + Creates a non-disposable task. + The result for the task. + The cacheable task. + + + Creates a cache. + A task cache for this result type. + + + Gets a cached task if one exists. + The result for which we want a cached task. + A cached task if one exists; otherwise, null. + + + Provides a cache for Boolean tasks. + + + A true task. + + + A false task. + + + Gets a cached task for the Boolean result. + true or false + A cached task for the Boolean result. + + + Provides a cache for zero Int32 tasks. + + + The minimum value, inclusive, for which we want a cached task. + + + The maximum value, exclusive, for which we want a cached task. + + + The cache of Task{Int32}. + + + Creates an array of cached tasks for the values in the range [INCLUSIVE_MIN,EXCLUSIVE_MAX). + + + Gets a cached task for the zero Int32 result. + The integer value + A cached task for the Int32 result or null if not cached. + + + + Represents state machines generated for asynchronous methods. + This type is intended for compiler use only. + + + + Moves the state machine to its next state. + + + Configures the state machine with a heap-allocated replica. + The heap-allocated replica. + + + + Represents an awaiter used to schedule continuations when an await operation completes. + + + + + Represents an operation that will schedule continuations when the operation completes. + + + + Schedules the continuation action to be invoked when the instance completes. + The action to invoke when the operation completes. + The argument is null (Nothing in Visual Basic). + + + Schedules the continuation action to be invoked when the instance completes. + The action to invoke when the operation completes. + The argument is null (Nothing in Visual Basic). + Unlike OnCompleted, UnsafeOnCompleted need not propagate ExecutionContext information. + + + Used with Task(of void) + + + + An interface similar to the one added in .NET 4.0. + + + + The exception that is thrown in a thread upon cancellation of an operation that the thread was executing. + + + Initializes the exception. + + + Initializes the exception. + The error message that explains the reason for the exception. + + + Initializes the exception. + The error message that explains the reason for the exception. + The exception that is the cause of the current exception. + + + Initializes the exception. + A cancellation token associated with the operation that was canceled. + + + Initializes the exception. + The error message that explains the reason for the exception. + A cancellation token associated with the operation that was canceled. + + + Initializes the exception. + The error message that explains the reason for the exception. + The exception that is the cause of the current exception. + A cancellation token associated with the operation that was canceled. + + + Gets a token associated with the operation that was canceled. + + + + A dummy replacement for the .NET internal class StackCrawlMark. + + + + + Propogates notification that operations should be canceled. + + + + A may be created directly in an unchangeable canceled or non-canceled state + using the CancellationToken's constructors. However, to have a CancellationToken that can change + from a non-canceled to a canceled state, + CancellationTokenSource must be used. + CancellationTokenSource exposes the associated CancellationToken that may be canceled by the source through its + Token property. + + + Once canceled, a token may not transition to a non-canceled state, and a token whose + is false will never change to one that can be canceled. + + + All members of this struct are thread-safe and may be used concurrently from multiple threads. + + + + + + Internal constructor only a CancellationTokenSource should create a CancellationToken + + + + + Initializes the CancellationToken. + + + The canceled state for the token. + + + Tokens created with this constructor will remain in the canceled state specified + by the parameter. If is false, + both and will be false. + If is true, + both and will be true. + + + + + Registers a delegate that will be called when this CancellationToken is canceled. + + + + If this token is already in the canceled state, the + delegate will be run immediately and synchronously. Any exception the delegate generates will be + propogated out of this method call. + + + The delegate to be executed when the CancellationToken is canceled. + The instance that can + be used to deregister the callback. + is null. + The associated CancellationTokenSource has been disposed. + + + + Registers a delegate that will be called when this + CancellationToken is canceled. + + + + If this token is already in the canceled state, the + delegate will be run immediately and synchronously. Any exception the delegate generates will be + propogated out of this method call. + + + The delegate to be executed when the CancellationToken is canceled. + A Boolean value that indicates whether to capture + the current SynchronizationContext and use it + when invoking the . + The instance that can + be used to deregister the callback. + is null. + The associated CancellationTokenSource has been disposed. + + + + Registers a delegate that will be called when this + CancellationToken is canceled. + + + + If this token is already in the canceled state, the + delegate will be run immediately and synchronously. Any exception the delegate generates will be + propogated out of this method call. + + + The delegate to be executed when the CancellationToken is canceled. + The state to pass to the when the delegate is invoked. This may be null. + The instance that can + be used to deregister the callback. + is null. + The associated CancellationTokenSource has been disposed. + + + + Registers a delegate that will be called when this + CancellationToken is canceled. + + + + If this token is already in the canceled state, the + delegate will be run immediately and synchronously. Any exception the delegate generates will be + propogated out of this method call. + + + The delegate to be executed when the CancellationToken is canceled. + The state to pass to the when the delegate is invoked. This may be null. + A Boolean value that indicates whether to capture + the current SynchronizationContext and use it + when invoking the . + The instance that can + be used to deregister the callback. + is null. + The associated CancellationTokenSource has been disposed. + + + + Determines whether the current CancellationToken instance is equal to the + specified token. + + The other CancellationToken to which to compare this + instance. + True if the instances are equal; otherwise, false. Two tokens are equal if they are associated + with the same CancellationTokenSource or if they were both constructed + from public CancellationToken constructors and their values are equal. + + + + Determines whether the current CancellationToken instance is equal to the + specified . + + The other object to which to compare this instance. + True if is a CancellationToken + and if the two instances are equal; otherwise, false. Two tokens are equal if they are associated + with the same CancellationTokenSource or if they were both constructed + from public CancellationToken constructors and their values are equal. + An associated CancellationTokenSource has been disposed. + + + + Serves as a hash function for a CancellationToken. + + A hash code for the current CancellationToken instance. + + + + Determines whether two CancellationToken instances are equal. + + The first instance. + The second instance. + True if the instances are equal; otherwise, false. + An associated CancellationTokenSource has been disposed. + + + + Determines whether two CancellationToken instances are not equal. + + The first instance. + The second instance. + True if the instances are not equal; otherwise, false. + An associated CancellationTokenSource has been disposed. + + + + Throws a OperationCanceledException if + this token has had cancellation requested. + + + This method provides functionality equivalent to: + + if (token.IsCancellationRequested) + throw new OperationCanceledException(token); + + + The token has had cancellation requested. + The associated CancellationTokenSource has been disposed. + + + + Returns an empty CancellationToken value. + + + The value returned by this property will be non-cancelable by default. + + + + + Gets whether cancellation has been requested for this token. + + Whether cancellation has been requested for this token. + + + This property indicates whether cancellation has been requested for this token, + either through the token initially being construted in a canceled state, or through + calling Cancel + on the token's associated . + + + If this property is true, it only guarantees that cancellation has been requested. + It does not guarantee that every registered handler + has finished executing, nor that cancellation requests have finished propagating + to all registered handlers. Additional synchronization may be required, + particularly in situations where related objects are being canceled concurrently. + + + + + + Gets whether this token is capable of being in the canceled state. + + + If CanBeCanceled returns false, it is guaranteed that the token will never transition + into a canceled state, meaning that will never + return true. + + + + + Gets a that is signaled when the token is canceled. + + Accessing this property causes a WaitHandle + to be instantiated. It is preferable to only use this property when necessary, and to then + dispose the associated instance at the earliest opportunity (disposing + the source will dispose of this allocated handle). The handle should not be closed or disposed directly. + + The associated CancellationTokenSource has been disposed. + + + + Represents a callback delegate that has been registered with a CancellationToken. + + + To unregister a callback, dispose the corresponding Registration instance. + + + + + Attempts to deregister the item. If it's already being run, this may fail. + Entails a full memory fence. + + True if the callback was found and deregistered, false otherwise. + + + + Disposes of the registration and unregisters the target callback from the associated + CancellationToken. + If the target callback is currently executing this method will wait until it completes, except + in the degenerate cases where a callback method deregisters itself. + + + + + Determines whether two CancellationTokenRegistration + instances are equal. + + The first instance. + The second instance. + True if the instances are equal; otherwise, false. + + + + Determines whether two CancellationTokenRegistration instances are not equal. + + The first instance. + The second instance. + True if the instances are not equal; otherwise, false. + + + + Determines whether the current CancellationTokenRegistration instance is equal to the + specified . + + The other object to which to compare this instance. + True, if both this and are equal. False, otherwise. + Two CancellationTokenRegistration instances are equal if + they both refer to the output of a single call to the same Register method of a + CancellationToken. + + + + + Determines whether the current CancellationToken instance is equal to the + specified . + + The other CancellationTokenRegistration to which to compare this instance. + True, if both this and are equal. False, otherwise. + Two CancellationTokenRegistration instances are equal if + they both refer to the output of a single call to the same Register method of a + CancellationToken. + + + + + Serves as a hash function for a CancellationTokenRegistration.. + + A hash code for the current CancellationTokenRegistration instance. + + + + Signals to a that it should be canceled. + + + + is used to instantiate a + (via the source's Token property) + that can be handed to operations that wish to be notified of cancellation or that can be used to + register asynchronous operations for cancellation. That token may have cancellation requested by + calling to the source's Cancel + method. + + + All members of this class, except Dispose, are thread-safe and may be used + concurrently from multiple threads. + + + + + The ID of the thread currently executing the main body of CTS.Cancel() + this helps us to know if a call to ctr.Dispose() is running 'within' a cancellation callback. + This is updated as we move between the main thread calling cts.Cancel() and any syncContexts that are used to + actually run the callbacks. + + + + Initializes the . + + + + + Communicates a request for cancellation. + + + + The associated will be + notified of the cancellation and will transition to a state where + IsCancellationRequested returns true. + Any callbacks or cancelable operations + registered with the will be executed. + + + Cancelable operations and callbacks registered with the token should not throw exceptions. + However, this overload of Cancel will aggregate any exceptions thrown into a , + such that one callback throwing an exception will not prevent other registered callbacks from being executed. + + + The that was captured when each callback was registered + will be reestablished when the callback is invoked. + + + An aggregate exception containing all the exceptions thrown + by the registered callbacks on the associated . + This has been disposed. + + + + Communicates a request for cancellation. + + + + The associated will be + notified of the cancellation and will transition to a state where + IsCancellationRequested returns true. + Any callbacks or cancelable operations + registered with the will be executed. + + + Cancelable operations and callbacks registered with the token should not throw exceptions. + If is true, an exception will immediately propagate out of the + call to Cancel, preventing the remaining callbacks and cancelable operations from being processed. + If is false, this overload will aggregate any + exceptions thrown into a , + such that one callback throwing an exception will not prevent other registered callbacks from being executed. + + + The that was captured when each callback was registered + will be reestablished when the callback is invoked. + + + Specifies whether exceptions should immediately propagate. + An aggregate exception containing all the exceptions thrown + by the registered callbacks on the associated . + This has been disposed. + + + + Releases the resources used by this . + + + This method is not thread-safe for any other concurrent calls. + + + + + Throws an exception if the source has been disposed. + + + + + InternalGetStaticSource() + + Whether the source should be set. + A static source to be shared among multiple tokens. + + + + Registers a callback object. If cancellation has already occurred, the + callback will have been run by the time this method returns. + + + + + + + + + + Invoke the Canceled event. + + + The handlers are invoked synchronously in LIFO order. + + + + + Creates a CancellationTokenSource that will be in the canceled state + when any of the source tokens are in the canceled state. + + The first CancellationToken to observe. + The second CancellationToken to observe. + A CancellationTokenSource that is linked + to the source tokens. + A CancellationTokenSource associated with + one of the source tokens has been disposed. + + + + Creates a CancellationTokenSource that will be in the canceled state + when any of the source tokens are in the canceled state. + + The CancellationToken instances to observe. + A CancellationTokenSource that is linked + to the source tokens. + is null. + A CancellationTokenSource associated with + one of the source tokens has been disposed. + + + + Gets whether cancellation has been requested for this CancellationTokenSource. + + Whether cancellation has been requested for this CancellationTokenSource. + + + This property indicates whether cancellation has been requested for this token source, such as + due to a call to its + Cancel method. + + + If this property returns true, it only guarantees that cancellation has been requested. It does not + guarantee that every handler registered with the corresponding token has finished executing, nor + that cancellation requests have finished propagating to all registered handlers. Additional + synchronization may be required, particularly in situations where related objects are being + canceled concurrently. + + + + + + A simple helper to determine whether cancellation has finished. + + + + + A simple helper to determine whether disposal has occured. + + + + + The ID of the thread that is running callbacks. + + + + + Gets the CancellationToken + associated with this . + + The CancellationToken + associated with this . + The token source has been + disposed. + + + + + + + + + + + + + + The currently executing callback + + + + + A helper class for collating the various bits of information required to execute + cancellation callbacks. + + + + + InternalExecuteCallbackSynchronously_GeneralPath + This will be called on the target synchronization context, however, we still need to restore the required execution context + + + + + A sparsely populated array. Elements can be sparse and some null, but this allows for + lock-free additions and growth, and also for constant time removal (by nulling out). + + The kind of elements contained within. + + + + Allocates a new array with the given initial size. + + How many array slots to pre-allocate. + + + + Adds an element in the first available slot, beginning the search from the tail-to-head. + If no slots are available, the array is grown. The method doesn't return until successful. + + The element to add. + Information about where the add happened, to enable O(1) deregistration. + + + + The tail of the doubly linked list. + + + + + A struct to hold a link to the exact spot in an array an element was inserted, enabling + constant time removal later on. + + + + + A fragment of a sparsely populated array, doubly linked. + + The kind of elements contained within. + + + + Provides lazy initialization routines. + + + These routines avoid needing to allocate a dedicated, lazy-initialization instance, instead using + references to ensure targets have been initialized as they are accessed. + + + + + Initializes a target reference type with the type's default constructor if the target has not + already been initialized. + + The refence type of the reference to be initialized. + A reference of type to initialize if it has not + already been initialized. + The initialized reference of type . + Type does not have a default + constructor. + + Permissions to access the constructor of type were missing. + + + + This method may only be used on reference types. To ensure initialization of value + types, see other overloads of EnsureInitialized. + + + This method may be used concurrently by multiple threads to initialize . + In the event that multiple threads access this method concurrently, multiple instances of + may be created, but only one will be stored into . In such an occurrence, this method will not dispose of the + objects that were not stored. If such objects must be disposed, it is up to the caller to determine + if an object was not used and to then dispose of the object appropriately. + + + + + + Initializes a target reference type using the specified function if it has not already been + initialized. + + The reference type of the reference to be initialized. + The reference of type to initialize if it has not + already been initialized. + The invoked to initialize the + reference. + The initialized reference of type . + Type does not have a + default constructor. + returned + null. + + + This method may only be used on reference types, and may + not return a null reference (Nothing in Visual Basic). To ensure initialization of value types or + to allow null reference types, see other overloads of EnsureInitialized. + + + This method may be used concurrently by multiple threads to initialize . + In the event that multiple threads access this method concurrently, multiple instances of + may be created, but only one will be stored into . In such an occurrence, this method will not dispose of the + objects that were not stored. If such objects must be disposed, it is up to the caller to determine + if an object was not used and to then dispose of the object appropriately. + + + + + + Initialize the target using the given delegate (slow path). + + The reference type of the reference to be initialized. + The variable that need to be initialized + The delegate that will be executed to initialize the target + The initialized variable + + + + Initializes a target reference or value type with its default constructor if it has not already + been initialized. + + The type of the reference to be initialized. + A reference or value of type to initialize if it + has not already been initialized. + A reference to a boolean that determines whether the target has already + been initialized. + A reference to an object used as the mutually exclusive lock for initializing + . + The initialized value of type . + + + + Initializes a target reference or value type with a specified function if it has not already been + initialized. + + The type of the reference to be initialized. + A reference or value of type to initialize if it + has not already been initialized. + A reference to a boolean that determines whether the target has already + been initialized. + A reference to an object used as the mutually exclusive lock for initializing + . + The invoked to initialize the + reference or value. + The initialized value of type . + + + + Ensure the target is initialized and return the value (slow path). This overload permits nulls + and also works for value type targets. Uses the supplied function to create the value. + + The type of target. + A reference to the target to be initialized. + A reference to a location tracking whether the target has been initialized. + A reference to a location containing a mutual exclusive lock. + + The to invoke in order to produce the lazily-initialized value. + + The initialized object. + + + + Provides a slimmed down version of . + + + All public and protected members of are thread-safe and may be used + concurrently from multiple threads, with the exception of Dispose, which + must only be used when all other operations on the have + completed, and Reset, which should only be used when no other threads are + accessing the event. + + + + + Initializes a new instance of the + class with an initial state of nonsignaled. + + + + + Initializes a new instance of the + class with a Boolen value indicating whether to set the intial state to signaled. + + true to set the initial state signaled; false to set the initial state + to nonsignaled. + + + + Initializes a new instance of the + class with a Boolen value indicating whether to set the intial state to signaled and a specified + spin count. + + true to set the initial state to signaled; false to set the initial state + to nonsignaled. + The number of spin waits that will occur before falling back to a true + wait. + is less than + 0 or greater than the maximum allowed value. + + + + Initializes the internal state of the event. + + Whether the event is set initially or not. + The spin count that decides when the event will block. + + + + Helper to ensure the lock object is created before first use. + + + + + This method lazily initializes the event object. It uses CAS to guarantee that + many threads racing to call this at once don't result in more than one event + being stored and used. The event will be signaled or unsignaled depending on + the state of the thin-event itself, with synchronization taken into account. + + True if a new event was created and stored, false otherwise. + + + + Sets the state of the event to signaled, which allows one or more threads waiting on the event to + proceed. + + + + + Private helper to actually perform the Set. + + Indicates whether we are calling Set() during cancellation. + The object has been canceled. + + + + Sets the state of the event to nonsignaled, which causes threads to block. + + + Unlike most of the members of , is not + thread-safe and may not be used concurrently with other members of this instance. + + + + + Blocks the current thread until the current is set. + + + The maximum number of waiters has been exceeded. + + + The caller of this method blocks indefinitely until the current instance is set. The caller will + return immediately if the event is currently in a set state. + + + + + Blocks the current thread until the current receives a signal, + while observing a . + + The to + observe. + + The maximum number of waiters has been exceeded. + + was + canceled. + + The caller of this method blocks indefinitely until the current instance is set. The caller will + return immediately if the event is currently in a set state. + + + + + Blocks the current thread until the current is set, using a + to measure the time interval. + + A that represents the number of milliseconds + to wait, or a that represents -1 milliseconds to wait indefinitely. + + true if the was set; otherwise, + false. + is a negative + number other than -1 milliseconds, which represents an infinite time-out -or- timeout is greater + than . + + The maximum number of waiters has been exceeded. + + + + + Blocks the current thread until the current is set, using a + to measure the time interval, while observing a . + + A that represents the number of milliseconds + to wait, or a that represents -1 milliseconds to wait indefinitely. + + The to + observe. + true if the was set; otherwise, + false. + is a negative + number other than -1 milliseconds, which represents an infinite time-out -or- timeout is greater + than . + was canceled. + + The maximum number of waiters has been exceeded. + + + + + Blocks the current thread until the current is set, using a + 32-bit signed integer to measure the time interval. + + The number of milliseconds to wait, or (-1) to wait indefinitely. + true if the was set; otherwise, + false. + is a + negative number other than -1, which represents an infinite time-out. + + The maximum number of waiters has been exceeded. + + + + + Blocks the current thread until the current is set, using a + 32-bit signed integer to measure the time interval, while observing a . + + The number of milliseconds to wait, or (-1) to wait indefinitely. + The to + observe. + true if the was set; otherwise, + false. + is a + negative number other than -1, which represents an infinite time-out. + + The maximum number of waiters has been exceeded. + + was canceled. + + + + Releases all resources used by the current instance of . + + + Unlike most of the members of , is not + thread-safe and may not be used concurrently with other members of this instance. + + + + + When overridden in a derived class, releases the unmanaged resources used by the + , and optionally releases the managed resources. + + true to release both managed and unmanaged resources; + false to release only unmanaged resources. + + Unlike most of the members of , is not + thread-safe and may not be used concurrently with other members of this instance. + + + + + Throw ObjectDisposedException if the MRES is disposed + + + + + Private helper method to wake up waiters when a cancellationToken gets canceled. + + + + + Private helper method for updating parts of a bit-string state value. + Mainly called from the IsSet and Waiters properties setters + + + Note: the parameter types must be int as CompareExchange cannot take a Uint + + The new value + The mask used to set the bits + + + + Private helper method - performs Mask and shift, particular helpful to extract a field from a packed word. + eg ExtractStatePortionAndShiftRight(0x12345678, 0xFF000000, 24) => 0x12, ie extracting the top 8-bits as a simple integer + + ?? is there a common place to put this rather than being private to MRES? + + + + + + + + + Performs a Mask operation, but does not perform the shift. + This is acceptable for boolean values for which the shift is unnecessary + eg (val & Mask) != 0 is an appropriate way to extract a boolean rather than using + ((val & Mask) >> shiftAmount) == 1 + + ?? is there a common place to put this rather than being private to MRES? + + + + + + + Helper function to measure and update the wait time + + The first time (in Ticks) observed when the wait started. + The orginal wait timeoutout in milliseconds. + The new wait time in milliseconds, -1 if the time expired, -2 if overflow in counters + has occurred. + + + + Gets the underlying object for this . + + The underlying event object fore this . + + Accessing this property forces initialization of an underlying event object if one hasn't + already been created. To simply wait on this , + the public Wait methods should be preferred. + + + + + Gets whether the event is set. + + true if the event has is set; otherwise, false. + + + + Gets the number of spin waits that will be occur before falling back to a true wait. + + + + + How many threads are waiting. + + + + + Provides support for spin-based waiting. + + + + encapsulates common spinning logic. On single-processor machines, yields are + always used instead of busy waits, and on computers with Intel™ processors employing Hyper-Threading™ + technology, it helps to prevent hardware thread starvation. SpinWait encapsulates a good mixture of + spinning and true yielding. + + + is a value type, which means that low-level code can utilize SpinWait without + fear of unnecessary allocation overheads. SpinWait is not generally useful for ordinary applications. + In most cases, you should use the synchronization classes provided by the .NET Framework, such as + . For most purposes where spin waiting is required, however, + the type should be preferred over the System.Threading.Thread.SpinWait method. + + + While SpinWait is designed to be used in concurrent applications, it is not designed to be + used from multiple threads concurrently. SpinWait's members are not thread-safe. If multiple + threads must spin, each should use its own instance of SpinWait. + + + + + + Performs a single spin. + + + This is typically called in a loop, and may change in behavior based on the number of times a + has been called thus far on this instance. + + + + + Resets the spin counter. + + + This makes and behave as though no calls + to had been issued on this instance. If a instance + is reused many times, it may be useful to reset it to avoid yielding too soon. + + + + + Spins until the specified condition is satisfied. + + A delegate to be executed over and over until it returns true. + The argument is null. + + + + Spins until the specified condition is satisfied or until the specified timeout is expired. + + A delegate to be executed over and over until it returns true. + + A that represents the number of milliseconds to wait, + or a TimeSpan that represents -1 milliseconds to wait indefinitely. + True if the condition is satisfied within the timeout; otherwise, false + The argument is null. + is a negative number + other than -1 milliseconds, which represents an infinite time-out -or- timeout is greater than + . + + + + Spins until the specified condition is satisfied or until the specified timeout is expired. + + A delegate to be executed over and over until it returns true. + The number of milliseconds to wait, or (-1) to wait indefinitely. + True if the condition is satisfied within the timeout; otherwise, false + The argument is null. + is a + negative number other than -1, which represents an infinite time-out. + + + + Gets the number of times has been called on this instance. + + + + + Gets whether the next call to will yield the processor, triggering a + forced context switch. + + Whether the next call to will yield the processor, triggering a + forced context switch. + + On a single-CPU machine, always yields the processor. On machines with + multiple CPUs, may yield after an unspecified number of calls. + + + + + A helper class to get the number of preocessors, it updates the numbers of processors every sampling interval + + + + + Gets the number of available processors + + + + + Gets whether the current machine has only a single processor. + + + + + Represents an asynchronous operation that produces a result at some time in the future. + + + The type of the result produced by this . + + + + instances may be created in a variety of ways. The most common approach is by + using the task's property to retrieve a instance that can be used to create tasks for several + purposes. For example, to create a that runs a function, the factory's StartNew + method may be used: + + // C# + var t = Task<int>.Factory.StartNew(() => GenerateResult()); + - or - + var t = Task.Factory.StartNew(() => GenerateResult()); + + ' Visual Basic + Dim t = Task<int>.Factory.StartNew(Function() GenerateResult()) + - or - + Dim t = Task.Factory.StartNew(Function() GenerateResult()) + + + + The class also provides constructors that initialize the task but that do not + schedule it for execution. For performance reasons, the StartNew method should be the + preferred mechanism for creating and scheduling computational tasks, but for scenarios where creation + and scheduling must be separated, the constructors may be used, and the task's + Start + method may then be used to schedule the task for execution at a later time. + + + All members of , except for + Dispose, are thread-safe + and may be used from multiple threads concurrently. + + + + + + Represents an asynchronous operation. + + + + instances may be created in a variety of ways. The most common approach is by + using the Task type's property to retrieve a instance that can be used to create tasks for several + purposes. For example, to create a that runs an action, the factory's StartNew + method may be used: + + // C# + var t = Task.Factory.StartNew(() => DoAction()); + + ' Visual Basic + Dim t = Task.Factory.StartNew(Function() DoAction()) + + + + The class also provides constructors that initialize the Task but that do not + schedule it for execution. For performance reasons, TaskFactory's StartNew method should be the + preferred mechanism for creating and scheduling computational tasks, but for scenarios where creation + and scheduling must be separated, the constructors may be used, and the task's + method may then be used to schedule the task for execution at a later time. + + + All members of , except for , are thread-safe + and may be used from multiple threads concurrently. + + + For operations that return values, the class + should be used. + + + For developers implementing custom debuggers, several internal and private members of Task may be + useful (these may change from release to release). The Int32 m_taskId field serves as the backing + store for the property, however accessing this field directly from a debugger may be + more efficient than accessing the same value through the property's getter method (the + s_taskIdCounter Int32 counter is used to retrieve the next available ID for a Task). Similarly, the + Int32 m_stateFlags field stores information about the current lifecycle stage of the Task, + information also accessible through the property. The m_action System.Object + field stores a reference to the Task's delegate, and the m_stateObject System.Object field stores the + async state passed to the Task by the developer. Finally, for debuggers that parse stack frames, the + InternalWait method serves a potential marker for when a Task is entering a wait operation. + + + + + + A type initializer that runs with the appropriate permissions. + + + + + Initializes a new with the specified action. + + The delegate that represents the code to execute in the Task. + The argument is null. + + + + Initializes a new with the specified action and CancellationToken. + + The delegate that represents the code to execute in the Task. + The CancellationToken + that will be assigned to the new Task. + The argument is null. + The provided CancellationToken + has already been disposed. + + + + + Initializes a new with the specified action and creation options. + + The delegate that represents the code to execute in the task. + + The TaskCreationOptions used to + customize the Task's behavior. + + + The argument is null. + + + The argument specifies an invalid value for . + + + + + Initializes a new with the specified action and creation options. + + The delegate that represents the code to execute in the task. + The that will be assigned to the new task. + + The TaskCreationOptions used to + customize the Task's behavior. + + + The argument is null. + + + The argument specifies an invalid value for . + + The provided CancellationToken + has already been disposed. + + + + + Initializes a new with the specified action and state. + + The delegate that represents the code to execute in the task. + An object representing data to be used by the action. + + The argument is null. + + + + + Initializes a new with the specified action, state, snd options. + + The delegate that represents the code to execute in the task. + An object representing data to be used by the action. + The that will be assigned to the new task. + + The argument is null. + + The provided CancellationToken + has already been disposed. + + + + + Initializes a new with the specified action, state, snd options. + + The delegate that represents the code to execute in the task. + An object representing data to be used by the action. + + The TaskCreationOptions used to + customize the Task's behavior. + + + The argument is null. + + + The argument specifies an invalid value for . + + + + + Initializes a new with the specified action, state, snd options. + + The delegate that represents the code to execute in the task. + An object representing data to be used by the action. + The that will be assigned to the new task. + + The TaskCreationOptions used to + customize the Task's behavior. + + + The argument is null. + + + The argument specifies an invalid value for . + + The provided CancellationToken + has already been disposed. + + + + + An internal constructor used by the factory methods on task and its descendent(s). + This variant does not capture the ExecutionContext; it is up to the caller to do that. + + An action to execute. + Optional state to pass to the action. + Parent of Task. + A CancellationToken for the task. + A task scheduler under which the task will run. + Options to control its execution. + Internal options to control its execution + + + + Common logic used by the following internal ctors: + Task() + Task(object action, object state, Task parent, TaskCreationOptions options, TaskScheduler taskScheduler) + + ASSUMES THAT m_creatingTask IS ALREADY SET. + + + Action for task to execute. + Object to which to pass to action (may be null) + Task scheduler on which to run thread (only used by continuation tasks). + A CancellationToken for the Task. + Options to customize behavior of Task. + Internal options to customize behavior of Task. + + + + Checks if we registered a CT callback during construction, and deregisters it. + This should be called when we know the registration isn't useful anymore. Specifically from Finish() if the task has completed + successfully or with an exception. + + + + + Captures the ExecutionContext so long as flow isn't suppressed. + + A stack crawl mark pointing to the frame of the caller. + + + + Internal function that will be called by a new child task to add itself to + the children list of the parent (this). + + Since a child task can only be created from the thread executing the action delegate + of this task, reentrancy is neither required nor supported. This should not be called from + anywhere other than the task construction/initialization codepaths. + + + + + Starts the , scheduling it for execution to the current TaskScheduler. + + + A task may only be started and run only once. Any attempts to schedule a task a second time + will result in an exception. + + + The is not in a valid state to be started. It may have already been started, + executed, or canceled, or it may have been created in a manner that doesn't support direct + scheduling. + + + The instance has been disposed. + + + + + Starts the , scheduling it for execution to the specified TaskScheduler. + + + A task may only be started and run only once. Any attempts to schedule a task a second time will + result in an exception. + + + The TaskScheduler with which to associate + and execute this task. + + + The argument is null. + + + The is not in a valid state to be started. It may have already been started, + executed, or canceled, or it may have been created in a manner that doesn't support direct + scheduling. + + + The instance has been disposed. + + + + + Runs the synchronously on the current TaskScheduler. + + + + A task may only be started and run only once. Any attempts to schedule a task a second time will + result in an exception. + + + Tasks executed with will be associated with the current TaskScheduler. + + + If the target scheduler does not support running this Task on the current thread, the Task will + be scheduled for execution on the scheduler, and the current thread will block until the + Task has completed execution. + + + + The is not in a valid state to be started. It may have already been started, + executed, or canceled, or it may have been created in a manner that doesn't support direct + scheduling. + + + The instance has been disposed. + + + + + Runs the synchronously on the scheduler provided. + + + + A task may only be started and run only once. Any attempts to schedule a task a second time will + result in an exception. + + + If the target scheduler does not support running this Task on the current thread, the Task will + be scheduled for execution on the scheduler, and the current thread will block until the + Task has completed execution. + + + + The is not in a valid state to be started. It may have already been started, + executed, or canceled, or it may have been created in a manner that doesn't support direct + scheduling. + + + The instance has been disposed. + + The parameter + is null. + The scheduler on which to attempt to run this task inline. + + + + Throws an exception if the task has been disposed, and hence can no longer be accessed. + + The task has been disposed. + + + + Sets the internal completion event. + + + + + Disposes the , releasing all of its unmanaged resources. + + + Unlike most of the members of , this method is not thread-safe. + Also, may only be called on a that is in one of + the final states: RanToCompletion, + Faulted, or + Canceled. + + + The exception that is thrown if the is not in + one of the final states: RanToCompletion, + Faulted, or + Canceled. + + + + + Disposes the , releasing all of its unmanaged resources. + + + A Boolean value that indicates whether this method is being called due to a call to . + + + Unlike most of the members of , this method is not thread-safe. + + + + + Schedules the task for execution. + + If true, TASK_STATE_STARTED bit is turned on in + an atomic fashion, making sure that TASK_STATE_CANCELED does not get set + underneath us. If false, TASK_STATE_STARTED bit is OR-ed right in. This + allows us to streamline things a bit for StartNew(), where competing cancellations + are not a problem. + + + + Adds an exception to the list of exceptions this task has thrown. + + An object representing either an Exception or a collection of Exceptions. + + + + Returns a list of exceptions by aggregating the holder's contents. Or null if + no exceptions have been thrown. + + Whether to include a TCE if cancelled. + An aggregate exception, or null if no exceptions have been caught. + + + + Throws an aggregate exception if the task contains exceptions. + + + + + Checks whether this is an attached task, and whether we are being called by the parent task. + And sets the TASK_STATE_EXCEPTIONOBSERVEDBYPARENT status flag based on that. + + This is meant to be used internally when throwing an exception, and when WaitAll is gathering + exceptions for tasks it waited on. If this flag gets set, the implicit wait on children + will skip exceptions to prevent duplication. + + This should only be called when this task has completed with an exception + + + + + + Signals completion of this particular task. + + The bUserDelegateExecuted parameter indicates whether this Finish() call comes following the + full execution of the user delegate. + + If bUserDelegateExecuted is false, it mean user delegate wasn't invoked at all (either due to + a cancellation request, or because this task is a promise style Task). In this case, the steps + involving child tasks (i.e. WaitForChildren) will be skipped. + + + + + + FinishStageTwo is to be executed as soon as we known there are no more children to complete. + It can happen i) either on the thread that originally executed this task (if no children were spawned, or they all completed by the time this task's delegate quit) + ii) or on the thread that executed the last child. + + + + + Final stage of the task completion code path. Notifies the parent (if any) that another of its childre are done, and runs continuations. + This function is only separated out from FinishStageTwo because these two operations are also needed to be called from CancellationCleanupLogic() + + + + + This is called by children of this task when they are completed. + + + + + This is to be called just before the task does its final state transition. + It traverses the list of exceptional children, and appends their aggregate exceptions into this one's exception list + + + + + Special purpose Finish() entry point to be used when the task delegate throws a ThreadAbortedException + This makes a note in the state flags so that we avoid any costly synchronous operations in the finish codepath + such as inlined continuations + + + Indicates whether the ThreadAbortException was added to this task's exception holder. + This should always be true except for the case of non-root self replicating task copies. + + Whether the delegate was executed. + + + + Executes the task. This method will only be called once, and handles bookeeping associated with + self-replicating tasks, in addition to performing necessary exception marshaling. + + The task has already been disposed. + + + + IThreadPoolWorkItem override, which is the entry function for this task when the TP scheduler decides to run it. + + + + + + Outermost entry function to execute this task. Handles all aspects of executing a task on the caller thread. + Currently this is called by IThreadPoolWorkItem.ExecuteWorkItem(), and TaskManager.TryExecuteInline. + + + Performs atomic updates to prevent double execution. Should only be set to true + in codepaths servicing user provided TaskSchedulers. The ConcRT or ThreadPool schedulers don't need this. + + + + The actual code which invokes the body of the task. This can be overriden in derived types. + + + + + Alternate InnerInvoke prototype to be called from ExecuteSelfReplicating() so that + the Parallel Debugger can discover the actual task being invoked. + Details: Here, InnerInvoke is actually being called on the rootTask object while we are actually executing the + childTask. And the debugger needs to discover the childTask, so we pass that down as an argument. + The NoOptimization and NoInlining flags ensure that the childTask pointer is retained, and that this + function appears on the callstack. + + + + + + Performs whatever handling is necessary for an unhandled exception. Normally + this just entails adding the exception to the holder object. + + The exception that went unhandled. + + + + Waits for the to complete execution. + + + The was canceled -or- an exception was thrown during + the execution of the . + + + The has been disposed. + + + + + Waits for the to complete execution. + + + A that represents the number of milliseconds to wait, or a that represents -1 milliseconds to wait indefinitely. + + + true if the completed execution within the allotted time; otherwise, false. + + + The was canceled -or- an exception was thrown during the execution of the . + + + is a negative number other than -1 milliseconds, which represents an + infinite time-out -or- timeout is greater than + . + + + The has been disposed. + + + + + Waits for the to complete execution. + + + A to observe while waiting for the task to complete. + + + The was canceled. + + + The was canceled -or- an exception was thrown during the execution of the . + + + The + has been disposed. + + + + + Waits for the to complete execution. + + + The number of milliseconds to wait, or (-1) to + wait indefinitely. + true if the completed execution within the allotted time; otherwise, + false. + + + is a negative number other than -1, which represents an + infinite time-out. + + + The was canceled -or- an exception was thrown during the execution of the . + + + The + has been disposed. + + + + + Waits for the to complete execution. + + + The number of milliseconds to wait, or (-1) to + wait indefinitely. + + + A to observe while waiting for the task to complete. + + + true if the completed execution within the allotted time; otherwise, false. + + + The was canceled -or- an exception was thrown during the execution of the . + + + The + has been disposed. + + + is a negative number other than -1, which represents an + infinite time-out. + + + The was canceled. + + + + + The core wait function, which is only accesible internally. It's meant to be used in places in TPL code where + the current context is known or cached. + + + + + Cancels the . + + Indiactes whether we should only cancel non-invoked tasks. + For the default scheduler this option will only be serviced through TryDequeue. + For custom schedulers we also attempt an atomic state transition. + true if the task was successfully canceled; otherwise, false. + The + has been disposed. + + + + Sets the task's cancellation acknowledged flag. + + + + + Runs all of the continuations, as appropriate. + + + + + Helper function to determine whether the current task is in the state desired by the + continuation kind under evaluation. Three possibilities exist: the task failed with + an unhandled exception (OnFailed), the task was canceled before running (OnAborted), + or the task completed successfully (OnCompletedSuccessfully). Note that the last + one includes completing due to cancellation. + + The continuation options under evaluation. + True if the continuation should be run given the task's current state. + + + + Creates a continuation that executes when the target completes. + + + An action to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed, whether it completes due to running to completion successfully, faulting due to an + unhandled exception, or exiting out early due to being canceled. + + + The argument is null. + + + The has been disposed. + + + + + Creates a continuation that executes when the target completes. + + + An action to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + The that will be assigned to the new continuation task. + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed, whether it completes due to running to completion successfully, faulting due to an + unhandled exception, or exiting out early due to being canceled. + + + The argument is null. + + + The has been disposed. + + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation that executes when the target completes. + + + An action to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + + The to associate with the continuation task and to use for its execution. + + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed, whether it completes due to running to completion successfully, faulting due to an + unhandled exception, or exiting out early due to being canceled. + + + The argument is null. + + + The argument is null. + + + The has been disposed. + + + + + Creates a continuation that executes when the target completes. + + + An action to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + + Options for when the continuation is scheduled and how it behaves. This includes criteria, such + as OnlyOnCanceled, as + well as execution options, such as ExecuteSynchronously. + + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed. If the continuation criteria specified through the parameter are not met, the continuation task will be canceled + instead of scheduled. + + + The argument is null. + + + The argument specifies an invalid value for TaskContinuationOptions. + + + The has been disposed. + + + + + Creates a continuation that executes when the target completes. + + + An action to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + + Options for when the continuation is scheduled and how it behaves. This includes criteria, such + as OnlyOnCanceled, as + well as execution options, such as ExecuteSynchronously. + + The that will be assigned to the new continuation task. + + The to associate with the continuation task and to use for its + execution. + + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed. If the criteria specified through the parameter + are not met, the continuation task will be canceled instead of scheduled. + + + The argument is null. + + + The argument specifies an invalid value for TaskContinuationOptions. + + + The argument is null. + + + The has been disposed. + + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation that executes when the target completes. + + + The type of the result produced by the continuation. + + + A function to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed, whether it completes due to running to completion successfully, faulting due to an + unhandled exception, or exiting out early due to being canceled. + + + The argument is null. + + + The has been disposed. + + + + + Creates a continuation that executes when the target completes. + + + The type of the result produced by the continuation. + + + A function to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + The that will be assigned to the new continuation task. + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed, whether it completes due to running to completion successfully, faulting due to an + unhandled exception, or exiting out early due to being canceled. + + + The argument is null. + + + The has been disposed. + + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation that executes when the target completes. + + + The type of the result produced by the continuation. + + + A function to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + + The to associate with the continuation task and to use for its execution. + + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed, whether it completes due to running to completion successfully, faulting due to an + unhandled exception, or exiting out early due to being canceled. + + + The argument is null. + + + The argument is null. + + + The has been disposed. + + + + + Creates a continuation that executes when the target completes. + + + The type of the result produced by the continuation. + + + A function to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + + Options for when the continuation is scheduled and how it behaves. This includes criteria, such + as OnlyOnCanceled, as + well as execution options, such as ExecuteSynchronously. + + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed. If the continuation criteria specified through the parameter are not met, the continuation task will be canceled + instead of scheduled. + + + The argument is null. + + + The argument specifies an invalid value for TaskContinuationOptions. + + + The has been disposed. + + + + + Creates a continuation that executes when the target completes. + + + The type of the result produced by the continuation. + + + A function to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + The that will be assigned to the new continuation task. + + Options for when the continuation is scheduled and how it behaves. This includes criteria, such + as OnlyOnCanceled, as + well as execution options, such as ExecuteSynchronously. + + + The to associate with the continuation task and to use for its + execution. + + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed. If the criteria specified through the parameter + are not met, the continuation task will be canceled instead of scheduled. + + + The argument is null. + + + The argument specifies an invalid value for TaskContinuationOptions. + + + The argument is null. + + + The has been disposed. + + The provided CancellationToken + has already been disposed. + + + + + Converts TaskContinuationOptions to TaskCreationOptions, and also does + some validity checking along the way. + + Incoming TaskContinuationOptions + Outgoing TaskCreationOptions + Outgoing InternalTaskOptions + + + + Registers the continuation and possibly runs it (if the task is already finished). + + The continuation task itself. + TaskScheduler with which to associate continuation task. + Restrictions on when the continuation becomes active. + + + + Waits for all of the provided objects to complete execution. + + + An array of instances on which to wait. + + + The argument is null. + + + The argument contains a null element. + + + At least one of the instances was canceled -or- an exception was thrown during + the execution of at least one of the instances. + + + The has been disposed. + + + + + Waits for all of the provided objects to complete execution. + + + true if all of the instances completed execution within the allotted time; + otherwise, false. + + + An array of instances on which to wait. + + + A that represents the number of milliseconds to wait, or a that represents -1 milliseconds to wait indefinitely. + + + The argument is null. + + + The argument contains a null element. + + + At least one of the instances was canceled -or- an exception was thrown during + the execution of at least one of the instances. + + + is a negative number other than -1 milliseconds, which represents an + infinite time-out -or- timeout is greater than + . + + + The has been disposed. + + + + + Waits for all of the provided objects to complete execution. + + + true if all of the instances completed execution within the allotted time; + otherwise, false. + + + The number of milliseconds to wait, or (-1) to + wait indefinitely. + An array of instances on which to wait. + + + The argument is null. + + + The argument contains a null element. + + + At least one of the instances was canceled -or- an exception was thrown during + the execution of at least one of the instances. + + + The has been disposed. + + + is a negative number other than -1, which represents an + infinite time-out. + + + + + Waits for all of the provided objects to complete execution. + + + true if all of the instances completed execution within the allotted time; + otherwise, false. + + + An array of instances on which to wait. + + + A to observe while waiting for the tasks to complete. + + + The argument is null. + + + The argument contains a null element. + + + At least one of the instances was canceled -or- an exception was thrown during + the execution of at least one of the instances. + + + The was canceled. + + + The has been disposed. + + + + + Waits for all of the provided objects to complete execution. + + + true if all of the instances completed execution within the allotted time; + otherwise, false. + + + An array of instances on which to wait. + + + The number of milliseconds to wait, or (-1) to + wait indefinitely. + + + A to observe while waiting for the tasks to complete. + + + The argument is null. + + + The argument contains a null element. + + + At least one of the instances was canceled -or- an exception was thrown during + the execution of at least one of the instances. + + + The has been disposed. + + + is a negative number other than -1, which represents an + infinite time-out. + + + The was canceled. + + + + + Waits for a set of handles in a STA-aware way. In other words, it will wait for each + of the events individually if we're on a STA thread, because MsgWaitForMultipleObjectsEx + can't do a true wait-all due to its hidden message queue event. This is not atomic, + of course, but we only wait on one-way (MRE) events anyway so this is OK. + + An array of wait handles to wait on. + The timeout to use during waits. + The cancellationToken that enables a wait to be canceled. + True if all waits succeeded, false if a timeout occurred. + + + + Internal WaitAll implementation which is meant to be used with small number of tasks, + optimized for Parallel.Invoke and other structured primitives. + + + + + This internal function is only meant to be called by WaitAll() + If the completed task is canceled or it has other exceptions, here we will add those + into the passed in exception list (which will be lazily initialized here). + + + + + Waits for any of the provided objects to complete execution. + + + An array of instances on which to wait. + + The index of the completed task in the array argument. + + The argument is null. + + + The argument contains a null element. + + + The has been disposed. + + + + + Waits for any of the provided objects to complete execution. + + + An array of instances on which to wait. + + + A that represents the number of milliseconds to wait, or a that represents -1 milliseconds to wait indefinitely. + + + The index of the completed task in the array argument, or -1 if the + timeout occurred. + + + The argument is null. + + + The argument contains a null element. + + + The has been disposed. + + + is a negative number other than -1 milliseconds, which represents an + infinite time-out -or- timeout is greater than + . + + + + + Waits for any of the provided objects to complete execution. + + + An array of instances on which to wait. + + + A to observe while waiting for a task to complete. + + + The index of the completed task in the array argument. + + + The argument is null. + + + The argument contains a null element. + + + The has been disposed. + + + The was canceled. + + + + + Waits for any of the provided objects to complete execution. + + + An array of instances on which to wait. + + + The number of milliseconds to wait, or (-1) to + wait indefinitely. + + + The index of the completed task in the array argument, or -1 if the + timeout occurred. + + + The argument is null. + + + The argument contains a null element. + + + The has been disposed. + + + is a negative number other than -1, which represents an + infinite time-out. + + + + + Waits for any of the provided objects to complete execution. + + + An array of instances on which to wait. + + + The number of milliseconds to wait, or (-1) to + wait indefinitely. + + + A to observe while waiting for a task to complete. + + + The index of the completed task in the array argument, or -1 if the + timeout occurred. + + + The argument is null. + + + The argument contains a null element. + + + The has been disposed. + + + is a negative number other than -1, which represents an + infinite time-out. + + + The was canceled. + + + + + Gets a unique ID for this Task instance. + + + Task IDs are assigned on-demand and do not necessarily represent the order in the which Task + instances were created. + + + + + Returns the unique ID of the currently executing Task. + + + + + Gets the Task instance currently executing, or + null if none exists. + + + + + Gets the Exception that caused the Task to end prematurely. If the Task completed successfully or has not yet thrown any + exceptions, this will return null. + + + Tasks that throw unhandled exceptions store the resulting exception and propagate it wrapped in a + in calls to Wait + or in accesses to the property. Any exceptions not observed by the time + the Task instance is garbage collected will be propagated on the finalizer thread. + + + The Task + has been disposed. + + + + + Gets the TaskStatus of this Task. + + + + + Gets whether this Task instance has completed + execution due to being canceled. + + + A Task will complete in Canceled state either if its CancellationToken + was marked for cancellation before the task started executing, or if the task acknowledged the cancellation request on + its already signaled CancellationToken by throwing an + OperationCanceledException2 that bears the same + CancellationToken. + + + + + Returns true if this task has a cancellation token and it was signaled. + To be used internally in execute entry codepaths. + + + + + This internal property provides access to the CancellationToken that was set on the task + when it was constructed. + + + + + Gets whether this threw an OperationCanceledException2 while its CancellationToken was signaled. + + + + + Gets whether this Task has completed. + + + will return true when the Task is in one of the three + final states: RanToCompletion, + Faulted, or + Canceled. + + + + + Checks whether this task has been disposed. + + + + + Gets the TaskCreationOptions used + to create this task. + + + + + Gets a that can be used to wait for the task to + complete. + + + Using the wait functionality provided by + should be preferred over using for similar + functionality. + + + The has been disposed. + + + + + Gets the state object supplied when the Task was created, + or null if none was supplied. + + + + + Gets an indication of whether the asynchronous operation completed synchronously. + + true if the asynchronous operation completed synchronously; otherwise, false. + + + + Provides access to the TaskScheduler responsible for executing this Task. + + + + + Provides access to factory methods for creating and instances. + + + The factory returned from is a default instance + of , as would result from using + the default constructor on TaskFactory. + + + + + Provides an event that can be used to wait for completion. + Only called by Wait*(), which means that we really do need to instantiate a completion event. + + + + + Determines whether this is the root task of a self replicating group. + + + + + Determines whether the task is a replica itself. + + + + + The property formerly known as IsFaulted. + + + + + Gets whether the completed due to an unhandled exception. + + + If is true, the Task's will be equal to + TaskStatus.Faulted, and its + property will be non-null. + + + + + Checks whether the TASK_STATE_EXCEPTIONOBSERVEDBYPARENT status flag is set, + This will only be used by the implicit wait to prevent double throws + + + + + + Checks whether the body was ever invoked. Used by task scheduler code to verify custom schedulers actually ran the task. + + + + + A structure to hold continuation information. + + + + + Constructs a new continuation structure. + + The task to be activated. + The continuation options. + The scheduler to use for the continuation. + + + + Invokes the continuation for the target completion task. + + The completed task. + Whether the continuation can be inlined. + + + + Initializes a new with the specified function. + + + The delegate that represents the code to execute in the task. When the function has completed, + the task's property will be set to return the result value of the function. + + + The argument is null. + + + + + Initializes a new with the specified function. + + + The delegate that represents the code to execute in the task. When the function has completed, + the task's property will be set to return the result value of the function. + + The to be assigned to this task. + + The argument is null. + + The provided CancellationToken + has already been disposed. + + + + + Initializes a new with the specified function and creation options. + + + The delegate that represents the code to execute in the task. When the function has completed, + the task's property will be set to return the result value of the function. + + + The TaskCreationOptions used to + customize the task's behavior. + + + The argument is null. + + + The argument specifies an invalid value for . + + + + + Initializes a new with the specified function and creation options. + + + The delegate that represents the code to execute in the task. When the function has completed, + the task's property will be set to return the result value of the function. + + The that will be assigned to the new task. + + The TaskCreationOptions used to + customize the task's behavior. + + + The argument is null. + + + The argument specifies an invalid value for . + + The provided CancellationToken + has already been disposed. + + + + + Initializes a new with the specified function and state. + + + The delegate that represents the code to execute in the task. When the function has completed, + the task's property will be set to return the result value of the function. + + An object representing data to be used by the action. + + The argument is null. + + + + + Initializes a new with the specified action, state, and options. + + + The delegate that represents the code to execute in the task. When the function has completed, + the task's property will be set to return the result value of the function. + + An object representing data to be used by the function. + The to be assigned to the new task. + + The argument is null. + + The provided CancellationToken + has already been disposed. + + + + + Initializes a new with the specified action, state, and options. + + + The delegate that represents the code to execute in the task. When the function has completed, + the task's property will be set to return the result value of the function. + + An object representing data to be used by the function. + + The TaskCreationOptions used to + customize the task's behavior. + + + The argument is null. + + + The argument specifies an invalid value for . + + + + + Initializes a new with the specified action, state, and options. + + + The delegate that represents the code to execute in the task. When the function has completed, + the task's property will be set to return the result value of the function. + + An object representing data to be used by the function. + The to be assigned to the new task. + + The TaskCreationOptions used to + customize the task's behavior. + + + The argument is null. + + + The argument specifies an invalid value for . + + The provided CancellationToken + has already been disposed. + + + + + Creates a new future object. + + The parent task for this future. + A function that yields the future value. + The task scheduler which will be used to execute the future. + The CancellationToken for the task. + Options to control the future's behavior. + Internal options to control the future's behavior. + The argument specifies + a SelfReplicating , which is illegal."/>. + + + + Creates a new future object. + + The parent task for this future. + An object containing data to be used by the action; may be null. + A function that yields the future value. + The CancellationToken for the task. + The task scheduler which will be used to execute the future. + Options to control the future's behavior. + Internal options to control the future's behavior. + The argument specifies + a SelfReplicating , which is illegal."/>. + + + + Evaluates the value selector of the Task which is passed in as an object and stores the result. + + + + + Creates a continuation that executes when the target completes. + + + An action to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed, whether it completes due to running to completion successfully, faulting due to an + unhandled exception, or exiting out early due to being canceled. + + + The argument is null. + + + The has been disposed. + + + + + Creates a continuation that executes when the target completes. + + + An action to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + The that will be assigned to the new continuation task. + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed, whether it completes due to running to completion successfully, faulting due to an + unhandled exception, or exiting out early due to being canceled. + + + The argument is null. + + + The has been disposed. + + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation that executes when the target completes. + + + An action to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + + The to associate with the continuation task and to use for its execution. + + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed, whether it completes due to running to completion successfully, faulting due to an + unhandled exception, or exiting out early due to being canceled. + + + The argument is null. + + + The argument is null. + + + The has been disposed. + + + + + Creates a continuation that executes when the target completes. + + + An action to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + + Options for when the continuation is scheduled and how it behaves. This includes criteria, such + as OnlyOnCanceled, as + well as execution options, such as ExecuteSynchronously. + + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed. If the continuation criteria specified through the parameter are not met, the continuation task will be canceled + instead of scheduled. + + + The argument is null. + + + The argument specifies an invalid value for TaskContinuationOptions. + + + The has been disposed. + + + + + Creates a continuation that executes when the target completes. + + + An action to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + The that will be assigned to the new continuation task. + + Options for when the continuation is scheduled and how it behaves. This includes criteria, such + as OnlyOnCanceled, as + well as execution options, such as ExecuteSynchronously. + + + The to associate with the continuation task and to use for its + execution. + + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed. If the criteria specified through the parameter + are not met, the continuation task will be canceled instead of scheduled. + + + The argument is null. + + + The argument specifies an invalid value for TaskContinuationOptions. + + + The argument is null. + + + The has been disposed. + + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation that executes when the target completes. + + + The type of the result produced by the continuation. + + + A function to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + A new continuation . + + The returned will not be scheduled for execution until the current + task has completed, whether it completes due to running to completion successfully, faulting due + to an unhandled exception, or exiting out early due to being canceled. + + + The argument is null. + + + The has been disposed. + + + + + Creates a continuation that executes when the target completes. + + + The type of the result produced by the continuation. + + + A function to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + The that will be assigned to the new task. + A new continuation . + + The returned will not be scheduled for execution until the current + task has completed, whether it completes due to running to completion successfully, faulting due + to an unhandled exception, or exiting out early due to being canceled. + + + The argument is null. + + + The has been disposed. + + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation that executes when the target completes. + + + The type of the result produced by the continuation. + + + A function to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + + The to associate with the continuation task and to use for its execution. + + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed, whether it completes due to running to completion successfully, faulting due to an + unhandled exception, or exiting out early due to being canceled. + + + The argument is null. + + + The argument is null. + + + The has been disposed. + + + + + Creates a continuation that executes when the target completes. + + + The type of the result produced by the continuation. + + + A function to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + + Options for when the continuation is scheduled and how it behaves. This includes criteria, such + as OnlyOnCanceled, as + well as execution options, such as ExecuteSynchronously. + + A new continuation . + + + The returned will not be scheduled for execution until the current + task has completed, whether it completes due to running to completion successfully, faulting due + to an unhandled exception, or exiting out early due to being canceled. + + + The , when executed, should return a . This task's completion state will be transferred to the task returned + from the ContinueWith call. + + + + The argument is null. + + + The argument specifies an invalid value for TaskContinuationOptions. + + + The has been disposed. + + + + + Creates a continuation that executes when the target completes. + + + The type of the result produced by the continuation. + + + A function to run when the completes. When run, the delegate will be passed as + an argument this completed task. + + The that will be assigned to the new task. + + Options for when the continuation is scheduled and how it behaves. This includes criteria, such + as OnlyOnCanceled, as + well as execution options, such as ExecuteSynchronously. + + + The to associate with the continuation task and to use for its + execution. + + A new continuation . + + + The returned will not be scheduled for execution until the current task has + completed, whether it completes due to running to completion successfully, faulting due to an + unhandled exception, or exiting out early due to being canceled. + + + The , when executed, should return a . + This task's completion state will be transferred to the task returned from the + ContinueWith call. + + + + The argument is null. + + + The argument specifies an invalid value for TaskContinuationOptions. + + + The argument is null. + + + The has been disposed. + + The provided CancellationToken + has already been disposed. + + + + + Gets the result value of this . + + + The get accessor for this property ensures that the asynchronous operation is complete before + returning. Once the result of the computation is available, it is stored and will be returned + immediately on later calls to . + + + + + Provides access to factory methods for creating instances. + + + The factory returned from is a default instance + of , as would result from using + the default constructor on the factory type. + + + + + Provides support for creating and scheduling + Task{TResult} objects. + + The type of the results that are available though + the Task{TResult} objects that are associated with + the methods in this class. + + + There are many common patterns for which tasks are relevant. The + class encodes some of these patterns into methods that pick up default settings, which are + configurable through its constructors. + + + A default instance of is available through the + Task{TResult}.Factory property. + + + + + + Initializes a instance with the default configuration. + + + This constructor creates a instance with a default configuration. The + property is initialized to + TaskCreationOptions.None, the + property is initialized to TaskContinuationOptions.None, + and the TaskScheduler property is + initialized to the current scheduler (see TaskScheduler.Current). + + + + + Initializes a instance with the default configuration. + + The default that will be assigned + to tasks created by this unless another CancellationToken is explicitly specified + while calling the factory methods. + + This constructor creates a instance with a default configuration. The + property is initialized to + TaskCreationOptions.None, the + property is initialized to TaskContinuationOptions.None, + and the TaskScheduler property is + initialized to the current scheduler (see TaskScheduler.Current). + + + + + Initializes a instance with the specified configuration. + + + The + TaskScheduler to use to schedule any tasks created with this TaskFactory{TResult}. A null value + indicates that the current TaskScheduler should be used. + + + With this constructor, the + property is initialized to + TaskCreationOptions.None, the + property is initialized to TaskContinuationOptions.None, + and the TaskScheduler property is + initialized to , unless it's null, in which case the property is + initialized to the current scheduler (see TaskScheduler.Current). + + + + + Initializes a instance with the specified configuration. + + + The default + TaskCreationOptions to use when creating tasks with this TaskFactory{TResult}. + + + The default + TaskContinuationOptions to use when creating continuation tasks with this TaskFactory{TResult}. + + + The exception that is thrown when the + argument or the + argument specifies an invalid value. + + + With this constructor, the + property is initialized to , + the + property is initialized to , and the TaskScheduler property is initialized to the + current scheduler (see TaskScheduler.Current). + + + + + Initializes a instance with the specified configuration. + + The default that will be assigned + to tasks created by this unless another CancellationToken is explicitly specified + while calling the factory methods. + + The default + TaskCreationOptions to use when creating tasks with this TaskFactory{TResult}. + + + The default + TaskContinuationOptions to use when creating continuation tasks with this TaskFactory{TResult}. + + + The default + TaskScheduler to use to schedule any Tasks created with this TaskFactory{TResult}. A null value + indicates that TaskScheduler.Current should be used. + + + The exception that is thrown when the + argument or the + argumentspecifies an invalid value. + + + With this constructor, the + property is initialized to , + the + property is initialized to , and the TaskScheduler property is initialized to + , unless it's null, in which case the property is initialized to the + current scheduler (see TaskScheduler.Current). + + + + + Creates and starts a . + + A function delegate that returns the future result to be available through + the . + The started . + The exception that is thrown when the + argument is null. + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + A function delegate that returns the future result to be available through + the . + The that will be assigned to the new task. + The started . + The exception that is thrown when the + argument is null. + The provided CancellationToken + has already been disposed. + + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + A function delegate that returns the future result to be available through + the . + A TaskCreationOptions value that controls the behavior of the + created + . + The started . + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + A function delegate that returns the future result to be available through + the . + A TaskCreationOptions value that controls the behavior of the + created + . + The that will be assigned to the new task. + The TaskScheduler + that is used to schedule the created + Task{TResult}. + The started . + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The provided CancellationToken + has already been disposed. + + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + A function delegate that returns the future result to be available through + the . + An object containing data to be used by the + delegate. + The started . + The exception that is thrown when the + argument is null. + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + A function delegate that returns the future result to be available through + the . + An object containing data to be used by the + delegate. + The that will be assigned to the new task. + The started . + The exception that is thrown when the + argument is null. + The provided CancellationToken + has already been disposed. + + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + A function delegate that returns the future result to be available through + the . + An object containing data to be used by the + delegate. + A TaskCreationOptions value that controls the behavior of the + created + . + The started . + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + A function delegate that returns the future result to be available through + the . + An object containing data to be used by the + delegate. + The that will be assigned to the new task. + A TaskCreationOptions value that controls the behavior of the + created + . + The TaskScheduler + that is used to schedule the created + Task{TResult}. + The started . + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The provided CancellationToken + has already been disposed. + + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates a Task that executes an end + method function when a specified IAsyncResult completes. + + The IAsyncResult whose completion should trigger the processing of the + . + The function delegate that processes the completed . + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + A Task that represents the + asynchronous operation. + + + + Creates a Task that executes an end + method function when a specified IAsyncResult completes. + + The IAsyncResult whose completion should trigger the processing of the + . + The function delegate that processes the completed . + The TaskCreationOptions value that controls the behavior of the + created Task. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + A Task that represents the + asynchronous operation. + + + + Creates a Task that executes an end + method function when a specified IAsyncResult completes. + + The IAsyncResult whose completion should trigger the processing of the + . + The function delegate that processes the completed . + The TaskScheduler + that is used to schedule the task that executes the end method. + The TaskCreationOptions value that controls the behavior of the + created Task. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + A Task that represents the + asynchronous operation. + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The TaskCreationOptions value that controls the behavior of the + created Task. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The TaskCreationOptions value that controls the behavior of the + created Task. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the delegate. + The type of the second argument passed to + delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The second argument passed to the + delegate. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the delegate. + The type of the second argument passed to + delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The second argument passed to the + delegate. + The TaskCreationOptions value that controls the behavior of the + created Task. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the delegate. + The type of the second argument passed to + delegate. + The type of the third argument passed to + delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The second argument passed to the + delegate. + The third argument passed to the + delegate. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the delegate. + The type of the second argument passed to + delegate. + The type of the third argument passed to + delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The second argument passed to the + delegate. + The third argument passed to the + delegate. + The TaskCreationOptions value that controls the behavior of the + created Task. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The array of tasks from which to continue. + The function delegate to execute when all tasks in + the array have completed. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The array of tasks from which to continue. + The function delegate to execute when all tasks in + the array have completed. + The CancellationToken + that will be assigned to the new continuation task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The array of tasks from which to continue. + The function delegate to execute when all tasks in the array have completed. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAll. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The array of tasks from which to continue. + The function delegate to execute when all tasks in the array have completed. + The CancellationToken + that will be assigned to the new continuation task. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The TaskScheduler + that is used to schedule the created continuation Task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAll. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result of the antecedent . + The array of tasks from which to continue. + The function delegate to execute when all tasks in the + array have completed. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result of the antecedent . + The array of tasks from which to continue. + The function delegate to execute when all tasks in the + array have completed. + The CancellationToken + that will be assigned to the new continuation task. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result of the antecedent . + The array of tasks from which to continue. + The function delegate to execute when all tasks in the + array have completed. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAll. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result of the antecedent . + The array of tasks from which to continue. + The function delegate to execute when all tasks in the + array have completed. + The CancellationToken + that will be assigned to the new continuation task. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The TaskScheduler + that is used to schedule the created continuation . + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAll. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the array completes. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the array completes. + The CancellationToken + that will be assigned to the new continuation task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the array completes. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAny. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the array completes. + The CancellationToken + that will be assigned to the new continuation task. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The TaskScheduler + that is used to schedule the created continuation Task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAny. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result of the antecedent . + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the + array completes. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result of the antecedent . + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the + array completes. + The CancellationToken + that will be assigned to the new continuation task. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result of the antecedent . + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the + array completes. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAny. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result of the antecedent . + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the + array completes. + The CancellationToken + that will be assigned to the new continuation task. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The TaskScheduler + that is used to schedule the created continuation . + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAny. + + + + + Gets the default CancellationToken of this + TaskFactory. + + + This property returns the default that will be assigned to all + tasks created by this factory unless another CancellationToken value is explicitly specified + during the call to the factory methods. + + + + + Gets the TaskScheduler of this + TaskFactory{TResult}. + + + This property returns the default scheduler for this factory. It will be used to schedule all + tasks unless another scheduler is explicitly specified during calls to this factory's methods. + If null, TaskScheduler.Current + will be used. + + + + + Gets the TaskCreationOptions + value of this TaskFactory{TResult}. + + + This property returns the default creation options for this factory. They will be used to create all + tasks unless other options are explicitly specified during calls to this factory's methods. + + + + + Gets the TaskContinuationOptions + value of this TaskFactory{TResult}. + + + This property returns the default continuation options for this factory. They will be used to create + all continuation tasks unless other options are explicitly specified during calls to this factory's methods. + + + + + Represents the current stage in the lifecycle of a . + + + + + The task has been initialized but has not yet been scheduled. + + + + + The task is waiting to be activated and scheduled internally by the .NET Framework infrastructure. + + + + + The task has been scheduled for execution but has not yet begun executing. + + + + + The task is running but has not yet completed. + + + + + The task has finished executing and is implicitly waiting for + attached child tasks to complete. + + + + + The task completed execution successfully. + + + + + The task acknowledged cancellation by throwing an OperationCanceledException2 with its own CancellationToken + while the token was in signaled state, or the task's CancellationToken was already signaled before the + task started executing. + + + + + The task completed due to an unhandled exception. + + + + + Specifies flags that control optional behavior for the creation and execution of tasks. + + + + + Specifies that the default behavior should be used. + + + + + A hint to a TaskScheduler to schedule a + task in as fair a manner as possible, meaning that tasks scheduled sooner will be more likely to + be run sooner, and tasks scheduled later will be more likely to be run later. + + + + + Specifies that a task will be a long-running, course-grained operation. It provides a hint to the + TaskScheduler that oversubscription may be + warranted. + + + + + Specifies that a task is attached to a parent in the task hierarchy. + + + + + Task creation flags which are only used internally. + + + + Specifies "No internal task options" + + + Used to filter out internal vs. public task creation options. + + + Specifies that the task will be queued by the runtime before handing it over to the user. + This flag will be used to skip the cancellationtoken registration step, which is only meant for unstarted tasks. + + + + Specifies flags that control optional behavior for the creation and execution of continuation tasks. + + + + + Default = "Continue on any, no task options, run asynchronously" + Specifies that the default behavior should be used. Continuations, by default, will + be scheduled when the antecedent task completes, regardless of the task's final TaskStatus. + + + + + A hint to a TaskScheduler to schedule a + task in as fair a manner as possible, meaning that tasks scheduled sooner will be more likely to + be run sooner, and tasks scheduled later will be more likely to be run later. + + + + + Specifies that a task will be a long-running, course-grained operation. It provides + a hint to the TaskScheduler that + oversubscription may be warranted. + + + + + Specifies that a task is attached to a parent in the task hierarchy. + + + + + Specifies that the continuation task should not be scheduled if its antecedent ran to completion. + This option is not valid for multi-task continuations. + + + + + Specifies that the continuation task should not be scheduled if its antecedent threw an unhandled + exception. This option is not valid for multi-task continuations. + + + + + Specifies that the continuation task should not be scheduled if its antecedent was canceled. This + option is not valid for multi-task continuations. + + + + + Specifies that the continuation task should be scheduled only if its antecedent ran to + completion. This option is not valid for multi-task continuations. + + + + + Specifies that the continuation task should be scheduled only if its antecedent threw an + unhandled exception. This option is not valid for multi-task continuations. + + + + + Specifies that the continuation task should be scheduled only if its antecedent was canceled. + This option is not valid for multi-task continuations. + + + + + Specifies that the continuation task should be executed synchronously. With this option + specified, the continuation will be run on the same thread that causes the antecedent task to + transition into its final state. If the antecedent is already complete when the continuation is + created, the continuation will run on the thread creating the continuation. Only very + short-running continuations should be executed synchronously. + + + + + Represents an exception used to communicate task cancellation. + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the + class with a specified error message. + + The error message that explains the reason for the exception. + + + + Initializes a new instance of the + class with a specified error message and a reference to the inner exception that is the cause of + this exception. + + The error message that explains the reason for the exception. + The exception that is the cause of the current exception. + + + + Initializes a new instance of the class + with a reference to the that has been canceled. + + A task that has been canceled. + + + + Gets the task associated with this exception. + + + It is permissible for no Task to be associated with a + , in which case + this property will return null. + + + + + Represents the producer side of a unbound to a + delegate, providing access to the consumer side through the property. + + + + It is often the case that a is desired to + represent another asynchronous operation. + TaskCompletionSource is provided for this purpose. It enables + the creation of a task that can be handed out to consumers, and those consumers can use the members + of the task as they would any other. However, unlike most tasks, the state of a task created by a + TaskCompletionSource is controlled explicitly by the methods on TaskCompletionSource. This enables the + completion of the external asynchronous operation to be propagated to the underlying Task. The + separation also ensures that consumers are not able to transition the state without access to the + corresponding TaskCompletionSource. + + + All members of are thread-safe + and may be used from multiple threads concurrently. + + + The type of the result value assocatied with this . + + + + Creates a . + + + + + Creates a + with the specified options. + + + The created + by this instance and accessible through its property + will be instantiated using the specified . + + The options to use when creating the underlying + . + + The represent options invalid for use + with a . + + + + + Creates a + with the specified state. + + The state to use as the underlying + 's AsyncState. + + + + Creates a with + the specified state and options. + + The options to use when creating the underlying + . + The state to use as the underlying + 's AsyncState. + + The represent options invalid for use + with a . + + + + + Attempts to transition the underlying + into the + Faulted + state. + + The exception to bind to this . + True if the operation was successful; otherwise, false. + This operation will return false if the + is already in one + of the three final states: + RanToCompletion, + Faulted, or + Canceled. + + The argument is null. + The was disposed. + + + + Attempts to transition the underlying + into the + Faulted + state. + + The collection of exceptions to bind to this . + True if the operation was successful; otherwise, false. + This operation will return false if the + is already in one + of the three final states: + RanToCompletion, + Faulted, or + Canceled. + + The argument is null. + There are one or more null elements in . + The collection is empty. + The was disposed. + + + + Transitions the underlying + into the + Faulted + state. + + The exception to bind to this . + The argument is null. + + The underlying is already in one + of the three final states: + RanToCompletion, + Faulted, or + Canceled. + + The was disposed. + + + + Transitions the underlying + into the + Faulted + state. + + The collection of exceptions to bind to this . + The argument is null. + There are one or more null elements in . + + The underlying is already in one + of the three final states: + RanToCompletion, + Faulted, or + Canceled. + + The was disposed. + + + + Attempts to transition the underlying + into the + RanToCompletion + state. + + The result value to bind to this . + True if the operation was successful; otherwise, false. + This operation will return false if the + is already in one + of the three final states: + RanToCompletion, + Faulted, or + Canceled. + + The was disposed. + + + + Transitions the underlying + into the + RanToCompletion + state. + + The result value to bind to this . + + The underlying is already in one + of the three final states: + RanToCompletion, + Faulted, or + Canceled. + + The was disposed. + + + + Transitions the underlying + into the + Canceled + state. + + + The underlying is already in one + of the three final states: + RanToCompletion, + Faulted, or + Canceled. + + The was disposed. + + + + Attempts to transition the underlying + into the + Canceled + state. + + True if the operation was successful; otherwise, false. + This operation will return false if the + is already in one + of the three final states: + RanToCompletion, + Faulted, or + Canceled. + + The was disposed. + + + + Gets the created + by this . + + + This property enables a consumer access to the that is controlled by this instance. + The , , + , and + methods (and their "Try" variants) on this instance all result in the relevant state + transitions on this underlying Task. + + + + + An exception holder manages a list of exceptions for one particular task. + It offers the ability to aggregate, but more importantly, also offers intrinsic + support for propagating unhandled exceptions that are never observed. It does + this by aggregating and throwing if the holder is ever GC'd without the holder's + contents ever having been requested (e.g. by a Task.Wait, Task.get_Exception, etc). + + + + + Creates a new holder; it will be registered for finalization. + + The task this holder belongs to. + + + + A finalizer that repropagates unhandled exceptions. + + + + + Add an exception to the internal list. This will ensure the holder is + in the proper state (handled/unhandled) depending on the list's contents. + + An exception object (either an Exception or an + IEnumerable{Exception}) to add to the list. + + + + A private helper method that ensures the holder is considered + unhandled, i.e. it is registered for finalization. + + + + + A private helper method that ensures the holder is considered + handled, i.e. it is not registered for finalization. + + Whether this is called from the finalizer thread. + + + + Allocates a new aggregate exception and adds the contents of the list to + it. By calling this method, the holder assumes exceptions to have been + "observed", such that the finalization check will be subsequently skipped. + + Whether this is being called from a finalizer. + An extra exception to be included (optionally). + The aggregate exception to throw. + + + + Provides a set of static (Shared in Visual Basic) methods for working with specific kinds of + instances. + + + + + Creates a proxy Task that represents the + asynchronous operation of a Task{Task}. + + + It is often useful to be able to return a Task from a + Task{TResult}, where the inner Task represents work done as part of the outer Task{TResult}. However, + doing so results in a Task{Task}, which, if not dealt with carefully, could produce unexpected behavior. Unwrap + solves this problem by creating a proxy Task that represents the entire asynchronous operation of such a Task{Task}. + + The Task{Task} to unwrap. + The exception that is thrown if the + argument is null. + A Task that represents the asynchronous operation of the provided Task{Task}. + + + + Creates a proxy Task{TResult} that represents the + asynchronous operation of a Task{Task{TResult}}. + + + It is often useful to be able to return a Task{TResult} from a Task{TResult}, where the inner Task{TResult} + represents work done as part of the outer Task{TResult}. However, doing so results in a Task{Task{TResult}}, + which, if not dealt with carefully, could produce unexpected behavior. Unwrap solves this problem by + creating a proxy Task{TResult} that represents the entire asynchronous operation of such a Task{Task{TResult}}. + + The Task{Task{TResult}} to unwrap. + The exception that is thrown if the + argument is null. + A Task{TResult} that represents the asynchronous operation of the provided Task{Task{TResult}}. /// Unwraps a Task that returns another Task. + + + + Provides support for creating and scheduling + Tasks. + + + + There are many common patterns for which tasks are relevant. The + class encodes some of these patterns into methods that pick up default settings, which are + configurable through its constructors. + + + A default instance of is available through the + Task.Factory property. + + + + + + Initializes a instance with the default configuration. + + + This constructor creates a instance with a default configuration. The + property is initialized to + TaskCreationOptions.None, the + property is initialized to TaskContinuationOptions.None, + and the TaskScheduler property is + initialized to the current scheduler (see TaskScheduler.Current). + + + + + Initializes a instance with the specified configuration. + + The default that will be assigned + to tasks created by this unless another CancellationToken is explicitly specified + while calling the factory methods. + + This constructor creates a instance with a default configuration. The + property is initialized to + TaskCreationOptions.None, the + property is initialized to TaskContinuationOptions.None, + and the TaskScheduler property is + initialized to the current scheduler (see TaskScheduler.Current). + + + + + Initializes a instance with the specified configuration. + + + The + TaskScheduler to use to schedule any tasks created with this TaskFactory. A null value + indicates that the current TaskScheduler should be used. + + + With this constructor, the + property is initialized to + TaskCreationOptions.None, the + property is initialized to TaskContinuationOptions.None, + and the TaskScheduler property is + initialized to , unless it's null, in which case the property is + initialized to the current scheduler (see TaskScheduler.Current). + + + + + Initializes a instance with the specified configuration. + + + The default + TaskCreationOptions to use when creating tasks with this TaskFactory. + + + The default + TaskContinuationOptions to use when creating continuation tasks with this TaskFactory. + + + The exception that is thrown when the + argument or the + argument specifies an invalid value. + + + With this constructor, the + property is initialized to , + the + property is initialized to , and the TaskScheduler property is initialized to the + current scheduler (see TaskScheduler.Current). + + + + + Initializes a instance with the specified configuration. + + The default that will be assigned + to tasks created by this unless another CancellationToken is explicitly specified + while calling the factory methods. + + The default + TaskCreationOptions to use when creating tasks with this TaskFactory. + + + The default + TaskContinuationOptions to use when creating continuation tasks with this TaskFactory. + + + The default + TaskScheduler to use to schedule any Tasks created with this TaskFactory. A null value + indicates that TaskScheduler.Current should be used. + + + The exception that is thrown when the + argument or the + argumentspecifies an invalid value. + + + With this constructor, the + property is initialized to , + the + property is initialized to , and the TaskScheduler property is initialized to + , unless it's null, in which case the property is initialized to the + current scheduler (see TaskScheduler.Current). + + + + + Creates and starts a Task. + + The action delegate to execute asynchronously. + The started Task. + The exception that is thrown when the + argument is null. + + Calling StartNew is functionally equivalent to creating a Task using one of its constructors + and then calling + Start to schedule it for execution. However, + unless creation and scheduling must be separated, StartNew is the recommended + approach for both simplicity and performance. + + + + + Creates and starts a Task. + + The action delegate to execute asynchronously. + The that will be assigned to the new task. + The started Task. + The exception that is thrown when the + argument is null. + The provided CancellationToken + has already been disposed. + + + Calling StartNew is functionally equivalent to creating a Task using one of its constructors + and then calling + Start to schedule it for execution. However, + unless creation and scheduling must be separated, StartNew is the recommended + approach for both simplicity and performance. + + + + + Creates and starts a Task. + + The action delegate to execute asynchronously. + A TaskCreationOptions value that controls the behavior of the + created + Task. + The started Task. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + + Calling StartNew is functionally equivalent to creating a Task using one of its constructors and + then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a Task. + + The action delegate to execute asynchronously. + The that will be assigned to the new + A TaskCreationOptions value that controls the behavior of the + created + Task. + The TaskScheduler + that is used to schedule the created Task. + The started Task. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The provided CancellationToken + has already been disposed. + + + Calling StartNew is functionally equivalent to creating a Task using one of its constructors and + then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a Task. + + The action delegate to execute asynchronously. + An object containing data to be used by the + delegate. + The started Task. + The exception that is thrown when the + argument is null. + + Calling StartNew is functionally equivalent to creating a Task using one of its constructors and + then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a Task. + + The action delegate to execute asynchronously. + An object containing data to be used by the + delegate. + The that will be assigned to the new + The started Task. + The exception that is thrown when the + argument is null. + The provided CancellationToken + has already been disposed. + + + Calling StartNew is functionally equivalent to creating a Task using one of its constructors and + then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a Task. + + The action delegate to execute asynchronously. + An object containing data to be used by the + delegate. + A TaskCreationOptions value that controls the behavior of the + created + Task. + The started Task. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + + Calling StartNew is functionally equivalent to creating a Task using one of its constructors and + then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a Task. + + The action delegate to execute asynchronously. + An object containing data to be used by the + delegate. + The that will be assigned to the new task. + A TaskCreationOptions value that controls the behavior of the + created + Task. + The TaskScheduler + that is used to schedule the created Task. + The started Task. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The provided CancellationToken + has already been disposed. + + + Calling StartNew is functionally equivalent to creating a Task using one of its constructors and + then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + The type of the result available through the + Task. + + A function delegate that returns the future result to be available through + the . + The started . + The exception that is thrown when the + argument is null. + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + The type of the result available through the + Task. + + A function delegate that returns the future result to be available through + the . + The that will be assigned to the new + The started . + The exception that is thrown when the + argument is null. + The provided CancellationToken + has already been disposed. + + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + The type of the result available through the + Task. + + A function delegate that returns the future result to be available through + the . + A TaskCreationOptions value that controls the behavior of the + created + . + The started . + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + The type of the result available through the + Task. + + A function delegate that returns the future result to be available through + the . + The that will be assigned to the new task. + A TaskCreationOptions value that controls the behavior of the + created + . + The TaskScheduler + that is used to schedule the created + Task{TResult}. + The started . + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The provided CancellationToken + has already been disposed. + + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + The type of the result available through the + Task. + + A function delegate that returns the future result to be available through + the . + An object containing data to be used by the + delegate. + The started . + The exception that is thrown when the + argument is null. + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + The type of the result available through the + Task. + + A function delegate that returns the future result to be available through + the . + An object containing data to be used by the + delegate. + The that will be assigned to the new + The started . + The exception that is thrown when the + argument is null. + The provided CancellationToken + has already been disposed. + + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + The type of the result available through the + Task. + + A function delegate that returns the future result to be available through + the . + An object containing data to be used by the + delegate. + A TaskCreationOptions value that controls the behavior of the + created + . + The started . + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + The type of the result available through the + Task. + + A function delegate that returns the future result to be available through + the . + An object containing data to be used by the + delegate. + The that will be assigned to the new task. + A TaskCreationOptions value that controls the behavior of the + created + . + The TaskScheduler + that is used to schedule the created + Task{TResult}. + The started . + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The provided CancellationToken + has already been disposed. + + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates a Task that executes an end method action + when a specified IAsyncResult completes. + + The IAsyncResult whose completion should trigger the processing of the + . + The action delegate that processes the completed . + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + A Task that represents the asynchronous + operation. + + + + Creates a Task that executes an end method action + when a specified IAsyncResult completes. + + The IAsyncResult whose completion should trigger the processing of the + . + The action delegate that processes the completed . + The TaskCreationOptions value that controls the behavior of the + created Task. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + A Task that represents the asynchronous + operation. + + + + Creates a Task that executes an end method action + when a specified IAsyncResult completes. + + The IAsyncResult whose completion should trigger the processing of the + . + The action delegate that processes the completed . + The TaskScheduler + that is used to schedule the task that executes the end method. + The TaskCreationOptions value that controls the behavior of the + created Task. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + A Task that represents the asynchronous + operation. + + + + Creates a Task that represents a pair of begin + and end methods that conform to the Asynchronous Programming Model pattern. + + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The created Task that represents the + asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of begin + and end methods that conform to the Asynchronous Programming Model pattern. + + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The TaskCreationOptions value that controls the behavior of the + created Task. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The created Task that represents the + asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of begin + and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the + delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The created Task that represents the + asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of begin + and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the + delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The TaskCreationOptions value that controls the behavior of the + created Task. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The created Task that represents the + asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of begin + and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the + delegate. + The type of the second argument passed to + delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The second argument passed to the + delegate. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The created Task that represents the + asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of begin + and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the + delegate. + The type of the second argument passed to + delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The second argument passed to the + delegate. + The TaskCreationOptions value that controls the behavior of the + created Task. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The created Task that represents the + asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of begin + and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the + delegate. + The type of the second argument passed to + delegate. + The type of the third argument passed to + delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The second argument passed to the + delegate. + The third argument passed to the + delegate. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The created Task that represents the + asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of begin + and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the + delegate. + The type of the second argument passed to + delegate. + The type of the third argument passed to + delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The second argument passed to the + delegate. + The third argument passed to the + delegate. + The TaskCreationOptions value that controls the behavior of the + created Task. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The created Task that represents the + asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that executes an end + method function when a specified IAsyncResult completes. + + The type of the result available through the + Task. + + The IAsyncResult whose completion should trigger the processing of the + . + The function delegate that processes the completed . + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + A Task that represents the + asynchronous operation. + + + + Creates a Task that executes an end + method function when a specified IAsyncResult completes. + + The type of the result available through the + Task. + + The IAsyncResult whose completion should trigger the processing of the + . + The function delegate that processes the completed . + The TaskCreationOptions value that controls the behavior of the + created Task. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + A Task that represents the + asynchronous operation. + + + + Creates a Task that executes an end + method function when a specified IAsyncResult completes. + + The type of the result available through the + Task. + + The IAsyncResult whose completion should trigger the processing of the + . + The function delegate that processes the completed . + The TaskScheduler + that is used to schedule the task that executes the end method. + The TaskCreationOptions value that controls the behavior of the + created Task. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + A Task that represents the + asynchronous operation. + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the result available through the + Task. + + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the result available through the + Task. + + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The TaskCreationOptions value that controls the behavior of the + created Task. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the delegate. + The type of the result available through the + Task. + + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the delegate. + The type of the result available through the + Task. + + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The TaskCreationOptions value that controls the behavior of the + created Task. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the delegate. + The type of the second argument passed to + delegate. + The type of the result available through the + Task. + + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The second argument passed to the + delegate. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the delegate. + The type of the second argument passed to + delegate. + The type of the result available through the + Task. + + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The second argument passed to the + delegate. + The TaskCreationOptions value that controls the behavior of the + created Task. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the delegate. + The type of the second argument passed to + delegate. + The type of the third argument passed to + delegate. + The type of the result available through the + Task. + + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The second argument passed to the + delegate. + The third argument passed to the + delegate. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the delegate. + The type of the second argument passed to + delegate. + The type of the third argument passed to + delegate. + The type of the result available through the + Task. + + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The second argument passed to the + delegate. + The third argument passed to the + delegate. + The TaskCreationOptions value that controls the behavior of the + created Task. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Check validity of options passed to FromAsync method + + The options to be validated. + determines type of FromAsync method that called this method + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The array of tasks from which to continue. + The action delegate to execute when all tasks in + the array have completed. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The array of tasks from which to continue. + The action delegate to execute when all tasks in + the array have completed. + The CancellationToken + that will be assigned to the new continuation task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The array of tasks from which to continue. + The action delegate to execute when all tasks in the array have completed. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAll. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The array of tasks from which to continue. + The action delegate to execute when all tasks in the array have completed. + The CancellationToken + that will be assigned to the new continuation task. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The TaskScheduler + that is used to schedule the created continuation Task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAll. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result of the antecedent . + The array of tasks from which to continue. + The action delegate to execute when all tasks in + the array have completed. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result of the antecedent . + The array of tasks from which to continue. + The action delegate to execute when all tasks in + the array have completed. + The CancellationToken + that will be assigned to the new continuation task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result of the antecedent . + The array of tasks from which to continue. + The action delegate to execute when all tasks in the array have completed. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAll. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result of the antecedent . + The array of tasks from which to continue. + The action delegate to execute when all tasks in the array have completed. + The CancellationToken + that will be assigned to the new continuation task. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The TaskScheduler + that is used to schedule the created continuation Task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAll. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result that is returned by the + delegate and associated with the created . + The array of tasks from which to continue. + The function delegate to execute when all tasks in the + array have completed. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result that is returned by the + delegate and associated with the created . + The array of tasks from which to continue. + The function delegate to execute when all tasks in the + array have completed. + The CancellationToken + that will be assigned to the new continuation task. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result that is returned by the + delegate and associated with the created . + The array of tasks from which to continue. + The function delegate to execute when all tasks in the + array have completed. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAll. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result that is returned by the + delegate and associated with the created . + The array of tasks from which to continue. + The function delegate to execute when all tasks in the + array have completed. + The CancellationToken + that will be assigned to the new continuation task. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The TaskScheduler + that is used to schedule the created continuation . + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAll. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result that is returned by the + delegate and associated with the created . + The type of the result of the antecedent . + The array of tasks from which to continue. + The function delegate to execute when all tasks in the + array have completed. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result that is returned by the + delegate and associated with the created . + The type of the result of the antecedent . + The array of tasks from which to continue. + The function delegate to execute when all tasks in the + array have completed. + The CancellationToken + that will be assigned to the new continuation task. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result that is returned by the + delegate and associated with the created . + The type of the result of the antecedent . + The array of tasks from which to continue. + The function delegate to execute when all tasks in the + array have completed. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAll. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result that is returned by the + delegate and associated with the created . + The type of the result of the antecedent . + The array of tasks from which to continue. + The function delegate to execute when all tasks in the + array have completed. + The CancellationToken + that will be assigned to the new continuation task. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The TaskScheduler + that is used to schedule the created continuation . + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAll. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The array of tasks from which to continue when one task completes. + The action delegate to execute when one task in the array completes. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The array of tasks from which to continue when one task completes. + The action delegate to execute when one task in the array completes. + The CancellationToken + that will be assigned to the new continuation task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The array of tasks from which to continue when one task completes. + The action delegate to execute when one task in the array completes. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAny. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The array of tasks from which to continue when one task completes. + The action delegate to execute when one task in the array completes. + The CancellationToken + that will be assigned to the new continuation task. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The TaskScheduler + that is used to schedule the created continuation Task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAny. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result that is returned by the + delegate and associated with the created . + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the + array completes. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result that is returned by the + delegate and associated with the created . + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the + array completes. + The CancellationToken + that will be assigned to the new continuation task. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result that is returned by the + delegate and associated with the created . + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the + array completes. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAny. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result that is returned by the + delegate and associated with the created . + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the + array completes. + The CancellationToken + that will be assigned to the new continuation task. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The TaskScheduler + that is used to schedule the created continuation . + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAny. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result that is returned by the + delegate and associated with the created . + The type of the result of the antecedent . + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the + array completes. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result that is returned by the + delegate and associated with the created . + The type of the result of the antecedent . + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the + array completes. + The CancellationToken + that will be assigned to the new continuation task. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result that is returned by the + delegate and associated with the created . + The type of the result of the antecedent . + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the + array completes. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAny. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result that is returned by the + delegate and associated with the created . + The type of the result of the antecedent . + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the + array completes. + The CancellationToken + that will be assigned to the new continuation task. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The TaskScheduler + that is used to schedule the created continuation . + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAny. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result of the antecedent . + The array of tasks from which to continue when one task completes. + The action delegate to execute when one task in the + array completes. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result of the antecedent . + The array of tasks from which to continue when one task completes. + The action delegate to execute when one task in the + array completes. + The CancellationToken + that will be assigned to the new continuation task. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result of the antecedent . + The array of tasks from which to continue when one task completes. + The action delegate to execute when one task in the + array completes. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAny. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result of the antecedent . + The array of tasks from which to continue when one task completes. + The action delegate to execute when one task in the + array completes. + The CancellationToken + that will be assigned to the new continuation task. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The TaskScheduler + that is used to schedule the created continuation . + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAny. + + + + + Gets the default CancellationToken of this + TaskFactory. + + + This property returns the default that will be assigned to all + tasks created by this factory unless another CancellationToken value is explicitly specified + during the call to the factory methods. + + + + + Gets the TaskScheduler of this + TaskFactory. + + + This property returns the default scheduler for this factory. It will be used to schedule all + tasks unless another scheduler is explicitly specified during calls to this factory's methods. + If null, TaskScheduler.Current + will be used. + + + + + Gets the TaskCreationOptions + value of this TaskFactory. + + + This property returns the default creation options for this factory. They will be used to create all + tasks unless other options are explicitly specified during calls to this factory's methods. + + + + + Gets the TaskContinuationOptions + value of this TaskFactory. + + + This property returns the default continuation options for this factory. They will be used to create + all continuation tasks unless other options are explicitly specified during calls to this factory's methods. + + + + + Represents an abstract scheduler for tasks. + + + + TaskScheduler acts as the extension point for all + pluggable scheduling logic. This includes mechanisms such as how to schedule a task for execution, and + how scheduled tasks should be exposed to debuggers. + + + All members of the abstract type are thread-safe + and may be used from multiple threads concurrently. + + + + + + Queues a Task to the scheduler. + + + + A class derived from TaskScheduler + implements this method to accept tasks being scheduled on the scheduler. + A typical implementation would store the task in an internal data structure, which would + be serviced by threads that would execute those tasks at some time in the future. + + + This method is only meant to be called by the .NET Framework and + should not be called directly by the derived class. This is necessary + for maintaining the consistency of the system. + + + The Task to be queued. + The argument is null. + + + + Determines whether the provided Task + can be executed synchronously in this call, and if it can, executes it. + + + + A class derived from TaskScheduler implements this function to + support inline execution of a task on a thread that initiates a wait on that task object. Inline + execution is optional, and the request may be rejected by returning false. However, better + scalability typically results the more tasks that can be inlined, and in fact a scheduler that + inlines too little may be prone to deadlocks. A proper implementation should ensure that a + request executing under the policies guaranteed by the scheduler can successfully inline. For + example, if a scheduler uses a dedicated thread to execute tasks, any inlining requests from that + thread should succeed. + + + If a scheduler decides to perform the inline execution, it should do so by calling to the base + TaskScheduler's + TryExecuteTask method with the provided task object, propagating + the return value. It may also be appropriate for the scheduler to remove an inlined task from its + internal data structures if it decides to honor the inlining request. Note, however, that under + some circumstances a scheduler may be asked to inline a task that was not previously provided to + it with the method. + + + The derived scheduler is responsible for making sure that the calling thread is suitable for + executing the given task as far as its own scheduling and execution policies are concerned. + + + The Task to be + executed. + A Boolean denoting whether or not task has previously been + queued. If this parameter is True, then the task may have been previously queued (scheduled); if + False, then the task is known not to have been queued, and this call is being made in order to + execute the task inline without queueing it. + A Boolean value indicating whether the task was executed inline. + The argument is + null. + The was already + executed. + + + + Generates an enumerable of Task instances + currently queued to the scheduler waiting to be executed. + + + + A class derived from implements this method in order to support + integration with debuggers. This method will only be invoked by the .NET Framework when the + debugger requests access to the data. The enumerable returned will be traversed by debugging + utilities to access the tasks currently queued to this scheduler, enabling the debugger to + provide a representation of this information in the user interface. + + + It is important to note that, when this method is called, all other threads in the process will + be frozen. Therefore, it's important to avoid synchronization with other threads that may lead to + blocking. If synchronization is necessary, the method should prefer to throw a + than to block, which could cause a debugger to experience delays. Additionally, this method and + the enumerable returned must not modify any globally visible state. + + + The returned enumerable should never be null. If there are currently no queued tasks, an empty + enumerable should be returned instead. + + + For developers implementing a custom debugger, this method shouldn't be called directly, but + rather this functionality should be accessed through the internal wrapper method + GetScheduledTasksForDebugger: + internal Task[] GetScheduledTasksForDebugger(). This method returns an array of tasks, + rather than an enumerable. In order to retrieve a list of active schedulers, a debugger may use + another internal method: internal static TaskScheduler[] GetTaskSchedulersForDebugger(). + This static method returns an array of all active TaskScheduler instances. + GetScheduledTasksForDebugger then may be used on each of these scheduler instances to retrieve + the list of scheduled tasks for each. + + + An enumerable that allows traversal of tasks currently queued to this scheduler. + + + This scheduler is unable to generate a list of queued tasks at this time. + + + + + Retrieves some thread static state that can be cached and passed to multiple + TryRunInline calls, avoiding superflous TLS fetches. + + A bag of TLS state (or null if none exists). + + + + Attempts to execute the target task synchronously. + + The task to run. + True if the task may have been previously queued, + false if the task was absolutely not previously queued. + The state retrieved from GetThreadStatics + True if it ran, false otherwise. + + + + Attempts to dequeue a Task that was previously queued to + this scheduler. + + The Task to be dequeued. + A Boolean denoting whether the argument was successfully dequeued. + The argument is null. + + + + Notifies the scheduler that a work item has made progress. + + + + + Initializes the . + + + + + Frees all resources associated with this scheduler. + + + + + Creates a + associated with the current . + + + All Task instances queued to + the returned scheduler will be executed through a call to the + Post method + on that context. + + + A associated with + the current SynchronizationContext, as + determined by SynchronizationContext.Current. + + + The current SynchronizationContext may not be used as a TaskScheduler. + + + + + Attempts to execute the provided Task + on this scheduler. + + + + Scheduler implementations are provided with Task + instances to be executed through either the method or the + method. When the scheduler deems it appropriate to run the + provided task, should be used to do so. TryExecuteTask handles all + aspects of executing a task, including action invocation, exception handling, state management, + and lifecycle control. + + + must only be used for tasks provided to this scheduler by the .NET + Framework infrastructure. It should not be used to execute arbitrary tasks obtained through + custom mechanisms. + + + + A Task object to be executed. + + The is not associated with this scheduler. + + A Boolean that is true if was successfully executed, false if it + was not. A common reason for execution failure is that the task had previously been executed or + is in the process of being executed by another thread. + + + + Provides an array of all queued Task instances + for the debugger. + + + The returned array is populated through a call to . + Note that this function is only meant to be invoked by a debugger remotely. + It should not be called by any other codepaths. + + An array of Task instances. + + This scheduler is unable to generate a list of queued tasks at this time. + + + + + Provides an array of all active TaskScheduler + instances for the debugger. + + + This function is only meant to be invoked by a debugger remotely. + It should not be called by any other codepaths. + + An array of TaskScheduler instances. + + + + Registers a new TaskScheduler instance in the global collection of schedulers. + + + + + Removes a TaskScheduler instance from the global collection of schedulers. + + + + + Indicates the maximum concurrency level this + is able to support. + + + + + Indicates whether this is a custom scheduler, in which case the safe code paths will be taken upon task entry + using a CAS to transition from queued state to executing. + + + + + Gets the default TaskScheduler instance. + + + + + Gets the TaskScheduler + associated with the currently executing task. + + + When not called from within a task, will return the scheduler. + + + + + Gets the unique ID for this . + + + + + Occurs when a faulted 's unobserved exception is about to trigger exception escalation + policy, which, by default, would terminate the process. + + + This AppDomain-wide event provides a mechanism to prevent exception + escalation policy (which, by default, terminates the process) from triggering. + Each handler is passed a + instance, which may be used to examine the exception and to mark it as observed. + + + + + Nested class that provides debugger view for TaskScheduler + + + + Default thread pool scheduler. + + + + A TaskScheduler implementation that executes all tasks queued to it through a call to + on the + that its associated with. The default constructor for this class binds to the current + + + + + Constructs a SynchronizationContextTaskScheduler associated with + + This constructor expects to be set. + + + + Implemetation of for this scheduler class. + + Simply posts the tasks to be executed on the associated . + + + + + + Implementation of for this scheduler class. + + The task will be executed inline only if the call happens within + the associated . + + + + + + + Implementes the property for + this scheduler class. + + By default it returns 1, because a based + scheduler only supports execution on a single thread. + + + + + Provides data for the event that is raised when a faulted 's + exception goes unobserved. + + + The Exception property is used to examine the exception without marking it + as observed, whereas the method is used to mark the exception + as observed. Marking the exception as observed prevents it from triggering exception escalation policy + which, by default, terminates the process. + + + + + Initializes a new instance of the class + with the unobserved exception. + + The Exception that has gone unobserved. + + + + Marks the as "observed," thus preventing it + from triggering exception escalation policy which, by default, terminates the process. + + + + + Gets whether this exception has been marked as "observed." + + + + + The Exception that went unobserved. + + + + + Represents an exception used to communicate an invalid operation by a + . + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the + class with a specified error message. + + The error message that explains the reason for the exception. + + + + Initializes a new instance of the + class using the default error message and a reference to the inner exception that is the cause of + this exception. + + The exception that is the cause of the current exception. + + + + Initializes a new instance of the + class with a specified error message and a reference to the inner exception that is the cause of + this exception. + + The error message that explains the reason for the exception. + The exception that is the cause of the current exception. + + + diff --git a/src/packages/Microsoft.Bcl.1.1.8/lib/sl4-windowsphone71/ensureRedirect.xml b/src/packages/Microsoft.Bcl.1.1.8/lib/sl4-windowsphone71/ensureRedirect.xml new file mode 100644 index 00000000..e69de29b diff --git a/src/packages/Microsoft.Bcl.1.1.8/lib/sl4/System.IO.dll b/src/packages/Microsoft.Bcl.1.1.8/lib/sl4/System.IO.dll new file mode 100644 index 0000000000000000000000000000000000000000..01edf729d6fd3f62b325ada34491065ecf202911 GIT binary patch literal 22704 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 + + + System.IO + + + + + A strongly-typed resource class, for looking up localized strings, etc. + + + + + Returns the cached ResourceManager instance used by this class. + + + + + Overrides the current thread's CurrentUICulture property for all + resource lookups using this strongly typed resource class. + + + + + Looks up a localized string similar to Found invalid data while decoding.. + + + + + The exception that is thrown when a data stream is in an invalid format. + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class with a specified error message. + + The error message that explains the reason for the exception. + + + + Initializes a new instance of the class with a reference to the inner exception that is the cause of this exception. + The error message that explains the reason for the exception. + The exception that is the cause of the current exception. If the parameter is not null, the current exception is raised in a catch block that handles the inner exception. + + + diff --git a/src/packages/Microsoft.Bcl.1.1.8/lib/sl4/System.Runtime.dll b/src/packages/Microsoft.Bcl.1.1.8/lib/sl4/System.Runtime.dll new file mode 100644 index 0000000000000000000000000000000000000000..967bb30a0d84f969455800059b74fae5c24271df GIT binary patch literal 22208 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 QU>aprW%>sEYaZx-0jWNPVE_OC literal 0 HcmV?d00001 diff --git a/src/packages/Microsoft.Bcl.1.1.8/lib/sl4/System.Runtime.xml b/src/packages/Microsoft.Bcl.1.1.8/lib/sl4/System.Runtime.xml new file mode 100644 index 00000000..93cb00d7 --- /dev/null +++ b/src/packages/Microsoft.Bcl.1.1.8/lib/sl4/System.Runtime.xml @@ -0,0 +1,56 @@ + + + + System.Runtime + + + + Defines a provider for progress updates. + The type of progress update value. + + + Reports a progress update. + The value of the updated progress. + + + Identities the async state machine type for this method. + + + Identities the state machine type for this method. + + + Initializes the attribute. + The type that implements the state machine. + + + Gets the type that implements the state machine. + + + Initializes the attribute. + The type that implements the state machine. + + + + Allows you to obtain the method or property name of the caller to the method. + + + + + Allows you to obtain the line number in the source file at which the method is called. + + + + + Allows you to obtain the full path of the source file that contains the caller. + This is the file path at the time of compile. + + + + Identities the iterator state machine type for this method. + + + Initializes the attribute. + The type that implements the state machine. + + + diff --git a/src/packages/Microsoft.Bcl.1.1.8/lib/sl4/System.Threading.Tasks.dll b/src/packages/Microsoft.Bcl.1.1.8/lib/sl4/System.Threading.Tasks.dll new file mode 100644 index 0000000000000000000000000000000000000000..03d08ad93e7cc6f8ae5664b89516ba2010a4f749 GIT binary patch literal 164576 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
    A;XM&re5ZI=Miv% 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 E10+ctx&QzG literal 0 HcmV?d00001 diff --git a/src/packages/Microsoft.Bcl.1.1.8/lib/sl4/System.Threading.Tasks.xml b/src/packages/Microsoft.Bcl.1.1.8/lib/sl4/System.Threading.Tasks.xml new file mode 100644 index 00000000..6c770122 --- /dev/null +++ b/src/packages/Microsoft.Bcl.1.1.8/lib/sl4/System.Threading.Tasks.xml @@ -0,0 +1,8969 @@ + + + + System.Threading.Tasks + + + + Represents one or more errors that occur during application execution. + + is used to consolidate multiple failures into a single, throwable + exception object. + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class with + a specified error message. + + The error message that explains the reason for the exception. + + + + Initializes a new instance of the class with a specified error + message and a reference to the inner exception that is the cause of this exception. + + The error message that explains the reason for the exception. + The exception that is the cause of the current exception. + The argument + is null. + + + + Initializes a new instance of the class with + references to the inner exceptions that are the cause of this exception. + + The exceptions that are the cause of the current exception. + The argument + is null. + An element of is + null. + + + + Initializes a new instance of the class with + references to the inner exceptions that are the cause of this exception. + + The exceptions that are the cause of the current exception. + The argument + is null. + An element of is + null. + + + + Initializes a new instance of the class with a specified error + message and references to the inner exceptions that are the cause of this exception. + + The error message that explains the reason for the exception. + The exceptions that are the cause of the current exception. + The argument + is null. + An element of is + null. + + + + Initializes a new instance of the class with a specified error + message and references to the inner exceptions that are the cause of this exception. + + The error message that explains the reason for the exception. + The exceptions that are the cause of the current exception. + The argument + is null. + An element of is + null. + + + + Allocates a new aggregate exception with the specified message and list of inner exceptions. + + The error message that explains the reason for the exception. + The exceptions that are the cause of the current exception. + The argument + is null. + An element of is + null. + + + + Returns the that is the root cause of this exception. + + + + + Invokes a handler on each contained by this . + + The predicate to execute for each exception. The predicate accepts as an + argument the to be processed and returns a Boolean to indicate + whether the exception was handled. + + Each invocation of the returns true or false to indicate whether the + was handled. After all invocations, if any exceptions went + unhandled, all unhandled exceptions will be put into a new + which will be thrown. Otherwise, the method simply returns. If any + invocations of the throws an exception, it will halt the processing + of any more exceptions and immediately propagate the thrown exception as-is. + + An exception contained by this was not handled. + The argument is + null. + + + + Flattens an instances into a single, new instance. + + A new, flattened . + + If any inner exceptions are themselves instances of + , this method will recursively flatten all of them. The + inner exceptions returned in the new + will be the union of all of the the inner exceptions from exception tree rooted at the provided + instance. + + + + + Creates and returns a string representation of the current . + + A string representation of the current exception. + + + + Gets a read-only collection of the instances that caused the + current exception. + + + + + A strongly-typed resource class, for looking up localized strings, etc. + + + + + Returns the cached ResourceManager instance used by this class. + + + + + Overrides the current thread's CurrentUICulture property for all + resource lookups using this strongly typed resource class. + + + + + Looks up a localized string similar to One or more errors occurred.. + + + + + Looks up a localized string similar to An element of innerExceptions was null.. + + + + + Looks up a localized string similar to {0}{1}---> (Inner Exception #{2}) {3}{4}{5}. + + + + + Looks up a localized string similar to No tokens were supplied.. + + + + + Looks up a localized string similar to The CancellationTokenSource associated with this CancellationToken has been disposed.. + + + + + Looks up a localized string similar to The CancellationTokenSource has been disposed.. + + + + + Looks up a localized string similar to The SyncRoot property may not be used for the synchronization of concurrent collections.. + + + + + Looks up a localized string similar to The array is multidimensional, or the type parameter for the set cannot be cast automatically to the type of the destination array.. + + + + + Looks up a localized string similar to The index is equal to or greater than the length of the array, or the number of elements in the dictionary is greater than the available space from index to the end of the destination array.. + + + + + Looks up a localized string similar to The capacity argument must be greater than or equal to zero.. + + + + + Looks up a localized string similar to The concurrencyLevel argument must be positive.. + + + + + Looks up a localized string similar to The index argument is less than zero.. + + + + + Looks up a localized string similar to TKey is a reference type and item.Key is null.. + + + + + Looks up a localized string similar to The key already existed in the dictionary.. + + + + + Looks up a localized string similar to The source argument contains duplicate keys.. + + + + + Looks up a localized string similar to The key was of an incorrect type for this dictionary.. + + + + + Looks up a localized string similar to The value was of an incorrect type for this dictionary.. + + + + + Looks up a localized string similar to The lazily-initialized type does not have a public, parameterless constructor.. + + + + + Looks up a localized string similar to ValueFactory returned null.. + + + + + Looks up a localized string similar to The spinCount argument must be in the range 0 to {0}, inclusive.. + + + + + Looks up a localized string similar to There are too many threads currently waiting on the event. A maximum of {0} waiting threads are supported.. + + + + + Looks up a localized string similar to The event has been disposed.. + + + + + Looks up a localized string similar to The operation was canceled.. + + + + + Looks up a localized string similar to The condition argument is null.. + + + + + Looks up a localized string similar to The timeout must represent a value between -1 and Int32.MaxValue, inclusive.. + + + + + Looks up a localized string similar to The specified TaskContinuationOptions combined LongRunning and ExecuteSynchronously. Synchronous continuations should not be long running.. + + + + + Looks up a localized string similar to The specified TaskContinuationOptions excluded all continuation kinds.. + + + + + Looks up a localized string similar to (Internal)An attempt was made to create a LongRunning SelfReplicating task.. + + + + + Looks up a localized string similar to The value needs to translate in milliseconds to -1 (signifying an infinite timeout), 0 or a positive integer less than or equal to Int32.MaxValue.. + + + + + Looks up a localized string similar to The value needs to be either -1 (signifying an infinite timeout), 0 or a positive integer.. + + + + + Looks up a localized string similar to A task may only be disposed if it is in a completion state (RanToCompletion, Faulted or Canceled).. + + + + + Looks up a localized string similar to It is invalid to specify TaskCreationOptions.LongRunning in calls to FromAsync.. + + + + + Looks up a localized string similar to It is invalid to specify TaskCreationOptions.PreferFairness in calls to FromAsync.. + + + + + Looks up a localized string similar to It is invalid to specify TaskCreationOptions.SelfReplicating in calls to FromAsync.. + + + + + Looks up a localized string similar to FromAsync was called with a TaskManager that had already shut down.. + + + + + Looks up a localized string similar to The tasks argument contains no tasks.. + + + + + Looks up a localized string similar to It is invalid to exclude specific continuation kinds for continuations off of multiple tasks.. + + + + + Looks up a localized string similar to The tasks argument included a null value.. + + + + + Looks up a localized string similar to RunSynchronously may not be called on a task that was already started.. + + + + + Looks up a localized string similar to RunSynchronously may not be called on a continuation task.. + + + + + Looks up a localized string similar to RunSynchronously may not be called on a task not bound to a delegate, such as the task returned from an asynchronous method.. + + + + + Looks up a localized string similar to RunSynchronously may not be called on a task that has already completed.. + + + + + Looks up a localized string similar to Start may not be called on a task that was already started.. + + + + + Looks up a localized string similar to Start may not be called on a continuation task.. + + + + + Looks up a localized string similar to Start may not be called on a task with null action.. + + + + + Looks up a localized string similar to Start may not be called on a promise-style task.. + + + + + Looks up a localized string similar to Start may not be called on a task that has completed.. + + + + + Looks up a localized string similar to The task has been disposed.. + + + + + Looks up a localized string similar to The tasks array included at least one null element.. + + + + + Looks up a localized string similar to The awaited task has not yet completed.. + + + + + Looks up a localized string similar to A task was canceled.. + + + + + Looks up a localized string similar to The exceptions collection was empty.. + + + + + Looks up a localized string similar to The exceptions collection included at least one null element.. + + + + + Looks up a localized string similar to A Task's exception(s) were not observed either by Waiting on the Task or accessing its Exception property. As a result, the unobserved exception was rethrown by the finalizer thread.. + + + + + Looks up a localized string similar to (Internal)Expected an Exception or an IEnumerable<Exception>. + + + + + Looks up a localized string similar to ExecuteTask may not be called for a task which was already executed.. + + + + + Looks up a localized string similar to ExecuteTask may not be called for a task which was previously queued to a different TaskScheduler.. + + + + + Looks up a localized string similar to The current SynchronizationContext may not be used as a TaskScheduler.. + + + + + Looks up a localized string similar to The TryExecuteTaskInline call to the underlying scheduler succeeded, but the task body was not invoked.. + + + + + Looks up a localized string similar to An exception was thrown by a TaskScheduler.. + + + + + Looks up a localized string similar to It is invalid to specify TaskCreationOptions.SelfReplicating for a Task<TResult>.. + + + + + Looks up a localized string similar to {Not yet computed}. + + + + + Looks up a localized string similar to A task's Exception may only be set directly if the task was created without a function.. + + + + + Looks up a localized string similar to An attempt was made to transition a task to a final state when it had already completed.. + + + + + Represents a thread-safe collection of keys and values. + + The type of the keys in the dictionary. + The type of the values in the dictionary. + + All public and protected members of are thread-safe and may be used + concurrently from multiple threads. + + + + + Initializes a new instance of the + class that is empty, has the default concurrency level, has the default initial capacity, and + uses the default comparer for the key type. + + + + + Initializes a new instance of the + class that is empty, has the specified concurrency level and capacity, and uses the default + comparer for the key type. + + The estimated number of threads that will update the + concurrently. + The initial number of elements that the + can contain. + is + less than 1. + is less than + 0. + + + + Initializes a new instance of the + class that contains elements copied from the specified , has the default concurrency + level, has the default initial capacity, and uses the default comparer for the key type. + + The whose elements are copied to + the new + . + is a null reference + (Nothing in Visual Basic). + contains one or more + duplicate keys. + + + + Initializes a new instance of the + class that is empty, has the specified concurrency level and capacity, and uses the specified + . + + The + implementation to use when comparing keys. + is a null reference + (Nothing in Visual Basic). + + + + Initializes a new instance of the + class that contains elements copied from the specified , has the default concurrency level, has the default + initial capacity, and uses the specified + . + + The whose elements are copied to + the new + . + The + implementation to use when comparing keys. + is a null reference + (Nothing in Visual Basic). -or- + is a null reference (Nothing in Visual Basic). + + + + + Initializes a new instance of the + class that contains elements copied from the specified , + has the specified concurrency level, has the specified initial capacity, and uses the specified + . + + The estimated number of threads that will update the + concurrently. + The whose elements are copied to the new + . + The implementation to use + when comparing keys. + + is a null reference (Nothing in Visual Basic). + -or- + is a null reference (Nothing in Visual Basic). + + + is less than 1. + + contains one or more duplicate keys. + + + + Initializes a new instance of the + class that is empty, has the specified concurrency level, has the specified initial capacity, and + uses the specified . + + The estimated number of threads that will update the + concurrently. + The initial number of elements that the + can contain. + The + implementation to use when comparing keys. + + is less than 1. -or- + is less than 0. + + is a null reference + (Nothing in Visual Basic). + + + + Attempts to add the specified key and value to the . + + The key of the element to add. + The value of the element to add. The value can be a null reference (Nothing + in Visual Basic) for reference types. + true if the key/value pair was added to the + successfully; otherwise, false. + is null reference + (Nothing in Visual Basic). + The + contains too many elements. + + + + Determines whether the contains the specified + key. + + The key to locate in the . + true if the contains an element with + the specified key; otherwise, false. + is a null reference + (Nothing in Visual Basic). + + + + Attempts to remove and return the the value with the specified key from the + . + + The key of the element to remove and return. + When this method returns, contains the object removed from the + or the default value of + if the operation failed. + true if an object was removed successfully; otherwise, false. + is a null reference + (Nothing in Visual Basic). + + + + Removes the specified key from the dictionary if it exists and returns its associated value. + If matchValue flag is set, the key will be removed only if is associated with a particular + value. + + The key to search for and remove if it exists. + The variable into which the removed value, if found, is stored. + Whether removal of the key is conditional on its value. + The conditional value to compare against if is true + + + + + Attempts to get the value associated with the specified key from the . + + The key of the value to get. + When this method returns, contains the object from + the + with the spedified key or the default value of + , if the operation failed. + true if the key was found in the ; + otherwise, false. + is a null reference + (Nothing in Visual Basic). + + + + Compares the existing value for the specified key with a specified value, and if they’re equal, + updates the key with a third value. + + The key whose value is compared with and + possibly replaced. + The value that replaces the value of the element with if the comparison results in equality. + The value that is compared to the value of the element with + . + true if the value with was equal to and replaced with ; otherwise, + false. + is a null + reference. + + + + Removes all keys and values from the . + + + + + Copies the elements of the to an array of + type , starting at the + specified array index. + + The one-dimensional array of type + that is the destination of the elements copied from the . The array must have zero-based indexing. + The zero-based index in at which copying + begins. + is a null reference + (Nothing in Visual Basic). + is less than + 0. + is equal to or greater than + the length of the . -or- The number of elements in the source + is greater than the available space from to the end of the destination + . + + + + Copies the key and value pairs stored in the to a + new array. + + A new array containing a snapshot of key and value pairs copied from the . + + + + Copy dictionary contents to an array - shared implementation between ToArray and CopyTo. + + Important: the caller must hold all locks in m_locks before calling CopyToPairs. + + + + + Copy dictionary contents to an array - shared implementation between ToArray and CopyTo. + + Important: the caller must hold all locks in m_locks before calling CopyToEntries. + + + + + Copy dictionary contents to an array - shared implementation between ToArray and CopyTo. + + Important: the caller must hold all locks in m_locks before calling CopyToObjects. + + + + Returns an enumerator that iterates through the . + An enumerator for the . + + The enumerator returned from the dictionary is safe to use concurrently with + reads and writes to the dictionary, however it does not represent a moment-in-time snapshot + of the dictionary. The contents exposed through the enumerator may contain modifications + made to the dictionary after was called. + + + + + Shared internal implementation for inserts and updates. + If key exists, we always return false; and if updateIfExists == true we force update with value; + If key doesn't exist, we always add value and return true; + + + + + Adds a key/value pair to the + if the key does not already exist. + + The key of the element to add. + The function used to generate a value for the key + is a null reference + (Nothing in Visual Basic). + is a null reference + (Nothing in Visual Basic). + The dictionary contains too many + elements. + The value for the key. This will be either the existing value for the key if the + key is already in the dictionary, or the new value for the key as returned by valueFactory + if the key was not in the dictionary. + + + + Adds a key/value pair to the + if the key does not already exist. + + The key of the element to add. + the value to be added, if the key does not already exist + is a null reference + (Nothing in Visual Basic). + The dictionary contains too many + elements. + The value for the key. This will be either the existing value for the key if the + key is already in the dictionary, or the new value if the key was not in the dictionary. + + + + Adds a key/value pair to the if the key does not already + exist, or updates a key/value pair in the if the key + already exists. + + The key to be added or whose value should be updated + The function used to generate a value for an absent key + The function used to generate a new value for an existing key + based on the key's existing value + is a null reference + (Nothing in Visual Basic). + is a null reference + (Nothing in Visual Basic). + is a null reference + (Nothing in Visual Basic). + The dictionary contains too many + elements. + The new value for the key. This will be either be the result of addValueFactory (if the key was + absent) or the result of updateValueFactory (if the key was present). + + + + Adds a key/value pair to the if the key does not already + exist, or updates a key/value pair in the if the key + already exists. + + The key to be added or whose value should be updated + The value to be added for an absent key + The function used to generate a new value for an existing key based on + the key's existing value + is a null reference + (Nothing in Visual Basic). + is a null reference + (Nothing in Visual Basic). + The dictionary contains too many + elements. + The new value for the key. This will be either be the result of addValueFactory (if the key was + absent) or the result of updateValueFactory (if the key was present). + + + + Adds the specified key and value to the . + + The object to use as the key of the element to add. + The object to use as the value of the element to add. + is a null reference + (Nothing in Visual Basic). + The dictionary contains too many + elements. + + An element with the same key already exists in the . + + + + Removes the element with the specified key from the . + + The key of the element to remove. + true if the element is successfully remove; otherwise false. This method also returns + false if + was not found in the original . + + is a null reference + (Nothing in Visual Basic). + + + + Adds the specified value to the + with the specified key. + + The + structure representing the key and value to add to the . + The of is null. + The + contains too many elements. + An element with the same key already exists in the + + + + + Determines whether the + contains a specific key and value. + + The + structure to locate in the . + true if the is found in the ; otherwise, false. + + + + Removes a key and value from the dictionary. + + The + structure representing the key and value to remove from the . + true if the key and value represented by is successfully + found and removed; otherwise, false. + The Key property of is a null reference (Nothing in Visual Basic). + + + Returns an enumerator that iterates through the . + An enumerator for the . + + The enumerator returned from the dictionary is safe to use concurrently with + reads and writes to the dictionary, however it does not represent a moment-in-time snapshot + of the dictionary. The contents exposed through the enumerator may contain modifications + made to the dictionary after was called. + + + + + Adds the specified key and value to the dictionary. + + The object to use as the key. + The object to use as the value. + is a null reference + (Nothing in Visual Basic). + The dictionary contains too many + elements. + + is of a type that is not assignable to the key type of the . -or- + is of a type that is not assignable to , + the type of values in the . + -or- A value with the same key already exists in the . + + + + + Gets whether the contains an + element with the specified key. + + The key to locate in the . + true if the contains + an element with the specified key; otherwise, false. + is a null reference + (Nothing in Visual Basic). + + + Provides an for the + . + An for the . + + + + Removes the element with the specified key from the . + + The key of the element to remove. + is a null reference + (Nothing in Visual Basic). + + + + Copies the elements of the to an array, starting + at the specified array index. + + The one-dimensional array that is the destination of the elements copied from + the . The array must have zero-based + indexing. + The zero-based index in at which copying + begins. + is a null reference + (Nothing in Visual Basic). + is less than + 0. + is equal to or greater than + the length of the . -or- The number of elements in the source + is greater than the available space from to the end of the destination + . + + + + Replaces the internal table with a larger one. To prevent multiple threads from resizing the + table as a result of races, the table of buckets that was deemed too small is passed in as + an argument to GrowTable(). GrowTable() obtains a lock, and then checks whether the bucket + table has been replaced in the meantime or not. + + Reference to the bucket table that was deemed too small. + + + + Computes the bucket and lock number for a particular key. + + + + + Acquires all locks for this hash table, and increments locksAcquired by the number + of locks that were successfully acquired. The locks are acquired in an increasing + order. + + + + + Acquires a contiguous range of locks for this hash table, and increments locksAcquired + by the number of locks that were successfully acquired. The locks are acquired in an + increasing order. + + + + + Releases a contiguous range of locks. + + + + + Gets a collection containing the keys in the dictionary. + + + + + Gets a collection containing the values in the dictionary. + + + + + A helper method for asserts. + + + + + Get the data array to be serialized + + + + + Construct the dictionary from a previously seiralized one + + + + + Gets or sets the value associated with the specified key. + + The key of the value to get or set. + The value associated with the specified key. If the specified key is not found, a get + operation throws a + , and a set operation creates a new + element with the specified key. + is a null reference + (Nothing in Visual Basic). + The property is retrieved and + + does not exist in the collection. + + + + Gets the number of key/value pairs contained in the . + + The dictionary contains too many + elements. + The number of key/value paris contained in the . + Count has snapshot semantics and represents the number of items in the + at the moment when Count was accessed. + + + + Gets a value that indicates whether the is empty. + + true if the is empty; otherwise, + false. + + + + Gets a collection containing the keys in the . + + An containing the keys in the + . + + + + Gets a collection containing the values in the . + + An containing the values in + the + . + + + + Gets a value indicating whether the dictionary is read-only. + + true if the is + read-only; otherwise, false. For , this property always returns + false. + + + + Gets a value indicating whether the has a fixed size. + + true if the has a + fixed size; otherwise, false. For , this property always + returns false. + + + + Gets a value indicating whether the is read-only. + + true if the is + read-only; otherwise, false. For , this property always + returns false. + + + + Gets an containing the keys of the . + + An containing the keys of the . + + + + Gets an containing the values in the . + + An containing the values in the . + + + + Gets or sets the value associated with the specified key. + + The key of the value to get or set. + The value associated with the specified key, or a null reference (Nothing in Visual Basic) + if is not in the dictionary or is of a type that is + not assignable to the key type of the . + is a null reference + (Nothing in Visual Basic). + + A value is being assigned, and is of a type that is not assignable to the + key type of the . -or- A value is being + assigned, and is of a type that is not assignable to the value type + of the + + + + + Gets a value indicating whether access to the is + synchronized with the SyncRoot. + + true if access to the is synchronized + (thread safe); otherwise, false. For , this property always + returns false. + + + + Gets an object that can be used to synchronize access to the . This property is not supported. + + The SyncRoot property is not supported. + + + + The number of concurrent writes for which to optimize by default. + + + + + A node in a singly-linked list representing a particular hash table bucket. + + + + + A private class to represent enumeration over the dictionary that implements the + IDictionaryEnumerator interface. + + + + Throws the exception on the ThreadPool. + The exception to propagate. + The target context on which to propagate the exception. Null to use the ThreadPool. + + + Copies the exception's stack trace so its stack trace isn't overwritten. + The exception to prepare. + + + + Provides a builder for asynchronous methods that return . + This type is intended for compiler use only. + + + AsyncTaskMethodBuilder is a value type, and thus it is copied by value. + Prior to being copied, one of its Task, SetResult, or SetException members must be accessed, + or else the copies may end up building distinct Task instances. + + + + Represents an asynchronous method builder. + + + A cached VoidTaskResult task used for builders that complete synchronously. + + + The generic builder object to which this non-generic instance delegates. + + + Initializes a new . + The initialized . + + + Initiates the builder's execution with the associated state machine. + Specifies the type of the state machine. + The state machine instance, passed by reference. + + + Associates the builder with the state machine it represents. + The heap-allocated state machine object. + The argument was null (Nothing in Visual Basic). + The builder is incorrectly initialized. + + + Perform any initialization necessary prior to lifting the builder to the heap. + + + + Schedules the specified state machine to be pushed forward when the specified awaiter completes. + + Specifies the type of the awaiter. + Specifies the type of the state machine. + The awaiter. + The state machine. + + + + Schedules the specified state machine to be pushed forward when the specified awaiter completes. + + Specifies the type of the awaiter. + Specifies the type of the state machine. + The awaiter. + The state machine. + + + + Completes the in the + RanToCompletion state. + + The builder is not initialized. + The task has already completed. + + + + Completes the in the + Faulted state with the specified exception. + + The to use to fault the task. + The argument is null (Nothing in Visual Basic). + The builder is not initialized. + The task has already completed. + + + + Called by the debugger to request notification when the first wait operation + (await, Wait, Result, etc.) on this builder's task completes. + + + true to enable notification; false to disable a previously set notification. + + + + Gets the for this builder. + The representing the builder's asynchronous operation. + The builder is not initialized. + + + + Gets an object that may be used to uniquely identify this builder to the debugger. + + + This property lazily instantiates the ID in a non-thread-safe manner. + It must only be used by the debugger, and only in a single-threaded manner + when no other threads are in the middle of accessing this property or this.Task. + + + + Holds state related to the builder's IAsyncStateMachine. + This is a mutable struct. Be very delicate with it. + + + A reference to the heap-allocated state machine object associated with this builder. + + + Initiates the builder's execution with the associated state machine. + Specifies the type of the state machine. + The state machine instance, passed by reference. + The argument is null (Nothing in Visual Basic). + + + Associates the builder with the state machine it represents. + The heap-allocated state machine object. + The argument was null (Nothing in Visual Basic). + The builder is incorrectly initialized. + + + + Gets the Action to use with an awaiter's OnCompleted or UnsafeOnCompleted method. + On first invocation, the supplied state machine will be boxed. + + Specifies the type of the method builder used. + Specifies the type of the state machine used. + The builder. + The state machine. + An Action to provide to the awaiter. + + + Provides the ability to invoke a state machine's MoveNext method under a supplied ExecutionContext. + + + The context with which to run MoveNext. + + + The state machine whose MoveNext method should be invoked. + + + Initializes the runner. + The context with which to run MoveNext. + + + Invokes MoveNext under the provided context. + + + Cached delegate used with ExecutionContext.Run. + + + Invokes the MoveNext method on the supplied IAsyncStateMachine. + The IAsyncStateMachine machine instance. + + + + Provides a builder for asynchronous methods that return void. + This type is intended for compiler use only. + + + + The synchronization context associated with this operation. + + + State related to the IAsyncStateMachine. + + + An object used by the debugger to uniquely identify this builder. Lazily initialized. + + + Temporary support for disabling crashing if tasks go unobserved. + + + Registers with UnobservedTaskException to suppress exception crashing. + + + Non-zero if PreventUnobservedTaskExceptions has already been invoked. + + + Initializes a new . + The initialized . + + + Initializes the . + The synchronizationContext associated with this operation. This may be null. + + + Initiates the builder's execution with the associated state machine. + Specifies the type of the state machine. + The state machine instance, passed by reference. + The argument was null (Nothing in Visual Basic). + + + Associates the builder with the state machine it represents. + The heap-allocated state machine object. + The argument was null (Nothing in Visual Basic). + The builder is incorrectly initialized. + + + Perform any initialization necessary prior to lifting the builder to the heap. + + + + Schedules the specified state machine to be pushed forward when the specified awaiter completes. + + Specifies the type of the awaiter. + Specifies the type of the state machine. + The awaiter. + The state machine. + + + + Schedules the specified state machine to be pushed forward when the specified awaiter completes. + + Specifies the type of the awaiter. + Specifies the type of the state machine. + The awaiter. + The state machine. + + + Completes the method builder successfully. + + + Faults the method builder with an exception. + The exception that is the cause of this fault. + The argument is null (Nothing in Visual Basic). + The builder is not initialized. + + + Notifies the current synchronization context that the operation completed. + + + + Gets an object that may be used to uniquely identify this builder to the debugger. + + + This property lazily instantiates the ID in a non-thread-safe manner. + It must only be used by the debugger and only in a single-threaded manner. + + + + + Provides a builder for asynchronous methods that return . + This type is intended for compiler use only. + + + AsyncTaskMethodBuilder{TResult} is a value type, and thus it is copied by value. + Prior to being copied, one of its Task, SetResult, or SetException members must be accessed, + or else the copies may end up building distinct Task instances. + + + + A cached task for default(TResult). + + + State related to the IAsyncStateMachine. + + + The lazily-initialized task. + Must be named m_task for debugger step-over to work correctly. + + + The lazily-initialized task completion source. + + + Temporary support for disabling crashing if tasks go unobserved. + + + Initializes a new . + The initialized . + + + Initiates the builder's execution with the associated state machine. + Specifies the type of the state machine. + The state machine instance, passed by reference. + + + Associates the builder with the state machine it represents. + The heap-allocated state machine object. + The argument was null (Nothing in Visual Basic). + The builder is incorrectly initialized. + + + Perform any initialization necessary prior to lifting the builder to the heap. + + + + Schedules the specified state machine to be pushed forward when the specified awaiter completes. + + Specifies the type of the awaiter. + Specifies the type of the state machine. + The awaiter. + The state machine. + + + + Schedules the specified state machine to be pushed forward when the specified awaiter completes. + + Specifies the type of the awaiter. + Specifies the type of the state machine. + The awaiter. + The state machine. + + + + Completes the in the + RanToCompletion state with the specified result. + + The result to use to complete the task. + The task has already completed. + + + + Completes the builder by using either the supplied completed task, or by completing + the builder's previously accessed task using default(TResult). + + A task already completed with the value default(TResult). + The task has already completed. + + + + Completes the in the + Faulted state with the specified exception. + + The to use to fault the task. + The argument is null (Nothing in Visual Basic). + The task has already completed. + + + + Called by the debugger to request notification when the first wait operation + (await, Wait, Result, etc.) on this builder's task completes. + + + true to enable notification; false to disable a previously set notification. + + + This should only be invoked from within an asynchronous method, + and only by the debugger. + + + + + Gets a task for the specified result. This will either + be a cached or new task, never null. + + The result for which we need a task. + The completed task containing the result. + + + Gets the lazily-initialized TaskCompletionSource. + + + Gets the for this builder. + The representing the builder's asynchronous operation. + + + + Gets an object that may be used to uniquely identify this builder to the debugger. + + + This property lazily instantiates the ID in a non-thread-safe manner. + It must only be used by the debugger, and only in a single-threaded manner + when no other threads are in the middle of accessing this property or this.Task. + + + + Provides a base class used to cache tasks of a specific return type. + Specifies the type of results the cached tasks return. + + + + A singleton cache for this result type. + This may be null if there are no cached tasks for this TResult. + + + + Creates a non-disposable task. + The result for the task. + The cacheable task. + + + Creates a cache. + A task cache for this result type. + + + Gets a cached task if one exists. + The result for which we want a cached task. + A cached task if one exists; otherwise, null. + + + Provides a cache for Boolean tasks. + + + A true task. + + + A false task. + + + Gets a cached task for the Boolean result. + true or false + A cached task for the Boolean result. + + + Provides a cache for zero Int32 tasks. + + + The minimum value, inclusive, for which we want a cached task. + + + The maximum value, exclusive, for which we want a cached task. + + + The cache of Task{Int32}. + + + Creates an array of cached tasks for the values in the range [INCLUSIVE_MIN,EXCLUSIVE_MAX). + + + Gets a cached task for the zero Int32 result. + The integer value + A cached task for the Int32 result or null if not cached. + + + + Represents state machines generated for asynchronous methods. + This type is intended for compiler use only. + + + + Moves the state machine to its next state. + + + Configures the state machine with a heap-allocated replica. + The heap-allocated replica. + + + + Represents an awaiter used to schedule continuations when an await operation completes. + + + + + Represents an operation that will schedule continuations when the operation completes. + + + + Schedules the continuation action to be invoked when the instance completes. + The action to invoke when the operation completes. + The argument is null (Nothing in Visual Basic). + + + Schedules the continuation action to be invoked when the instance completes. + The action to invoke when the operation completes. + The argument is null (Nothing in Visual Basic). + Unlike OnCompleted, UnsafeOnCompleted need not propagate ExecutionContext information. + + + Used with Task(of void) + + + + An interface similar to the one added in .NET 4.0. + + + + The exception that is thrown in a thread upon cancellation of an operation that the thread was executing. + + + Initializes the exception. + + + Initializes the exception. + The error message that explains the reason for the exception. + + + Initializes the exception. + The error message that explains the reason for the exception. + The exception that is the cause of the current exception. + + + Initializes the exception. + A cancellation token associated with the operation that was canceled. + + + Initializes the exception. + The error message that explains the reason for the exception. + A cancellation token associated with the operation that was canceled. + + + Initializes the exception. + The error message that explains the reason for the exception. + The exception that is the cause of the current exception. + A cancellation token associated with the operation that was canceled. + + + Gets a token associated with the operation that was canceled. + + + + A dummy replacement for the .NET internal class StackCrawlMark. + + + + + Propogates notification that operations should be canceled. + + + + A may be created directly in an unchangeable canceled or non-canceled state + using the CancellationToken's constructors. However, to have a CancellationToken that can change + from a non-canceled to a canceled state, + CancellationTokenSource must be used. + CancellationTokenSource exposes the associated CancellationToken that may be canceled by the source through its + Token property. + + + Once canceled, a token may not transition to a non-canceled state, and a token whose + is false will never change to one that can be canceled. + + + All members of this struct are thread-safe and may be used concurrently from multiple threads. + + + + + + Internal constructor only a CancellationTokenSource should create a CancellationToken + + + + + Initializes the CancellationToken. + + + The canceled state for the token. + + + Tokens created with this constructor will remain in the canceled state specified + by the parameter. If is false, + both and will be false. + If is true, + both and will be true. + + + + + Registers a delegate that will be called when this CancellationToken is canceled. + + + + If this token is already in the canceled state, the + delegate will be run immediately and synchronously. Any exception the delegate generates will be + propogated out of this method call. + + + The delegate to be executed when the CancellationToken is canceled. + The instance that can + be used to deregister the callback. + is null. + The associated CancellationTokenSource has been disposed. + + + + Registers a delegate that will be called when this + CancellationToken is canceled. + + + + If this token is already in the canceled state, the + delegate will be run immediately and synchronously. Any exception the delegate generates will be + propogated out of this method call. + + + The delegate to be executed when the CancellationToken is canceled. + A Boolean value that indicates whether to capture + the current SynchronizationContext and use it + when invoking the . + The instance that can + be used to deregister the callback. + is null. + The associated CancellationTokenSource has been disposed. + + + + Registers a delegate that will be called when this + CancellationToken is canceled. + + + + If this token is already in the canceled state, the + delegate will be run immediately and synchronously. Any exception the delegate generates will be + propogated out of this method call. + + + The delegate to be executed when the CancellationToken is canceled. + The state to pass to the when the delegate is invoked. This may be null. + The instance that can + be used to deregister the callback. + is null. + The associated CancellationTokenSource has been disposed. + + + + Registers a delegate that will be called when this + CancellationToken is canceled. + + + + If this token is already in the canceled state, the + delegate will be run immediately and synchronously. Any exception the delegate generates will be + propogated out of this method call. + + + The delegate to be executed when the CancellationToken is canceled. + The state to pass to the when the delegate is invoked. This may be null. + A Boolean value that indicates whether to capture + the current SynchronizationContext and use it + when invoking the . + The instance that can + be used to deregister the callback. + is null. + The associated CancellationTokenSource has been disposed. + + + + Determines whether the current CancellationToken instance is equal to the + specified token. + + The other CancellationToken to which to compare this + instance. + True if the instances are equal; otherwise, false. Two tokens are equal if they are associated + with the same CancellationTokenSource or if they were both constructed + from public CancellationToken constructors and their values are equal. + + + + Determines whether the current CancellationToken instance is equal to the + specified . + + The other object to which to compare this instance. + True if is a CancellationToken + and if the two instances are equal; otherwise, false. Two tokens are equal if they are associated + with the same CancellationTokenSource or if they were both constructed + from public CancellationToken constructors and their values are equal. + An associated CancellationTokenSource has been disposed. + + + + Serves as a hash function for a CancellationToken. + + A hash code for the current CancellationToken instance. + + + + Determines whether two CancellationToken instances are equal. + + The first instance. + The second instance. + True if the instances are equal; otherwise, false. + An associated CancellationTokenSource has been disposed. + + + + Determines whether two CancellationToken instances are not equal. + + The first instance. + The second instance. + True if the instances are not equal; otherwise, false. + An associated CancellationTokenSource has been disposed. + + + + Throws a OperationCanceledException if + this token has had cancellation requested. + + + This method provides functionality equivalent to: + + if (token.IsCancellationRequested) + throw new OperationCanceledException(token); + + + The token has had cancellation requested. + The associated CancellationTokenSource has been disposed. + + + + Returns an empty CancellationToken value. + + + The value returned by this property will be non-cancelable by default. + + + + + Gets whether cancellation has been requested for this token. + + Whether cancellation has been requested for this token. + + + This property indicates whether cancellation has been requested for this token, + either through the token initially being construted in a canceled state, or through + calling Cancel + on the token's associated . + + + If this property is true, it only guarantees that cancellation has been requested. + It does not guarantee that every registered handler + has finished executing, nor that cancellation requests have finished propagating + to all registered handlers. Additional synchronization may be required, + particularly in situations where related objects are being canceled concurrently. + + + + + + Gets whether this token is capable of being in the canceled state. + + + If CanBeCanceled returns false, it is guaranteed that the token will never transition + into a canceled state, meaning that will never + return true. + + + + + Gets a that is signaled when the token is canceled. + + Accessing this property causes a WaitHandle + to be instantiated. It is preferable to only use this property when necessary, and to then + dispose the associated instance at the earliest opportunity (disposing + the source will dispose of this allocated handle). The handle should not be closed or disposed directly. + + The associated CancellationTokenSource has been disposed. + + + + Represents a callback delegate that has been registered with a CancellationToken. + + + To unregister a callback, dispose the corresponding Registration instance. + + + + + Attempts to deregister the item. If it's already being run, this may fail. + Entails a full memory fence. + + True if the callback was found and deregistered, false otherwise. + + + + Disposes of the registration and unregisters the target callback from the associated + CancellationToken. + If the target callback is currently executing this method will wait until it completes, except + in the degenerate cases where a callback method deregisters itself. + + + + + Determines whether two CancellationTokenRegistration + instances are equal. + + The first instance. + The second instance. + True if the instances are equal; otherwise, false. + + + + Determines whether two CancellationTokenRegistration instances are not equal. + + The first instance. + The second instance. + True if the instances are not equal; otherwise, false. + + + + Determines whether the current CancellationTokenRegistration instance is equal to the + specified . + + The other object to which to compare this instance. + True, if both this and are equal. False, otherwise. + Two CancellationTokenRegistration instances are equal if + they both refer to the output of a single call to the same Register method of a + CancellationToken. + + + + + Determines whether the current CancellationToken instance is equal to the + specified . + + The other CancellationTokenRegistration to which to compare this instance. + True, if both this and are equal. False, otherwise. + Two CancellationTokenRegistration instances are equal if + they both refer to the output of a single call to the same Register method of a + CancellationToken. + + + + + Serves as a hash function for a CancellationTokenRegistration.. + + A hash code for the current CancellationTokenRegistration instance. + + + + Signals to a that it should be canceled. + + + + is used to instantiate a + (via the source's Token property) + that can be handed to operations that wish to be notified of cancellation or that can be used to + register asynchronous operations for cancellation. That token may have cancellation requested by + calling to the source's Cancel + method. + + + All members of this class, except Dispose, are thread-safe and may be used + concurrently from multiple threads. + + + + + The ID of the thread currently executing the main body of CTS.Cancel() + this helps us to know if a call to ctr.Dispose() is running 'within' a cancellation callback. + This is updated as we move between the main thread calling cts.Cancel() and any syncContexts that are used to + actually run the callbacks. + + + + Initializes the . + + + + + Communicates a request for cancellation. + + + + The associated will be + notified of the cancellation and will transition to a state where + IsCancellationRequested returns true. + Any callbacks or cancelable operations + registered with the will be executed. + + + Cancelable operations and callbacks registered with the token should not throw exceptions. + However, this overload of Cancel will aggregate any exceptions thrown into a , + such that one callback throwing an exception will not prevent other registered callbacks from being executed. + + + The that was captured when each callback was registered + will be reestablished when the callback is invoked. + + + An aggregate exception containing all the exceptions thrown + by the registered callbacks on the associated . + This has been disposed. + + + + Communicates a request for cancellation. + + + + The associated will be + notified of the cancellation and will transition to a state where + IsCancellationRequested returns true. + Any callbacks or cancelable operations + registered with the will be executed. + + + Cancelable operations and callbacks registered with the token should not throw exceptions. + If is true, an exception will immediately propagate out of the + call to Cancel, preventing the remaining callbacks and cancelable operations from being processed. + If is false, this overload will aggregate any + exceptions thrown into a , + such that one callback throwing an exception will not prevent other registered callbacks from being executed. + + + The that was captured when each callback was registered + will be reestablished when the callback is invoked. + + + Specifies whether exceptions should immediately propagate. + An aggregate exception containing all the exceptions thrown + by the registered callbacks on the associated . + This has been disposed. + + + + Releases the resources used by this . + + + This method is not thread-safe for any other concurrent calls. + + + + + Throws an exception if the source has been disposed. + + + + + InternalGetStaticSource() + + Whether the source should be set. + A static source to be shared among multiple tokens. + + + + Registers a callback object. If cancellation has already occurred, the + callback will have been run by the time this method returns. + + + + + + + + + + Invoke the Canceled event. + + + The handlers are invoked synchronously in LIFO order. + + + + + Creates a CancellationTokenSource that will be in the canceled state + when any of the source tokens are in the canceled state. + + The first CancellationToken to observe. + The second CancellationToken to observe. + A CancellationTokenSource that is linked + to the source tokens. + A CancellationTokenSource associated with + one of the source tokens has been disposed. + + + + Creates a CancellationTokenSource that will be in the canceled state + when any of the source tokens are in the canceled state. + + The CancellationToken instances to observe. + A CancellationTokenSource that is linked + to the source tokens. + is null. + A CancellationTokenSource associated with + one of the source tokens has been disposed. + + + + Gets whether cancellation has been requested for this CancellationTokenSource. + + Whether cancellation has been requested for this CancellationTokenSource. + + + This property indicates whether cancellation has been requested for this token source, such as + due to a call to its + Cancel method. + + + If this property returns true, it only guarantees that cancellation has been requested. It does not + guarantee that every handler registered with the corresponding token has finished executing, nor + that cancellation requests have finished propagating to all registered handlers. Additional + synchronization may be required, particularly in situations where related objects are being + canceled concurrently. + + + + + + A simple helper to determine whether cancellation has finished. + + + + + A simple helper to determine whether disposal has occured. + + + + + The ID of the thread that is running callbacks. + + + + + Gets the CancellationToken + associated with this . + + The CancellationToken + associated with this . + The token source has been + disposed. + + + + + + + + + + + + + + The currently executing callback + + + + + A helper class for collating the various bits of information required to execute + cancellation callbacks. + + + + + InternalExecuteCallbackSynchronously_GeneralPath + This will be called on the target synchronization context, however, we still need to restore the required execution context + + + + + A sparsely populated array. Elements can be sparse and some null, but this allows for + lock-free additions and growth, and also for constant time removal (by nulling out). + + The kind of elements contained within. + + + + Allocates a new array with the given initial size. + + How many array slots to pre-allocate. + + + + Adds an element in the first available slot, beginning the search from the tail-to-head. + If no slots are available, the array is grown. The method doesn't return until successful. + + The element to add. + Information about where the add happened, to enable O(1) deregistration. + + + + The tail of the doubly linked list. + + + + + A struct to hold a link to the exact spot in an array an element was inserted, enabling + constant time removal later on. + + + + + A fragment of a sparsely populated array, doubly linked. + + The kind of elements contained within. + + + + Provides lazy initialization routines. + + + These routines avoid needing to allocate a dedicated, lazy-initialization instance, instead using + references to ensure targets have been initialized as they are accessed. + + + + + Initializes a target reference type with the type's default constructor if the target has not + already been initialized. + + The refence type of the reference to be initialized. + A reference of type to initialize if it has not + already been initialized. + The initialized reference of type . + Type does not have a default + constructor. + + Permissions to access the constructor of type were missing. + + + + This method may only be used on reference types. To ensure initialization of value + types, see other overloads of EnsureInitialized. + + + This method may be used concurrently by multiple threads to initialize . + In the event that multiple threads access this method concurrently, multiple instances of + may be created, but only one will be stored into . In such an occurrence, this method will not dispose of the + objects that were not stored. If such objects must be disposed, it is up to the caller to determine + if an object was not used and to then dispose of the object appropriately. + + + + + + Initializes a target reference type using the specified function if it has not already been + initialized. + + The reference type of the reference to be initialized. + The reference of type to initialize if it has not + already been initialized. + The invoked to initialize the + reference. + The initialized reference of type . + Type does not have a + default constructor. + returned + null. + + + This method may only be used on reference types, and may + not return a null reference (Nothing in Visual Basic). To ensure initialization of value types or + to allow null reference types, see other overloads of EnsureInitialized. + + + This method may be used concurrently by multiple threads to initialize . + In the event that multiple threads access this method concurrently, multiple instances of + may be created, but only one will be stored into . In such an occurrence, this method will not dispose of the + objects that were not stored. If such objects must be disposed, it is up to the caller to determine + if an object was not used and to then dispose of the object appropriately. + + + + + + Initialize the target using the given delegate (slow path). + + The reference type of the reference to be initialized. + The variable that need to be initialized + The delegate that will be executed to initialize the target + The initialized variable + + + + Initializes a target reference or value type with its default constructor if it has not already + been initialized. + + The type of the reference to be initialized. + A reference or value of type to initialize if it + has not already been initialized. + A reference to a boolean that determines whether the target has already + been initialized. + A reference to an object used as the mutually exclusive lock for initializing + . + The initialized value of type . + + + + Initializes a target reference or value type with a specified function if it has not already been + initialized. + + The type of the reference to be initialized. + A reference or value of type to initialize if it + has not already been initialized. + A reference to a boolean that determines whether the target has already + been initialized. + A reference to an object used as the mutually exclusive lock for initializing + . + The invoked to initialize the + reference or value. + The initialized value of type . + + + + Ensure the target is initialized and return the value (slow path). This overload permits nulls + and also works for value type targets. Uses the supplied function to create the value. + + The type of target. + A reference to the target to be initialized. + A reference to a location tracking whether the target has been initialized. + A reference to a location containing a mutual exclusive lock. + + The to invoke in order to produce the lazily-initialized value. + + The initialized object. + + + + Provides a slimmed down version of . + + + All public and protected members of are thread-safe and may be used + concurrently from multiple threads, with the exception of Dispose, which + must only be used when all other operations on the have + completed, and Reset, which should only be used when no other threads are + accessing the event. + + + + + Initializes a new instance of the + class with an initial state of nonsignaled. + + + + + Initializes a new instance of the + class with a Boolen value indicating whether to set the intial state to signaled. + + true to set the initial state signaled; false to set the initial state + to nonsignaled. + + + + Initializes a new instance of the + class with a Boolen value indicating whether to set the intial state to signaled and a specified + spin count. + + true to set the initial state to signaled; false to set the initial state + to nonsignaled. + The number of spin waits that will occur before falling back to a true + wait. + is less than + 0 or greater than the maximum allowed value. + + + + Initializes the internal state of the event. + + Whether the event is set initially or not. + The spin count that decides when the event will block. + + + + Helper to ensure the lock object is created before first use. + + + + + This method lazily initializes the event object. It uses CAS to guarantee that + many threads racing to call this at once don't result in more than one event + being stored and used. The event will be signaled or unsignaled depending on + the state of the thin-event itself, with synchronization taken into account. + + True if a new event was created and stored, false otherwise. + + + + Sets the state of the event to signaled, which allows one or more threads waiting on the event to + proceed. + + + + + Private helper to actually perform the Set. + + Indicates whether we are calling Set() during cancellation. + The object has been canceled. + + + + Sets the state of the event to nonsignaled, which causes threads to block. + + + Unlike most of the members of , is not + thread-safe and may not be used concurrently with other members of this instance. + + + + + Blocks the current thread until the current is set. + + + The maximum number of waiters has been exceeded. + + + The caller of this method blocks indefinitely until the current instance is set. The caller will + return immediately if the event is currently in a set state. + + + + + Blocks the current thread until the current receives a signal, + while observing a . + + The to + observe. + + The maximum number of waiters has been exceeded. + + was + canceled. + + The caller of this method blocks indefinitely until the current instance is set. The caller will + return immediately if the event is currently in a set state. + + + + + Blocks the current thread until the current is set, using a + to measure the time interval. + + A that represents the number of milliseconds + to wait, or a that represents -1 milliseconds to wait indefinitely. + + true if the was set; otherwise, + false. + is a negative + number other than -1 milliseconds, which represents an infinite time-out -or- timeout is greater + than . + + The maximum number of waiters has been exceeded. + + + + + Blocks the current thread until the current is set, using a + to measure the time interval, while observing a . + + A that represents the number of milliseconds + to wait, or a that represents -1 milliseconds to wait indefinitely. + + The to + observe. + true if the was set; otherwise, + false. + is a negative + number other than -1 milliseconds, which represents an infinite time-out -or- timeout is greater + than . + was canceled. + + The maximum number of waiters has been exceeded. + + + + + Blocks the current thread until the current is set, using a + 32-bit signed integer to measure the time interval. + + The number of milliseconds to wait, or (-1) to wait indefinitely. + true if the was set; otherwise, + false. + is a + negative number other than -1, which represents an infinite time-out. + + The maximum number of waiters has been exceeded. + + + + + Blocks the current thread until the current is set, using a + 32-bit signed integer to measure the time interval, while observing a . + + The number of milliseconds to wait, or (-1) to wait indefinitely. + The to + observe. + true if the was set; otherwise, + false. + is a + negative number other than -1, which represents an infinite time-out. + + The maximum number of waiters has been exceeded. + + was canceled. + + + + Releases all resources used by the current instance of . + + + Unlike most of the members of , is not + thread-safe and may not be used concurrently with other members of this instance. + + + + + When overridden in a derived class, releases the unmanaged resources used by the + , and optionally releases the managed resources. + + true to release both managed and unmanaged resources; + false to release only unmanaged resources. + + Unlike most of the members of , is not + thread-safe and may not be used concurrently with other members of this instance. + + + + + Throw ObjectDisposedException if the MRES is disposed + + + + + Private helper method to wake up waiters when a cancellationToken gets canceled. + + + + + Private helper method for updating parts of a bit-string state value. + Mainly called from the IsSet and Waiters properties setters + + + Note: the parameter types must be int as CompareExchange cannot take a Uint + + The new value + The mask used to set the bits + + + + Private helper method - performs Mask and shift, particular helpful to extract a field from a packed word. + eg ExtractStatePortionAndShiftRight(0x12345678, 0xFF000000, 24) => 0x12, ie extracting the top 8-bits as a simple integer + + ?? is there a common place to put this rather than being private to MRES? + + + + + + + + + Performs a Mask operation, but does not perform the shift. + This is acceptable for boolean values for which the shift is unnecessary + eg (val & Mask) != 0 is an appropriate way to extract a boolean rather than using + ((val & Mask) >> shiftAmount) == 1 + + ?? is there a common place to put this rather than being private to MRES? + + + + + + + Helper function to measure and update the wait time + + The first time (in Ticks) observed when the wait started. + The orginal wait timeoutout in milliseconds. + The new wait time in milliseconds, -1 if the time expired, -2 if overflow in counters + has occurred. + + + + Gets the underlying object for this . + + The underlying event object fore this . + + Accessing this property forces initialization of an underlying event object if one hasn't + already been created. To simply wait on this , + the public Wait methods should be preferred. + + + + + Gets whether the event is set. + + true if the event has is set; otherwise, false. + + + + Gets the number of spin waits that will be occur before falling back to a true wait. + + + + + How many threads are waiting. + + + + + Provides support for spin-based waiting. + + + + encapsulates common spinning logic. On single-processor machines, yields are + always used instead of busy waits, and on computers with Intel™ processors employing Hyper-Threading™ + technology, it helps to prevent hardware thread starvation. SpinWait encapsulates a good mixture of + spinning and true yielding. + + + is a value type, which means that low-level code can utilize SpinWait without + fear of unnecessary allocation overheads. SpinWait is not generally useful for ordinary applications. + In most cases, you should use the synchronization classes provided by the .NET Framework, such as + . For most purposes where spin waiting is required, however, + the type should be preferred over the System.Threading.Thread.SpinWait method. + + + While SpinWait is designed to be used in concurrent applications, it is not designed to be + used from multiple threads concurrently. SpinWait's members are not thread-safe. If multiple + threads must spin, each should use its own instance of SpinWait. + + + + + + Performs a single spin. + + + This is typically called in a loop, and may change in behavior based on the number of times a + has been called thus far on this instance. + + + + + Resets the spin counter. + + + This makes and behave as though no calls + to had been issued on this instance. If a instance + is reused many times, it may be useful to reset it to avoid yielding too soon. + + + + + Spins until the specified condition is satisfied. + + A delegate to be executed over and over until it returns true. + The argument is null. + + + + Spins until the specified condition is satisfied or until the specified timeout is expired. + + A delegate to be executed over and over until it returns true. + + A that represents the number of milliseconds to wait, + or a TimeSpan that represents -1 milliseconds to wait indefinitely. + True if the condition is satisfied within the timeout; otherwise, false + The argument is null. + is a negative number + other than -1 milliseconds, which represents an infinite time-out -or- timeout is greater than + . + + + + Spins until the specified condition is satisfied or until the specified timeout is expired. + + A delegate to be executed over and over until it returns true. + The number of milliseconds to wait, or (-1) to wait indefinitely. + True if the condition is satisfied within the timeout; otherwise, false + The argument is null. + is a + negative number other than -1, which represents an infinite time-out. + + + + Gets the number of times has been called on this instance. + + + + + Gets whether the next call to will yield the processor, triggering a + forced context switch. + + Whether the next call to will yield the processor, triggering a + forced context switch. + + On a single-CPU machine, always yields the processor. On machines with + multiple CPUs, may yield after an unspecified number of calls. + + + + + A helper class to get the number of preocessors, it updates the numbers of processors every sampling interval + + + + + Gets the number of available processors + + + + + Gets whether the current machine has only a single processor. + + + + + Represents an asynchronous operation that produces a result at some time in the future. + + + The type of the result produced by this . + + + + instances may be created in a variety of ways. The most common approach is by + using the task's property to retrieve a instance that can be used to create tasks for several + purposes. For example, to create a that runs a function, the factory's StartNew + method may be used: + + // C# + var t = Task<int>.Factory.StartNew(() => GenerateResult()); + - or - + var t = Task.Factory.StartNew(() => GenerateResult()); + + ' Visual Basic + Dim t = Task<int>.Factory.StartNew(Function() GenerateResult()) + - or - + Dim t = Task.Factory.StartNew(Function() GenerateResult()) + + + + The class also provides constructors that initialize the task but that do not + schedule it for execution. For performance reasons, the StartNew method should be the + preferred mechanism for creating and scheduling computational tasks, but for scenarios where creation + and scheduling must be separated, the constructors may be used, and the task's + Start + method may then be used to schedule the task for execution at a later time. + + + All members of , except for + Dispose, are thread-safe + and may be used from multiple threads concurrently. + + + + + + Represents an asynchronous operation. + + + + instances may be created in a variety of ways. The most common approach is by + using the Task type's property to retrieve a instance that can be used to create tasks for several + purposes. For example, to create a that runs an action, the factory's StartNew + method may be used: + + // C# + var t = Task.Factory.StartNew(() => DoAction()); + + ' Visual Basic + Dim t = Task.Factory.StartNew(Function() DoAction()) + + + + The class also provides constructors that initialize the Task but that do not + schedule it for execution. For performance reasons, TaskFactory's StartNew method should be the + preferred mechanism for creating and scheduling computational tasks, but for scenarios where creation + and scheduling must be separated, the constructors may be used, and the task's + method may then be used to schedule the task for execution at a later time. + + + All members of , except for , are thread-safe + and may be used from multiple threads concurrently. + + + For operations that return values, the class + should be used. + + + For developers implementing custom debuggers, several internal and private members of Task may be + useful (these may change from release to release). The Int32 m_taskId field serves as the backing + store for the property, however accessing this field directly from a debugger may be + more efficient than accessing the same value through the property's getter method (the + s_taskIdCounter Int32 counter is used to retrieve the next available ID for a Task). Similarly, the + Int32 m_stateFlags field stores information about the current lifecycle stage of the Task, + information also accessible through the property. The m_action System.Object + field stores a reference to the Task's delegate, and the m_stateObject System.Object field stores the + async state passed to the Task by the developer. Finally, for debuggers that parse stack frames, the + InternalWait method serves a potential marker for when a Task is entering a wait operation. + + + + + + A type initializer that runs with the appropriate permissions. + + + + + Initializes a new with the specified action. + + The delegate that represents the code to execute in the Task. + The argument is null. + + + + Initializes a new with the specified action and CancellationToken. + + The delegate that represents the code to execute in the Task. + The CancellationToken + that will be assigned to the new Task. + The argument is null. + The provided CancellationToken + has already been disposed. + + + + + Initializes a new with the specified action and creation options. + + The delegate that represents the code to execute in the task. + + The TaskCreationOptions used to + customize the Task's behavior. + + + The argument is null. + + + The argument specifies an invalid value for . + + + + + Initializes a new with the specified action and creation options. + + The delegate that represents the code to execute in the task. + The that will be assigned to the new task. + + The TaskCreationOptions used to + customize the Task's behavior. + + + The argument is null. + + + The argument specifies an invalid value for . + + The provided CancellationToken + has already been disposed. + + + + + Initializes a new with the specified action and state. + + The delegate that represents the code to execute in the task. + An object representing data to be used by the action. + + The argument is null. + + + + + Initializes a new with the specified action, state, snd options. + + The delegate that represents the code to execute in the task. + An object representing data to be used by the action. + The that will be assigned to the new task. + + The argument is null. + + The provided CancellationToken + has already been disposed. + + + + + Initializes a new with the specified action, state, snd options. + + The delegate that represents the code to execute in the task. + An object representing data to be used by the action. + + The TaskCreationOptions used to + customize the Task's behavior. + + + The argument is null. + + + The argument specifies an invalid value for . + + + + + Initializes a new with the specified action, state, snd options. + + The delegate that represents the code to execute in the task. + An object representing data to be used by the action. + The that will be assigned to the new task. + + The TaskCreationOptions used to + customize the Task's behavior. + + + The argument is null. + + + The argument specifies an invalid value for . + + The provided CancellationToken + has already been disposed. + + + + + An internal constructor used by the factory methods on task and its descendent(s). + This variant does not capture the ExecutionContext; it is up to the caller to do that. + + An action to execute. + Optional state to pass to the action. + Parent of Task. + A CancellationToken for the task. + A task scheduler under which the task will run. + Options to control its execution. + Internal options to control its execution + + + + Common logic used by the following internal ctors: + Task() + Task(object action, object state, Task parent, TaskCreationOptions options, TaskScheduler taskScheduler) + + ASSUMES THAT m_creatingTask IS ALREADY SET. + + + Action for task to execute. + Object to which to pass to action (may be null) + Task scheduler on which to run thread (only used by continuation tasks). + A CancellationToken for the Task. + Options to customize behavior of Task. + Internal options to customize behavior of Task. + + + + Checks if we registered a CT callback during construction, and deregisters it. + This should be called when we know the registration isn't useful anymore. Specifically from Finish() if the task has completed + successfully or with an exception. + + + + + Captures the ExecutionContext so long as flow isn't suppressed. + + A stack crawl mark pointing to the frame of the caller. + + + + Internal function that will be called by a new child task to add itself to + the children list of the parent (this). + + Since a child task can only be created from the thread executing the action delegate + of this task, reentrancy is neither required nor supported. This should not be called from + anywhere other than the task construction/initialization codepaths. + + + + + Starts the , scheduling it for execution to the current TaskScheduler. + + + A task may only be started and run only once. Any attempts to schedule a task a second time + will result in an exception. + + + The is not in a valid state to be started. It may have already been started, + executed, or canceled, or it may have been created in a manner that doesn't support direct + scheduling. + + + The instance has been disposed. + + + + + Starts the , scheduling it for execution to the specified TaskScheduler. + + + A task may only be started and run only once. Any attempts to schedule a task a second time will + result in an exception. + + + The TaskScheduler with which to associate + and execute this task. + + + The argument is null. + + + The is not in a valid state to be started. It may have already been started, + executed, or canceled, or it may have been created in a manner that doesn't support direct + scheduling. + + + The instance has been disposed. + + + + + Runs the synchronously on the current TaskScheduler. + + + + A task may only be started and run only once. Any attempts to schedule a task a second time will + result in an exception. + + + Tasks executed with will be associated with the current TaskScheduler. + + + If the target scheduler does not support running this Task on the current thread, the Task will + be scheduled for execution on the scheduler, and the current thread will block until the + Task has completed execution. + + + + The is not in a valid state to be started. It may have already been started, + executed, or canceled, or it may have been created in a manner that doesn't support direct + scheduling. + + + The instance has been disposed. + + + + + Runs the synchronously on the scheduler provided. + + + + A task may only be started and run only once. Any attempts to schedule a task a second time will + result in an exception. + + + If the target scheduler does not support running this Task on the current thread, the Task will + be scheduled for execution on the scheduler, and the current thread will block until the + Task has completed execution. + + + + The is not in a valid state to be started. It may have already been started, + executed, or canceled, or it may have been created in a manner that doesn't support direct + scheduling. + + + The instance has been disposed. + + The parameter + is null. + The scheduler on which to attempt to run this task inline. + + + + Throws an exception if the task has been disposed, and hence can no longer be accessed. + + The task has been disposed. + + + + Sets the internal completion event. + + + + + Disposes the , releasing all of its unmanaged resources. + + + Unlike most of the members of , this method is not thread-safe. + Also, may only be called on a that is in one of + the final states: RanToCompletion, + Faulted, or + Canceled. + + + The exception that is thrown if the is not in + one of the final states: RanToCompletion, + Faulted, or + Canceled. + + + + + Disposes the , releasing all of its unmanaged resources. + + + A Boolean value that indicates whether this method is being called due to a call to . + + + Unlike most of the members of , this method is not thread-safe. + + + + + Schedules the task for execution. + + If true, TASK_STATE_STARTED bit is turned on in + an atomic fashion, making sure that TASK_STATE_CANCELED does not get set + underneath us. If false, TASK_STATE_STARTED bit is OR-ed right in. This + allows us to streamline things a bit for StartNew(), where competing cancellations + are not a problem. + + + + Adds an exception to the list of exceptions this task has thrown. + + An object representing either an Exception or a collection of Exceptions. + + + + Returns a list of exceptions by aggregating the holder's contents. Or null if + no exceptions have been thrown. + + Whether to include a TCE if cancelled. + An aggregate exception, or null if no exceptions have been caught. + + + + Throws an aggregate exception if the task contains exceptions. + + + + + Checks whether this is an attached task, and whether we are being called by the parent task. + And sets the TASK_STATE_EXCEPTIONOBSERVEDBYPARENT status flag based on that. + + This is meant to be used internally when throwing an exception, and when WaitAll is gathering + exceptions for tasks it waited on. If this flag gets set, the implicit wait on children + will skip exceptions to prevent duplication. + + This should only be called when this task has completed with an exception + + + + + + Signals completion of this particular task. + + The bUserDelegateExecuted parameter indicates whether this Finish() call comes following the + full execution of the user delegate. + + If bUserDelegateExecuted is false, it mean user delegate wasn't invoked at all (either due to + a cancellation request, or because this task is a promise style Task). In this case, the steps + involving child tasks (i.e. WaitForChildren) will be skipped. + + + + + + FinishStageTwo is to be executed as soon as we known there are no more children to complete. + It can happen i) either on the thread that originally executed this task (if no children were spawned, or they all completed by the time this task's delegate quit) + ii) or on the thread that executed the last child. + + + + + Final stage of the task completion code path. Notifies the parent (if any) that another of its childre are done, and runs continuations. + This function is only separated out from FinishStageTwo because these two operations are also needed to be called from CancellationCleanupLogic() + + + + + This is called by children of this task when they are completed. + + + + + This is to be called just before the task does its final state transition. + It traverses the list of exceptional children, and appends their aggregate exceptions into this one's exception list + + + + + Special purpose Finish() entry point to be used when the task delegate throws a ThreadAbortedException + This makes a note in the state flags so that we avoid any costly synchronous operations in the finish codepath + such as inlined continuations + + + Indicates whether the ThreadAbortException was added to this task's exception holder. + This should always be true except for the case of non-root self replicating task copies. + + Whether the delegate was executed. + + + + Executes the task. This method will only be called once, and handles bookeeping associated with + self-replicating tasks, in addition to performing necessary exception marshaling. + + The task has already been disposed. + + + + IThreadPoolWorkItem override, which is the entry function for this task when the TP scheduler decides to run it. + + + + + + Outermost entry function to execute this task. Handles all aspects of executing a task on the caller thread. + Currently this is called by IThreadPoolWorkItem.ExecuteWorkItem(), and TaskManager.TryExecuteInline. + + + Performs atomic updates to prevent double execution. Should only be set to true + in codepaths servicing user provided TaskSchedulers. The ConcRT or ThreadPool schedulers don't need this. + + + + The actual code which invokes the body of the task. This can be overriden in derived types. + + + + + Alternate InnerInvoke prototype to be called from ExecuteSelfReplicating() so that + the Parallel Debugger can discover the actual task being invoked. + Details: Here, InnerInvoke is actually being called on the rootTask object while we are actually executing the + childTask. And the debugger needs to discover the childTask, so we pass that down as an argument. + The NoOptimization and NoInlining flags ensure that the childTask pointer is retained, and that this + function appears on the callstack. + + + + + + Performs whatever handling is necessary for an unhandled exception. Normally + this just entails adding the exception to the holder object. + + The exception that went unhandled. + + + + Waits for the to complete execution. + + + The was canceled -or- an exception was thrown during + the execution of the . + + + The has been disposed. + + + + + Waits for the to complete execution. + + + A that represents the number of milliseconds to wait, or a that represents -1 milliseconds to wait indefinitely. + + + true if the completed execution within the allotted time; otherwise, false. + + + The was canceled -or- an exception was thrown during the execution of the . + + + is a negative number other than -1 milliseconds, which represents an + infinite time-out -or- timeout is greater than + . + + + The has been disposed. + + + + + Waits for the to complete execution. + + + A to observe while waiting for the task to complete. + + + The was canceled. + + + The was canceled -or- an exception was thrown during the execution of the . + + + The + has been disposed. + + + + + Waits for the to complete execution. + + + The number of milliseconds to wait, or (-1) to + wait indefinitely. + true if the completed execution within the allotted time; otherwise, + false. + + + is a negative number other than -1, which represents an + infinite time-out. + + + The was canceled -or- an exception was thrown during the execution of the . + + + The + has been disposed. + + + + + Waits for the to complete execution. + + + The number of milliseconds to wait, or (-1) to + wait indefinitely. + + + A to observe while waiting for the task to complete. + + + true if the completed execution within the allotted time; otherwise, false. + + + The was canceled -or- an exception was thrown during the execution of the . + + + The + has been disposed. + + + is a negative number other than -1, which represents an + infinite time-out. + + + The was canceled. + + + + + The core wait function, which is only accesible internally. It's meant to be used in places in TPL code where + the current context is known or cached. + + + + + Cancels the . + + Indiactes whether we should only cancel non-invoked tasks. + For the default scheduler this option will only be serviced through TryDequeue. + For custom schedulers we also attempt an atomic state transition. + true if the task was successfully canceled; otherwise, false. + The + has been disposed. + + + + Sets the task's cancellation acknowledged flag. + + + + + Runs all of the continuations, as appropriate. + + + + + Helper function to determine whether the current task is in the state desired by the + continuation kind under evaluation. Three possibilities exist: the task failed with + an unhandled exception (OnFailed), the task was canceled before running (OnAborted), + or the task completed successfully (OnCompletedSuccessfully). Note that the last + one includes completing due to cancellation. + + The continuation options under evaluation. + True if the continuation should be run given the task's current state. + + + + Creates a continuation that executes when the target completes. + + + An action to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed, whether it completes due to running to completion successfully, faulting due to an + unhandled exception, or exiting out early due to being canceled. + + + The argument is null. + + + The has been disposed. + + + + + Creates a continuation that executes when the target completes. + + + An action to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + The that will be assigned to the new continuation task. + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed, whether it completes due to running to completion successfully, faulting due to an + unhandled exception, or exiting out early due to being canceled. + + + The argument is null. + + + The has been disposed. + + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation that executes when the target completes. + + + An action to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + + The to associate with the continuation task and to use for its execution. + + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed, whether it completes due to running to completion successfully, faulting due to an + unhandled exception, or exiting out early due to being canceled. + + + The argument is null. + + + The argument is null. + + + The has been disposed. + + + + + Creates a continuation that executes when the target completes. + + + An action to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + + Options for when the continuation is scheduled and how it behaves. This includes criteria, such + as OnlyOnCanceled, as + well as execution options, such as ExecuteSynchronously. + + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed. If the continuation criteria specified through the parameter are not met, the continuation task will be canceled + instead of scheduled. + + + The argument is null. + + + The argument specifies an invalid value for TaskContinuationOptions. + + + The has been disposed. + + + + + Creates a continuation that executes when the target completes. + + + An action to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + + Options for when the continuation is scheduled and how it behaves. This includes criteria, such + as OnlyOnCanceled, as + well as execution options, such as ExecuteSynchronously. + + The that will be assigned to the new continuation task. + + The to associate with the continuation task and to use for its + execution. + + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed. If the criteria specified through the parameter + are not met, the continuation task will be canceled instead of scheduled. + + + The argument is null. + + + The argument specifies an invalid value for TaskContinuationOptions. + + + The argument is null. + + + The has been disposed. + + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation that executes when the target completes. + + + The type of the result produced by the continuation. + + + A function to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed, whether it completes due to running to completion successfully, faulting due to an + unhandled exception, or exiting out early due to being canceled. + + + The argument is null. + + + The has been disposed. + + + + + Creates a continuation that executes when the target completes. + + + The type of the result produced by the continuation. + + + A function to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + The that will be assigned to the new continuation task. + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed, whether it completes due to running to completion successfully, faulting due to an + unhandled exception, or exiting out early due to being canceled. + + + The argument is null. + + + The has been disposed. + + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation that executes when the target completes. + + + The type of the result produced by the continuation. + + + A function to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + + The to associate with the continuation task and to use for its execution. + + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed, whether it completes due to running to completion successfully, faulting due to an + unhandled exception, or exiting out early due to being canceled. + + + The argument is null. + + + The argument is null. + + + The has been disposed. + + + + + Creates a continuation that executes when the target completes. + + + The type of the result produced by the continuation. + + + A function to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + + Options for when the continuation is scheduled and how it behaves. This includes criteria, such + as OnlyOnCanceled, as + well as execution options, such as ExecuteSynchronously. + + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed. If the continuation criteria specified through the parameter are not met, the continuation task will be canceled + instead of scheduled. + + + The argument is null. + + + The argument specifies an invalid value for TaskContinuationOptions. + + + The has been disposed. + + + + + Creates a continuation that executes when the target completes. + + + The type of the result produced by the continuation. + + + A function to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + The that will be assigned to the new continuation task. + + Options for when the continuation is scheduled and how it behaves. This includes criteria, such + as OnlyOnCanceled, as + well as execution options, such as ExecuteSynchronously. + + + The to associate with the continuation task and to use for its + execution. + + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed. If the criteria specified through the parameter + are not met, the continuation task will be canceled instead of scheduled. + + + The argument is null. + + + The argument specifies an invalid value for TaskContinuationOptions. + + + The argument is null. + + + The has been disposed. + + The provided CancellationToken + has already been disposed. + + + + + Converts TaskContinuationOptions to TaskCreationOptions, and also does + some validity checking along the way. + + Incoming TaskContinuationOptions + Outgoing TaskCreationOptions + Outgoing InternalTaskOptions + + + + Registers the continuation and possibly runs it (if the task is already finished). + + The continuation task itself. + TaskScheduler with which to associate continuation task. + Restrictions on when the continuation becomes active. + + + + Waits for all of the provided objects to complete execution. + + + An array of instances on which to wait. + + + The argument is null. + + + The argument contains a null element. + + + At least one of the instances was canceled -or- an exception was thrown during + the execution of at least one of the instances. + + + The has been disposed. + + + + + Waits for all of the provided objects to complete execution. + + + true if all of the instances completed execution within the allotted time; + otherwise, false. + + + An array of instances on which to wait. + + + A that represents the number of milliseconds to wait, or a that represents -1 milliseconds to wait indefinitely. + + + The argument is null. + + + The argument contains a null element. + + + At least one of the instances was canceled -or- an exception was thrown during + the execution of at least one of the instances. + + + is a negative number other than -1 milliseconds, which represents an + infinite time-out -or- timeout is greater than + . + + + The has been disposed. + + + + + Waits for all of the provided objects to complete execution. + + + true if all of the instances completed execution within the allotted time; + otherwise, false. + + + The number of milliseconds to wait, or (-1) to + wait indefinitely. + An array of instances on which to wait. + + + The argument is null. + + + The argument contains a null element. + + + At least one of the instances was canceled -or- an exception was thrown during + the execution of at least one of the instances. + + + The has been disposed. + + + is a negative number other than -1, which represents an + infinite time-out. + + + + + Waits for all of the provided objects to complete execution. + + + true if all of the instances completed execution within the allotted time; + otherwise, false. + + + An array of instances on which to wait. + + + A to observe while waiting for the tasks to complete. + + + The argument is null. + + + The argument contains a null element. + + + At least one of the instances was canceled -or- an exception was thrown during + the execution of at least one of the instances. + + + The was canceled. + + + The has been disposed. + + + + + Waits for all of the provided objects to complete execution. + + + true if all of the instances completed execution within the allotted time; + otherwise, false. + + + An array of instances on which to wait. + + + The number of milliseconds to wait, or (-1) to + wait indefinitely. + + + A to observe while waiting for the tasks to complete. + + + The argument is null. + + + The argument contains a null element. + + + At least one of the instances was canceled -or- an exception was thrown during + the execution of at least one of the instances. + + + The has been disposed. + + + is a negative number other than -1, which represents an + infinite time-out. + + + The was canceled. + + + + + Waits for a set of handles in a STA-aware way. In other words, it will wait for each + of the events individually if we're on a STA thread, because MsgWaitForMultipleObjectsEx + can't do a true wait-all due to its hidden message queue event. This is not atomic, + of course, but we only wait on one-way (MRE) events anyway so this is OK. + + An array of wait handles to wait on. + The timeout to use during waits. + The cancellationToken that enables a wait to be canceled. + True if all waits succeeded, false if a timeout occurred. + + + + Internal WaitAll implementation which is meant to be used with small number of tasks, + optimized for Parallel.Invoke and other structured primitives. + + + + + This internal function is only meant to be called by WaitAll() + If the completed task is canceled or it has other exceptions, here we will add those + into the passed in exception list (which will be lazily initialized here). + + + + + Waits for any of the provided objects to complete execution. + + + An array of instances on which to wait. + + The index of the completed task in the array argument. + + The argument is null. + + + The argument contains a null element. + + + The has been disposed. + + + + + Waits for any of the provided objects to complete execution. + + + An array of instances on which to wait. + + + A that represents the number of milliseconds to wait, or a that represents -1 milliseconds to wait indefinitely. + + + The index of the completed task in the array argument, or -1 if the + timeout occurred. + + + The argument is null. + + + The argument contains a null element. + + + The has been disposed. + + + is a negative number other than -1 milliseconds, which represents an + infinite time-out -or- timeout is greater than + . + + + + + Waits for any of the provided objects to complete execution. + + + An array of instances on which to wait. + + + A to observe while waiting for a task to complete. + + + The index of the completed task in the array argument. + + + The argument is null. + + + The argument contains a null element. + + + The has been disposed. + + + The was canceled. + + + + + Waits for any of the provided objects to complete execution. + + + An array of instances on which to wait. + + + The number of milliseconds to wait, or (-1) to + wait indefinitely. + + + The index of the completed task in the array argument, or -1 if the + timeout occurred. + + + The argument is null. + + + The argument contains a null element. + + + The has been disposed. + + + is a negative number other than -1, which represents an + infinite time-out. + + + + + Waits for any of the provided objects to complete execution. + + + An array of instances on which to wait. + + + The number of milliseconds to wait, or (-1) to + wait indefinitely. + + + A to observe while waiting for a task to complete. + + + The index of the completed task in the array argument, or -1 if the + timeout occurred. + + + The argument is null. + + + The argument contains a null element. + + + The has been disposed. + + + is a negative number other than -1, which represents an + infinite time-out. + + + The was canceled. + + + + + Gets a unique ID for this Task instance. + + + Task IDs are assigned on-demand and do not necessarily represent the order in the which Task + instances were created. + + + + + Returns the unique ID of the currently executing Task. + + + + + Gets the Task instance currently executing, or + null if none exists. + + + + + Gets the Exception that caused the Task to end prematurely. If the Task completed successfully or has not yet thrown any + exceptions, this will return null. + + + Tasks that throw unhandled exceptions store the resulting exception and propagate it wrapped in a + in calls to Wait + or in accesses to the property. Any exceptions not observed by the time + the Task instance is garbage collected will be propagated on the finalizer thread. + + + The Task + has been disposed. + + + + + Gets the TaskStatus of this Task. + + + + + Gets whether this Task instance has completed + execution due to being canceled. + + + A Task will complete in Canceled state either if its CancellationToken + was marked for cancellation before the task started executing, or if the task acknowledged the cancellation request on + its already signaled CancellationToken by throwing an + OperationCanceledException2 that bears the same + CancellationToken. + + + + + Returns true if this task has a cancellation token and it was signaled. + To be used internally in execute entry codepaths. + + + + + This internal property provides access to the CancellationToken that was set on the task + when it was constructed. + + + + + Gets whether this threw an OperationCanceledException2 while its CancellationToken was signaled. + + + + + Gets whether this Task has completed. + + + will return true when the Task is in one of the three + final states: RanToCompletion, + Faulted, or + Canceled. + + + + + Checks whether this task has been disposed. + + + + + Gets the TaskCreationOptions used + to create this task. + + + + + Gets a that can be used to wait for the task to + complete. + + + Using the wait functionality provided by + should be preferred over using for similar + functionality. + + + The has been disposed. + + + + + Gets the state object supplied when the Task was created, + or null if none was supplied. + + + + + Gets an indication of whether the asynchronous operation completed synchronously. + + true if the asynchronous operation completed synchronously; otherwise, false. + + + + Provides access to the TaskScheduler responsible for executing this Task. + + + + + Provides access to factory methods for creating and instances. + + + The factory returned from is a default instance + of , as would result from using + the default constructor on TaskFactory. + + + + + Provides an event that can be used to wait for completion. + Only called by Wait*(), which means that we really do need to instantiate a completion event. + + + + + Determines whether this is the root task of a self replicating group. + + + + + Determines whether the task is a replica itself. + + + + + The property formerly known as IsFaulted. + + + + + Gets whether the completed due to an unhandled exception. + + + If is true, the Task's will be equal to + TaskStatus.Faulted, and its + property will be non-null. + + + + + Checks whether the TASK_STATE_EXCEPTIONOBSERVEDBYPARENT status flag is set, + This will only be used by the implicit wait to prevent double throws + + + + + + Checks whether the body was ever invoked. Used by task scheduler code to verify custom schedulers actually ran the task. + + + + + A structure to hold continuation information. + + + + + Constructs a new continuation structure. + + The task to be activated. + The continuation options. + The scheduler to use for the continuation. + + + + Invokes the continuation for the target completion task. + + The completed task. + Whether the continuation can be inlined. + + + + Initializes a new with the specified function. + + + The delegate that represents the code to execute in the task. When the function has completed, + the task's property will be set to return the result value of the function. + + + The argument is null. + + + + + Initializes a new with the specified function. + + + The delegate that represents the code to execute in the task. When the function has completed, + the task's property will be set to return the result value of the function. + + The to be assigned to this task. + + The argument is null. + + The provided CancellationToken + has already been disposed. + + + + + Initializes a new with the specified function and creation options. + + + The delegate that represents the code to execute in the task. When the function has completed, + the task's property will be set to return the result value of the function. + + + The TaskCreationOptions used to + customize the task's behavior. + + + The argument is null. + + + The argument specifies an invalid value for . + + + + + Initializes a new with the specified function and creation options. + + + The delegate that represents the code to execute in the task. When the function has completed, + the task's property will be set to return the result value of the function. + + The that will be assigned to the new task. + + The TaskCreationOptions used to + customize the task's behavior. + + + The argument is null. + + + The argument specifies an invalid value for . + + The provided CancellationToken + has already been disposed. + + + + + Initializes a new with the specified function and state. + + + The delegate that represents the code to execute in the task. When the function has completed, + the task's property will be set to return the result value of the function. + + An object representing data to be used by the action. + + The argument is null. + + + + + Initializes a new with the specified action, state, and options. + + + The delegate that represents the code to execute in the task. When the function has completed, + the task's property will be set to return the result value of the function. + + An object representing data to be used by the function. + The to be assigned to the new task. + + The argument is null. + + The provided CancellationToken + has already been disposed. + + + + + Initializes a new with the specified action, state, and options. + + + The delegate that represents the code to execute in the task. When the function has completed, + the task's property will be set to return the result value of the function. + + An object representing data to be used by the function. + + The TaskCreationOptions used to + customize the task's behavior. + + + The argument is null. + + + The argument specifies an invalid value for . + + + + + Initializes a new with the specified action, state, and options. + + + The delegate that represents the code to execute in the task. When the function has completed, + the task's property will be set to return the result value of the function. + + An object representing data to be used by the function. + The to be assigned to the new task. + + The TaskCreationOptions used to + customize the task's behavior. + + + The argument is null. + + + The argument specifies an invalid value for . + + The provided CancellationToken + has already been disposed. + + + + + Creates a new future object. + + The parent task for this future. + A function that yields the future value. + The task scheduler which will be used to execute the future. + The CancellationToken for the task. + Options to control the future's behavior. + Internal options to control the future's behavior. + The argument specifies + a SelfReplicating , which is illegal."/>. + + + + Creates a new future object. + + The parent task for this future. + An object containing data to be used by the action; may be null. + A function that yields the future value. + The CancellationToken for the task. + The task scheduler which will be used to execute the future. + Options to control the future's behavior. + Internal options to control the future's behavior. + The argument specifies + a SelfReplicating , which is illegal."/>. + + + + Evaluates the value selector of the Task which is passed in as an object and stores the result. + + + + + Creates a continuation that executes when the target completes. + + + An action to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed, whether it completes due to running to completion successfully, faulting due to an + unhandled exception, or exiting out early due to being canceled. + + + The argument is null. + + + The has been disposed. + + + + + Creates a continuation that executes when the target completes. + + + An action to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + The that will be assigned to the new continuation task. + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed, whether it completes due to running to completion successfully, faulting due to an + unhandled exception, or exiting out early due to being canceled. + + + The argument is null. + + + The has been disposed. + + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation that executes when the target completes. + + + An action to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + + The to associate with the continuation task and to use for its execution. + + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed, whether it completes due to running to completion successfully, faulting due to an + unhandled exception, or exiting out early due to being canceled. + + + The argument is null. + + + The argument is null. + + + The has been disposed. + + + + + Creates a continuation that executes when the target completes. + + + An action to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + + Options for when the continuation is scheduled and how it behaves. This includes criteria, such + as OnlyOnCanceled, as + well as execution options, such as ExecuteSynchronously. + + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed. If the continuation criteria specified through the parameter are not met, the continuation task will be canceled + instead of scheduled. + + + The argument is null. + + + The argument specifies an invalid value for TaskContinuationOptions. + + + The has been disposed. + + + + + Creates a continuation that executes when the target completes. + + + An action to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + The that will be assigned to the new continuation task. + + Options for when the continuation is scheduled and how it behaves. This includes criteria, such + as OnlyOnCanceled, as + well as execution options, such as ExecuteSynchronously. + + + The to associate with the continuation task and to use for its + execution. + + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed. If the criteria specified through the parameter + are not met, the continuation task will be canceled instead of scheduled. + + + The argument is null. + + + The argument specifies an invalid value for TaskContinuationOptions. + + + The argument is null. + + + The has been disposed. + + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation that executes when the target completes. + + + The type of the result produced by the continuation. + + + A function to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + A new continuation . + + The returned will not be scheduled for execution until the current + task has completed, whether it completes due to running to completion successfully, faulting due + to an unhandled exception, or exiting out early due to being canceled. + + + The argument is null. + + + The has been disposed. + + + + + Creates a continuation that executes when the target completes. + + + The type of the result produced by the continuation. + + + A function to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + The that will be assigned to the new task. + A new continuation . + + The returned will not be scheduled for execution until the current + task has completed, whether it completes due to running to completion successfully, faulting due + to an unhandled exception, or exiting out early due to being canceled. + + + The argument is null. + + + The has been disposed. + + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation that executes when the target completes. + + + The type of the result produced by the continuation. + + + A function to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + + The to associate with the continuation task and to use for its execution. + + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed, whether it completes due to running to completion successfully, faulting due to an + unhandled exception, or exiting out early due to being canceled. + + + The argument is null. + + + The argument is null. + + + The has been disposed. + + + + + Creates a continuation that executes when the target completes. + + + The type of the result produced by the continuation. + + + A function to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + + Options for when the continuation is scheduled and how it behaves. This includes criteria, such + as OnlyOnCanceled, as + well as execution options, such as ExecuteSynchronously. + + A new continuation . + + + The returned will not be scheduled for execution until the current + task has completed, whether it completes due to running to completion successfully, faulting due + to an unhandled exception, or exiting out early due to being canceled. + + + The , when executed, should return a . This task's completion state will be transferred to the task returned + from the ContinueWith call. + + + + The argument is null. + + + The argument specifies an invalid value for TaskContinuationOptions. + + + The has been disposed. + + + + + Creates a continuation that executes when the target completes. + + + The type of the result produced by the continuation. + + + A function to run when the completes. When run, the delegate will be passed as + an argument this completed task. + + The that will be assigned to the new task. + + Options for when the continuation is scheduled and how it behaves. This includes criteria, such + as OnlyOnCanceled, as + well as execution options, such as ExecuteSynchronously. + + + The to associate with the continuation task and to use for its + execution. + + A new continuation . + + + The returned will not be scheduled for execution until the current task has + completed, whether it completes due to running to completion successfully, faulting due to an + unhandled exception, or exiting out early due to being canceled. + + + The , when executed, should return a . + This task's completion state will be transferred to the task returned from the + ContinueWith call. + + + + The argument is null. + + + The argument specifies an invalid value for TaskContinuationOptions. + + + The argument is null. + + + The has been disposed. + + The provided CancellationToken + has already been disposed. + + + + + Gets the result value of this . + + + The get accessor for this property ensures that the asynchronous operation is complete before + returning. Once the result of the computation is available, it is stored and will be returned + immediately on later calls to . + + + + + Provides access to factory methods for creating instances. + + + The factory returned from is a default instance + of , as would result from using + the default constructor on the factory type. + + + + + Provides support for creating and scheduling + Task{TResult} objects. + + The type of the results that are available though + the Task{TResult} objects that are associated with + the methods in this class. + + + There are many common patterns for which tasks are relevant. The + class encodes some of these patterns into methods that pick up default settings, which are + configurable through its constructors. + + + A default instance of is available through the + Task{TResult}.Factory property. + + + + + + Initializes a instance with the default configuration. + + + This constructor creates a instance with a default configuration. The + property is initialized to + TaskCreationOptions.None, the + property is initialized to TaskContinuationOptions.None, + and the TaskScheduler property is + initialized to the current scheduler (see TaskScheduler.Current). + + + + + Initializes a instance with the default configuration. + + The default that will be assigned + to tasks created by this unless another CancellationToken is explicitly specified + while calling the factory methods. + + This constructor creates a instance with a default configuration. The + property is initialized to + TaskCreationOptions.None, the + property is initialized to TaskContinuationOptions.None, + and the TaskScheduler property is + initialized to the current scheduler (see TaskScheduler.Current). + + + + + Initializes a instance with the specified configuration. + + + The + TaskScheduler to use to schedule any tasks created with this TaskFactory{TResult}. A null value + indicates that the current TaskScheduler should be used. + + + With this constructor, the + property is initialized to + TaskCreationOptions.None, the + property is initialized to TaskContinuationOptions.None, + and the TaskScheduler property is + initialized to , unless it's null, in which case the property is + initialized to the current scheduler (see TaskScheduler.Current). + + + + + Initializes a instance with the specified configuration. + + + The default + TaskCreationOptions to use when creating tasks with this TaskFactory{TResult}. + + + The default + TaskContinuationOptions to use when creating continuation tasks with this TaskFactory{TResult}. + + + The exception that is thrown when the + argument or the + argument specifies an invalid value. + + + With this constructor, the + property is initialized to , + the + property is initialized to , and the TaskScheduler property is initialized to the + current scheduler (see TaskScheduler.Current). + + + + + Initializes a instance with the specified configuration. + + The default that will be assigned + to tasks created by this unless another CancellationToken is explicitly specified + while calling the factory methods. + + The default + TaskCreationOptions to use when creating tasks with this TaskFactory{TResult}. + + + The default + TaskContinuationOptions to use when creating continuation tasks with this TaskFactory{TResult}. + + + The default + TaskScheduler to use to schedule any Tasks created with this TaskFactory{TResult}. A null value + indicates that TaskScheduler.Current should be used. + + + The exception that is thrown when the + argument or the + argumentspecifies an invalid value. + + + With this constructor, the + property is initialized to , + the + property is initialized to , and the TaskScheduler property is initialized to + , unless it's null, in which case the property is initialized to the + current scheduler (see TaskScheduler.Current). + + + + + Creates and starts a . + + A function delegate that returns the future result to be available through + the . + The started . + The exception that is thrown when the + argument is null. + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + A function delegate that returns the future result to be available through + the . + The that will be assigned to the new task. + The started . + The exception that is thrown when the + argument is null. + The provided CancellationToken + has already been disposed. + + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + A function delegate that returns the future result to be available through + the . + A TaskCreationOptions value that controls the behavior of the + created + . + The started . + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + A function delegate that returns the future result to be available through + the . + A TaskCreationOptions value that controls the behavior of the + created + . + The that will be assigned to the new task. + The TaskScheduler + that is used to schedule the created + Task{TResult}. + The started . + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The provided CancellationToken + has already been disposed. + + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + A function delegate that returns the future result to be available through + the . + An object containing data to be used by the + delegate. + The started . + The exception that is thrown when the + argument is null. + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + A function delegate that returns the future result to be available through + the . + An object containing data to be used by the + delegate. + The that will be assigned to the new task. + The started . + The exception that is thrown when the + argument is null. + The provided CancellationToken + has already been disposed. + + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + A function delegate that returns the future result to be available through + the . + An object containing data to be used by the + delegate. + A TaskCreationOptions value that controls the behavior of the + created + . + The started . + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + A function delegate that returns the future result to be available through + the . + An object containing data to be used by the + delegate. + The that will be assigned to the new task. + A TaskCreationOptions value that controls the behavior of the + created + . + The TaskScheduler + that is used to schedule the created + Task{TResult}. + The started . + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The provided CancellationToken + has already been disposed. + + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates a Task that executes an end + method function when a specified IAsyncResult completes. + + The IAsyncResult whose completion should trigger the processing of the + . + The function delegate that processes the completed . + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + A Task that represents the + asynchronous operation. + + + + Creates a Task that executes an end + method function when a specified IAsyncResult completes. + + The IAsyncResult whose completion should trigger the processing of the + . + The function delegate that processes the completed . + The TaskCreationOptions value that controls the behavior of the + created Task. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + A Task that represents the + asynchronous operation. + + + + Creates a Task that executes an end + method function when a specified IAsyncResult completes. + + The IAsyncResult whose completion should trigger the processing of the + . + The function delegate that processes the completed . + The TaskScheduler + that is used to schedule the task that executes the end method. + The TaskCreationOptions value that controls the behavior of the + created Task. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + A Task that represents the + asynchronous operation. + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The TaskCreationOptions value that controls the behavior of the + created Task. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The TaskCreationOptions value that controls the behavior of the + created Task. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the delegate. + The type of the second argument passed to + delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The second argument passed to the + delegate. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the delegate. + The type of the second argument passed to + delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The second argument passed to the + delegate. + The TaskCreationOptions value that controls the behavior of the + created Task. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the delegate. + The type of the second argument passed to + delegate. + The type of the third argument passed to + delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The second argument passed to the + delegate. + The third argument passed to the + delegate. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the delegate. + The type of the second argument passed to + delegate. + The type of the third argument passed to + delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The second argument passed to the + delegate. + The third argument passed to the + delegate. + The TaskCreationOptions value that controls the behavior of the + created Task. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The array of tasks from which to continue. + The function delegate to execute when all tasks in + the array have completed. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The array of tasks from which to continue. + The function delegate to execute when all tasks in + the array have completed. + The CancellationToken + that will be assigned to the new continuation task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The array of tasks from which to continue. + The function delegate to execute when all tasks in the array have completed. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAll. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The array of tasks from which to continue. + The function delegate to execute when all tasks in the array have completed. + The CancellationToken + that will be assigned to the new continuation task. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The TaskScheduler + that is used to schedule the created continuation Task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAll. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result of the antecedent . + The array of tasks from which to continue. + The function delegate to execute when all tasks in the + array have completed. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result of the antecedent . + The array of tasks from which to continue. + The function delegate to execute when all tasks in the + array have completed. + The CancellationToken + that will be assigned to the new continuation task. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result of the antecedent . + The array of tasks from which to continue. + The function delegate to execute when all tasks in the + array have completed. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAll. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result of the antecedent . + The array of tasks from which to continue. + The function delegate to execute when all tasks in the + array have completed. + The CancellationToken + that will be assigned to the new continuation task. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The TaskScheduler + that is used to schedule the created continuation . + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAll. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the array completes. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the array completes. + The CancellationToken + that will be assigned to the new continuation task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the array completes. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAny. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the array completes. + The CancellationToken + that will be assigned to the new continuation task. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The TaskScheduler + that is used to schedule the created continuation Task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAny. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result of the antecedent . + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the + array completes. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result of the antecedent . + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the + array completes. + The CancellationToken + that will be assigned to the new continuation task. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result of the antecedent . + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the + array completes. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAny. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result of the antecedent . + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the + array completes. + The CancellationToken + that will be assigned to the new continuation task. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The TaskScheduler + that is used to schedule the created continuation . + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAny. + + + + + Gets the default CancellationToken of this + TaskFactory. + + + This property returns the default that will be assigned to all + tasks created by this factory unless another CancellationToken value is explicitly specified + during the call to the factory methods. + + + + + Gets the TaskScheduler of this + TaskFactory{TResult}. + + + This property returns the default scheduler for this factory. It will be used to schedule all + tasks unless another scheduler is explicitly specified during calls to this factory's methods. + If null, TaskScheduler.Current + will be used. + + + + + Gets the TaskCreationOptions + value of this TaskFactory{TResult}. + + + This property returns the default creation options for this factory. They will be used to create all + tasks unless other options are explicitly specified during calls to this factory's methods. + + + + + Gets the TaskContinuationOptions + value of this TaskFactory{TResult}. + + + This property returns the default continuation options for this factory. They will be used to create + all continuation tasks unless other options are explicitly specified during calls to this factory's methods. + + + + + Represents the current stage in the lifecycle of a . + + + + + The task has been initialized but has not yet been scheduled. + + + + + The task is waiting to be activated and scheduled internally by the .NET Framework infrastructure. + + + + + The task has been scheduled for execution but has not yet begun executing. + + + + + The task is running but has not yet completed. + + + + + The task has finished executing and is implicitly waiting for + attached child tasks to complete. + + + + + The task completed execution successfully. + + + + + The task acknowledged cancellation by throwing an OperationCanceledException2 with its own CancellationToken + while the token was in signaled state, or the task's CancellationToken was already signaled before the + task started executing. + + + + + The task completed due to an unhandled exception. + + + + + Specifies flags that control optional behavior for the creation and execution of tasks. + + + + + Specifies that the default behavior should be used. + + + + + A hint to a TaskScheduler to schedule a + task in as fair a manner as possible, meaning that tasks scheduled sooner will be more likely to + be run sooner, and tasks scheduled later will be more likely to be run later. + + + + + Specifies that a task will be a long-running, course-grained operation. It provides a hint to the + TaskScheduler that oversubscription may be + warranted. + + + + + Specifies that a task is attached to a parent in the task hierarchy. + + + + + Task creation flags which are only used internally. + + + + Specifies "No internal task options" + + + Used to filter out internal vs. public task creation options. + + + Specifies that the task will be queued by the runtime before handing it over to the user. + This flag will be used to skip the cancellationtoken registration step, which is only meant for unstarted tasks. + + + + Specifies flags that control optional behavior for the creation and execution of continuation tasks. + + + + + Default = "Continue on any, no task options, run asynchronously" + Specifies that the default behavior should be used. Continuations, by default, will + be scheduled when the antecedent task completes, regardless of the task's final TaskStatus. + + + + + A hint to a TaskScheduler to schedule a + task in as fair a manner as possible, meaning that tasks scheduled sooner will be more likely to + be run sooner, and tasks scheduled later will be more likely to be run later. + + + + + Specifies that a task will be a long-running, course-grained operation. It provides + a hint to the TaskScheduler that + oversubscription may be warranted. + + + + + Specifies that a task is attached to a parent in the task hierarchy. + + + + + Specifies that the continuation task should not be scheduled if its antecedent ran to completion. + This option is not valid for multi-task continuations. + + + + + Specifies that the continuation task should not be scheduled if its antecedent threw an unhandled + exception. This option is not valid for multi-task continuations. + + + + + Specifies that the continuation task should not be scheduled if its antecedent was canceled. This + option is not valid for multi-task continuations. + + + + + Specifies that the continuation task should be scheduled only if its antecedent ran to + completion. This option is not valid for multi-task continuations. + + + + + Specifies that the continuation task should be scheduled only if its antecedent threw an + unhandled exception. This option is not valid for multi-task continuations. + + + + + Specifies that the continuation task should be scheduled only if its antecedent was canceled. + This option is not valid for multi-task continuations. + + + + + Specifies that the continuation task should be executed synchronously. With this option + specified, the continuation will be run on the same thread that causes the antecedent task to + transition into its final state. If the antecedent is already complete when the continuation is + created, the continuation will run on the thread creating the continuation. Only very + short-running continuations should be executed synchronously. + + + + + Represents an exception used to communicate task cancellation. + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the + class with a specified error message. + + The error message that explains the reason for the exception. + + + + Initializes a new instance of the + class with a specified error message and a reference to the inner exception that is the cause of + this exception. + + The error message that explains the reason for the exception. + The exception that is the cause of the current exception. + + + + Initializes a new instance of the class + with a reference to the that has been canceled. + + A task that has been canceled. + + + + Gets the task associated with this exception. + + + It is permissible for no Task to be associated with a + , in which case + this property will return null. + + + + + Represents the producer side of a unbound to a + delegate, providing access to the consumer side through the property. + + + + It is often the case that a is desired to + represent another asynchronous operation. + TaskCompletionSource is provided for this purpose. It enables + the creation of a task that can be handed out to consumers, and those consumers can use the members + of the task as they would any other. However, unlike most tasks, the state of a task created by a + TaskCompletionSource is controlled explicitly by the methods on TaskCompletionSource. This enables the + completion of the external asynchronous operation to be propagated to the underlying Task. The + separation also ensures that consumers are not able to transition the state without access to the + corresponding TaskCompletionSource. + + + All members of are thread-safe + and may be used from multiple threads concurrently. + + + The type of the result value assocatied with this . + + + + Creates a . + + + + + Creates a + with the specified options. + + + The created + by this instance and accessible through its property + will be instantiated using the specified . + + The options to use when creating the underlying + . + + The represent options invalid for use + with a . + + + + + Creates a + with the specified state. + + The state to use as the underlying + 's AsyncState. + + + + Creates a with + the specified state and options. + + The options to use when creating the underlying + . + The state to use as the underlying + 's AsyncState. + + The represent options invalid for use + with a . + + + + + Attempts to transition the underlying + into the + Faulted + state. + + The exception to bind to this . + True if the operation was successful; otherwise, false. + This operation will return false if the + is already in one + of the three final states: + RanToCompletion, + Faulted, or + Canceled. + + The argument is null. + The was disposed. + + + + Attempts to transition the underlying + into the + Faulted + state. + + The collection of exceptions to bind to this . + True if the operation was successful; otherwise, false. + This operation will return false if the + is already in one + of the three final states: + RanToCompletion, + Faulted, or + Canceled. + + The argument is null. + There are one or more null elements in . + The collection is empty. + The was disposed. + + + + Transitions the underlying + into the + Faulted + state. + + The exception to bind to this . + The argument is null. + + The underlying is already in one + of the three final states: + RanToCompletion, + Faulted, or + Canceled. + + The was disposed. + + + + Transitions the underlying + into the + Faulted + state. + + The collection of exceptions to bind to this . + The argument is null. + There are one or more null elements in . + + The underlying is already in one + of the three final states: + RanToCompletion, + Faulted, or + Canceled. + + The was disposed. + + + + Attempts to transition the underlying + into the + RanToCompletion + state. + + The result value to bind to this . + True if the operation was successful; otherwise, false. + This operation will return false if the + is already in one + of the three final states: + RanToCompletion, + Faulted, or + Canceled. + + The was disposed. + + + + Transitions the underlying + into the + RanToCompletion + state. + + The result value to bind to this . + + The underlying is already in one + of the three final states: + RanToCompletion, + Faulted, or + Canceled. + + The was disposed. + + + + Transitions the underlying + into the + Canceled + state. + + + The underlying is already in one + of the three final states: + RanToCompletion, + Faulted, or + Canceled. + + The was disposed. + + + + Attempts to transition the underlying + into the + Canceled + state. + + True if the operation was successful; otherwise, false. + This operation will return false if the + is already in one + of the three final states: + RanToCompletion, + Faulted, or + Canceled. + + The was disposed. + + + + Gets the created + by this . + + + This property enables a consumer access to the that is controlled by this instance. + The , , + , and + methods (and their "Try" variants) on this instance all result in the relevant state + transitions on this underlying Task. + + + + + An exception holder manages a list of exceptions for one particular task. + It offers the ability to aggregate, but more importantly, also offers intrinsic + support for propagating unhandled exceptions that are never observed. It does + this by aggregating and throwing if the holder is ever GC'd without the holder's + contents ever having been requested (e.g. by a Task.Wait, Task.get_Exception, etc). + + + + + Creates a new holder; it will be registered for finalization. + + The task this holder belongs to. + + + + A finalizer that repropagates unhandled exceptions. + + + + + Add an exception to the internal list. This will ensure the holder is + in the proper state (handled/unhandled) depending on the list's contents. + + An exception object (either an Exception or an + IEnumerable{Exception}) to add to the list. + + + + A private helper method that ensures the holder is considered + unhandled, i.e. it is registered for finalization. + + + + + A private helper method that ensures the holder is considered + handled, i.e. it is not registered for finalization. + + Whether this is called from the finalizer thread. + + + + Allocates a new aggregate exception and adds the contents of the list to + it. By calling this method, the holder assumes exceptions to have been + "observed", such that the finalization check will be subsequently skipped. + + Whether this is being called from a finalizer. + An extra exception to be included (optionally). + The aggregate exception to throw. + + + + Provides a set of static (Shared in Visual Basic) methods for working with specific kinds of + instances. + + + + + Creates a proxy Task that represents the + asynchronous operation of a Task{Task}. + + + It is often useful to be able to return a Task from a + Task{TResult}, where the inner Task represents work done as part of the outer Task{TResult}. However, + doing so results in a Task{Task}, which, if not dealt with carefully, could produce unexpected behavior. Unwrap + solves this problem by creating a proxy Task that represents the entire asynchronous operation of such a Task{Task}. + + The Task{Task} to unwrap. + The exception that is thrown if the + argument is null. + A Task that represents the asynchronous operation of the provided Task{Task}. + + + + Creates a proxy Task{TResult} that represents the + asynchronous operation of a Task{Task{TResult}}. + + + It is often useful to be able to return a Task{TResult} from a Task{TResult}, where the inner Task{TResult} + represents work done as part of the outer Task{TResult}. However, doing so results in a Task{Task{TResult}}, + which, if not dealt with carefully, could produce unexpected behavior. Unwrap solves this problem by + creating a proxy Task{TResult} that represents the entire asynchronous operation of such a Task{Task{TResult}}. + + The Task{Task{TResult}} to unwrap. + The exception that is thrown if the + argument is null. + A Task{TResult} that represents the asynchronous operation of the provided Task{Task{TResult}}. /// Unwraps a Task that returns another Task. + + + + Provides support for creating and scheduling + Tasks. + + + + There are many common patterns for which tasks are relevant. The + class encodes some of these patterns into methods that pick up default settings, which are + configurable through its constructors. + + + A default instance of is available through the + Task.Factory property. + + + + + + Initializes a instance with the default configuration. + + + This constructor creates a instance with a default configuration. The + property is initialized to + TaskCreationOptions.None, the + property is initialized to TaskContinuationOptions.None, + and the TaskScheduler property is + initialized to the current scheduler (see TaskScheduler.Current). + + + + + Initializes a instance with the specified configuration. + + The default that will be assigned + to tasks created by this unless another CancellationToken is explicitly specified + while calling the factory methods. + + This constructor creates a instance with a default configuration. The + property is initialized to + TaskCreationOptions.None, the + property is initialized to TaskContinuationOptions.None, + and the TaskScheduler property is + initialized to the current scheduler (see TaskScheduler.Current). + + + + + Initializes a instance with the specified configuration. + + + The + TaskScheduler to use to schedule any tasks created with this TaskFactory. A null value + indicates that the current TaskScheduler should be used. + + + With this constructor, the + property is initialized to + TaskCreationOptions.None, the + property is initialized to TaskContinuationOptions.None, + and the TaskScheduler property is + initialized to , unless it's null, in which case the property is + initialized to the current scheduler (see TaskScheduler.Current). + + + + + Initializes a instance with the specified configuration. + + + The default + TaskCreationOptions to use when creating tasks with this TaskFactory. + + + The default + TaskContinuationOptions to use when creating continuation tasks with this TaskFactory. + + + The exception that is thrown when the + argument or the + argument specifies an invalid value. + + + With this constructor, the + property is initialized to , + the + property is initialized to , and the TaskScheduler property is initialized to the + current scheduler (see TaskScheduler.Current). + + + + + Initializes a instance with the specified configuration. + + The default that will be assigned + to tasks created by this unless another CancellationToken is explicitly specified + while calling the factory methods. + + The default + TaskCreationOptions to use when creating tasks with this TaskFactory. + + + The default + TaskContinuationOptions to use when creating continuation tasks with this TaskFactory. + + + The default + TaskScheduler to use to schedule any Tasks created with this TaskFactory. A null value + indicates that TaskScheduler.Current should be used. + + + The exception that is thrown when the + argument or the + argumentspecifies an invalid value. + + + With this constructor, the + property is initialized to , + the + property is initialized to , and the TaskScheduler property is initialized to + , unless it's null, in which case the property is initialized to the + current scheduler (see TaskScheduler.Current). + + + + + Creates and starts a Task. + + The action delegate to execute asynchronously. + The started Task. + The exception that is thrown when the + argument is null. + + Calling StartNew is functionally equivalent to creating a Task using one of its constructors + and then calling + Start to schedule it for execution. However, + unless creation and scheduling must be separated, StartNew is the recommended + approach for both simplicity and performance. + + + + + Creates and starts a Task. + + The action delegate to execute asynchronously. + The that will be assigned to the new task. + The started Task. + The exception that is thrown when the + argument is null. + The provided CancellationToken + has already been disposed. + + + Calling StartNew is functionally equivalent to creating a Task using one of its constructors + and then calling + Start to schedule it for execution. However, + unless creation and scheduling must be separated, StartNew is the recommended + approach for both simplicity and performance. + + + + + Creates and starts a Task. + + The action delegate to execute asynchronously. + A TaskCreationOptions value that controls the behavior of the + created + Task. + The started Task. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + + Calling StartNew is functionally equivalent to creating a Task using one of its constructors and + then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a Task. + + The action delegate to execute asynchronously. + The that will be assigned to the new + A TaskCreationOptions value that controls the behavior of the + created + Task. + The TaskScheduler + that is used to schedule the created Task. + The started Task. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The provided CancellationToken + has already been disposed. + + + Calling StartNew is functionally equivalent to creating a Task using one of its constructors and + then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a Task. + + The action delegate to execute asynchronously. + An object containing data to be used by the + delegate. + The started Task. + The exception that is thrown when the + argument is null. + + Calling StartNew is functionally equivalent to creating a Task using one of its constructors and + then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a Task. + + The action delegate to execute asynchronously. + An object containing data to be used by the + delegate. + The that will be assigned to the new + The started Task. + The exception that is thrown when the + argument is null. + The provided CancellationToken + has already been disposed. + + + Calling StartNew is functionally equivalent to creating a Task using one of its constructors and + then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a Task. + + The action delegate to execute asynchronously. + An object containing data to be used by the + delegate. + A TaskCreationOptions value that controls the behavior of the + created + Task. + The started Task. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + + Calling StartNew is functionally equivalent to creating a Task using one of its constructors and + then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a Task. + + The action delegate to execute asynchronously. + An object containing data to be used by the + delegate. + The that will be assigned to the new task. + A TaskCreationOptions value that controls the behavior of the + created + Task. + The TaskScheduler + that is used to schedule the created Task. + The started Task. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The provided CancellationToken + has already been disposed. + + + Calling StartNew is functionally equivalent to creating a Task using one of its constructors and + then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + The type of the result available through the + Task. + + A function delegate that returns the future result to be available through + the . + The started . + The exception that is thrown when the + argument is null. + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + The type of the result available through the + Task. + + A function delegate that returns the future result to be available through + the . + The that will be assigned to the new + The started . + The exception that is thrown when the + argument is null. + The provided CancellationToken + has already been disposed. + + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + The type of the result available through the + Task. + + A function delegate that returns the future result to be available through + the . + A TaskCreationOptions value that controls the behavior of the + created + . + The started . + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + The type of the result available through the + Task. + + A function delegate that returns the future result to be available through + the . + The that will be assigned to the new task. + A TaskCreationOptions value that controls the behavior of the + created + . + The TaskScheduler + that is used to schedule the created + Task{TResult}. + The started . + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The provided CancellationToken + has already been disposed. + + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + The type of the result available through the + Task. + + A function delegate that returns the future result to be available through + the . + An object containing data to be used by the + delegate. + The started . + The exception that is thrown when the + argument is null. + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + The type of the result available through the + Task. + + A function delegate that returns the future result to be available through + the . + An object containing data to be used by the + delegate. + The that will be assigned to the new + The started . + The exception that is thrown when the + argument is null. + The provided CancellationToken + has already been disposed. + + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + The type of the result available through the + Task. + + A function delegate that returns the future result to be available through + the . + An object containing data to be used by the + delegate. + A TaskCreationOptions value that controls the behavior of the + created + . + The started . + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + The type of the result available through the + Task. + + A function delegate that returns the future result to be available through + the . + An object containing data to be used by the + delegate. + The that will be assigned to the new task. + A TaskCreationOptions value that controls the behavior of the + created + . + The TaskScheduler + that is used to schedule the created + Task{TResult}. + The started . + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The provided CancellationToken + has already been disposed. + + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates a Task that executes an end method action + when a specified IAsyncResult completes. + + The IAsyncResult whose completion should trigger the processing of the + . + The action delegate that processes the completed . + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + A Task that represents the asynchronous + operation. + + + + Creates a Task that executes an end method action + when a specified IAsyncResult completes. + + The IAsyncResult whose completion should trigger the processing of the + . + The action delegate that processes the completed . + The TaskCreationOptions value that controls the behavior of the + created Task. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + A Task that represents the asynchronous + operation. + + + + Creates a Task that executes an end method action + when a specified IAsyncResult completes. + + The IAsyncResult whose completion should trigger the processing of the + . + The action delegate that processes the completed . + The TaskScheduler + that is used to schedule the task that executes the end method. + The TaskCreationOptions value that controls the behavior of the + created Task. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + A Task that represents the asynchronous + operation. + + + + Creates a Task that represents a pair of begin + and end methods that conform to the Asynchronous Programming Model pattern. + + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The created Task that represents the + asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of begin + and end methods that conform to the Asynchronous Programming Model pattern. + + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The TaskCreationOptions value that controls the behavior of the + created Task. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The created Task that represents the + asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of begin + and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the + delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The created Task that represents the + asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of begin + and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the + delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The TaskCreationOptions value that controls the behavior of the + created Task. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The created Task that represents the + asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of begin + and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the + delegate. + The type of the second argument passed to + delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The second argument passed to the + delegate. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The created Task that represents the + asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of begin + and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the + delegate. + The type of the second argument passed to + delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The second argument passed to the + delegate. + The TaskCreationOptions value that controls the behavior of the + created Task. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The created Task that represents the + asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of begin + and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the + delegate. + The type of the second argument passed to + delegate. + The type of the third argument passed to + delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The second argument passed to the + delegate. + The third argument passed to the + delegate. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The created Task that represents the + asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of begin + and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the + delegate. + The type of the second argument passed to + delegate. + The type of the third argument passed to + delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The second argument passed to the + delegate. + The third argument passed to the + delegate. + The TaskCreationOptions value that controls the behavior of the + created Task. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The created Task that represents the + asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that executes an end + method function when a specified IAsyncResult completes. + + The type of the result available through the + Task. + + The IAsyncResult whose completion should trigger the processing of the + . + The function delegate that processes the completed . + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + A Task that represents the + asynchronous operation. + + + + Creates a Task that executes an end + method function when a specified IAsyncResult completes. + + The type of the result available through the + Task. + + The IAsyncResult whose completion should trigger the processing of the + . + The function delegate that processes the completed . + The TaskCreationOptions value that controls the behavior of the + created Task. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + A Task that represents the + asynchronous operation. + + + + Creates a Task that executes an end + method function when a specified IAsyncResult completes. + + The type of the result available through the + Task. + + The IAsyncResult whose completion should trigger the processing of the + . + The function delegate that processes the completed . + The TaskScheduler + that is used to schedule the task that executes the end method. + The TaskCreationOptions value that controls the behavior of the + created Task. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + A Task that represents the + asynchronous operation. + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the result available through the + Task. + + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the result available through the + Task. + + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The TaskCreationOptions value that controls the behavior of the + created Task. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the delegate. + The type of the result available through the + Task. + + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the delegate. + The type of the result available through the + Task. + + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The TaskCreationOptions value that controls the behavior of the + created Task. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the delegate. + The type of the second argument passed to + delegate. + The type of the result available through the + Task. + + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The second argument passed to the + delegate. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the delegate. + The type of the second argument passed to + delegate. + The type of the result available through the + Task. + + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The second argument passed to the + delegate. + The TaskCreationOptions value that controls the behavior of the + created Task. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the delegate. + The type of the second argument passed to + delegate. + The type of the third argument passed to + delegate. + The type of the result available through the + Task. + + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The second argument passed to the + delegate. + The third argument passed to the + delegate. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the delegate. + The type of the second argument passed to + delegate. + The type of the third argument passed to + delegate. + The type of the result available through the + Task. + + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The second argument passed to the + delegate. + The third argument passed to the + delegate. + The TaskCreationOptions value that controls the behavior of the + created Task. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Check validity of options passed to FromAsync method + + The options to be validated. + determines type of FromAsync method that called this method + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The array of tasks from which to continue. + The action delegate to execute when all tasks in + the array have completed. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The array of tasks from which to continue. + The action delegate to execute when all tasks in + the array have completed. + The CancellationToken + that will be assigned to the new continuation task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The array of tasks from which to continue. + The action delegate to execute when all tasks in the array have completed. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAll. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The array of tasks from which to continue. + The action delegate to execute when all tasks in the array have completed. + The CancellationToken + that will be assigned to the new continuation task. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The TaskScheduler + that is used to schedule the created continuation Task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAll. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result of the antecedent . + The array of tasks from which to continue. + The action delegate to execute when all tasks in + the array have completed. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result of the antecedent . + The array of tasks from which to continue. + The action delegate to execute when all tasks in + the array have completed. + The CancellationToken + that will be assigned to the new continuation task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result of the antecedent . + The array of tasks from which to continue. + The action delegate to execute when all tasks in the array have completed. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAll. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result of the antecedent . + The array of tasks from which to continue. + The action delegate to execute when all tasks in the array have completed. + The CancellationToken + that will be assigned to the new continuation task. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The TaskScheduler + that is used to schedule the created continuation Task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAll. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result that is returned by the + delegate and associated with the created . + The array of tasks from which to continue. + The function delegate to execute when all tasks in the + array have completed. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result that is returned by the + delegate and associated with the created . + The array of tasks from which to continue. + The function delegate to execute when all tasks in the + array have completed. + The CancellationToken + that will be assigned to the new continuation task. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result that is returned by the + delegate and associated with the created . + The array of tasks from which to continue. + The function delegate to execute when all tasks in the + array have completed. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAll. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result that is returned by the + delegate and associated with the created . + The array of tasks from which to continue. + The function delegate to execute when all tasks in the + array have completed. + The CancellationToken + that will be assigned to the new continuation task. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The TaskScheduler + that is used to schedule the created continuation . + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAll. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result that is returned by the + delegate and associated with the created . + The type of the result of the antecedent . + The array of tasks from which to continue. + The function delegate to execute when all tasks in the + array have completed. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result that is returned by the + delegate and associated with the created . + The type of the result of the antecedent . + The array of tasks from which to continue. + The function delegate to execute when all tasks in the + array have completed. + The CancellationToken + that will be assigned to the new continuation task. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result that is returned by the + delegate and associated with the created . + The type of the result of the antecedent . + The array of tasks from which to continue. + The function delegate to execute when all tasks in the + array have completed. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAll. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result that is returned by the + delegate and associated with the created . + The type of the result of the antecedent . + The array of tasks from which to continue. + The function delegate to execute when all tasks in the + array have completed. + The CancellationToken + that will be assigned to the new continuation task. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The TaskScheduler + that is used to schedule the created continuation . + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAll. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The array of tasks from which to continue when one task completes. + The action delegate to execute when one task in the array completes. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The array of tasks from which to continue when one task completes. + The action delegate to execute when one task in the array completes. + The CancellationToken + that will be assigned to the new continuation task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The array of tasks from which to continue when one task completes. + The action delegate to execute when one task in the array completes. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAny. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The array of tasks from which to continue when one task completes. + The action delegate to execute when one task in the array completes. + The CancellationToken + that will be assigned to the new continuation task. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The TaskScheduler + that is used to schedule the created continuation Task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAny. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result that is returned by the + delegate and associated with the created . + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the + array completes. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result that is returned by the + delegate and associated with the created . + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the + array completes. + The CancellationToken + that will be assigned to the new continuation task. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result that is returned by the + delegate and associated with the created . + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the + array completes. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAny. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result that is returned by the + delegate and associated with the created . + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the + array completes. + The CancellationToken + that will be assigned to the new continuation task. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The TaskScheduler + that is used to schedule the created continuation . + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAny. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result that is returned by the + delegate and associated with the created . + The type of the result of the antecedent . + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the + array completes. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result that is returned by the + delegate and associated with the created . + The type of the result of the antecedent . + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the + array completes. + The CancellationToken + that will be assigned to the new continuation task. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result that is returned by the + delegate and associated with the created . + The type of the result of the antecedent . + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the + array completes. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAny. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result that is returned by the + delegate and associated with the created . + The type of the result of the antecedent . + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the + array completes. + The CancellationToken + that will be assigned to the new continuation task. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The TaskScheduler + that is used to schedule the created continuation . + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAny. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result of the antecedent . + The array of tasks from which to continue when one task completes. + The action delegate to execute when one task in the + array completes. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result of the antecedent . + The array of tasks from which to continue when one task completes. + The action delegate to execute when one task in the + array completes. + The CancellationToken + that will be assigned to the new continuation task. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result of the antecedent . + The array of tasks from which to continue when one task completes. + The action delegate to execute when one task in the + array completes. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAny. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result of the antecedent . + The array of tasks from which to continue when one task completes. + The action delegate to execute when one task in the + array completes. + The CancellationToken + that will be assigned to the new continuation task. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The TaskScheduler + that is used to schedule the created continuation . + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAny. + + + + + Gets the default CancellationToken of this + TaskFactory. + + + This property returns the default that will be assigned to all + tasks created by this factory unless another CancellationToken value is explicitly specified + during the call to the factory methods. + + + + + Gets the TaskScheduler of this + TaskFactory. + + + This property returns the default scheduler for this factory. It will be used to schedule all + tasks unless another scheduler is explicitly specified during calls to this factory's methods. + If null, TaskScheduler.Current + will be used. + + + + + Gets the TaskCreationOptions + value of this TaskFactory. + + + This property returns the default creation options for this factory. They will be used to create all + tasks unless other options are explicitly specified during calls to this factory's methods. + + + + + Gets the TaskContinuationOptions + value of this TaskFactory. + + + This property returns the default continuation options for this factory. They will be used to create + all continuation tasks unless other options are explicitly specified during calls to this factory's methods. + + + + + Represents an abstract scheduler for tasks. + + + + TaskScheduler acts as the extension point for all + pluggable scheduling logic. This includes mechanisms such as how to schedule a task for execution, and + how scheduled tasks should be exposed to debuggers. + + + All members of the abstract type are thread-safe + and may be used from multiple threads concurrently. + + + + + + Queues a Task to the scheduler. + + + + A class derived from TaskScheduler + implements this method to accept tasks being scheduled on the scheduler. + A typical implementation would store the task in an internal data structure, which would + be serviced by threads that would execute those tasks at some time in the future. + + + This method is only meant to be called by the .NET Framework and + should not be called directly by the derived class. This is necessary + for maintaining the consistency of the system. + + + The Task to be queued. + The argument is null. + + + + Determines whether the provided Task + can be executed synchronously in this call, and if it can, executes it. + + + + A class derived from TaskScheduler implements this function to + support inline execution of a task on a thread that initiates a wait on that task object. Inline + execution is optional, and the request may be rejected by returning false. However, better + scalability typically results the more tasks that can be inlined, and in fact a scheduler that + inlines too little may be prone to deadlocks. A proper implementation should ensure that a + request executing under the policies guaranteed by the scheduler can successfully inline. For + example, if a scheduler uses a dedicated thread to execute tasks, any inlining requests from that + thread should succeed. + + + If a scheduler decides to perform the inline execution, it should do so by calling to the base + TaskScheduler's + TryExecuteTask method with the provided task object, propagating + the return value. It may also be appropriate for the scheduler to remove an inlined task from its + internal data structures if it decides to honor the inlining request. Note, however, that under + some circumstances a scheduler may be asked to inline a task that was not previously provided to + it with the method. + + + The derived scheduler is responsible for making sure that the calling thread is suitable for + executing the given task as far as its own scheduling and execution policies are concerned. + + + The Task to be + executed. + A Boolean denoting whether or not task has previously been + queued. If this parameter is True, then the task may have been previously queued (scheduled); if + False, then the task is known not to have been queued, and this call is being made in order to + execute the task inline without queueing it. + A Boolean value indicating whether the task was executed inline. + The argument is + null. + The was already + executed. + + + + Generates an enumerable of Task instances + currently queued to the scheduler waiting to be executed. + + + + A class derived from implements this method in order to support + integration with debuggers. This method will only be invoked by the .NET Framework when the + debugger requests access to the data. The enumerable returned will be traversed by debugging + utilities to access the tasks currently queued to this scheduler, enabling the debugger to + provide a representation of this information in the user interface. + + + It is important to note that, when this method is called, all other threads in the process will + be frozen. Therefore, it's important to avoid synchronization with other threads that may lead to + blocking. If synchronization is necessary, the method should prefer to throw a + than to block, which could cause a debugger to experience delays. Additionally, this method and + the enumerable returned must not modify any globally visible state. + + + The returned enumerable should never be null. If there are currently no queued tasks, an empty + enumerable should be returned instead. + + + For developers implementing a custom debugger, this method shouldn't be called directly, but + rather this functionality should be accessed through the internal wrapper method + GetScheduledTasksForDebugger: + internal Task[] GetScheduledTasksForDebugger(). This method returns an array of tasks, + rather than an enumerable. In order to retrieve a list of active schedulers, a debugger may use + another internal method: internal static TaskScheduler[] GetTaskSchedulersForDebugger(). + This static method returns an array of all active TaskScheduler instances. + GetScheduledTasksForDebugger then may be used on each of these scheduler instances to retrieve + the list of scheduled tasks for each. + + + An enumerable that allows traversal of tasks currently queued to this scheduler. + + + This scheduler is unable to generate a list of queued tasks at this time. + + + + + Retrieves some thread static state that can be cached and passed to multiple + TryRunInline calls, avoiding superflous TLS fetches. + + A bag of TLS state (or null if none exists). + + + + Attempts to execute the target task synchronously. + + The task to run. + True if the task may have been previously queued, + false if the task was absolutely not previously queued. + The state retrieved from GetThreadStatics + True if it ran, false otherwise. + + + + Attempts to dequeue a Task that was previously queued to + this scheduler. + + The Task to be dequeued. + A Boolean denoting whether the argument was successfully dequeued. + The argument is null. + + + + Notifies the scheduler that a work item has made progress. + + + + + Initializes the . + + + + + Frees all resources associated with this scheduler. + + + + + Creates a + associated with the current . + + + All Task instances queued to + the returned scheduler will be executed through a call to the + Post method + on that context. + + + A associated with + the current SynchronizationContext, as + determined by SynchronizationContext.Current. + + + The current SynchronizationContext may not be used as a TaskScheduler. + + + + + Attempts to execute the provided Task + on this scheduler. + + + + Scheduler implementations are provided with Task + instances to be executed through either the method or the + method. When the scheduler deems it appropriate to run the + provided task, should be used to do so. TryExecuteTask handles all + aspects of executing a task, including action invocation, exception handling, state management, + and lifecycle control. + + + must only be used for tasks provided to this scheduler by the .NET + Framework infrastructure. It should not be used to execute arbitrary tasks obtained through + custom mechanisms. + + + + A Task object to be executed. + + The is not associated with this scheduler. + + A Boolean that is true if was successfully executed, false if it + was not. A common reason for execution failure is that the task had previously been executed or + is in the process of being executed by another thread. + + + + Provides an array of all queued Task instances + for the debugger. + + + The returned array is populated through a call to . + Note that this function is only meant to be invoked by a debugger remotely. + It should not be called by any other codepaths. + + An array of Task instances. + + This scheduler is unable to generate a list of queued tasks at this time. + + + + + Provides an array of all active TaskScheduler + instances for the debugger. + + + This function is only meant to be invoked by a debugger remotely. + It should not be called by any other codepaths. + + An array of TaskScheduler instances. + + + + Registers a new TaskScheduler instance in the global collection of schedulers. + + + + + Removes a TaskScheduler instance from the global collection of schedulers. + + + + + Indicates the maximum concurrency level this + is able to support. + + + + + Indicates whether this is a custom scheduler, in which case the safe code paths will be taken upon task entry + using a CAS to transition from queued state to executing. + + + + + Gets the default TaskScheduler instance. + + + + + Gets the TaskScheduler + associated with the currently executing task. + + + When not called from within a task, will return the scheduler. + + + + + Gets the unique ID for this . + + + + + Occurs when a faulted 's unobserved exception is about to trigger exception escalation + policy, which, by default, would terminate the process. + + + This AppDomain-wide event provides a mechanism to prevent exception + escalation policy (which, by default, terminates the process) from triggering. + Each handler is passed a + instance, which may be used to examine the exception and to mark it as observed. + + + + + Nested class that provides debugger view for TaskScheduler + + + + Default thread pool scheduler. + + + + A TaskScheduler implementation that executes all tasks queued to it through a call to + on the + that its associated with. The default constructor for this class binds to the current + + + + + Constructs a SynchronizationContextTaskScheduler associated with + + This constructor expects to be set. + + + + Implemetation of for this scheduler class. + + Simply posts the tasks to be executed on the associated . + + + + + + Implementation of for this scheduler class. + + The task will be executed inline only if the call happens within + the associated . + + + + + + + Implementes the property for + this scheduler class. + + By default it returns 1, because a based + scheduler only supports execution on a single thread. + + + + + Provides data for the event that is raised when a faulted 's + exception goes unobserved. + + + The Exception property is used to examine the exception without marking it + as observed, whereas the method is used to mark the exception + as observed. Marking the exception as observed prevents it from triggering exception escalation policy + which, by default, terminates the process. + + + + + Initializes a new instance of the class + with the unobserved exception. + + The Exception that has gone unobserved. + + + + Marks the as "observed," thus preventing it + from triggering exception escalation policy which, by default, terminates the process. + + + + + Gets whether this exception has been marked as "observed." + + + + + The Exception that went unobserved. + + + + + Represents an exception used to communicate an invalid operation by a + . + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the + class with a specified error message. + + The error message that explains the reason for the exception. + + + + Initializes a new instance of the + class using the default error message and a reference to the inner exception that is the cause of + this exception. + + The exception that is the cause of the current exception. + + + + Initializes a new instance of the + class with a specified error message and a reference to the inner exception that is the cause of + this exception. + + The error message that explains the reason for the exception. + The exception that is the cause of the current exception. + + + diff --git a/src/packages/Microsoft.Bcl.1.1.8/lib/sl5/System.IO.dll b/src/packages/Microsoft.Bcl.1.1.8/lib/sl5/System.IO.dll new file mode 100644 index 0000000000000000000000000000000000000000..01edf729d6fd3f62b325ada34491065ecf202911 GIT binary patch literal 22704 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 + + + System.IO + + + + + A strongly-typed resource class, for looking up localized strings, etc. + + + + + Returns the cached ResourceManager instance used by this class. + + + + + Overrides the current thread's CurrentUICulture property for all + resource lookups using this strongly typed resource class. + + + + + Looks up a localized string similar to Found invalid data while decoding.. + + + + + The exception that is thrown when a data stream is in an invalid format. + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class with a specified error message. + + The error message that explains the reason for the exception. + + + + Initializes a new instance of the class with a reference to the inner exception that is the cause of this exception. + The error message that explains the reason for the exception. + The exception that is the cause of the current exception. If the parameter is not null, the current exception is raised in a catch block that handles the inner exception. + + + diff --git a/src/packages/Microsoft.Bcl.1.1.8/lib/sl5/System.Runtime.dll b/src/packages/Microsoft.Bcl.1.1.8/lib/sl5/System.Runtime.dll new file mode 100644 index 0000000000000000000000000000000000000000..967bb30a0d84f969455800059b74fae5c24271df GIT binary patch literal 22208 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 QU>aprW%>sEYaZx-0jWNPVE_OC literal 0 HcmV?d00001 diff --git a/src/packages/Microsoft.Bcl.1.1.8/lib/sl5/System.Runtime.xml b/src/packages/Microsoft.Bcl.1.1.8/lib/sl5/System.Runtime.xml new file mode 100644 index 00000000..93cb00d7 --- /dev/null +++ b/src/packages/Microsoft.Bcl.1.1.8/lib/sl5/System.Runtime.xml @@ -0,0 +1,56 @@ + + + + System.Runtime + + + + Defines a provider for progress updates. + The type of progress update value. + + + Reports a progress update. + The value of the updated progress. + + + Identities the async state machine type for this method. + + + Identities the state machine type for this method. + + + Initializes the attribute. + The type that implements the state machine. + + + Gets the type that implements the state machine. + + + Initializes the attribute. + The type that implements the state machine. + + + + Allows you to obtain the method or property name of the caller to the method. + + + + + Allows you to obtain the line number in the source file at which the method is called. + + + + + Allows you to obtain the full path of the source file that contains the caller. + This is the file path at the time of compile. + + + + Identities the iterator state machine type for this method. + + + Initializes the attribute. + The type that implements the state machine. + + + diff --git a/src/packages/Microsoft.Bcl.1.1.8/lib/sl5/System.Threading.Tasks.dll b/src/packages/Microsoft.Bcl.1.1.8/lib/sl5/System.Threading.Tasks.dll new file mode 100644 index 0000000000000000000000000000000000000000..b8f78dafd6ddbae13acf85b07ecf545afb460b32 GIT binary patch literal 34528 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 Hh0y;2j36FU literal 0 HcmV?d00001 diff --git a/src/packages/Microsoft.Bcl.1.1.8/lib/sl5/System.Threading.Tasks.xml b/src/packages/Microsoft.Bcl.1.1.8/lib/sl5/System.Threading.Tasks.xml new file mode 100644 index 00000000..b47921e5 --- /dev/null +++ b/src/packages/Microsoft.Bcl.1.1.8/lib/sl5/System.Threading.Tasks.xml @@ -0,0 +1,475 @@ + + + + System.Threading.Tasks + + + + Holds state related to the builder's IAsyncStateMachine. + This is a mutable struct. Be very delicate with it. + + + A reference to the heap-allocated state machine object associated with this builder. + + + Initiates the builder's execution with the associated state machine. + Specifies the type of the state machine. + The state machine instance, passed by reference. + The argument is null (Nothing in Visual Basic). + + + Associates the builder with the state machine it represents. + The heap-allocated state machine object. + The argument was null (Nothing in Visual Basic). + The builder is incorrectly initialized. + + + + Gets the Action to use with an awaiter's OnCompleted or UnsafeOnCompleted method. + On first invocation, the supplied state machine will be boxed. + + Specifies the type of the method builder used. + Specifies the type of the state machine used. + The builder. + The state machine. + An Action to provide to the awaiter. + + + Provides the ability to invoke a state machine's MoveNext method under a supplied ExecutionContext. + + + The context with which to run MoveNext. + + + The state machine whose MoveNext method should be invoked. + + + Initializes the runner. + The context with which to run MoveNext. + + + Invokes MoveNext under the provided context. + + + Cached delegate used with ExecutionContext.Run. + + + Invokes the MoveNext method on the supplied IAsyncStateMachine. + The IAsyncStateMachine machine instance. + + + Provides a base class used to cache tasks of a specific return type. + Specifies the type of results the cached tasks return. + + + + A singleton cache for this result type. + This may be null if there are no cached tasks for this TResult. + + + + Creates a non-disposable task. + The result for the task. + The cacheable task. + + + Creates a cache. + A task cache for this result type. + + + Gets a cached task if one exists. + The result for which we want a cached task. + A cached task if one exists; otherwise, null. + + + Provides a cache for Boolean tasks. + + + A true task. + + + A false task. + + + Gets a cached task for the Boolean result. + true or false + A cached task for the Boolean result. + + + Provides a cache for zero Int32 tasks. + + + The minimum value, inclusive, for which we want a cached task. + + + The maximum value, exclusive, for which we want a cached task. + + + The cache of Task{Int32}. + + + Creates an array of cached tasks for the values in the range [INCLUSIVE_MIN,EXCLUSIVE_MAX). + + + Gets a cached task for the zero Int32 result. + The integer value + A cached task for the Int32 result or null if not cached. + + + Throws the exception on the ThreadPool. + The exception to propagate. + The target context on which to propagate the exception. Null to use the ThreadPool. + + + Copies the exception's stack trace so its stack trace isn't overwritten. + The exception to prepare. + + + + Provides a builder for asynchronous methods that return . + This type is intended for compiler use only. + + + AsyncTaskMethodBuilder is a value type, and thus it is copied by value. + Prior to being copied, one of its Task, SetResult, or SetException members must be accessed, + or else the copies may end up building distinct Task instances. + + + + Represents an asynchronous method builder. + + + A cached VoidTaskResult task used for builders that complete synchronously. + + + The generic builder object to which this non-generic instance delegates. + + + Initializes a new . + The initialized . + + + Initiates the builder's execution with the associated state machine. + Specifies the type of the state machine. + The state machine instance, passed by reference. + + + Associates the builder with the state machine it represents. + The heap-allocated state machine object. + The argument was null (Nothing in Visual Basic). + The builder is incorrectly initialized. + + + Perform any initialization necessary prior to lifting the builder to the heap. + + + + Schedules the specified state machine to be pushed forward when the specified awaiter completes. + + Specifies the type of the awaiter. + Specifies the type of the state machine. + The awaiter. + The state machine. + + + + Schedules the specified state machine to be pushed forward when the specified awaiter completes. + + Specifies the type of the awaiter. + Specifies the type of the state machine. + The awaiter. + The state machine. + + + + Completes the in the + RanToCompletion state. + + The builder is not initialized. + The task has already completed. + + + + Completes the in the + Faulted state with the specified exception. + + The to use to fault the task. + The argument is null (Nothing in Visual Basic). + The builder is not initialized. + The task has already completed. + + + + Called by the debugger to request notification when the first wait operation + (await, Wait, Result, etc.) on this builder's task completes. + + + true to enable notification; false to disable a previously set notification. + + + + Gets the for this builder. + The representing the builder's asynchronous operation. + The builder is not initialized. + + + + Gets an object that may be used to uniquely identify this builder to the debugger. + + + This property lazily instantiates the ID in a non-thread-safe manner. + It must only be used by the debugger, and only in a single-threaded manner + when no other threads are in the middle of accessing this property or this.Task. + + + + + Provides a builder for asynchronous methods that return . + This type is intended for compiler use only. + + + AsyncTaskMethodBuilder{TResult} is a value type, and thus it is copied by value. + Prior to being copied, one of its Task, SetResult, or SetException members must be accessed, + or else the copies may end up building distinct Task instances. + + + + A cached task for default(TResult). + + + State related to the IAsyncStateMachine. + + + The lazily-initialized task. + Must be named m_task for debugger step-over to work correctly. + + + The lazily-initialized task completion source. + + + Temporary support for disabling crashing if tasks go unobserved. + + + Initializes a new . + The initialized . + + + Initiates the builder's execution with the associated state machine. + Specifies the type of the state machine. + The state machine instance, passed by reference. + + + Associates the builder with the state machine it represents. + The heap-allocated state machine object. + The argument was null (Nothing in Visual Basic). + The builder is incorrectly initialized. + + + Perform any initialization necessary prior to lifting the builder to the heap. + + + + Schedules the specified state machine to be pushed forward when the specified awaiter completes. + + Specifies the type of the awaiter. + Specifies the type of the state machine. + The awaiter. + The state machine. + + + + Schedules the specified state machine to be pushed forward when the specified awaiter completes. + + Specifies the type of the awaiter. + Specifies the type of the state machine. + The awaiter. + The state machine. + + + + Completes the in the + RanToCompletion state with the specified result. + + The result to use to complete the task. + The task has already completed. + + + + Completes the builder by using either the supplied completed task, or by completing + the builder's previously accessed task using default(TResult). + + A task already completed with the value default(TResult). + The task has already completed. + + + + Completes the in the + Faulted state with the specified exception. + + The to use to fault the task. + The argument is null (Nothing in Visual Basic). + The task has already completed. + + + + Called by the debugger to request notification when the first wait operation + (await, Wait, Result, etc.) on this builder's task completes. + + + true to enable notification; false to disable a previously set notification. + + + This should only be invoked from within an asynchronous method, + and only by the debugger. + + + + + Gets a task for the specified result. This will either + be a cached or new task, never null. + + The result for which we need a task. + The completed task containing the result. + + + Gets the lazily-initialized TaskCompletionSource. + + + Gets the for this builder. + The representing the builder's asynchronous operation. + + + + Gets an object that may be used to uniquely identify this builder to the debugger. + + + This property lazily instantiates the ID in a non-thread-safe manner. + It must only be used by the debugger, and only in a single-threaded manner + when no other threads are in the middle of accessing this property or this.Task. + + + + + Provides a builder for asynchronous methods that return void. + This type is intended for compiler use only. + + + + The synchronization context associated with this operation. + + + State related to the IAsyncStateMachine. + + + An object used by the debugger to uniquely identify this builder. Lazily initialized. + + + Temporary support for disabling crashing if tasks go unobserved. + + + Registers with UnobservedTaskException to suppress exception crashing. + + + Non-zero if PreventUnobservedTaskExceptions has already been invoked. + + + Initializes a new . + The initialized . + + + Initializes the . + The synchronizationContext associated with this operation. This may be null. + + + Initiates the builder's execution with the associated state machine. + Specifies the type of the state machine. + The state machine instance, passed by reference. + The argument was null (Nothing in Visual Basic). + + + Associates the builder with the state machine it represents. + The heap-allocated state machine object. + The argument was null (Nothing in Visual Basic). + The builder is incorrectly initialized. + + + Perform any initialization necessary prior to lifting the builder to the heap. + + + + Schedules the specified state machine to be pushed forward when the specified awaiter completes. + + Specifies the type of the awaiter. + Specifies the type of the state machine. + The awaiter. + The state machine. + + + + Schedules the specified state machine to be pushed forward when the specified awaiter completes. + + Specifies the type of the awaiter. + Specifies the type of the state machine. + The awaiter. + The state machine. + + + Completes the method builder successfully. + + + Faults the method builder with an exception. + The exception that is the cause of this fault. + The argument is null (Nothing in Visual Basic). + The builder is not initialized. + + + Notifies the current synchronization context that the operation completed. + + + + Gets an object that may be used to uniquely identify this builder to the debugger. + + + This property lazily instantiates the ID in a non-thread-safe manner. + It must only be used by the debugger and only in a single-threaded manner. + + + + + Represents state machines generated for asynchronous methods. + This type is intended for compiler use only. + + + + Moves the state machine to its next state. + + + Configures the state machine with a heap-allocated replica. + The heap-allocated replica. + + + + Represents an awaiter used to schedule continuations when an await operation completes. + + + + + Represents an operation that will schedule continuations when the operation completes. + + + + Schedules the continuation action to be invoked when the instance completes. + The action to invoke when the operation completes. + The argument is null (Nothing in Visual Basic). + + + Schedules the continuation action to be invoked when the instance completes. + The action to invoke when the operation completes. + The argument is null (Nothing in Visual Basic). + Unlike OnCompleted, UnsafeOnCompleted need not propagate ExecutionContext information. + + + Used with Task(of void) + + + diff --git a/src/packages/Microsoft.Bcl.1.1.8/lib/win8/_._ b/src/packages/Microsoft.Bcl.1.1.8/lib/win8/_._ new file mode 100644 index 00000000..e69de29b diff --git a/src/packages/Microsoft.Bcl.1.1.8/lib/wp8/_._ b/src/packages/Microsoft.Bcl.1.1.8/lib/wp8/_._ new file mode 100644 index 00000000..e69de29b diff --git a/src/packages/Microsoft.Bcl.1.1.8/lib/wpa81/_._ b/src/packages/Microsoft.Bcl.1.1.8/lib/wpa81/_._ new file mode 100644 index 00000000..e69de29b diff --git a/src/packages/Microsoft.Bcl.Async.1.0.168/License-Stable.rtf b/src/packages/Microsoft.Bcl.Async.1.0.168/License-Stable.rtf new file mode 100644 index 00000000..3aec6b65 --- /dev/null +++ b/src/packages/Microsoft.Bcl.Async.1.0.168/License-Stable.rtf @@ -0,0 +1,118 @@ +{\rtf1\ansi\ansicpg1252\deff0\nouicompat\deflang1033{\fonttbl{\f0\fswiss\fprq2\fcharset0 Tahoma;}{\f1\froman\fprq2\fcharset0 Times New Roman;}{\f2\fswiss\fprq2\fcharset0 Calibri;}{\f3\fnil\fcharset0 Calibri;}{\f4\fnil\fcharset2 Symbol;}} +{\colortbl ;\red31\green73\blue125;\red0\green0\blue255;} +{\*\listtable +{\list\listhybrid +{\listlevel\levelnfc0\leveljc0\levelstartat1{\leveltext\'02\'00.;}{\levelnumbers\'01;}\jclisttab\tx360} +{\listlevel\levelnfc4\leveljc0\levelstartat1{\leveltext\'02\'01.;}{\levelnumbers\'01;}\jclisttab\tx363} +{\listlevel\levelnfc2\leveljc0\levelstartat1{\leveltext\'02\'02.;}{\levelnumbers\'01;}\jclisttab\tx720}\listid1 } +{\list\listhybrid +{\listlevel\levelnfc0\leveljc0\levelstartat1{\leveltext\'02\'00.;}{\levelnumbers\'01;}\jclisttab\tx363} +{\listlevel\levelnfc4\leveljc0\levelstartat1{\leveltext\'02\'01.;}{\levelnumbers\'01;}\jclisttab\tx363}\listid2 }} +{\*\listoverridetable{\listoverride\listid1\listoverridecount0\ls1}{\listoverride\listid2\listoverridecount0\ls2}} +{\stylesheet{ Normal;}{\s1 heading 1;}{\s2 heading 2;}{\s3 heading 3;}} +{\*\generator Riched20 6.2.9200}\viewkind4\uc1 +\pard\nowidctlpar\sb120\sa120\b\f0\fs24 MICROSOFT SOFTWARE LICENSE TERMS\par + +\pard\brdrb\brdrs\brdrw10\brsp20 \nowidctlpar\sb120\sa120 MICROSOFT .NET LIBRARY \par + +\pard\nowidctlpar\sb120\sa120\fs19 These license terms are an agreement between Microsoft Corporation (or based on where you live, one of its affiliates) and you. Please read them. They apply to the software named above, which includes the media on which you received it, if any. The terms also apply to any Microsoft\par + +\pard{\pntext\f4\'B7\tab}{\*\pn\pnlvlblt\pnf4\pnindent363{\pntxtb\'B7}}\nowidctlpar\fi-363\li720\sb120\sa120\b0 updates,\par +{\pntext\f4\'B7\tab}supplements,\par +{\pntext\f4\'B7\tab}Internet-based services, and\par +{\pntext\f4\'B7\tab}support services\par + +\pard\nowidctlpar\sb120\sa120\b for this software, unless other terms accompany those items. If so, those terms apply.\par +BY USING THE SOFTWARE, YOU ACCEPT THESE TERMS. IF YOU DO NOT ACCEPT THEM, DO NOT USE THE SOFTWARE.\par + +\pard\brdrt\brdrs\brdrw10\brsp20 \nowidctlpar\sb120\sa120 IF YOU COMPLY WITH THESE LICENSE TERMS, YOU HAVE THE PERPETUAL RIGHTS BELOW.\par + +\pard +{\listtext\f0 1.\tab}\jclisttab\tx360\ls1\nowidctlpar\s1\fi-357\li357\sb120\sa120 INSTALLATION AND USE RIGHTS. \par + +\pard +{\listtext\f0 a.\tab}\jclisttab\tx363\ls1\ilvl1\nowidctlpar\s2\fi-363\li720\sb120\sa120 Installation and Use.\b0\fs20 You may install and use any number of copies of the software to design, develop and test your programs.\par +{\listtext\f0 b.\tab}\b\fs19 Third Party Programs.\b0\fs20 The software may include third party programs that Microsoft, not the third party, licenses to you under this agreement. Notices, if any, for the third party program are included for your information only.\b\fs19\par + +\pard +{\listtext\f0 2.\tab}\jclisttab\tx360\ls1\nowidctlpar\s1\fi-357\li357\sb120\sa120\fs20 ADDITIONAL LICENSING REQUIREMENTS AND/OR USE RIGHTS.\par + +\pard +{\listtext\f0 a.\tab}\jclisttab\tx363\ls1\ilvl1\nowidctlpar\s2\fi-363\li720\sb120\sa120 DISTRIBUTABLE CODE.\~ \b0 The software is comprised of Distributable Code. \f1\ldblquote\f0 Distributable Code\f1\rdblquote\f0 is code that you are permitted to distribute in programs you develop if you comply with the terms below.\b\par + +\pard +{\listtext\f0 i.\tab}\jclisttab\tx720\ls1\ilvl2\nowidctlpar\s3\fi-357\li1077\sb120\sa120\tx1077 Right to Use and Distribute. \par + +\pard{\pntext\f4\'B7\tab}{\*\pn\pnlvlblt\pnf4\pnindent360{\pntxtb\'B7}}\nowidctlpar\fi-357\li1434\sb120\sa120\b0 You may copy and distribute the object code form of the software.\par +{\pntext\f4\'B7\tab}Third Party Distribution. You may permit distributors of your programs to copy and distribute the Distributable Code as part of those programs.\par + +\pard\nowidctlpar\s3\fi-357\li1077\sb120\sa120\tx1077\b ii.\tab Distribution Requirements.\b0 \b For any Distributable Code you distribute, you must\par + +\pard{\pntext\f4\'B7\tab}{\*\pn\pnlvlblt\pnf4\pnindent360{\pntxtb\'B7}}\nowidctlpar\fi-357\li1434\sb120\sa120\b0 add significant primary functionality to it in your programs;\par +{\pntext\f4\'B7\tab}require distributors and external end users to agree to terms that protect it at least as much as this agreement;\par +{\pntext\f4\'B7\tab}display your valid copyright notice on your programs; and\par +{\pntext\f4\'B7\tab}indemnify, defend, and hold harmless Microsoft from any claims, including attorneys\rquote fees, related to the distribution or use of your programs.\par + +\pard\nowidctlpar\s3\fi-357\li1077\sb120\sa120\tx1077\b iii.\tab Distribution Restrictions.\b0 \b You may not\par + +\pard{\pntext\f4\'B7\tab}{\*\pn\pnlvlblt\pnf4\pnindent360{\pntxtb\'B7}}\nowidctlpar\fi-357\li1434\sb120\sa120\b0 alter any copyright, trademark or patent notice in the Distributable Code;\par +{\pntext\f4\'B7\tab}use Microsoft\rquote s trademarks in your programs\rquote names or in a way that suggests your programs come from or are endorsed by Microsoft;\par +{\pntext\f4\'B7\tab}include Distributable Code in malicious, deceptive or unlawful programs; or\par +{\pntext\f4\'B7\tab}modify or distribute the source code of any Distributable Code so that any part of it becomes subject to an Excluded License. An Excluded License is one that requires, as a condition of use, modification or distribution, that\par + +\pard{\pntext\f4\'B7\tab}{\*\pn\pnlvlblt\pnf4\pnindent360{\pntxtb\'B7}}\nowidctlpar\fi-358\li1792\sb120\sa120 the code be disclosed or distributed in source code form; or\cf1\f2\par +{\pntext\f4\'B7\tab}\cf0\f0 others have the right to modify it.\cf1\f2\par + +\pard\nowidctlpar\s1\fi-357\li357\sb120\sa120\cf0\b\f0 3.\tab\fs19 SCOPE OF LICENSE. \b0 The software is licensed, not sold. This agreement only gives you some rights to use the software. Microsoft reserves all other rights. Unless applicable law gives you more rights despite this limitation, you may use the software only as expressly permitted in this agreement. In doing so, you must comply with any technical limitations in the software that only allow you to use it in certain ways. You may not\par + +\pard{\pntext\f4\'B7\tab}{\*\pn\pnlvlblt\pnf4\pnindent363{\pntxtb\'B7}}\nowidctlpar\fi-363\li720\sb120\sa120 work around any technical limitations in the software;\par +{\pntext\f4\'B7\tab}reverse engineer, decompile or disassemble the software, except and only to the extent that applicable law expressly permits, despite this limitation;\par +{\pntext\f4\'B7\tab}publish the software for others to copy;\par +{\pntext\f4\'B7\tab}rent, lease or lend the software;\par +{\pntext\f4\'B7\tab}transfer the software or this agreement to any third party; or\par +{\pntext\f4\'B7\tab}use the software for commercial software hosting services.\par + +\pard\nowidctlpar\s1\fi-357\li357\sb120\sa120\b\fs20 4.\tab\fs19 BACKUP COPY. \b0 You may make one backup copy of the software. You may use it only to reinstall the software.\par +\b\fs20 5.\tab\fs19 DOCUMENTATION. \b0 Any person that has valid access to your computer or internal network may copy and use the documentation for your internal, reference purposes.\par +\b\fs20 6.\tab\fs19 EXPORT RESTRICTIONS. \b0 The software is subject to United States export laws and regulations. You must comply with all domestic and international export laws and regulations that apply to the software. These laws include restrictions on destinations, end users and end use. For additional information, see {\cf2\ul\fs20{\field{\*\fldinst{HYPERLINK www.microsoft.com/exporting }}{\fldrslt{www.microsoft.com/exporting}}}}\f0\fs19 .\cf2\ul\fs20\par +\cf0\ulnone\b 7.\tab\fs19 SUPPORT SERVICES. \b0 Because this software is \ldblquote as is,\rdblquote we may not provide support services for it.\par +\b\fs20 8.\tab\fs19 ENTIRE AGREEMENT. \b0 This agreement, and the terms for supplements, updates, Internet-based services and support services that you use, are the entire agreement for the software and support services.\par +\b\fs20 9.\tab\fs19 APPLICABLE LAW.\par + +\pard +{\listtext\f0 a.\tab}\jclisttab\tx363\ls2\ilvl1\nowidctlpar\s2\fi-363\li720\sb120\sa120 United States. \b0 If you acquired the software in the United States, Washington state law governs the interpretation of this agreement and applies to claims for breach of it, regardless of conflict of laws principles. The laws of the state where you live govern all other claims, including claims under state consumer protection laws, unfair competition laws, and in tort.\par +{\listtext\f0 b.\tab}\b Outside the United States. If you acquired the software in any other country, the laws of that country apply.\par + +\pard\nowidctlpar\s1\fi-357\li357\sb120\sa120\fs20 10.\tab\fs19 LEGAL EFFECT. \b0 This agreement describes certain legal rights. You may have other rights under the laws of your country. You may also have rights with respect to the party from whom you acquired the software. This agreement does not change your rights under the laws of your country if the laws of your country do not permit it to do so.\par +\b\fs20 11.\tab\fs19 DISCLAIMER OF WARRANTY. THE SOFTWARE IS LICENSED \ldblquote AS-IS.\rdblquote YOU BEAR THE RISK OF USING IT. MICROSOFT GIVES NO EXPRESS WARRANTIES, GUARANTEES OR CONDITIONS. YOU MAY HAVE ADDITIONAL CONSUMER RIGHTS OR STATUTORY GUARANTEES UNDER YOUR LOCAL LAWS WHICH THIS AGREEMENT CANNOT CHANGE. TO THE EXTENT PERMITTED UNDER YOUR LOCAL LAWS, MICROSOFT EXCLUDES THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.\par + +\pard\nowidctlpar\li357\sb120\sa120 FOR AUSTRALIA \endash YOU HAVE STATUTORY GUARANTEES UNDER THE AUSTRALIAN CONSUMER LAW AND NOTHING IN THESE TERMS IS INTENDED TO AFFECT THOSE RIGHTS.\par + +\pard\nowidctlpar\s1\fi-357\li357\sb120\sa120\fs20 12.\tab\fs19 LIMITATION ON AND EXCLUSION OF REMEDIES AND DAMAGES. YOU CAN RECOVER FROM MICROSOFT AND ITS SUPPLIERS ONLY DIRECT DAMAGES UP TO U.S. $5.00. YOU CANNOT RECOVER ANY OTHER DAMAGES, INCLUDING CONSEQUENTIAL, LOST PROFITS, SPECIAL, INDIRECT OR INCIDENTAL DAMAGES.\par + +\pard\nowidctlpar\li357\sb120\sa120\b0 This limitation applies to\par + +\pard{\pntext\f4\'B7\tab}{\*\pn\pnlvlblt\pnf4\pnindent363{\pntxtb\'B7}}\nowidctlpar\fi-363\li720\sb120\sa120 anything related to the software, services, content (including code) on third party Internet sites, or third party programs; and\par +{\pntext\f4\'B7\tab}claims for breach of contract, breach of warranty, guarantee or condition, strict liability, negligence, or other tort to the extent permitted by applicable law.\par + +\pard\nowidctlpar\sb120\sa120 It also applies even if Microsoft knew or should have known about the possibility of the damages. The above limitation or exclusion may not apply to you because your country may not allow the exclusion or limitation of incidental, consequential or other damages.\par +\lang9 Please note: As this software is distributed in Quebec, Canada, some of the clauses in this agreement are provided below in French.\par +Remarque : Ce logiciel \'e9tant distribu\'e9 au Qu\'e9bec, Canada, certaines des clauses dans ce contrat sont fournies ci-dessous en fran\'e7ais.\par + +\pard\nowidctlpar\s1\sb120\sa120\b\lang1033 EXON\'c9RATION DE GARANTIE. \b0 Le logiciel vis\'e9 par une licence est offert \'ab tel quel \'bb. Toute utilisation de ce logiciel est \'e0 votre seule risque et p\'e9ril. Microsoft n\rquote accorde aucune autre garantie expresse. Vous pouvez b\'e9n\'e9ficier de droits additionnels en vertu du droit local sur la protection des consommateurs, que ce contrat ne peut modifier. La ou elles sont permises par le droit locale, les garanties implicites de qualit\'e9 marchande, d\rquote ad\'e9quation \'e0 un usage particulier et d\rquote absence de contrefa\'e7on sont exclues.\par +\b LIMITATION DES DOMMAGES-INT\'c9R\'caTS ET EXCLUSION DE RESPONSABILIT\'c9 POUR LES DOMMAGES. \b0 Vous pouvez obtenir de Microsoft et de ses fournisseurs une indemnisation en cas de dommages directs uniquement \'e0 hauteur de 5,00 $ US. Vous ne pouvez pr\'e9tendre \'e0 aucune indemnisation pour les autres dommages, y compris les dommages sp\'e9ciaux, indirects ou accessoires et pertes de b\'e9n\'e9fices.\par + +\pard\nowidctlpar\sb120\sa120\lang9 Cette limitation concerne :\par + +\pard{\pntext\f4\'B7\tab}{\*\pn\pnlvlblt\pnf4\pnindent360{\pntxtb\'B7}}\nowidctlpar\li720\sb120\sa120 tout ce qui est reli\'e9 au logiciel, aux services ou au contenu (y compris le code) figurant sur des sites Internet tiers ou dans des programmes tiers ; et\par +{\pntext\f4\'B7\tab}les r\'e9clamations au titre de violation de contrat ou de garantie, ou au titre de responsabilit\'e9 stricte, de n\'e9gligence ou d\rquote une autre faute dans la limite autoris\'e9e par la loi en vigueur.\par + +\pard\nowidctlpar\sb120\sa120 Elle s\rquote applique \'e9galement, m\'eame si Microsoft connaissait ou devrait conna\'eetre l\rquote\'e9ventualit\'e9 d\rquote un tel dommage. Si votre pays n\rquote autorise pas l\rquote exclusion ou la limitation de responsabilit\'e9 pour les dommages indirects, accessoires ou de quelque nature que ce soit, il se peut que la limitation ou l\rquote exclusion ci-dessus ne s\rquote appliquera pas \'e0 votre \'e9gard.\par + +\pard\nowidctlpar\s1\sb120\sa120\b\lang1033 EFFET JURIDIQUE. \b0 Le pr\'e9sent contrat d\'e9crit certains droits juridiques. Vous pourriez avoir d\rquote autres droits pr\'e9vus par les lois de votre pays. Le pr\'e9sent contrat ne modifie pas les droits que vous conf\'e8rent les lois de votre pays si celles-ci ne le permettent pas.\par + +\pard\nowidctlpar\sb120\sa120\b\fs20\lang1036\par + +\pard\sa200\sl276\slmult1\b0\f3\fs22\lang9\par +} + \ No newline at end of file diff --git a/src/packages/Microsoft.Bcl.Async.1.0.168/Microsoft.Bcl.Async.1.0.168.nupkg b/src/packages/Microsoft.Bcl.Async.1.0.168/Microsoft.Bcl.Async.1.0.168.nupkg new file mode 100644 index 0000000000000000000000000000000000000000..fe97bce4469c6458b83462590de4b718b6db25db GIT binary patch literal 491429 zcmb5V1yChHuq}Au;_h7B-7fC#?(XjHGPt`t4DRmk?heB+$N&Qju7l6cd+~SozuovR z{;!Cxh>FfUk(rg9(S5R7MIH!+0Qip~Z5}0Y97)ji3;_WA$At(W1Q@$nI=Hhi|Hn*P z0s_z$Vg0A*|986X9TX7uadaT{vUGE|b#@XYXJrPHlUh2NJ6qT~SqqYTdRQ^>kP8b5 zs98Fgdi;}cx3P6`C;g}5dx%!V(Iknj+L{Uqp8QgrJFU2 zi>bN2skJ2w8yL*R^3R(87lZu2Vv=h3x>)}I5FKsJ-JIQ>tvr~`ogM!N*gw1e!Lfo_ zz}zg3rcSn2mhK+pq#CAf)|MWE2Mfz3F%IKUj{ykIUk$5Txs;)$>U_wB6v)!_SLCRiAX!f~x5M_J%*Nk)$h5yir1yKP8GAF1?wv%pZQ#o1 zMBq0YeXsm;Lsx%Ri&S#qKuW6d&BpFXT#vH49Mp+r8<+m)V_Ig5mK1xa4g6eGw(B?s zGTLcy7S=JnYv#p_bj-Y@dF`B@g4CfpD?XyST8Qj}+*xn|#2Bw%jvNb__Aey{j!%06 zH;nlbSM!NTdc%OT{5@*Ep5g*ov*9}v^d@GI9f#1@@e*vPer=<}U3e(i1fH#_73+=V zU3#2)TAi)>Vev3hc)xlKj_@F!ez={wOYXM14!xX&u7Q*56OTZ??!GS2cu6PwGkyLC zBIe)K0iijX*5%U+0i6Bb4C&Lt4_m{*bhGO!`DhQ zr?W39lC#;tK4Djs)v-Sr?VZ%u#C=rD z1Oj|tZ|ahJX~y!`WL8zimjL-*%5x<&EH__2p@Tjf2e|RweCA(_*^d88PpHn*@7PX%_!v`Y%QT;&dS`n#7%liR z2}RyASKAGN6|a%Ob@}r_70bJ20s;~{ZMVI$Qq4B5Fk3N9UJYt2SKHX{Z>SfIiTvkX z#GWK$X3js1INTKDzW2WEMphE}&gC({I@K8DdGd%qVIq6<-aCi$KSQwZMbqRTf&Su{|bS^zq;h)ZpozXVQS`J z$?WD~_1_hMaXtMseCZaU#l)MSs;GpfKTu{NDIA%P;UKBsoWSh3qnQ2jQ|6+&3Ia{f zMVp1O3+FwS*4G)uRPQf+2a@96hAnJ^?{{hf%nB`bEEX1=LC?LOz4s-paBFt!dJ?WR zA3nWl@PcrbZBCuc%*430JaVa)(ZYIh8U33Z%v${S)vY=&1h#c@dS=wzw^{>%BiT=8 zmN(uWJW|dX*y5fn)DMNQ-bzecX~jnP^I^<5wK7pOMna8)7tv>tCpTtI5mg zN`!`={FW|yoe{_sX zO^Zm|FaNqO_~{=tXpFVTVstXns96@TU`9c`y;oJViouds@T*n{F|vR4_h)Hh=t9n4{m0i)TjROc zv^=`{`w#CIKY7e-svy13K4)_#b8occHKPoo+|f^@+QA$Tn$D7e8#+<#jt{vxt{HlC zJ7dXbZdEJ$2oAX^8JV9+^|2Vu8qgz z@PPybT*sUiL4 zqh%ULAeG_T#+k5-<_PuHLmy?M*6v(P0of^WvCcJMwzn%D)Pw6&1ZSmE6?2{baCe#s zJw`f@UlJ+*!Nh8|c>hp2kdb`_LomNb@;LMWb6g2$Z-e;r`tsqSY z*C-r}6`3dzjrL26^8iAkkcrIcpkMz5fO=voK;9l(uogj0jw8Hl>m&SG!wQ{`S5~yC z3j9l+InG~*Iw%*76Tg+?<48G_)hqTGKYI~Bn@_=s#VR!wfOcqRM0Q%&)0~#g8}klv z?H4a4mw)Zu|*){K>(`l3BNqd3+#=G%7IF7+#1n%hck5em_V zv{qD_0U_TZl!rXY-C8IqWFZJew6gbVJwqB44$C7<#`5(csK7t%Q!xlG3BdE0HCN;I zAkMpnAt2|MX#4pgf&sn6A4S0mqWJ>J0zk%oi$n^q*IrEv^95 zL_@PFLEZN{sYmpL)CRW%uiyCnw2HebMo;BA2L)vo}cl&?uO{coy*@!7qMuRM9ls~7G{_Z}+s7&5L}T?VaNYv0;;*tq6w zIcvxh3NWtFRK)bG05sIl8-g?Z_^X2sf@6M{q^kU}*;UHbT+9q)ZdfkZuE>RC1487) zrENSCVS~=QO>#<6WB1nx#9ZnV@42F+qF_c zOUbyhkPy~5_85tmdL;%EU@EFKTLMus>RWwE+8|FVHHQJm$3Bp8k z!syv7#-4V(xVFifofgV}MzdRMYBGT>W}35Dao===IBoeW9U~!__bc6sG- z?Ta?3{4#eUl!p$&cG@!2HKuTbMN}KB&d{wiyYsfN+_h`emytEl6b_Ix3_F_XyhIJ# zSL3~KK(=unO}?sg34B5tsqLD3djS+i?LBVCOO7b*%} z0X%;$wI`;tDfp?Bp=kcnT+wT%3e(nh7}6L^Ae`0p*L^6@r;=m4stL2)>r!ZvPH~gk zHSCc{X|DdB9J@Ye-HP;l5kmnbys0tPmz-MLsDWdqYoR@J5#l{~wLlP&LH-s{$8!VA zhgR35Ik5?Lyd~828|hl~b3VDtW`A$>Xn(v%ci%JVH?lCR9Q@=#Fq|@r5P^vMr~a&_cc>f(t#U=) z4lpVwK#t{wV>>ky0A->HLbGoe2@bx0zVh1niqv<&^7Hd^pnD#uiAnz)#ZTZniuofd zGNjq`&c|v8^Yg^X$fVB7^JK09D{~bLxs}pktR;RQFjrCVM01Uv&)zzqI^ZEw!_huH zU`Z2YmfMlg;!H8tKXV96mFk`A*59AVN0H(dkG~dJBj(6+PyJ>23;&rrF5{$bMub6u z=98Pv^6!2T*920f9pKG7@LQ}EW@QX>sM@nkRX7tJ*qH;zkGErM7v5M?X^SW+1=iKv zap^;C^vy%Q@jij6KUbKq-mgKF`pZK0c{4d`Te~gtt>`u~AZtjGQP8a$!%$7?3O}|V zYZ+`#T(PPLMds-G>_KFtjnt}^B_*rzXn=wyT3?Lj9Vb?QWfKuSI}XWzy)g8JQ^Dy+ z29EIDbRJdh-h`!?*4^MJn?Tw)XZ{cJt<6vw#oeeP_GK-P(bm*$)mAx=vVa9gSR)>NOHl4M)VceI< zJ-doQVvnm)R~9Qo3(1oj&Nt!Q^9;4M^y1!?i+#4OGfN&2e=7D0ZXRN|KO%5EH{*!o zb$6=rOB~=N}dq2IdM*8qyuk3w^2Pr0NBmWSDF@voSTJ87D3dndvj?Y;* zL;9vkQlXdvH*Z}!?daM4a)S`oG$Vl|CD;Qx3mn?L?j!y|`!ico2d)1q*@@l%x@WYL zme!g=Nd0doUcZD*|E(2!)!}Ju!i?)C#SKl-fZ`N_YiA*g~}79wqKpGqe>6hoqYsD+zd(iFN34J)BElSziD~z zdyYfu!un{Z<5pR>NuSVGpvbQu?&laRQQ`&Y^z%|9`Rc&P8>F!HUhIKb`CMNf5|CD^ z*`i?&yUsT+U@{ZH$FQ5BPJ<0Hj}O0U{8ztxUo3*oJ9Kn@AfD_ljCZ29Dr+WAmV7}{ z;0Za14Abvg3{Om{Cs%>lcetnCc>5k_RjbJ;uQH>3h2jkD5kA;rD?eCx#C`0-t;9?YF@2EQojqsoAP*$XJNuel606$_F&7el!!PB)|H+GSP+i1 z8t%hmf@C!!us77#blM-Nl#k-*V@FQd7!d7D>p|0k)RoZz*mhzXTso=^Hz zLgnek6#TRrxrjN?lCSf>Yu~ffwxmB8d!CxW-_BD$bLru}qY2_oi*OlKf>$9`Qdbrc zQF@%OQom_3hxC$Gh;C|7JG1#xuiZo~{j^>Vd-~b_r1~vp9QC)R7_N2qzgM^^tk5N6 zPTiI|8CUM+Wa?yeDg``)>c7+FQg-B_!Hr){n-bKEAdUq{<1AUqKgIIOcJZczJ`sC} zka2~d8>th+8()7qZjSS3Eg{p>^sZ(uhGM6@TMTA~P<+KK2>28>6de^^0WojMVw+s1}q-B4ghdMu-#IEX&c zd_>mtl$U4~GA%$4ImIYMlgd6T(;3dRI09tlG=Xz)2t?2i2w^%}8y@(@EfLPF)po+j zvdBxGyw*U_}eG_QN$quMjw zqjEkzDw*Tl*NEISy()*$Efn2MzB;x)ef1a+tuQAI9_!S-MrWhSeTJ*(UUk(;HI_nn z2bPc25`5#0<<%HBBg*n>LNK5g8%O}iDBlT$XU%-+q#VJ9*eZYzAD=kZZg$mZAl%&7 ztjoD7q6U02q@@XU$z%Qbo?n7?-fX}&x9zSUkP+RbrJawB5RKMcx0Zu(h4e9<#A=js zVcG#^imIcb<85$LN#x9#O9W)PgTrfTMmkmxZ7o z$ay{q_-W`%>k_Llq*_1~I7c>DJkD()kTts{kp5YSPn7J^5kD|t1FqF%?pzA7fs_!O#cyIc|G{{H3;}$xiNVs z=LJng0N^GW0HFEDjXBtwu{c?JaDe}(j)R7co2BW0G)|Z`Ox^9>nJpX~{yW0#q94{k zU49ija8j1K1gWMmL|Wvb1PMn=YN(nUYy!a=4oJaJ2#qa*eA;c|Zu+z9e{I;YFo0nApn)J*6ZRruvVG&A znS&(PwE78?{$cpHd5Jmrw z0txXxiTK3uDS$CFr2RjKkiM=1KqHe>cmS@TQR@HijE- zM|{*-$)J3cjkgYoBP4!@1%!Rwrh;p)_czEbHoyw@t7_`P0?Qw#Kgt~6`D%Sq=&8?t3`rxW=_fG2 z{k3ske@`)FzR-F5Y*pc+`gj~eK_-q5sxY!^-@I2kU0xU=@ZRat{}ov4f#QL$4aXNf0=aTl;*Qfsp}P%IWg>foDgB1Lj{tW8 z${d=402krGxyM5Li6B4(i$GtF{c4^LtimMlel)4AGdUSRLSz}h=%7>6rC7sL;?Mh0 zM1nD96=Z%Qrm>E;!O_&DB1)drP>h{Y($O{5q#{z$XVn16R;P3+tyD1);}P#XeB5tl z@{2~^8oAyZL_H;2$&zk4UO+SNtw<&gCA3)zB|7(8iy&x>R&b68z0icj#5yq!5N679X+BD~IP`tJPJ z{gDuO1(-zLLZurn?Y;j-jFi}mElAyhb+!P4#x*vN;9qH@n^y5zqBkeD87LxyiifU3 zPO=)W)Wvh#;U(-C!Hn@fag*&BL417B5T!ZHpt$djmF48%KR_ai{qYAD>dq1A+BFxW(@ zl<38ZpfoDeUJ>gF6i3xKKlDpJ>4fFk){*8kxSKLLMw&`^Kf>*DS4QC}uVixTv+i($WNK-q<*8^N;dgcQ;+@8?3ogqY*N|0InFd(UyIYXn!^Y;hG( z$j%doK=$WxRwIm@tDwh6ZsQ~WAn^UVf?U6hrcsFuSmK{AB9)|l3OvfIZ-TM;*dpa_ zS?$pdS>V5H^JrPa!9(b!T`LV?M;g57*+K+JLJ;3|l9WZCIW3THhjv9unG{)t=_K^$ z7c;c}Kz=0PA4N{u9E{N_6)RKaS%FId8?N#}VlWj@ET5Kgn1UMYxm>84VxW+pk&y^M z)kn!8yy`<1590k$3Ojg_EdqwLnBW}Zco-)}LXx*{OZ7{mf*R^7Lrh=2w?PRIS3LsC zxT%Mxj3$BRe?+z=OS^`LU*S@8Z40(d3$lp`MTp)SF1{LDOH+lNnEP` z%jOEc3^iD{Y6vNy6&z9jk+LoO@yAuSvwbrT#Q?zmU(nC|;$s#tsW`xRWAn4I1 zelWG$mtndcYP3nA!LQ=gD9Mk%3$D3S*0E?n z4*z)&GS->Tup;T3zHQVxUh{QiWQ0ui)m$l!zGGr)7SdR|a9Frwv3+lKPpK@ogb)PN zS)>wLvN`n`(q;jHgL&xolnR0Rm?VF-$AUV-rE~nH^RzWcH<$g#4l>l-S)_p^7k*m| z-u};zF}%dA%ZWpJH?*9#pNQF71u9saAPU^CCcXO2*xj_uG4a!CAQN8)Nz^)+$sf_w zw0Eay8oA2XtJzw?*rKdGFuzSh&D(0wq*kYx1`~-xOp@5IqG7f4Vy#P< z?JSYV1pK}(xhV^f`4ovM{v1WULxoi_VlgF+{6?V;iBaf(2=t-j=so*IdqKAKXIt_? zT$qozGKl#GYs{8{*a)5N5Lt&L9U(5|NWt1wQ=uGF|~sEDC8_(TTsZbY0#( zoaW{!v1$owTeWkKG$4A-NQe4U*fw6~`YgcNI*GH;;~6L5Ofzw8#gB9KY(03R7BZ){ zg}9&5reDQ)oU}eE1<(Lz68V&(3QlvX!;jZSsRo5A%vRLb#I66z)p3kB=e#Th>lNuR znqa{eF+N2hhg~|&Xdy{LMv?t_lj=d&%B`my4im456t{!z@W*5mZOqA_2|Jju+9#A{ zg@lcVf-wwM{edCrNhrA0&<=JgX#!qiiQ6dKf7G|jYnH@`{Cheni9*^Ao0sBY6Y?+l zdWF1_ld$zlC{o%rOKp0K3E8C5Fj;qyvtyU5HhSAx({|(a!Pw?YavY@C<|#x!2yYUIy?POoTu7!~vNb+{L zQblP3{VZWdLWSv-+{a7^fafC^3Pc@b0Lwp$Ph-l40v) zHN3)?Kt8E)rgKh+WCRvwazeU5`^keljuyBPDzuhi!<}>NNF1a!>eP^#0v9|m37VA& zE#_m-bWO;yHlxP*sM8b|(9}V~c~L4LQY@CLYif7Y3J6n47G6O(c7O@n&T?qw_RR$2 z4-aGG#0^~JA65vc zzCI$0$zlzNAj?W(8kK$>J8X$h(n}mU*3EWu&;d?jSVhwkA){ON6|W>Cp!d8EDVV9CsQE@U>#Frx}JxHxD! zNG=^g;sJCt$oV=7nP7y|hlMRzn?^3^Pf{#%LJ<)$ZWW|2VMD~G2rwc@>v&;q zTh34uI^Y3P2R)7LNQkoNnlL@n9lFh zx4~Y;52H=6Mv7-of>7%RLSGWn8Gi*< z8XGya7b7_SbYT-Ns?$tJmpvQ&I4257cb)boFT7ehGQgfrd-gqLCZLb4dj=;M8B(L; zh|p?ieWGB&0vO9qFd|Yq>{5v0qEes2x-vQGgCB=%&=q!2BL~JC-{|l@K-m{rJVrS# zY7xdA4m2R}KN3tECT&3{G|WJ0g++2v2%D!iERu9O2P4P@G!AQ}kuCMc=h-!PEV1Wv zY%#a6Kg9pSzaY(lV0XujM{XXFky9;9^rDDAK5Ysc^K1beJK0h>&2P zxi&)ydTvohCzP^Y(N2(qAW-d_?4pOWqZ?J9F!Mn6MW`?47hKH*W(gut6Z9fX=9qI} zIaaP+KN?}+>rz0xB9y={p=e(Im2BvHP!mx6EOQ?qoW2gFVcXP*h6%~N<3_r60r?QY z1tNfC@*$$fXw*Id+@0|`5#OUfjA6w8pqT)F6?JHX$wO(jDv}ztI$u%>7LFf(@op=H{SfB` zPjghL4Q4(6#Hj2_d7>I^x_Ty);d=S<|)Ycv_?3_9*UeKk8TaCl?Tcvo0!<@=` zBcLa!XjubW#yv{l6}tY8%|+idofn@^<#3%M1PxGN&17Cdkp~0qP?MV>r>GW}$&}L{ zg#wdt-4qc|&BZ9J-=xvfB18mXkttEoZ7Js$q!l6?saE-L1H1w95ou`28?WmE_{bz3 z#yvy_)upf|tq|7f%*V*$C}een4<33yRpn5=PZ7=CQA=AJPRs_WjcbM+VHgs51J4Yh zNk6QbR10b>cbyf#A+gY;9!4LEmFo0DZ&Dq)i~}ZBkxSH}1m@g{JmRgi(%(>?^QMv& zyz0Rwjr{7jwvHVphYy4aMRQ^W-`3ThL)ZNSM@Kp-F~|z`$D48a;1SN!{|hCHb}Qda zFu9fv)!k(fe%9~WEzFGiSv?1!Sk}hxqT0Cz=Z75Z?+y8an1=~B4(^BrU;75vE`y2R zdmVq5zS~6seHdQ}ZR!*8*B7Np3fDz33?`0g_@1v--UCBlJse*yjYTl5D1z1_3yJud z?Yg0|?3Xhb=JW%Z-?GVNUe!po_ zHS{ekbUZoZAPde2j-=J*3igeGn4^EbnT}Exf942Rrg-KERmObg7=EY)?{y(B>G?n% z04Erbgw15o;P6dohnmPDpFlk(v?E}^s0vak>jmIIJrZh!8;LjM`OnxAV3wXN@viJf zzy)XIAX|v|Pp(wa#W|Y;dzLR=^vi6{GHLK&jBc2{BVb#U2x5jTb4fsy_b=2c(aFRW zkA4jxI*flI`A0LOcRqXXp@T0nYfMm1cZAN!;G}_gmkTqye<)LcdnUh#t`2FJQbS0$ z(9Db9&jIP8^rt#OomzGY?@@^jOPvJ^Pk_x{!cgwm{skYT^#VFiuM&(sG65#hkm=}W z(=o3&osVQud^ym^i6@$qFo2bC_%&LZgLo!26oqus2Z90FUI@7=ezOT_3Vnh=7pi;B zhkq8}z$G+pCsWAz8I}?8-2-48e?81~{GL!3z=+%KVNC%V!AaSmJ_9{jP}CY(KqXIY zXF-J8ElpY==p)1A352%PkPZdyQ;5whzJ6G!-K9%QoLp8h&? zDA$;4mo0L76xH>)c2D{%u=d20wKRL zx)4b3Oc04nD|l0??4Yha@-28y_9s6m?lTiFqnm{f&5=fmygE_tibc11uRhkf|_V`>5AY;U8G zCRPwK-EI*TW9Nvmt&Hln3cR#w8Lr)H1?+ zi)hphsg`vo;egmjt=@8HVyRFIOD%Z@MmkR zzL?}RUv8mXBwQd8(m0V^!7{H7O${vvvn7L?T)wiwpzf*P+|H8&rIc}w!kl`!*!JF` zV4GnuUa^?L5&a4WG3Y-&zm4otx`cl$Gm*oJu^uUe;$(X>%yr{An4^5yh$Z*>Tv65UEE#}U3^?fU*I}0Bob9pRKi;0ShHGVTXUZXo#34?odBce6Mjy( z(YRH*mHPn#+`iSeYq1qKn;n@j z?j->x&PA!*%F17K8v?NQh2orx%ef~y^X`$qc%|>_mIZKa3*|W$Epty`=H1hNb&KEc zlrLWc#`r@w=gNn21fkl@7DI)_MQENt?{k)$LnjW;>c|64+#@GKXfwQkuhJ%YkJ(0$ zw@Me@BJ+kwx4KS$YN=W!q zPnjG!>~Hc~RZa|ab2C|Vy>Y)K&hSM_Iud!H7T;dj zs_~UDX;oygX99dHDiFr3pMp8TG0{v5QBs*zYv?Tjx``5v?2c4u_1x@qsqbdGZnEfQ zkqpOG#)0`_OpDB-6?0jpvde=ishF1Zw9sp3xXg6vGk5n?ReZWBGz6(TsB|e1DkHzK#OEsj={P*N=- zbZ=*%y2w3R5ZI2g`>lx9>JweI=%h2DDRp)6gjdsBASGG8u^c^*Na&`BRqF@#oFOQn zJgsTi5-$rQB>X$ARYcTQBmI;z6MOm+3OrA!2V$pT%cip#8m5co(5jdE@xa;k&z6&l zCr~44*B(cVw>*!y$fn?PuEx%!RI`_8;-iL`FI5pYsLXKSgpbzLUg=b&TFgGsEfH{} zRV`8r2r={WHJDpS1sF*A*oe7Jj!i`)NyJ~I=cA+JVQ;fivMk23q|)8~<18{m zU?9G9CK@By!D&Nzz>4TIDXC^_Fh($_OA^56iYJv-nsN|UwWy?`?$gJrujOPC^I8#> zCd+Y9Cos=t;g(>3;A+y_DA$`6&*cAv1W6ypt>1o&nL=e-vQx#XE#`8y!JhS>{+ZFd z^jh;QhNt#(lM1#Z7O{Lu{h%i+UF1npE=TE0-;tWTWkfM}|J;hk7*j!`(9t4-t=s^i zgaWacTuzZ^jb{+lxYYBg+~}y&Xc}FKmxU-VlCGv&lp{w-DH?B3F4fo4f`R3dq&j<0 zLU*RKrB6pkpK5u=SUn>62&-9XEt*n-_7wg-htarorX4u?9hKv&9D8v}DtW&MHrXUa zGOhd)smeu!mnuEh6giwaS^K`77$SPrX>tZMkQ^ax>n!N{u8CS+N!sj`9$W~7CJI5^ zcT=-~z>ddIF<`+m3DF>+O>eVoE0!piy49_?r*4;kCz4};TxmyGf=OADmwla`vmVXa z1dHe^g-X!T!D-S{QF)^4l^dECs|l*wxCP@oP0Q&nnsuw;FsRDAhah#gTVcc@W`L7N zVpQyYBB_}3|C*Ky-0fB`5+$=g+L_Mw$I=kr&@Y~=RTu9ak6?(EOTWuE@cg0)?UF_N z(oT+Wb%~ERs3nDK#gGoYMV_sovc{G_ z$1`bBOQm8+UbDxsaccv9_S~-SRzteBn04X(I)`Hg>tTuic`J`I+J+GqvvO5J(OdVN zx53Y6Y^zhL33sCrNS6SKyzZygG;~{~-X2vQ=iCK!>p91IoS74yb;{DfA!S-wNK9!; zf|VjpgzI<=0*m=q9UqXC>tI~2Dgpo0 zjde>%9fg8tS6M|Utb^A=y^m(~PSp-#l`#JVYUA=po8d?rAutTc#x_E=VnAE3qN<}- zM5{Iav#J!E;GUC^e3{IyUEXxSm81Z7iLVX*np*C9WBOlxU@Enu8~qz zlvj0uA#)9^b*fi8Dg#v3RE)01^_-ZA@3RMm@r)Jl{5 zjn|KUtChh`Mnq-NbSPdMc&_$9JS#>vzgM(4vo>?m7HZydYt&b?mViF1lc?5Ojmc?0 zU;su)H)){V4qV1ry|jK91~hVnlEUu}8766D#Y}qb6T1cLo_nSO|98Igfx!xm7@zaf z4``Wn7v7&oa_p`>Ejo<~Ar_XhsZMWY==HsJn3jUPF)oK0)oZzYI+)a}?MiDGeI62G zFET~c$6~4P!5YH->L2~n_kTmAhfuSjs?I3Y>I`RC??wuXm}$bTzXk-%XzX8<6e_6w zV_KiWLoRUnt%n`JDlDE7sqCDYF=9e@X$5T+sv<#4Tk67}cGP-l-#>dgRq#zCeEeF@ z21{mtgK3k0+FRozS^iYcLo8|!4~km12=ps@ zS_B1Q9}`ps5uZ(px^Xn3Mm7cclH34Q)cxn_gI5HZ+U6ZyNZ69bpkTAzOP3OaDTmfKg6IP@GgC#98L;Hj1Z~nQ&gEcw_sX>uhVy@A=4#VEreLoAH7; zxd|8T&IJ(ZbJ%98qp6idHjs-Hp531rRv1djK?IJL9T!tQvgqGW# zTu}jKOXjk%EQ@m?jbHlRIT8(xkxX_=rxl$8R)B0(0qU#O02d>fXm$+9p%s9FMF2HE z;#LJwwgM{29idSarCJ*$1e3KbubCoK%tIDM-k?vLAQGmKR$-~bK_w;^BTiEn<4|Ve z%)7u)9x=GkB-2xdU~$1xYQx#!r=Epa0^CK=D8KVO5B~DisY660oq|S!n=g@#mlA(V zMq(yCyR|JtfSl$2>+C7R0q^4DB6CU>J^mRgI5JWP42L|TdG%pLeH4k#i6i?hi3{EQ zOZZ_eJ@8a93#yrMEF_K!F~7+oB#ksP48h!&e3m>0+l6iASjY5tD*mb#-Rcq8tORGwt-$||*zvgp7hWBa1I5oSShdw7 z6{=$c#1TCg$(^=g5DOEp%t*6>=GtmRSn^}%n%Ij1FLOiL^n+T-(9#=4ES-EgUBZvt z05t%=91_TA8tRDHWSrA4x(hkV)o>ngoTwy%wDeje1; zwSh)s{4*8Zl@>jW>D@a&Jji4U8g9D&)C6^EQoqr_a<<}`;xM=3;9L}*Vtzlqkmzzk z+)wHcNtVsd_}X;fc2Fe4oHb20hp}(RW#$4$oR=u+!1o|BZwhJx+XFVyN%Sh;**?A& z(+xKPE2hT0f@fDHQeg;T440xPkpgIa!nZ;0GJG)0*ts_rGp3|+Ll3Q^P`VT<88x0w`CXhF>^_*Rs>vg!R4mJ@zJ}RsriuRfrcsQ6b3RT6;SX(Vx~9# zCHL8bS9CjT9LH-h30pQVm_~tzv4PeqX-j1mWxGJaXrmzMZCPCobvlgL9A`WC z{5N>KArW%izNCiCszH`FpEfm9Zp%(kLEBc^ro7e1WmkqdswhVcDk}vqx$=#Gl%_UV zh+ukI;GiV@Jk3%LumklS{e_Q&29>BNG*pL2nrjOuh1R)+m5MjlXYP=6a#)fOo*oh( zBX>_vmO5ddPJEdlXc{I7T>>9sN8pe=4HHZ5eZHvoS0pRk2X&%=opn*$!v}M>eT8laQp4vF)H3^)ZvrmQPl|TP}036iol+hF@8g7A{`t#IQR$1_&(1a1t>$Z z8>Qk1!h^v%9i;oW$C&yRBlo`fyU54`vufzM-0*Ed>ad<2A!D5?H{ZEzXyRq`s@|>8 zzE_f({T?or)^@T<34fK*udu9md47pr85@8Iw52cSP)t-3f^K2t6`(Hv`26l#T_aO{ znu5NcMTdgcnOtFedGkgrsk^!zMP}T2dq!A#>Rp_I|vxXU{{w&c9>hM$~p!IS2<{Vqc4vU0Y1ZE&rf&PLSZ&&FNvZ zKh>yS`ekh(5A({`bp`47D>aNVhT9z8N+G2#Lv{_G%k6)ja2Qkt@O z@%aW5kyn2`8o6k1e0e5u$Qqk&qxuxKAn5oEeu-BO-d|?_ zEQ%Oda+Wx!Vq8dkjTNw3v~oxndP(<80m&3B%uMm+!i40NFnk;L=e_ce)6Xx00=G=C zdZ=N+xJN{#yz|HAdH;T#Enfa5LVS8{$`sP^`u21m&MAf#`-1rRTm_DFh?!WD_m_th z*7XUv&FyfTe{SQVe|N^SW-DBU+9CJ>DDD*dyDj|rXz+U2{ho5N$gZ~+0Q0l+TP7_Ei=!hz;4uu4HCKwrkl*4r>6_9icg0b+HL!=^{?##L< zwEq2pb1)Pb`DyW)<^DU`#C~mhkC#RnZ||t<88{glRPH32(>hx7r0}U6(u04mzBIlh z`%YXM%r-~vrl%;ehC*weCUBa0ShUPfC(4q$%LSt~@Um!@%tYW-=&91OmB*u}m@mkt zTVm59v`ToTBbVIFoiDyfK51ZTEP^{5YNd_+{3)xcpe0AbZ&YR$W@L^Oed9jHu#Q=t zt{_!OY9dg|={G*4IoL~{s|uYL;uDl*usAF8ZPpsV21e-&>If96FNm0oLsgUtMdD}zEvckK%LLK{xg0t9YB{cS z3IT=sO|BbP{fjg2S)O-BDcUJbzS)8-U)HgbTn$k!?+pmtjcTqQ9)E=#Ojo{44lWQ< z(&`E=4%mkLsn6if7bB+`!;|fHqWEZ-boVoG7qr~Abg+A^D^k`{yE9R}>8M!jY4By) z_3J!&O1&mY6qIwUXYT*oW2|dO(|By1fNMzK6uv z?p}rzmWF*7N>H->Di zj{u5$3nKufArxbOp-q9bZA?b$1YExA{*F03pn>`l6ShUGCp(YHPdm_eWGT>6UOScB z;riKum$mW_gyF!sZu)#fM@mF&DMy3KK6II7M@<& zD7p(924W82+G7!U$ysR&JQYlGP6f7U$Kd3-*v$8`ZUG^g8S7bTvGQ@B{lvVcW0Glj zS7J68^h5Vn<0qe9VT+|HX&qcd%(j$M*Y7?KK07x!L-S+7tNZVhulPe3_uZiL)ySD( z(-@-hiMpHaW)f19Rs3%xB)t($aUBT;8qKz=^tNhh%e;h2xeD7!2!XcMhHY8!f!nvj1pRy4%rufrMAK+?F8 z$hG4<<`bH${@{&Hd6NtZg*H`Wevx>2&}K7C6oBt?D8(81Wkk}jvcAqAfMO!Vmt2Ya z^eO&hp2PgD^ttDo9I9r?Bo@A}1Jn8x9Z~(>a}r=YCrJm`i9ct*iF@^0QG?@Be=QAg zuzDY%tigHRe3bGyvc`juwO*;;0R}WWdM>hC4@SXJOoQ$OsCGj8lkjn?1&kX{qH;o?8Iscmur6`WtiKVTplGmkDpLx#GCNFLxfpP{v*?q^V?a5cJ z+nU|`wljB0kH;3-D>TM6pNGl|sML-;*G zwb`bde^>1Gx71_LV=!8`>od}^yXs8_hN`HAu~Yakg1I_C*=sE!gCO7WV)Kh-EK3w< z{aix6nak^equ{9rVce-a7%l5PQ$bV;vku6k92>#_lmZr5Zcm1$-#b?NOzX z{=Bq|B&&2A*^`h+FQI<9PT$#`Z8~S<|1S9^(8b6I{400NS)g(Pg{#nkE-)1_rj>qTC<8REdL3< zrvu~hyYCGftJ58u7qhOaqqI&(kAU{3;l+uAD*_hxg{qaBq_08*n;^k`+kZ2r{n-Hq zom72&N2kq%x0)}P3Galkqmwk`MOU`O>^zW5v$Bq~sYZRHmr=8p7uQY!`$zO)QO#WW z+U|Qo4%NuJFnLrtwt&B$Xk$ei_0>=s=_4 z+Rz%x{-zJ#)(yqhB>t|A{JnGfc<*emIZMInbwu4})1R=^Zx$ZPV#(ZR-;rJJ$ZqpD zPTF>~aB$GE5OE22evLLAszm5eePh%(rb~8mML;oQ`ErLHF<1y?&-%^G2$@deL>SNf zQyoUP>LPn7er(N@zpFzDm#aoo#m`|MDRO@pAUO5PH8^*_G?{u97{leM9+l_U)4;IBWn*GOsAlbstA_Wz!qv*iF$9yIEDx8TAfER@u9C+Od90 z=^V7E(+An{9xGTjTLh}4+>TYAU21OAnLdO9@Z7q{;ZYue0ySr2K}_skeLC&SDPeE+ z7z<1-U7d+_-1&U|Jp6oj=MCg|%7r0}lap6rN@dARrBm{#&x5e)QNcqwOGr@;?*XC-I7wr0yoU&dk?v@?P%4Kg~-_7f;a$0+>9#4#e z8fXK(QwdC1rYy;|xGfTxk`W@m9l_k>j27Zv7vOZA#Zb^_t!A=h%s_`Lnb|;3(*6zl z-N<5`{&8kOv3L6rO>?Q&^gYQ=5xiy9Al1O)@JfkVSx~DCooHz>3@x3HYZByu_9Di> z4gjnQQj|O=dn+6n=-J;TQn_~X=gH(7YjZ4yMOLHKp%BfzTn)47b9#*vhyEZOOnfNR z(nW+b?V>sQyrOWj=nI+G^N%s0_`(MdgKB}@auz{m65}BjM?C}xjVjs}9;NZao*&yc zdP4jF8pjFzx+9EDqm*L=DjEiqN4DAmJ_}65ns0rt_h-IH+7sxE#xbVT z-aq|ST*-6l-&g2pT8|=T;L04=ig&WU`}0^)M;$up^KdkH$1j%o1Y@U=@xeA~SbzQ| zlNHgTPPo3@;z%N~Na$nL(y#V zo5_cI-3yl`5Ig}+4ljF^YgORiv(9kzEwsJIjmx3;A+yQN(&6}ey6oGrmY3}{vh)0V zU-<@h=*Usjl*!hdZn|?+7<6no+qr;H@m?vR$!#}&a{IB+Nto*;8f8ul&`B8 z7@d6`-ddlj_qY!wpOsjQUcFRl@UWs-5aZU+-j8EnKk2-tD@F~R@2u7lYE3@pS?z}lngBhM4UV5GFTc~l`|yr;R*yUsL`3hjx5<5{c2x>>D8^IoZ7lvq zQ{uRyScoWgR!;m zHD^1vg0E3$*VTl*#1Ql8O6U53Muh6DppR=^@*L*pxDN9Y%TdJfOt(cOjlbo5U5Dx3 zV;{@E-g{hK!dtm=*o+MD$qNS`B+oVPyS*BV#TXifR5zQf0}GxTllWza?H&c}x!l!6 zkB-!CwX$af4A&mINn0w`HC!|8oYzxv8+~;1mdO=`ZN&xZHhEKr`2;|=;Bktm^P6$1 z4PO?}Fv+3!rDm6zH?o-k{?*w^^T}PF!R2Gdk>!1^s&4ZppWRZrK(5o=QD#5}FEKnH zuJDwcwJon}alI>JS;Eu4qjCqJ@CP^L=kAaUAuqx0G9ic@^GZDaRuSaWy&H@8PI zoAkPY#*lotK*!qp{R(oeGImCpMtB7Pj0}XN5eiJN;L00u7Rs+N-1qK9aMH`cA8d zAffRkbwwsS7temByS-At-rz?6S#43an|cqf%fd%LM#mHRe4gaCm*NQK!1FuGIO;aD zPp8G0bi%m%KD7Qk(;!!E`~9f3oAq>Ts;A_{u`iZ7-*y3Aj(sAGXy4)E^x^n}LDqsk znWiS8_-W>lKQb2M@_MNy0b=mMMqABLf`W0$R zn@{?>3Suw)Z{n6}X=lB+sh^N-*d-1+;K%0eyQQ_E26_N^U8t^0dDbkrwWOmz+(K*ZJ_lII!!S-{024s;zO9+RbUa6q4mfd5!zdGdwV#dMS{FQChlsvTf%5 zJpNWMbhFk_w1xU8+oL_D!TI-dKv(Hin*2I9`4fXVfwLbZFtCei67T(>s&0B+kbD9- zjcn;|V%elwgHVN)rnup(HSJpEiHP^eA797^QdOVrx_;36t?q|;y)>dUZ zb-R*-VP(s7tuI{B+Q#ddQ2FTcu7RR2XU>8fdDHd9P-S2W{7W_uE68@SRBgaF$Bo&- zN=vDAfwk8V5&#?}p(f6GYULPkcibD}y0{82UGxJaTcK~cfdjF3VGZ{E->WE)L&#kn`FkWh7ZZTm0_;$X7 z-uBYsFf*L#Z8A=an5J=kPQsr1I|1zBADAr(b#iP%ID(sKRJBDPHt8<~mSX6Ws z`^C~02X8VEE&s~e>W$Y0sI8_#J5@dn=%s^i<76}a&Abi|HBUM?ie7ygKeVKq$;YAe z@4)y4cz0`hxH2`3!4IFY%Ei-D0CZAYq`ACBbUv-aG_ zy#%AqrH(}BaU8fHRg?R$pN-xtzo^^8$Ktt`T)hYmA; z{42GzO!W_GZMpVVtG#7E^s)pDHRH}?iV#@(xIz&g;k%G_CAxqW%Z^i8bDwc75-&|- z;dBq5aXdiw#b~!nsvgwNpRAPVmUf{9x{+@_zl6wq=o!$@XFe%`{gAOvfp2L7;Et7J z4Y~6#vqKUDj2avqJqbL8s~l0evTRw-Z`j|8>Dcd{@46dfs`2ZuwsjnR=1g+y$2UfS z_9ZHTry1-h#i-l@VCTEr62)$27!-1Mf1kNa+g_}?+)_oD^Nsf-EI~pethav7v-@;0 z-L)Y69?ftRVIJ$W<*A27DvM+fYArpih3%Kc=nn8aj63rMflbm1J%o{i`b_E0s{8YUn1ou;TY#+=MPV_z>BM6U|Nd(&U5 z_JL}aqV)~k4XI^0vkP_gBOai(;kfv>8_OK~?}xR8#;wR- zYzK|qV~qN4t!vFEWjdzx*1Z&cbz5T0^xV=vv2gX*$o(oSRDZ zPZq4arx1gL#jLONk!n1HOFcc}m)U^<@Q25u&-;YBg=xm_#fdv3XHFL*{s(WAy&cTpwaw|3 z;r-6<;D$aJ;Xnc>?40etyAO${|7?cytHI~V{~`48zj{pUuhsXp)6KyoW|YE*|#uI-f_0+uV$4Mn;1w%(%pWU zS8MG!pS>N_9O}fKGaY+#4|)`Xqi0Ktxvq|N=VE*H*!la!^=<0|Te29Zu7_j;IKNyg zmS=XA@nU*^r{H@$C1kA2C*T#mdA#FmEh(^_H}58TlUYZ7hf`bCz4*g5y|5Zw)mpSi zy}~%|KEbvDGCQo7JT20v$`n91A)#xL?4pnH5ls#s@&RqhKYWrqiErnV%gj3@YwMXOQnOB!Fe3}W?q z-dv8`pR22HCvkueo4@_z&y{o<+>Xk7o2TE_iq{0=S~E>3lv1+0)hOvzy-$qELT$aZ=y;ylf*j+ z2Uy#!jw{Nj5=>*IA*N|$4!zj;b~PluXV(wadd7h$7&a#!?f*t^@%_##*mUjb3^q%9 zVt$7x7}p6AUc=9dV7l40DN8TSe5h{{-Dyt7=04K^*H^RH6PIo`AT^-QzqY0Z!Rk2F z?m}x_-_MoZ>caQ_nwbGmQynoBYNA$>{VaQ^i#)V1vy5TwbxIetx?|S7#)Yjt4O8v& zLKjsq;+#n_gg4szSYOC%OhlWv(9K8cykmMW?zh%kTE z#=E}Wn1{DPneUfSZRo_-DGu$~8N-~Z->|Wu0t8k zX0e#sl`Bav7(6~Y7G2fBxCFNF={A0a|H4TXM_35dwU4EV>g+JjYrJASgdWc7C@dxN zXjrCtIP0BNG%l(TA0OKAS#zDLWM0-ZU%t#xQGU7TZ+b*6)W^=?XVzO_E_?gO8@gx%CTZHoRZiu3JuZbB7P$b`rg!}Qb^1}IAmsY3$rI*o;-_7>^R#p3 zcUy(i*+k43r0ux?Ece%&La{=2lmXvzrh6`UcQU$ezE;qC{E7d0lv11BZe?hcIuOHD zX$#MYb?X9jYU>uE_7$rPxElK2g;dhBQ&&oN^y4seB9c~397~-QU{0Y3Cx=n7q~l0o zc=}%VxWo{u1}jO${BP7%EKWDA=lTV!&{#x8$jzvrW=nSf?}>58$A^l!&;L#|X8XU? zU5NFp_jvBl^%uA8>}4@*xvmtwxskgKN>_z>ytmPy^*Mz3ekusRt`U!29K*o8;M0K6 zVMb8kwp**;2>+UuW)|h$)<~UtQIUF090zQNb)lHFRClv!4;*}#+Ep1a=VM^aTDACZG(yZPKNUU!r7zC z0x}D-I*$nHT1L@|*#SK7c3Vs*?~j0r4CziUo*<5U18m)YIES$ zBh+uV!?zk$-AdExtj2a*3{3H{sC?}7luUk_o>udjLSGwvw{Z$OIctQOg@lBC6({TQ zDg;&c)+8=b_}PjyH36RMopqGXj~6sFCyo@#rgjV5yCLOsd+h3#H^keNaxZ1vwcEr9 z4+@!!SaCClt&e{Bq^f^K#y$-uODfuFRrNggRML+=5r<5 zwh+5F(8GE;wKcj*;k1wL+Ql>Vu!N-Mw=SKXZSpkXeRlu9KdGfD>JE?MWF_n?4s~N5 z{6JOe5`f{X4f3$Z@LX!S^Cj9nlbKK<`Co%L!_wNGaaGad8LE1*kTs)PE)Ui!a_5Uw zW%D>9q^?bWp}funyvH5gOy|q&Nn*>oDVI+cx4l900twrp(xwQ4v?07#6za~nx^5z7 z|C}z*x8TIThCovT#prK($%>DP+)seDxs(aE4EFl%-6-x!$#!JIB+I&Q_V1++C5DmE z1UfBxXnky36w=nLv0*IaA&KVRtqFC}y0;PT_bBBS(UFVUK{g43m5OY|aX zxV;ntt{&p;4;9qy6!u(y`?hEk>SspqTYujgA;@L3CAFt)WV;6`)DAEvy=Ut>nEH%G z@OiUrJkU=zAlO-Pt%U0MOY30UN3az%_XMLpdMT~W#&13E7L52NECY4$xze07*NL?+ z8S$6w3cI_T#uiedOcJ7E`uSZxOF6c=w6&*0x}@b*GmS^qCZ-jF9c@AD^D^i&)}aV} zpze8QGB1pMEpoUsJw4{M-eFF-;;z^TTrS-CY#2s!Hv zi)8U!^j*n6a2SYc$a-%-@2^$V^Ai;>;i}5Uv2=O4>EObmcH?!!aX%w|0I6n??uoit zNl!gRM;>sNQ4PthH2E98;6->A-1SM2geTi~&_1KLl(p9w$7VDpy#G-LH-%A~)JlJ@ zbx6;QFYF!iON0!Dx$qdXB@tz_@900;4ITXXU{(Nr>Uh|{%yLEn}Ffv>k> znp$B<;%&Z;$Dgjxj;*a%Wc&1LjeQd=WDL7kER6EV2H}G$EVXz*H{DB3bI9YYOCx@6 z{6UKNXG(2PLJiehd=1t6rcH{ozZQJaS}?G*wf1E6zf8`$Awa|BX#f7zFMh=at2Ce2 zWSyCK9Uw&HF@czSThL?Ge7In+Dd*B>sT4)9JkaerN@4~>H20bZ_?wa!|emsyKZgsFOyuio-ZQ5#`mUX6E$ z%!~@hJ;Fvls)ZQO_o`0gB2mSGFB*OKHIKlBynAkwJ#Ko354QVVtXu1B?4<_s$e#CS z2hA6bMct4QLWg$|{*NcKmM@9~t>?5k>Q)Bz_D7xVfq8KESsTWBd7-f8_S0_`uY;c| zi|fHi9!cR7+pHb4GG;5ilLTYt91l2l4xqG$`}cMI_mZ3(xfd_E;>XN&XIk%&QHSxG zMDZZwd1gFd2EcFUK0>_A;GW>=)~zZRj(dJlHOq-oQ-gYi)~yqSY$t@~c%*3a3|K0i z9zcy+XY%$JTQx{5JLxLkTOkWR{IZ@)EZ|n*)O8yIUY`s`=(wGZ3GbkSuLgS^)+-NN z`i58PI9@3}cnG|t0?RVSJ2nBMli+O<0I~a^=UpbHCUu=YCKqI+BCMbR80O=WBcvEF zpR-q=ItyJ>R4lxLXj zTxLEhsjDkkB4vucL?!z@eCTM)b9Q=1-$WbrClUI}xRw24%E+oIxjw#P*N^5~Jp*;y zRPTHi#Y5~9JL7qO1x9-oNro;#)5ylRmG^u>Bsw7NAsKQgPmpo{IrYa<_|{OI^dm&I7t7z)OaDWj_e>hZmbcfM8<=a|#r=%na- z3paHlIxwb}{?X@U`12J}>6yq-E*p^D4yy9qeW+b0Y+c#+dAhdG9?g%68$8 zZ4-npy#8f<^KtO892XqHeZ2lSF9q@DbOw;Va=~u4roDU)hsAyJgoREk1ahZa}V9LA!JCWq7ls+xNVut)urjxG8*VyVM;@7**zeyQSkT z3^JYe@p+a*(0%maST%Cl6vmX@d}=h5q8^0P+E0qHCF})!7FSOMnK}>YC8aVAcW`hK zdc8PrZW8hvxgtE!1W+rm$$@^VhJ50;79lyeO10C!i&>eEVD>2-ju5MP%D2MAf%tJJ0B94oD48F-{n_vB*l__WHKhm)4!er-w1 zl&^Qr|wDWj;RcRjFuO%S5r9 z9wbJ3Oqg?d(LtZ;03VW}2?gi1vMzmNH6w62Zs1Uh<{z zz0%xm+oo(Ir{!K^O>}usAIrdCN^o?&`)*99-VURR`uwiuRK62Z)^{ zGJPlA4-qp-c`q8NcI?)DKNiR$cSJk%aEe`p#XPFvS)y(|T5V6M)7n*cbLIzUps9Kr zN#tFhOK%ei#7#Cu!!|-N^Ly<%L3-TOvKry6ds5r)etW9(n8gt6n+;)&@e1=cF6j(IvKPd8Z3693Gd&<451oEYcRWOUA1N` z-8bZz_6MFwN@jAilo2(q;B^Tm0k_hWnM#z8K7-*Adyl{w?(6^ zVbl03KcZ@$kVcMg^Tj%SN(7EL#kMSw509<4dc!t+utb(F@Lthp{=yr~Z4K!et*vAV?p7=ce*deJ+hc7mFS2xl?J`H z-N3=&X|E$LYNVs+XIQqc_pQ(U!>Bv+=LZny3uHGA{u6*kd%DM^lXZ25Pmc6*>w1F3 z^vpple-xDX!=!08WMum=%KXgz?yadGiW&PFnQ9`ojM?*P1xTIbAFD|bJuN(xyxVvn zeWc;qA%~4bwiG)4bXBwCZYWYB37+2y8geFgt78Y5-rE!F4 zW%lpiigPXSsiaOQ^wJ%7qHqSdnPKKal`&<`oR3c6qty4kSRr;_>^SL>=}LK72GN4D zC=K(tXHi6oNi3?F)MuqCNFMwJ@pe2DZ7@S^4DRyndMgDOcfrOedlAlZ`5%H(}b ztl}@Qx%T0TqtbTdB1hoQauWJJ4IIPDpchsPFeO|*5l44rve>Do7WqWp485B~YJdtp zl!_6{gZO{O2{eadiRsKD9nZuJ@>8P|9hBXfxS~5`*`d+D^79KvlIkO==k72_X`=qY zy6%pHnywW~h$eqMTS8I)xgzja2&O39GawFk97MEPs^F$fD5jh)Oz=iyPqmd$aK*MU6;P+pfj{f=nhZ&3Ai5nC;~ziPgr=`-YdyZcP^VKG57(KhAP~N>Plk;m8pQB{_LLd{zFz>emGsL ze>jZHAE)RcD{)_hU|7dvc&->=kl}ByYWh6@@$a2=egJ6{$jvvnoLQ)M7eR#Y3p>2M zD@oK%?UJ2jH<=qnR+EA3Jgbi}FJq`3nX09!SC`P56NX=t1CI6S5dV8X+RsVGir^%j zJ%;}Ya@_q;jd31Ur~hwH=~+v_p^E`|Pq&_qvXxHNqbOTX4a4jPps`=45RklcOd`5- zjTdgttbJC6V$ypEBd8Bc2R(-blTN9uRMZti@9Ae!F%Rj5^irotL6LrZ;KXPl=u` z7ScKXp$$hdj`GeXmGavX-zVWAs@o$u0C2?7ut=auhi*NGx5oc>@Oz1|+V8SWeDe)m zGeYA4d1(Fkb7G}d%vqh61T^Fci5OKRt(Mnk;~4G=_TTu{oUt=@oubFt$?x4*qx^pS z4#3KZA^GSA$F7Rc1j)erVvsDkwj^N}*gTeSOemh8xSudvnLkdf9~~Jbj3{Y#ick*v z<^(Gzks^}&In}sc>}*H}Rdvvm^*g&2Y-nlvUK(`h2#d(GPUu$hEsN@5{Bx%+ z=m4i*fufpsXlmkaCjyu|dHKl0{Jp-6&*I{va#Q}>PjB4_4Z@?7F56k*QdNoKO#Ar8vdGoy zIjWOv!cJ4dP@1SwA2PB~KB70rJ_9KvTbn$RR2ZdYg!32st%!}Qdqg0G_34OR16+2} zPxwzX&)~yUtiDnO2*li6;oxmIEno25Z4a=jLQY9d&@lhF=$=k@vgStF5L+Wm?l;2Q zm(1agv*G$WJPTLPmjD>)xR?5Km1aLDxUjTd#3vk68%a3_2d-BmdQrY$%Qdlx_ND1V%|j6MX&SG%=hWGMML*E`sZtzJxeD3j<4pJX-oX@ zIbu9pxHX|xaS~Rutmb%_O^JJTuyi{edcCpzWym(cL|=HG_>_o9;ALH{Zo0AXt7ByA z2>VYuTioN+Ay?fuO&9qxHKn8Z{<&)9p<=ZChDeKwKT9l4>LQ}^#k?3*vepDK)z?t7 zGUL;Ilp<9GAzurrImtKhX8f={P|5CNrP)e?e;@~$Xu6GFijW1-BOUyZwKYZ9Bi7B= z*2DtkId&asS#Ss zu6nP}?OaOJ`5K}gT#7kJ^!w^7JNR1MR_I|9-M7Pgv@Ln6o5LJggG->b}18{O;{A0dxRq zuz*SY6?L#4J&_p7^NQ1m?jf5EHB4ibe4X)_w#oD3#o6S+?PSLtMALpNFJ@a|OFys2 zD-LJ+lil<4?9J%yvP{~zwVybD#=K0fy-T`LQ_|CW!t8*eQ9-wRxTCjbg`xiVC)5ul zI?4>o{JH3zzDXl*GD zrN+9$q+Y&D%;jX>7;_ND5JV+Rc!8W?jYZoGB|HxjHi zdEr8o5K8+sMfp!z(M`8P66CbDfb3xk!^8`t>%HwC@mN} z>VZA)?@AA}Yo1lV>iiIN$Z9jkZUjuP_aoKl_%f;7$jnF4rqFnOxRatcjbM3ECnQe} zBKiA77Q64~ijDKG!I0Sr#P>(;DEjVqiwdktF?PM7G1J4=yy^MH6?a~v8ULme(Ui8M zdgloObX)5W)JDeHs`?&`PeMQIpDnqBDz#!`t`4aLzf4xLaA8bWvMi|S#gupJv2JNv ze}ckPS75#VbC0Vwx$Ys2`Ko!odQ;slXdPma{M+8wSor!a(e}6Osy+>mn5r|(tO31m z&hV&)q)`Wm7}lv-d3zt3+R<9=wn1x#*kaTNtaVbESeL0Cj)`TJ5$thH4z=ADSeJA;~^c zO^(c0G^OEw@gs)*7dlWK;qo7MneKZ6i?+v?Wb7@s!n!L)M8S8dcM3cDhpE{yrYI&- z6F7N_rY}u0y7KJyRj1#-yGxzo?$9OjzNbh_8l`RzD|=-?Ze}{vTcjMHIqPWL?N@hX z@|3E_#y5&qp?v>_Ii&|SG)AX*B43O5zaiVd*^Tn6;#LSkRysH}E`XB7tb_p&#WgXD zSle=c8gK!LV?=FW2`GbfP!ZXEyAILQg=x4!^>w91CRE-N6Ce#o9T)c+c~sS~1Shw? z)9O>|BJ2icf8rP(x39DKwUoNar2RH2j9+PHRJi@Y@93e5b;y-``(ig{Jd+9Axx>e50!?pGvQ zl+fSmPB^{fg+8hQ>$+MWUvT02+O)Zdc|kb2cpe8&9wzkk4>Kzk!IT7=tE@0q1!m&G z*lJqM7eNdT#E|!2-`;#!{4|g}0wy~7`T1BNVn&xy$P-r=s649MYU64Z)!_`hnD z3^RTuo_i}`4e#$tQ>&+k;EZ3e%?wJg8*cM}*er^AI0ZfD|z6@i!Seb+DGPNY{zcI^{IK0S7VX1 z?xyf#RicG)dBy5NzCqXBI+izD;H&yy@BKz(IcLKynQ#PIKf<$6th z4A{gqZ<@cw5iPR0Ec5=Urg#tKGC!eM1a6xoFywItb(Kl)@!&8CN>9?XXjRGf~ zk|3=BZ2cc>XT3f~BPQx`>_7l`GJN>}v2{am`hCh4dpkJ#{kr9ARk=_?mRfXDs{oFT>RH5=3a9I^FU zvCTNYO&q{vzy#t8>xZuuItZ#cOu6`RKMWDlPSPI{rn8i7AxL9B5^2%IG-W6;e$XGS z#NO8;Bhnq%Ae-}!oG5|4YVa_tBQ{AYnDH2P%a1UXE?o?xmvw0u``9Gq-Dl!i_{bwKQJ0e#V7c$TGf?1EEn(bXVbcC&Bbj|sgaxN zAR`m!>LP)0TVKxX_pBE6GEGvsdhyK_rVDjhi>Tb#VoT0wbNEuZel;5!X04*bNkD(Y z#M1fiZ$#zMQqo%F+dY;2;NX?zxy7P4(q8{j=`1X5i-B^yfdEn)s{beI|1PLnVkHr8 zM4_O5ctb(4{eNl@X8X*vH##{B;>41j&$wf-3fu5**%3NUC@#I79BL0{)!D-eUe zB9exXQKrMdeu2G!^{)HzSi91J<9*cy3H#k)^a;5@K*QSh?z!^c{`A|vdz<~I7s$!^ zXBhaW7ohk>DG$d11x3`|^Up58pAY!hsWZU3uCW8D64_`7nYI!|37BH%<&Ym@%ly?w z7ZuW^p`k$=Z#yNcEiMnpQtd^Kjo3emV*fQ|Wo0AV9=(DFMaGJM{XvMkOb21=om6AN zf_g$zF0?@M{@ELP#Svmv$fmH0Eb@x6pmaaDhI^s8CY6}-w*6t_ov(?T9EB;?j^z@H zNK#%)uqdtGD9->T;cqOr2H4=5pOr<}Gem4_l2c;{o~9J=?0HJw6poN`PL-nk`2&c& z_Fwun_>nwM`0a|}`(Z?Aa*c(Nl(xR#F4EiTL}cy)`!`NQC|OA;fDTmt8-@Wx8v3hd zU5m8!G92+A#kX{u$!Ip=Tidarc6owjkK@$S?0VU4w$8()e9c@~(f4zlI4@SiAU;1Y zkLV#SoTNC@S`y9o_STndx6j414zEangIl`BHv=B}i;lszHf{SZTg|E}BGlg-=re++;y0Q{sTasmm7dr)RhM9{6{xj{UKDZn@YlOC`=jtzT5bM zdMWq0v-_CQ05O`yz-Gk6kdrnwoV~{YvEKp6uTYjcYdcveKKN{495)J7#GpUHYN%vw zY9yTSbTBAnhx;PVYNb*9NiDUT3k8eyF6+TeTp@~*rh4D>BW%IHrEv(7V34!v{>YiSx$)F|MNFqm7JH zby6GE@X>=iG&C}w1K{`BMA75pQs#-Pq6uT#=TNdcrRt4nlS%)Hop-TCa8mOqWRrevaKhts zD67VISnH;AVyT|}1A5c`w)oANpdJPTt!89lX?5Cgqr!9RqF#dLRDu$6 zrC40yL5rkP)wPqKGQcSX!IxE$%{YKcPK43#OpZb0IdtLB2DLimG%Yq;w(9RDi7l6| zzr@4A?1B!95%r<~wLgW%ciwt+Hn3~I!0SKOU{hpP@69;c4sjE$;K@aavYzL+Dy5Pn zm&ljV-Kc~Wk{%cv#cp6ynjms41P&~it-U0*);DXneko@BXv^Ke)@ax1U}V@x4Yg@! z9Fmph3lFuX_ni;yHZCvuQS2?})|-K1!k-A7YfDA8!zbTb!0ulOFBVh=&pJ+V?*D)7Z~gCyAaR zQIG8al)%hr>hy&kweXewR(S*0?En~+HE8nA_kT4V7+kS zxdI43QLKMO5j>zWF06sQq9Uz7I}AFR*+M$!0CZpBcoD63rb-9fQ|@B7IfzS8)(;y)kGGF^ksO!tNK-(7oUBxasA0eo; zn6%6P)||@{NzpFqyJ-~bp%_&%Y6jVOw4XWNC$r>N1(r0moct3px?+H4JAg^0?>z?* z*u%bJRvvd$T=+NdNHb;OkZIXe;$fDsg5xzuCa$Mw?rTLeh5Dm%wgIO~UYTAVY{@kG z>Axq(e|qC=gZ;dtWkgz_#0;FM?p%Dg@MImIWfX7&n|=)2+RD$i{JBLuRr`Iak;&iO z4=lAP9eGzJdIqLjwhmWYc~=OXHmH0W;KCESR#{=^oA6WlK?W|9I#pCrAw8i`u#O@( z0o6*c?a~8-P3+XqBXG2S{jA9%>rrEx5b@M%kWoD4+98-68_4vg5t=HYr^>T?(b>MGyaA@ z#)Cs^BVPuVcKcWT+|$ z9jP8HDS=Jc+{zBm$`?a&I{!c=q7_5JHeE@>yFji#!%`nIHY`IhlHcD@3YhBu^6!HJ z0^$+Uo72!T=jceyabWh*7=AfW1)YBvh~9yQapXfl{(djQ5<@Iz9)x#K2g0l_PFez# z*oP-$|JM@86wII~QXeR)V>(XZoq$r7gfNy)VagB!_ZvE?*@vW3Fv==RSvyPoaW+9* zrC*!EpEW4yyWUV`P@;W<)D(3!*oBKlc};=)%Uz00GE=~$LlWB;RKsUDI(AX&!{_)p z?F@!E&DuhO06x>X)~>N)H(7NR1srviWh-?RKj;tP1&|zl-kE z?|BaBUSPc$6cY${utj-1CWfZCp#T&U=nd4QSUULKzY3UwaVNS08o1(D3+53>=eZM6 zucnOP@VA{a6N%2jgx2HV-6zLdNbl1b2OHqr0vYIr!XK6J#wNnAdSY6W4xIfX&XF3eF^IJrU9a#C%0Q4#l_PRp>Tf=xDh*wpsj!AOLK1$R z+J+PKCNz^|qs|41_l)6-(0xA@Jp4qs~DOwt2h;V~t7=5w=+` z(TA#SGkC&J*V0mGy$;J@Ro`E!@}bE7!@Gj&3T!x|--O#4w+zZV*H%z(8r~j=#9EVj z9iZ^3gX0S2?r*=TdWCuif@ZU3G6&u~#=z=}@EQQyscMbz)EZ^8_6HH@>Po9Y={Hny zi$R(JbGPO02EdCxP24HJzV=mV4sEs0;Ws_3JpYbqh;Q-I(@=GpOgtL54wFd+9fOntg~T~OO$W97H!=xlhHxW zEzyQp83TR#%E`}yT7KQOOc}#f-||kfy3W80WNWm`cO}f%$P4^Wd4QmYdOww8u7yve|XM`l+sW@OyQiMYc6FD7Z;5~i|7sHIB&T2#67OK%R#G2`b;wT3&= z@#R~&wEuMtDdbzKD)ub-MXI;q!pxJZE5QBcr?l&$>>;2r;2ps@0+ zeW&`2#~IBW>Lf=TVa7883$^_Z1o1ohTOj)m$99OhDyjtlaJ^)ja}URlFAZ<;1|u!O zbTFdK=nL@jP!r&_!BQf83d%Skd(Pk;de->(*aUmr!gyy#+=)4Ncre`M#U~{34gS6S z_i$d|l(NBlF#2BN$+`x66}Ay%4nLA30w~jpQl^#sjp=YFHcG!>pN!GD#MuqzdJHFs zK>@N;uRnVXQu+PKqY(|6acefD1uP9K-`Mc2Mu&Xngvycz|<%;FwTgYKrg?F zn-D0^4xJEGuH`@8FV_y5a4GL1NWqbRqow5IH}Q8Hj++PK#ZPfFkjIF1{u2pK`BCJE zNLg0Uh?qhp-wx6L1+`OhG$%eLGDpzQ3`T`mEnv_0Zxt}-AvrO|bNE-?E7n&3Qi)sO zS?u#CYWJ0N;XJvz61t+gQoDS+0xAiS*x+R(kN2H7BUNXK7p=aRsO#?V>9s{$c0@zw^(n=s`B~SsfLk}Sui}Yc@t1h91LN089z`^GLH-J7 zJJuCH?-{sPfU>`^M69$hn$Tlp@wzgDxVAbn-FFGD?r#(c7%+Q9;bBI_Q1L)v@RNv; zc2u?q(G%40jRtoI@c?bCby$jIdCyI(V|39d^DwO< zGrPu-WAZn5+7WTzeroeDNu+1q67T5hJKe?Geu0pIP?((eFztz;zm-?Zf87#I=;^i$|&U{Mdk8Xy_rkeXccI?BHT zo4`0Wn}u$r;nFB2Q|p)&Ap8x=$q7P>(g`)BP3hQs3gZn6pg06ZA?_3Y?kKWrGnPXH zW55PpA|oAF%UgC86U!18*@w4A5w8mpBV!Jcr@mmrq}3TE(qNCsp_&MR8!u4>G$asD zG9bo+1ZU?()&+KTIS0^VfDK^E^N&>Kk!Hd)-~&O>D@V!mMm|0GuhhmM2M%D5%b}I8 z!NT2JAk;1qOH|lP+1MR%qb2l*HM6NFQXdHi|g9RXAD5fRncxal)k7WCCe z7nFSh#`rXxh8lS!6jRCt!}%xr;kP8WII4^<7Szl-0vfMx*OD^D1ME`d73*p4L5%Q&!TYRslzal#U4XVG7f4oBB3WC|8I*6RK`D!wh2;^a_O0p z?`paE#N=|nQ#?WQT8V?6-06~keNK=Sziu!=C31B0RK2!{kS-U}xc$Zn-*|}Cd-L$F z6!5|qY~8!xNJ@g==)r{%^2%x;6s1@&6TjKMRd}fTn1mR1gc(SZfTcQki= z0hYs_48s!h>0Nf1=RT5suA3$(cER-w#DhI}K_}c|)yoNN0+kStL z@l9vqUnBTiXu|n6TbxJ7Es}22FY=UbTo04mhr|d;oQ@Ls#g3ty0kHJe%+%CK($I7B zOMOy)DJd}&BmQD0VS5`RJR2tUxz<7l;8KV);-tjZ90nl?2~c`edKwzme5)#ja7z7V z^p@s$7#l7UayZ`R<|A+$F885g7)eTHCG~{`OQi#2X(dHPh%s6h8!~ju5v4Rfi)74P zhM0v(qIL=uZq{Y-O`Xlo7W1;}>Ai#W4$hn?g9})w=E$)^MG?5)y&yodr;GdH4C72p zLtew+cVl&^33Cr&s4mG|J)br-Rp*^KK4B)M*hm6fsrtwadIt-)YD2f>LS`6yI zB>e}lCgOD=gl6On3S1;&fuXSbKuiBlP@nW~mkbphq`WZ^X_jcDF_8JDA~_NfxIk@+ zaX+@?g6gF_Ol8_+J}4}cAp_E~_%}bus-r%_5_w=kYO3n6sCZE_?qG(bbE)buMR|Yh zNH8c+rzkS*zO>@MSsH0*&urCU4jUGBV4#(HXxvd|8UIq~5yQbuDb1W_W(M2`-Jn6K z7@is7@XGq|%WYG+6=%2Euuw6Z0L((q%1aSM2(m&6Fc zptr>LL_i3TUz2`gN43l8^4#T=uIazcz#gkcf zW;t5e7fafMwQNgt4rtmm7FjnErEGrXZ^_nf)$07! zsj}x%jK`xOPs~=Yk*sEVzUPBDaA@)G;=bP_Pxn9W6NZ!O_YZP%7Wbx}>KiAXSMUV` zko0;VK+TS2(2G2$@O5|PgFVaI03aTG=&%cO#Q$umQf&P#bpGc`4+T!+Q+3=_)U%CO z2T}5I&bL2tEFjT#9{+tTDSYS5DxSO#>kka!%xMkm&k2$2F%!%*J2;sE#7_Wfom?me zvmoLj$;~zpbLSiyYY_{Kri?@$aN2H7<4%YUU0jHIG(^GOSOagIK(Co)G*BK@5OqMq*?qaRo>zakSX0m6;mdfa_{J7oB^R8=~QBiaB#Eyk_%KYnQj_;ZBYF#&X?OiJcUKfqW zue4ZD4Q6IC3i)WPPFsY~xm&8IM+^7{fluuXp_jf``X?>VQ+_h}%wM)=Y&Z5vA}Atw z;MR=#{D^H9S-&1d?tuK$H4V_qTviXT2O^NZ$YxWPHarFL&-jG? zP>R1}uYCHilm1UST+@gQdNtt=g(`P-Dbu_K0!F!umH^&BX{LM`#xaqTObtA7Ng;0G zO+L1G*;wFku#R|qFpmd;KMM*VUc~tc4q7s!|`&#BmRlOJ+Y7<{i<^r z{*IOvfwcJ6QhjU)?m%?Pq}Rw=9w0Hd2&EA|3F3w%Ya3O_N*jP#%zslC|rp_oEkpJd^- z5q4tTvAQ7T7Ns#>axj_S7Ao3UR5(?H(Ygc53u|f%_Az6fvgOa3R%)Ix}y;Ya70p1OK!D+l-qGKD7qdiWZ`Y7IM(Fy z>Yq6EQql7GXG&a8Woc`=TsQ-f0#a}Rj*xXiXf}4*U>szOZIY#&+vB5)^Yil~w7v8G zCPM0Rd@PqWqBn}5@_{KdF-#*MO|(*AJP@Np6-?Y{1z6&S^VZXjyGuTM&KKpjx?DuXGZ)wPK zNnDdsczu<0Q`bgKrahj~R!6iS*{%)o?e*5N>p0%VE}nv`_uT}wL`7M&XPG$&@itr@ ze|MWmSy>u)t8q&%B8USx31M_(R;Q)iza7>i`k1~Bn6xRiX54|{rnkHXbE>`ubVJFW z+&S1zx1r&tXQ|up|8-8g^dsGbA5xqKJ4uticvUngvstU$*f3$>dNQl3g-{G486b|> zi^nXVcRb1F#}()u7OYNLczN{TXRVe$9kQtr5-_&rU!ruNF);`0~7_+_m;Xk$S z7zhP8$*M|=l)9sPB`8hPff&L+^y=Y z61Yv7So*XWSe&36=;uct@X}>bz8Z^X64mj7-E))_vMRFi@-NnfyO#=I$cyZTLtiwl zFhMTHwh>;0j$YegqtT0O5);smb9&oKk+Vd1^2_P7T7%&F#OIFfMuo#c9@FM5%foYX zMMsJ?kML?j&gIA3J#u!O^qB+AcZxzc`%h(pmyX?)l{Sw3->JFAXs4tv5<}cHgKBQq zNH(es>UURNjs4o?x^@&TQ;f20T)wYp^V_L$Y?enc=2B~lU*$;b*U%HlSZiuJ+Pt;5 zkl#TaWMP$T8Mm31UM_>de*?~%KRXz}Svl=Hj)OwaWw<(tja__gd_tTg2fDBPl%}r^@b}USQmr3#yLJs8SAb2C z1;zfPWUFzF?9aHlIH4GSA_B>o z^YHlkHrWzfrI$5T)!xL8wOcC@2Eh0;fWZc^(1XRoywQR4pH0ps6`+(M+t(d(+(Y9B z2QG_G&DJ#ODMEHPE%=Fb&fjjqq%jXb!z@q{L5S`KQU zSz2zl^A^?P@J(NwsCD$a6d#l3A=b0fv$sO1XvDPbvNfEq z#MikaS5@;a2KuTn&!HaL3mGjlXN{ZZIm^n0MurS}8>6exds}F<+cgk1E70VcdtZ2` z3Ubf-lrqh@oR<*>(93G6Akf)M>5~{3;p0}1eGVjeWo`4`hocwdCS>DO!hji%XhUZu3wQO*%~Bp_^u@nBbz*S+^M)y(CzKMHMcsOR~itLX_Cdzb z$rzo3p^tNU>_iQV%`AKeSl3#EfE@42l_(BI63&8&mE8VabO#dA*P||__e;cGGOOgi zyn>crvm|o$v0j|UDsgNDX52nq=(hOTjmmZg&(Jjz(7cc<`0gC_yY~zH$?{}DD-CU3+dG3vK;JO zHCNHN?-}#9)pEjTY@~DSJ1U`Zh5`uV;RE^m5E`U?WK=T!0;j9RRI}+`0Ba6R@4VWA zLy8U5*=MrBOJK`j(HAcOBMq$m+)f9}8rjrQIXVU_b}@BQ zM>E4z$R~W{TP;3LQsb%iuaGh3V zx>=^#y$ct2T5S78>zG|&`Fpi)#!bu22o!u-6nzAxdpOB9+NNl&dycj?yAC0B(N{=h zWvKIXb&N1YrQYpJX`^VgF6PgU3f-O>hLk>X+>7K?mq&H8Ds@~$NG}d;Ep}$y$$0TR z?*n(55`&(mF?hLl81UNc;Xar~NBph_;{dAgzqW@ZFKHzo<8}~V89N$$<;PW8vmARA zz-Rw)GCym?TJi{7R<*MjKD?@Hoz{6n*W*8!K&&0HOJy=0s^2fTn_Mg@9eQ%!9jW(b8Dx@kAmfmVd zzaYJ5GuR$`PGF{|a~mYnaJ(ZZNq>#pmae?kWXXIfP!#zQ`l93p;{X%2c2WtD7J1_f z?knIF{%kq?)D;2>H@afnY=dQ5=q6omyzOScAj3|cn!|Ox-cx;>OGc`kCTB%zQ;@W4 zFsh~QnVbj8a3ExL*tkOKd*B`OQg1vsQcLaya(FvEt|S&wYEz3ax;)ZMj$TWi#xW01 zb_AOMc=G{p3T_67BKv@Q`u-PBd@3D{=yZ_@HWD^v}!O>mb%d`hcS=N zf|AOS!ie@>OHscvKRr~xmzg$&wq~DpscfL9?OHjF9f=s^ivgr*a5|^Zn(%e?RbSLU z9fllhZgP^V&|}Q6bUxv-tZ=KCkO6OR8OWZm2mzyEkzQHt7$0}CHpQ@*Ool2TT2 z!S}WdkOcnx^-{G+tzNFVR%mjzDQ=$SLLb$5>LtDSsVU;ZwVKvA#8x!#$8XEE(dBv_ zIZw=0SQ9l{?>q8VnYmc>k|MKl>nZPc7xaC95&jfrPD9~3T|xZ$i0E7aWLP=RV&b%z zs@-SZo9Vd@>u&FIMNG46;<@&6$eyZBT~r|CDI@$8Yt()nD3Aw6XxWoljboSS#-TweD6_>^qh(KPDRxow7Z$CrEbj5+k^5?_w% zqkHz@L!9MwiqNWW_?U9-Nmn?Ez;$#p*K4~QwS7z(P=awtY+4t7*cmB8F`ka!ne_g4 znPb`uSWj3l+ZjI|A5AEdeUWzW$hY_0!M+`f@=LwaD&ZsEuC=)5=3+b14|+1{A$==V znWhxOb<2US^n1EDc}s>$7M5{b|l z7Q`cbw8(e$3o80GJv{@#Gb5#|9IRa`*_t;MIb5Lj%}ju^_(<0U^~<8;uPm_ z(eqGw)f_>|<$^m1^>^#L-MjtJD(OY)D09NgxPug+XM!!Ka?gm3Jr`SXw*)<`iN}a# zZ6ki#pT8tw*%Pazz{g=;ndCGl?rlCbcAp_^5+aDBk{e83eXfG^arPO9&^w&YlU-H6yJ>Anlr;O*cMg@K}Le6Qz)h$ZhsLeiz z$jHoJ|9OrLX-k1A>*D^cu0ALX8@YDM>^=xq)-LuIiREb9dHZseS#!y==4h8`3#q8t zhxn)IF`H@<^m!H&uZQLD-q*8;6>A>tr)TUv=Rw0o*w0mO+!|oZ0<#bC}Au6KGH)tT!`Gr=B(A5Ak?fcgBO+ z*(pK{X)`3g=8Xsnw`El|i7=Y&I&XlqE?O<9gyxtD*|!me;3$C_IlDEVpx(Tm$_Af7 zfBr)&HiTSIM<5Zm$Bs9f+HA4j*0cWyaNK-hU&!EjQXXuMHlz08RL>(HxYL3f_ts#x zAVjs6cH4Nb*b+bu^sv;W7oEfSEo&Cq3Qz6`%=~VLOvdSbOR-z3{eJlyyiPA&_u9+D zT2bRZq2N4e)<-XHdJe~X$jWiK<2#QMT!1dp5Pr#hJH-@d(PnAVN%v*Sa{hZljLFW59!0aZ{SLO|BB}IBVR1tRPfMwU742j@lm6CL z;V&60W|x%eEN7Y2*SQYpu!c$iDcsjTJ}QlY3`g7f?IA;&+@1Twq~TdAw;Wq84uTH) z6_=AO0Nad5%xrJM87K90VP9CqGgoq3 ztu#}Y?BuZ1N^T~7{DhPy*W=cfaDS1`XQ#l|NM*KTyWRCU$tx*!`1OlG@5%ktXWJzI zujA9WN75GliygceHU=%F)fjyC*`m6|++_fP zU&pQd*Xkp_Xt6m@*B1Q(ah#~Q8-Z3p3Z1&wO?NZLdj8U|Gq<1J*AR_PozLqxYfG-u zNJi@4?$X|mtNj*RTRZr9jO$nQ$}-Ml*(A|hKE2#0UQ)#6jqZ)AV~f8vzv}@FNjImS z%Zo6lv#wg^rwxjAPL&fqE5<&UxCx3Erh}1P>*l@GwvUhEB+`F8+MMrrcs;%aHwhzV zv6ek|N3Ez)-oG(uV|lh-;l1e)2)A?S9FaSqwR5(%wi&Y*Lbwx>sPxWg$Hw+NBD*38 zXtf4l81aW0X_adh9-o+Z6MGNbk$4XQdD$-MSW&-9$RGbb^+~olQov+`%TV@16zu{8 zFSfJ7gLtgux`n^xR>gCE&?3JhkJrf zDVW5h?VEGmBM*Ycv(A`jV#mX^^vEZo2$p>z4A!$-HUyuJKR*nB`kab|Eu^{o z^&&5?HQkc7GD^u(ZS(dwX7YzwX>G5*&d3O)DW^9h<)m2^Y?hwQVi)s9sn4zp=F}1m zlb+3pieIF)52s+Y`>vfIWu@kR5BHI1t7NP(l9??>-T%Pq2?tNhhuKz!*2~R&_?#>y zTroa#hv|0{H3&puPj8vr?w1-X&sdG_`y7W04f`lEydNyq*nkUt)wPAf7(KaD znyR|?O$vwTztmSQYr*Liq*ag9Ov-My+H5Bpy_RXVlsxyzz*Z~Hv0a!P#4cg`spbHe zb{v3?Oyj=>Gi@^4kJsr~lw1Psfq#s1C%Ma2?ZpBqZ2W32Mb4L^de=)BQ^~!W)aZU0 z=^e#IGtCOJ)TJ|Hx;Z}^EzaO3S>%arGu>L$aUQv;ql)P+^G8}{;%SSCajI#qLn*-` zbYwX@d%W-(=cB3%CP? zf9`dvV18Wq`o_P2!ajhtovO0@KDk-LQd?)m5xX(SoE(hScm{qEY44!9C%#&TuzXnhFCU5+{XS)8% zSdWH2uc~rZ;}mv%PfYcUF2Z8YGD7kk0~%LcJsLGBUZj2QT7A_JI2R*T&3btfep;m@ zYi>H{a@@KZS5S@rV$f9~S+eWg<*hvIu}WPlN{%nscam9pS+NHJWC1qspM8HM7MUsg zUGEXcb*^bQ2R`&{tYI@5KQ+%w7ZgHQKUrnZ0M6D^P(f@hv_1r~Hy6z_EwcqSzPqm& z7ZyD@Y&CfoEKi?-Fr$EZXr-yG8tkrLjG@EV*>w%AO~c_Rx2_AKDt_WNyqi|L!RJM8 zw`@roCI47GJQhZmCM=tsVWSz1F-ogg8q|6jZ;JYyd$~5RflCa4ns*)gsJlxSdnrRU zDb2_BKjXA%)cB|`i)UDze|y0HsUr||lHCn@WxjFy!#hZFT~;i)8o{?K|CBHEhdcft z<1w9alu51+!Bbqz_d)Xek-LjDh5ez2Wt7`4Y2D`U$r`u}0K!xywN2L+<~{M2Eyt+q z`olwY5!}CQjP6$g$74bmX%OvWrrzY{ z6elkZM^92&46Ae_EgEw=TUF)Z}y7){5*AJCQH(|4!fBh_Xfw;D! zzlX~p__VFR9H~nGPD^BW>~)O`aB(se-ty@A2D{A|R^ucH+c?>i5gJ++S`vze{G{;` zgj}N6YW`Kosyvm2v#};o1x~@ zE989hCtqHluPYI7r1g7k>)y_7jC0#w^)cDr%*Gk;Ik}NCdq#;#*XHGAZUv|;SD2i_ z5k~L4gT>yuxDKvvLHbggb$Z14z@_PK8FIUK0KUwyMgx7K!qmHtlj*Xkadf|Kf?4n_ ze@5A-b)-}ol}}kr{U%&<6^wSLdE4av&M9-0{kC|S3LD(L&U<2A+J8x_H3R%*LsPHu zYThZmzp81wxIA5($;2zUsd^B#xH4IU==uIS5t1!S!mx!0m=c)&IJjSTh-KAo&tWYx z6~|%t<;V2b$J|pG@s6x&7N^_cvCJAikh>*rvAUs*90`3FUP?g6Hp@Vgpgb zoQL@1ApEz@s0-}(XGwx(ed?!lmW!F^HX1u;tJ94wt`_H&b+xZxV1z`CN3jnENTyi^ zHuMbF4Jt%yiyn`)_#S|4ACk+aTAK(ho!OU07ULu3Uu~R@vfE7!sT86C=2PYLTyWPg z))}o08sqwikNw9e3_5Jap--hX*u~|%PA%mwy|qRQICCA%%0U*K1&qGk)r-gQ zILR0MQfx*VJN+L{YGc2>29Kb`bu@!^Jt=g&wWK`0J#{(?F&ptK3f&aiu=0gvem7{Q z@AH_;HZj4FBvUx5g1$ z5Bt&WCevY%sKW`sSDKK@SucP2yC2C#;!q`pbX&WWb7~`eP-nINV9BJ@GXtAV++&v6 zLLqkIuJ+gte;IW*T0_a3M}huL#akxtxx0>~t=!WJvWv9U!`JpmOY2H8v!`6|@j5#> zW5cBuR9lfyWxIN^?nU{-S-d*=eah^$t87Nk`LJGmyZD@xy8AY;O!bfpV6Iucp+X4mp@!no@F^{CvtSw`Ega)w25-D$q4 zEflxI?BKY2K$7(Fr0%tz;qLmn9(rWu7n|d#FJOaK2B|P?(fgA>Pp^wM3cBFi^|PnW zpGXlq@7w)TKH!}}S<{mrF<(%{G0@Nwf|fcrd{ij*WU^QfPs{%fpZRF>%&v53X5=<9 zGHQF~V|i3hhF;f6mU8Rhm#1FX1Z_6rQG2mzTr?X{yW_ike0+6slOo(_16J*DhLqxAlxIHc!%(FfHp zI6^v}g`|bi_b|gEK?wm@d*wFUUrFCLvPD^uw)(tP$@boz>dM)K_yxzfjhUs5gx}GvIXu%`SAU$zyu8C_||= zR>9Fv)4F+oJzI%aPCL+z*3XT}XcqYjNX@Y@!B(v!QiY~yRt&CIO|SNu^&Ud@WM*015}$ZKbZDf)w| z*GF>dR(k2jf&6jJpX)Y{8RM3t(Xe1SD6SL7=@2Ca*HabT%5MjWZU3l~`Pv~!_Wc8L zsxzYyz;kTm#{*bTg+^*D<)1FP1i*1|U&WYtD6$o?IZ1j-pM$S>S)6sdQB&IY86F52jO5H?wy8R;t49m#NHoJ;+vzy^m&Q^osr`)Z#qKE(y5h8xqGnd(&^Rm&;Dvv0f;*L`36=FoQ?8G)FO>gFol z$vQ~Vj4o~G?2`dITgCEFhn}5cD?^7e-_o|Q#i>gi4u&Gxc4`dtYADW(OJU?o*uW`F ztlAZX+cc+zJLWZSEZ;5fkF~hkD-GOi%4zML7IyIW?bg?iW6_2r&K4rhkA7O|wtA}V zh|41tla7uLS@KE>GIXnMQBflSa|%^20tJr$_@@uV`4_{N=h#5wy=!O_ozrtRn_S)e z46kxLmCKz2Gb47#8Lt;{6kQjaRci6UkkKxv6qQzw6KKtQp1e;p-V=z%+ zSv^fkPGtwm(3&In_|M%%C4US~lj_ynkAvH}`R;q~md@U1|2k3cjm$Mrt}NK?e<-M; zFS7&?pUY~_%167btG^_)=snk?ZPXO&>Q*foPhvCQ_t!tJWfl*Ob*#;!SUT2nq#2d* zd|sUR%B|#LT2GaC<$UE+9_t7oTYs@Cm-3SQ&egU!Cu;c=EL+$}Ya9NfO`= zJ2=#J*s?f#>KT+;j;4THOjT1((hvId?<3tAPW!UXB|0%k=U75%0q5ClBwRA}MeqKT zQc*r8@66VTC+}4bow{~>ya3+1j!wx}?|sgXOV=vf>#1C=xAXbP{KqKXI`YFO=gWcF zx=FqouD9SliPv06R<^X;9;+u6*P2Kpp1vG6q0~I?i1hUKT!x!Q8jDz2-kW@`RD#Jxjwyo zt&cMwq|dr|%m*c-;lMhHmXtrgDFHMUTQbTwuV$WDcm!h4iF;n0;2y!A9QT3UUGDI~ zc*|0c1YYAM-_~?&lKkJ}>b8h)7#F_pz92I|X*iH_gj3Hf8*zTzY&}+rIQ>$xzm0{{ zUYbbp4mprtz_e)nr_2p5!0oyHV!QJB{40H2q=TxT<;|m#+~{locxOkNgQUr0rp()r z7A-Xzx4IU9gKb1_(ypUAQ>&w-qz-xSXI4Kfc!zR%ZqM zmIorVln#{2mlOm$)3cgiw4Fs?7oJ^KYM$p?eLTksY=(A#Zu*ViZr8CEY*blfCUSFj z5d@9Nj2v3}|Y1jhSi`(jD-2D>+oLWma8vKqeCNwy{GVs1ng_UZxtZ zGu2IJ$YX>@L>#!0DO8r~bG@!D`%!rD?d6(3_`UA0pvW22-D(IqneFfXSPj5Oz zorlwIK_GFPYCO4llQC^(Je+u*M>d*#I&3)8dOs341(bKx5dEtjC}&Yp%)%#JdXs%K1am(t~riuG!N3h#PByv zk=3{d8G}2eAx{6kUtyj$8&0Q}{)t+Aq6N>i^Q>hv`dFO@@tZW7Z*raB-CFMe6v5fu z2V{Y#b>abZd5zSM1$QjIT4L)`hx9yJIVbxOf1C}ohh}?k)^V~bnBZJl^nA`b9A27w zR_V-LGLKbHko>-CYZu4WZZUP=!p`m5q&=@)=ghxbi$qPG5|geH37(_d*BGa)woFJ) ze^oGAPpawc>(&|Hh7=7R_72#uOk^7HMa&9=+#R zti6vI-fj>7KU{+C)$fWM8VD#}`hS8;{5KG)_O{a|E3)6M^bcfo?nZ?qmrRx}XDe6j z?77E{p&50H$C)!JVtblGvw-4HcFxO{(ZDJ|HB&Kd@1HVHhLY<}w<@c+E<>y$8@oy8=+ zL1Qo&W3i1rN0o$Cx_vwlh0}4N<)+rrK4e#|&y%DJLQk_tT?@t22Tc_Q@$ePh?*&uk zrag?v@a7bKW2*lXG_l1TU)o6-j{mCVYTf|=loK0H8yk(^yx#5(y_C#N(8|keyUNu*+#2kJvZ|lc;+QeAd591M2WLV9aruS!thH~hXp?rMa zYd=+5ymv{-SoZsT3)&R?>1~Vw)SN3!NNKY|j-DZGvCHBg>vk|mtL1p3L#5l$7lXO= zOvDirie_ViMXJsF5b85B+_lmcwWOByFs@~+Vv>LNr!o+xInt*&!roINS{{p24q9Io zQ-G3V+5M7%Epi=LC>^`z{s^Of)`_EakvzM^?!*D76|5x(4(-@m#X4LsoUg(2KmDrg z5z9m{U<5fVdPs+x$I+gPZZ~k3QVUF!QDQP(bdZcL*3+U0QM!rQf+^5XE-a$J0E20V z8NpL>&Il%_BW>D9*G!I zm-zE*x-?Qwo^?7@vEl5qd3GmXTEC=CaPi&QKM(S^w9v~L^87%o2M|YRxF-YyaUST< zRG(e%hn(3!*JtU=ALg|Pl!9JS0O*h;OiO=spkH{#h$cC0G9llpDo`k^DR(=ezDq81 z0%uDrsh(tx%4EAqdgMT@t88W;J?d|6LjtaUOuB0Qz#FMQX5*_HV|fkm-eQtyu+m@G>~zLNa{8x5lxHlqe*5M&=$3JBG&7y*_c zJt#y)v{*Ja_7Wo=$le?=%*N1AMGA3;!F^{g#0Y7})OBPCq_hwYSP@b0p%)bY8@PEt z0>sx@UQYyO)4`JE2&)pbNS6Mx9&B~k2r6oO>aUvN`~TE~HlU>4`!=;>bwEv7*it?1yQ}sbg2vQ&pse0wZaY ztX@CZEx&WR@Dw>NOnI@l_T*O%)t+*D5__VI|`-HhjBr9*7@) z6C;x|Sge&9+6-$_KX)L9DP<=&BGq!w_h_>))m1Py_2x!I#d2D4tq=v8ai$3%VcDz# zG-%#un_sJSxdl?Ty^y_+8)OG9ZJs>!AI}>-8tqw^-5>K|zaW6g`#X)P z&=AXZ=YZAPp$PSGESvuNrrhxNRc3YsnB2mRf~6@N#RHEp58n3 z+_v*cfK2E4?LzW7*E#V+gytAQmd{!D%)OwLVa&Ehz;f080gXqrTt zZ8O`LidWwInbqHTrckK?rwv-+u-gF7a!c+9R_!Yi@UqKyABM_;0(<2)$X7DwY62L zu5_xalXOzmIi2^s4;;PN-`bg0m+Y(uE2n7={W;r;ok0J9A1(9~5}Cln--pn2BH7{9 zNqa-hm5j70+MM})gGsDkmglS#(~nO1NPEP+0$1vOXazpe>C#1B43kas?@oQNcDtHb zC>8%!q)qcf;2qU_bgmV{uHB~8Aq-wN$y(fE+W*1)9S)qb*A@7t zizwJLX^KIyBk6vZqtH<;=*SPmR`XnrP-fqsa;<0>~W({?Q&NeBn2A-aGFkr;B_gJ-elxkD!oi<8qKKRx7RVCFM|o zH$vxdsH-3rRHt@GvQ_Idv6>g?C%s=PyClde?Qv$$HhLIq=eK^RK~aEGZi&rgX}n*8 zmt(*v)ycTl@Lh-htkGy{@8gwvGr_QTb1&hk>#}5Ag#bufz#463@KlFuZu8eEb0hBe z(7^NFpPR!Q!=4`>_j>F9#x9gj)YMse5nNeqpSBU` z60ZE*&Yfx(aI#p;3#_}`>2ktCb^F%+yr{NEXJgLTWTc)|>tgbtX6yA6&+Bfk+%G0v zGkgLncfdjN-GNzWL%-+5`FcJO9}HZ#&@Xt8F>_P-7mKEbiQn~=Cj1#go~7^nXUn|7 zd^l|FKbblo&@X@I%YXmd1dKDjR?$!g3{0d042=K(ZvrM^;cDmR1pL3uz%F}WwNqrD zX@$-O6X$(Uze@y##v?33m%_tgV~WE?LJUw=XoF8}f}Ro54Geq?d^`<&ZtQM)>J4tD zyPXCRLqDFn{_T18{rb$Ga#T8f;IOisofe2nTz6nM1_R5yeLR8%(*wW5K>mDG=JSm* zXpI@5-i2TL;`w0Io%bNRHKNy28&xwVSEi1P;P)^}GcBcKPa#BGEKJxmk}KA2>QNqc zrEsg6g2@!HiEObX*}!zQf$eCBV1TJWpfQX7$%6|5^j3YT3b)+I9l>n(3faqqujN8M zesdv275%f@i*tJU<%uA33H9 zbn5XgAntv~N%^2BJFK%R%4pLp*8ped#-%VG%4n_A=l#2@y}sHH|+A<>+hLc2WJQ^#< z&vWC9zeXHg9Ljw;=N8W|dQubp%EepWk*zcN-Lf90$LpS5PW6-b@xO_#`+KX}_v(0m zN&ZV&^wD$3K+0jgP%AY*ZojBypG(l?_W3@1?dZl$vr6bJvpJg-?}G$w?VL_WyYx~eZD`&B)>%_pa205xYmSt+qfSt$)Lk)t0h71Ep`t~rdb z39qwE#h#XZq?Irl!dU#ntz-|t#tJ<)PCaNB|IHX8B#vVKM}dMacQr*A|J_a=rge~y z#8AvP1Z_(Qd0w^VP5nE9i8L@epX83iVyHV{pL0q~Cey`9bky5g+$Bl=cpBIRFj5~r zQr}(r!%p&;ekzkeDp$WDv6i`ni8zUYB^4bxiGew*x=v<~;D1j1XQ1N{twYQfzk^H* zvohVh4iq?OUN;EnXna5|Hs>nl7*9_cq6A{ta7uglO>q7!+>UaV1FDB+`bXM~lMy@$ zWM8)7C5gM%kW#u>D;dj)NyCSZ5_K>LiGn_TK{E zv8$%gJIk2t;dqG)D+srMZYH<6WYEM{sE%X(?KDF$YJ+HD;%aC1DDtWHsr4!I*!t<{ zyu}nM=UCR+MMcC>(flFG-p1BNiM^2L6T!0sA>sOx6cD)w6RX3d?(&Cz+KiLtKGSAC zzxORCaZGTJ@7(9JkYDC5DLc2#RK=`xbCEI$attuq$|P=G{(i?KC@>Ez za6rsY{&*ef9U`<2?w-Lny#e&6l@hfq`~yjD!v7(lXLiYt=((evGF)*JX1G9Gijh#Yan`C;dg*Fi-*)2iRoWE{($OdHSC!-OtF_{?7=#c5(Zd&C3MDXMD5 zbW$z)VmgBbatEqcYLeGw#Dgmuq&hIvo}8C!wz#^GnM_hKk1Pq34=YP1V^e1t#H{K{ zS3Of&OHS{)yU>Y#kcd3>@g>Ql)Ep=sFNTbth{!Qd z;ZKxeZqQRXa1|df=8jvavuAuH`GcDpBg7{vLao96YRn?bkWpP)OO%h+cVf@D4#=3w zA_fNCp8r6*bsv$?3)!Tq=-0Ddr}ZsPO(!p{X5m^9R|d+Vl?yKr2X3-*_{uBdMVnNO zkp{D6l5;|}M3@$u$XGKU)Sr9K0*f&vCXtAlxUgjG8&qr1ou!s>%vhPY2r)P2qy|(Y zc{&S8r__cdlUwq}R0I=he|Z(E+7lke*0aE<4_06NfH2kIN)(TOm1$f(lo-yDAWxyg zhIT(GBVGNDo+Xupp~iooD@f#QiF%c_JRSKvaz?CXgL-(_efX4gRUgCDau|>)4LVha z@dUSJ8Sc=Nm=3fJRuxCnjop+7&8v|QOu>!LMcyGU7{+fh0BksDASg~W$#<(@T+;F3 z(K%{9J01p@ZYLjyK~&+jtPg{Ta!ujdwAert(F}5I>mFqCH9N#^!w7G5Dlobx9q}Y? zy=lVe2WM9MZ*3dxR`!?i=t-rPOl$*dNsw)M{4?C7<`mdl5||7LGZo=bstkBF#=F+C zPT(($a}cbk#!-iaVxv*(Kl+Vn#gW1yO|I?;e3$G?@sUNt=YB5Ss(UaXL*~ZndE>iu z#<7cRT|D+17b^N8Vy_P(i`mhP3^Fh8#xY$M>cZ7J4WR3-%UfR+Yp*A4!h*s=h86fF zSpCc4h@`HBLGx(jD<$))!@Qcxa5Jb3MZ-y^G^iKmer)n_T<*lGqk|}MBQ_$J)Vzfhb}&4=U9t=b2d3BV>53JnWU&^%`yj9+^VClaJ>NUY=B{?$PJB~((@0XJ?C zP9DY|;ep2pgkR2k?}U^`Y8cCu(Pd5URiI{qv!F+%0po#0{S$3MgwEF_`avl9#1T2J z!>V~l*F`F+Q|uIgxczr4hiU;fV&AbRaA=O}6zk{=~cJK``i{XOBgp4Zlh3 zwCO?Y2c&H!3O5nBJg6h{z$F5TJkcaRiNn8}41-#SkXex~#CbI0I^oBV$ysBE9k0O; zFQs0bCH$$A{RiQN(L(cOF2R>T;Ad9JHo`+^A;q8wYk(PR?8xpl!5TM)FoOVDK#FXD zYG|MJpb?e!Y3yh-qYBmNdo`QY@EU(qFVdXh zS)~^+s||LC;S_DPOlf6z-p`V#{jI83joWEef$vT|`5i{5?36TR4vk`{VvHKXAG{J2 zhsnu;1RXsXAcjrLc#D9WZ^aSFy9VSLmawAO55IQJWMor+#*e-`w@(=MmMkN<_VWA& zbc(gZSi$vNZi6=8>qI+RC4vn?tATuPKz%%7l2cS0(hJF3_eR0|B_OhmZw~Hjmxwg3 z7lMCO3;s28IPaJ2;^W@$V2(6L##YiG7t(`1*iEB()e&^R$slC5J-AuV;aAaS zaHLinPR0`z>1fgF7RfXh$^?E!{Jga!8zOR>vlP5TM}&vx=X9UW}2{ZVy zVWd29>Y-N0{%z3MxPbXtl=DzapwzZxF;}Fp9+eQ! zamqr|fG7xY&3aYC31N5h8Sn zZ0|EqG8BgEXa?IjvJXcv;)^x}i@V4RC&ycX(@SXH!4y7$+9>LY{QKQnDFB&7VE{;B zMLXROvujU0P3FXAFWi3%8y@cqMZtC%Ux+;zV%A_};Fdw-D8$n(I-lPvdX+n#Wlp zf<#v(aNmr1$6*$%j-G4*4i0E;K`IDu8;{K)ehuR6h^&OxeTb0*%1_pqn*s%@2faN|1hq)2*#_4xj1BuNwgG}|khcJFG~75ArPD;gA)J-$?2FqInJh)#ZRtbsOo7Zn1C!%j?ycaCt*`9M>XD4N?ef!Swr94}cw>sbqYW6x?h$+L z!&xheYt?B%aTh8P3$N_2bZjO|7l7`$COYzByI}e%f zL=WPDvm*g*0C?L_yCU?sSR(2xQbgjw1=xYqy8>C`yg_8UJga9~lHMtZ!1Y=DZ2TyO z^!R5Kz(I?+QMvT}E|G;kL#}YL`Cx~WPPUXMHQ_id3V)5f9fU)kTB;#6!KJh%QGwG% zb~#}dvti7sOv)WQXxmVqSs>pp`fKa5iT%5*Ww6ta1p7nVeo7ECWui9x4E%LzHY@k0 z2j>h5aKNU92RbsWDNCQ!jS3_=xJTNWvYai87@T~r2+*c{xQiS{o=-N0rt{=5-Z3U> zcB26yCR!nH$7%Cu3-rWk3)RrT#$^((2Qn+dU!v8b3$<0nu1madYT6H<4*Y_0yqcm#c`DKeeOw@q2>FEj5@bbL zR?r6>w4aSuydVa)wiKAPv>9wmaVmxgJHQ0b7=A4t19K-;!&ECM!(&QhP1Mgpu?l@^ zW6l7fC&yA)8f+wMPcytYV1xc1V<TdEABA!SeEhi`o$Z|t;Tb;cnQMH1BE;<#iLWE=ny zv)^4d2fh@CYdj5k6PuaY0A>!2%W5UX#p^iSjVmwmqX67)>;?Lg)08eYjr7}iU?tu~ zpc!iegbSZV?2NG$D2OMn0n3-uGzPb;KNL0OxIR{}K*KJ$EwCx3futmPop_cc7Sgx? zO<;}}4%-y4l9(MUzK>g4LVC5EqcGK$#scHnm9aJi>kbnOs}J8Ogh=g^$UWw=$1K1ExEj* z&cp~Jjgos7|L*Ngg~}ZY#&P5Nmp+8hz3wg+s)RA=0FViW}1n46f8YW}+u#PU)>X*Z=}DX!i6lf|Ru+{Tc3StY}?($NixO z$K^OzUishQBT2m&azFYp0`n4Qfwl(*$ensW#zlD`Z{|I3`;7?yUI{ZF%5_9uya=yb zf;|U_*u0|9%EY`ToZbJc<%RqNKMCNT4Y^~$xfE=*NNMt)ExfjiLj7y z^GM72A`!NU-TmeuZCDFf@Tirx>Mzgf-0n=(#iRB`XQ$H1Ff_`8&d^RR{ z#85|IEybP6FnL8l@Z>C2T%md&uXRu!W>8my4UP5X@;DZwB5@Qlp+{sw-z2eL>h+Zbk1GEEgo=IXhL)HT;X9y}w z+~!=rhKi=lCnIFOGhUgul54-L1AFXY(56RgKx+;H#tet_Ib-}ng%qoT=ctQqUhRpsnIDaF z3+pom*-CE`u^XI*cgo^?}AL(P-Uo{LHue>xt-#0Sz)_xBf;9?bC#29J&RE>a(H6XYPr&S&5>F><^WGITZZ7GPSyr?EdGW{+n1&eKDvJSD|VP2%Q$HU zYZhud5Bbo3*ZI^ei_RD$H48#%lNXp_dQCr_3rQ^UMhIpf;ga|v!dz4We38PelmvJ|k~^qQr0??-&*MSMps z>odl>k{@9d0}cqml@cx#O5h9xIOdrr$ zldmZ00nK3$4?i4naz@M@wI+`O$G^yU5m|%(Ilxfx*F)2*1LP2Kz8gL)_<-kTP$GbdxiKR7Uzf-7U2NKRix8 zxIO&fB$>`*`2N~0HBOU~XV9WzJs&hA>^8m90 zKDJG87KjyUvmczrbA~7Zx&rGQ^pKt=0{?7i@_FD-YBaS>+02-NU@mnjn%mb-C?S5cwP6tm0+c1FTbd$5u z{#9TXPB^^+-PjdcyFuKRJkW>5k);1huiX!)4IE=^V%Yiczq`S7d>(Yba?CjL;0l*# zwfLV_NZPzgfFZWaFcZG;72NBQTkP<_xDz(O7zii)1Xt6n9cM@n7XmqbjFoW65I5aS zJMO>`;A8^Vu1!1y1o)U}$D444`>=I~k?os!eRae*2ErfenO4z6S+!qPTfM1qt$AjI z>4Mjr+8q@d{v7Z)8Rx6aQJD4d7ZB|L7Ty*nQr%;PMe|3pOV}nUaT+#@xQRbVK@Haq zn;aTU7f*9cODhO#Qrbb-f!lHU@VryKV{~P5Bsb-`=D246i8Y&WKk|0<0cJSw0c*Vq zyA^i9cI|hScD;5Db`f`tzG3g>I88mDj@_xh{&~%Rg$Rlxl}%(iW5A`vWyz$fz^=i$ zMAt|4#j*}74%HZB7_=Jn94sqZD)J%Ma&B(VXjjpvCuXQatHXI4?kuSImd%av*>rCgh7FLK}KR z4mWbU0}yk4VGd%U3&pfN5lpbk|$@ZtEY2;sKcHb~O#(l7IuIk+8_(6mt$E(WP=V2zrapxbH>x|;XfrgaE#%B3`5q4Clyd+8EWGI z=}RY)QHEr`H5nteUreSX%77Q70|r+|Y1nVpMD2n_TeqLzdOW?IYIU>pRB~=|>y{r^ zyv6{_)iLhSKTUHzn|0T;>gn!gnHZrWv&vSVSX3(ANoy6#wQyFnpwT)TO*P~Szpxt% z*ejdh3nQJGK`^D1EyM`FmnHeaETU|C*tIIPq|P2UgLBk+Hc3;fW*NR$Kd2C3o`1)8 zFcC$bfSBO(BZXbABHcqGhftj~P3uG*g>Wdbd#j2Oti!trO>_i8n9ZW}yj&XM1yg3|?^iD&e5wX<>OD0pa_zC@8sOq!ylaO6+C7S4`^ z{8BnC!LHK$q>-{PQvcZ~K@qm;ZQeMg31!&;$ zTXl;CX;Hg2OiKIB&T1wDcUq>^fm0JGl3;)x}*YiEcBaC~KGrEj|`8O!7Vv`rO7OL9%8I({C>>V*_U+N!q3c5MS(9hF!dsjnZ8!^^sZI^sK+iY7r-fMs;_ z<&PC4Gnt@23K}X9#X}5Cy%iF*D>l(-m`Da>8*AR@H7O)G!Ef?}ZNB@R}upqk`Ka&aiNAto+4Zm6T$}P+11ik5F|urf*^y%ik}4zldMNY(6Pn zXvu^}=}Mp{Iy5iKDoU`>2R}k16A;4o@XM-iS7I`k@TYfSVnMu!K|@kUrE;RjmL)EA zvb#g!GdnIJ8rG`YAj$zt!cTHw#wO-xs10q=;K<7Fy>5y z?1!Rj)FI7~$dD*3G3g^WA*iHm?Vy(zFrTytG-S7F6%Shw=ztR?Rq_Z^Kt$!V&S~>) zBO;x<1%FYjs731wg*yog@M(jjT~ zOBe4nWNQ-*`uQr1G;a;30+?4@!H$tMY`c|L>j~?qTv*c z{_8%(6&Cn?&MPfqAvesEo_IY@K9%prX|@$Ar$W;hN_3 z6HU@puY%<(_3~mh!gpzxHxZE-bRYd)SWUF{?Z;}MV2C7IA%6h_l@b%*&u#Wh6Vv|p zswt5G3lp2G%JOF1jz6=3QGtdkBImr&4Im!d@A0}D5b|BQdk=#*C^r4 z!sgwPZ?VOIl{dw{*k9GHTBApd3x(2lkvjl!szfoXoZ<|5se)-~HuINr3L9mKUy+N3 zgoM$j)qQFgi3Xmp;?K=OfqQak7*r5O>UHY6mXH&F^AlAPCEGS37!JLNz6&*&`t*!{ zEO7Y1aMo7xXeE>=?Px|l zoTCFKaMW__q9T35HJKl$U)_a{AC@}fcgi0%)vSmULq&UhYRLPMQ~sgH^fKuSq26|3 zea}ppXtC<^P4@OB)OLJ_D3}x(MycwsUk+j=>Eiq5CiVnnle6LPGO~r}*f6C^zt$2l zRc;ClpC6oPE9fCtL|z1_{*KSLCjAk%;0$hRLgb>iD4hN0REiZa^*Bpo2RX3&aDU>XZI(xOZ;Xbo;>-&XvUw?GvT?UCh;5p8&Y9B%!<6O5{1h^ z+`Krz#%3Rnri5%oge-Z!pco+x{-@EEYxemy&tTn^=Z=*SW_zdM7*=nb>?zl%%6MgN z{l(t;ySF(-Wy2?Ib^+bRx00VqqDSZw*a||YhlWtga}wiwvap{-9OH?oDGU2KnWrk1 zEmIU~mFfifW~?Z~7s+ynh$$^>l2o?`sH;>j?Gf}uzS=i%b1JvfNkmKa-=nx8%w8q% z-K+JxnaN>^4NX2IQC=g1NnpWDR=%hd#PRTLNu|(X75KQGm_rz`vjVkHdHMx?q9B|z z&eR}ex>RYxV&_IkxCC0p%L?Wtw88=({PxNrSNurYpr#O3@$K#9P0>oy-@Lw{wc=}h zQ@ORoboWumeMK;jngNCTwCsY{)s7QZ!7lua3cd7;ZU23`Bt0jOSNcyS-4D;{?l-D- zB~Et)paF8)=6L5HBzAX2i!*<{6ds`;#kcmfA3P@ zJXYseFh2Xhd}KesnQyOgI%4eW%(CWXQCP6Ek)TeT(5C9Nq(X=&Budyg-iXj9m>e7= zEUjXR3`H3oalavsn$iz&dsWE?pQ{Wl@3b9WF(-mfmWZmz2%fL%Nv9-yCF^;U*wfv3 zd;VIWgK;CL#_){hWmR{(q!0Xo$XTkakHNi6bFLlIT`ndTPHht9!WF@!;v6k;)snAT zksf+7zk*+(xRme&57TlrK|s>j?R(H&!Si$waMKkNmnbYp^%c-doD#3 z)hQQEsxp7Z2DfllnM1Nw0Z#Jbr&G`z60rj?qzwXi8|Y4;l>&T4t%{nLJF16dYXgcN zpSh^gtb)&+zKyTmh0DtrAPnNu6?{@F)qRfYiK!b@1O!EjR|eoeqS#2Vg3vne0J?h| z*GiD&veq@~9mD*U7lWb3f!nFZdGMmb7{TDZ)KHL$@GzOE05&RXQ%;EQWl*jPaHm=5 zoDGeTeu{7~KQq^YM5(RGUewkfdN&irr?X&qM%Rl2dSo$hw=>N}%wk3ERY?qtQZQ&s z2ZrPgW(pv53^ z8M?|T>AfW0nw!_Leb5UM%9|CG?<@oO_8yFd#ro?W{uB&nr3^V*=90Ch8pBVHM46gt z8^*|W(NJdh#^lby@Mb!37;9en)R$NSI~n9Wx!8^mgnN zZ?aSybFn%dCIqfrZLw(P6;y8d1TKvmVBWdYci64|eHe*%Py2S4cBvec!Qv=``T6du5d-|x*W`tS= zGHD1dD)iz_KxFj9L=YN+6LK0)IkQtxbGMY35>c#759P_!G+;4Pt#>f8K0UoYBi)Jn zaErBf%Gxi#`EO!#eq?m?4B!-=T1#PML?1qhief9uLa8*8Y#@0YOHxADe>hkU6N6Kr z%0`;O<`uqsk(3#XF?Eu|8v8D)IWH;QDDjYuQCOYfLZ%EKnIVV9JiSil{VvXdO4o6$aF{i zTD|epsc0;r_tA^{yqqQWGmHZLRKb0B{`6p*0q1ku)9-pi1X1hFJgD`m{2p%zWtZ4k z=u1)(c#NIkJEEQs%G>cd?)2Q4lCF1cLJwVfs?9lCpeSFd|E;N%&l3LI$GZEvk9gI! zc4Hu`aE5S9ws^U-u7u!ov)mw)0s9O?)dMT&W@zdO9Ccf6*}@ zlTbS)(-&@C!p{_AL>>$pZ2%&jt>Su|dJke9pnJMp2=d_Sc-*k z)(U-pL|Y3N=%6P72;>IBkmZM6M&tR?&KAlN>4Z`r^EIlv8OH15iHK?!?3c6>+Ur({ zSc=JX70%ZI(8NptYS1RUP|sip_h^At*D#9fql;)I-hl7VBB8iq91yb2hvT^OUF&FM znFPwwG-A$t2ENJ486u*YOV%ZeN zI|9J3Hy!-F0hdMt-sdoMk@VCB3}eP1mBmI9g-wAdBaE;(R9q1mc2gWsF`TA}i3;!X zMQ@22PkbLp3_&X-VV@#DWFCYM4)%pIUUoqG2_jMe6jG?sTbMB@0nzyy8Mht7RvE!~z!ejghObP`0D2)|4H=Sq5?kb}Y#L9b&VEa<2ZcFV zS$r7oqF5}^WlBXIH(F`2%BVzg?r@|DjAVL)3{-OV_&H-uTkHuS#|Fv!3=k2f9C2@o zho~2nO^lu_l7?kZfuJ*U%z8zxAZ0u2hS8dH9#1F)X_sU+pT-VjAd8f`TxVG#+?;R9 ze?A{MBq~;hIy=@1Bpp`4GbPW(RLS|z1_!hq)`twhi?KEnBD$`Y`2FTgS9xKTDB^WK zhGl|AlWZSvkz*US?#n+IdB-4mq@`>1S8n2tfr>IZQ9_j{id?NIa{Vr<8&x`Zvs(rD zEu!$9K5qc(9+?TKH-N@I+Xz!^o@sZ?J8+!*3%MwSQ4aa*#sv2t*nZaVgjK*SPzLJ) z!~0h*hl`pzO!2Z=<;@9eXWfv!A`d2SRbk@u*$@+DN(y~3-@3@q+q3nLK3;zK+;?pN05ZBzRV2^VqKXhXOc z?`M7#Gy-~C@%*kRb}mC4U6Qi>)@Qh*v;9i49lmzVD|pT=2{LS9h~XOu%*+3xa;_&N z)b1DK?#{m#4(j@R6CVtF(GPo+yKUV{h(Qx1AU7=%M0LVHgNj@rv+k3$5|+juo}5bR zq7cK2vE-#he@KFmL06|U1AOd7czZ`)zM+)}gR92x_uf!EC5xN4Js&vU48c&ReC$SW zoBY@pZH6brMEX0h4sCu3fWT=t|3wtFtq(k2Bj#zibUXe7b#Mh$Hhr2Hq4JO_swu@R z0`=QXG7Mf>Yn_zl5er;X#AP&kV@|~pTxe=F>qZOk=L4at{38z>H~)0L%v;#9j#=m5 z$#f?X8I^RU>PdRq)i2%5Z~X_Z^O}GQBZdk$DqY2V`!F?P%;TGjYzvvyK8q5{wOawI zf65=ewN(xR1fPz1Q6xiq{?+d(NWV1POiYRz1OMV+*m8YZ5uE*!R=1woPF?-?{`zkS z1qr3jAw>95I#s*_p8qW>q@H;N>{#vd;5#$MM`I=+5vGwW_Dhz8g_10aK72$LJJN@Q z9%wL~u?MbWZ};zG&E>B^>;ekA&dnTour*^Ec&Z5E6=tAVK{$7eDDk{;ufVEYguWX? z)mMxt_qWE3SRwB{F;YAw`!E#OA0Do_`3aCKkZt7^gMDPUS>7A40>5?Ep zRfMN{8_eLDeiNZBALS!uB%?nlW;wRLCCP;X8TrZq@LsUBrSED3bzNT60!2_`w`d)q zm!rl!`(=7@-jqmMPa76RhtDOfVwa|>9oH$b-?}~#?HUzKf<@_N`HkMyw(E*62Gc@ zF9QKbnM$ztlO71%bFOaNXDHqy3u%UKG=ygpjW01PU>3r zNF_7Ph>5L92U<)Hz64RomFbZO7gEpCGd89bd0|OvhxV5S+8@t(q9lLi#NBA(wX}3K zCK<9|kJDn)Rsj5QN^K&2t+O}&e-`A2iM~xahx)rDv9aPKhO>f651&n&>&*+4(=i^S zhXR>ivg8b$eqgTIMPr@1u#vkk@>c%dCRcQ>8`Qaur1eEyQdU9G>Oef?V6?Y;J%^UG zt>^4%tdK}Y$0GA=MWg$B?B6Te>*58fH{ywWn}Uq1=r%nHpkz&v;VF`ir}mK$I-FpzQLMl# zYXB=wwuGU9ic_vHS?FINkiMGMx3v6jX%zn;ILEZvXngbeOFUT1<4$jb5mLF$b4y$zdxYiJM^7 z(l6yX_0t_{izjW=w+$)De?64;(kZ`o)&g#K{Ok8-8%anK1ZVBbN&fE7%#&pq_-f{2 zvGlQ@%C*a1P@{SNm^oV+yWtV!BMTUwSx+cNN70{g6{;avwNwwt&d<=$x)5OL+neGh zr+ESKdr&R$vm8y7=O;+!{Z7ieP`|tT&dSPh)u{=MY}NsEL(XQ7!Yjgxp9PW~E7{WqnhE(en+P6X&z zgke+pm1Zc6qb}9i!Fv_N92pHyS?zY`_TtRHqqOC9^v^%HEFXRL_8nhoeNr4={OCXv z>Pdmgqv|cKvDok0}e6?h3j#>OB5Unrq@liK@`_zKWjI+VauN`)8rQhSKYq@$K99 zmcohnO5%()MVaj7F2DDmQ_b%6X_~MOw%ymQ%nGYDNPf=6Bb{evuw|!CurxE&a)x<@ zTJ(qIbB6PDj{COdF$a3acs?*w>t1qrdNevyU#6lnMHeqgmIfc}nolHj*p4n*rVCr@ zuN}5Jx}rjFR)MKvWw(#dkB@);Ad(?u^`WI{#l8ruj>|YpQ5^njWEIrSZqcTGJ7Y7a zvAexpVaa3s>H z$-}B#{Sd>J&0PuO-d*2;Kg6|S#xLKJ%h*BC+WXaY_feXD*cykE9;V>UW> z!Wj;`E?39p$pggANqT~MIh#$vBb|OzHAaVRD>{x8y59tSD~3oCekOe5xqPM_0QBqT z*Iav!t7Li)#F}U6RsiH$esA9Va`cbVvT~gah;`fjSfZ(Q8Yb|f8BS+4>Cwh#NT?GQ z0)~^OS{$60!@rUZQ z_Hapk!Q4zCy6eBXx`lpvZ*Yt!0j`ifgszPwzkik)Pz^TN0kC4v8QySdU!&{xJwf1O z4%(rmVwFXXAuWXp|7b#Ak96p%^e%7zen~g;P~8sNe=g70%}-D|X7*k9W0`;5mzG;J zx3|&vJUGGi2O2hKcS|#GRN~Np{Hv8Q$}Aw^ZJw9 zc8n;3BHJ1$*E4@!B=R5C2G{fQJH7Xg;yUx^s+8Q?F+6S@7TZX; z+C1i&HXjmq&bA#Veoh=j@2e%`O=C4kqU@s3BkrBJ9I8%-ad~=&_OJ;4B~@OzcnRyE z2&i(&2>5XxpnK9R#NHRuew4R*n4xFc{7Lm)ihSl zCHcXg5mybH&(pH8ZsVkTvUpj8$9jh#;O1C@>NV=D`eQ;5-F={^mAS;06U4jh&tVYW z`>js2j~xPs;|JIu^_RD=3}Igrwm(#=MxmcP7ngli#stjJo&bJR>F>#2?{P<1<-2{?5}1Cbx9+AJ}W*NrejqW zU6cGz*=u>Ok9telh;m~&ZyGp)f7M1>+PZe3m<5xu{`}fpDQx@ZJ=gfpB1<#lZqxFu z#|eC?Wd-NmN&qDikBxr)t+`GBQ7Nm+f&js{ZWF#&d8Ms=X^-Zkv$XqStVx4!FP>;3 zUZcd`&e54g-(PNPaJzWoprB;lc5i-y#x{7PxG|ZXUhtbvZ=ZX2YK`}gRfb>g3THza z`nOv4GlLvEG@SB2oM&suPNvGxEl7s#HX^I+*gaEl^x-F3#nFYC5P|9KrH$4?+v_sjFYMK*ne*bkLQD<$ZNQ3 zjNI_g@X@)ubuKr{f8IX!X1{;KddFl*_;<_M_24B&P%p1q4ZW8j_@u_@EFeT_;n882 zpiw9UzlFmxml@DzKDMezGQ~Y+Cmbpmh3o&&I$yTG-uTL1KNp-Df=APR?ZMmCbbR2l zU^?0utEV^SKJCjv;qrOW#$vQhbalArVK=(1W#d@4NtBo-eqCfh3q9XAydDK{%e*Ny^*Z>UlrJM`_^;Yp-L+qw z^0@5TD2?U`Tm5OjBz0ZtV5xQNjMZz8{x?$O_43;%-?1K-xGQ9-x~Eg?$71KWmFyhP z6HC|h^DivEbO!zF$ff$d`d62}p4Z>o8^UTeJrS2C9mt&=6h&SGK{hFtgq5A&=G^0G z?LMnV?4+KF$u5stiUW-HIb9zKE(QX05`cT$r{D8WuCRn$|8;M%JfP#IFMUo=ut~RW z`eWNwKQX}@$fMl+DK_4n7C4=n;ejp%vJk_iX*KeJ{QEeUoi27?GP)qg{z-kL!%lph zfJ|XuCKgPVwSrV%Dv%cb?H+yhRqe*uBCPFoWAm)I${0CyZGAza1Ubu7^d^6&tU07? z&lu*so+u33_UKc4O?D&-4bl5|iXSg?H8ma2)CKn@z}$Fqr<*;APUn2sUOH!(`Ckh& z{rJPY*RZlSfHKA_==JrnYniXNxllF7R{o>hr%tekIl1FyX)bK(p2h1gUUsYF!}&XL z!|se$oYHj;efOC4W9i)S#QkCZu16Zn%eTw_BJCccJBgw^0LQkCj%_>X*tR;>Kep|p zW81cEqhs5)F`08_GqagFXKG!`s#ovby7%|(RYu3^n8ClhE$z`gw>0K2$TB5h4*4To z-jhygAJFAEU*mP;5A4a4_{KH19H`RcymsFAUN^SMQEe#p>JYqtwBQ2jcn~~_7_`oL z8HJg4UOF>u#AGTI=Qw!6mwZ1NZ9y-M6JkyU`0EfZQlQ}$J;^3V8GO~dWci_%%eIad z&fuv8^_Vg!yU`O4(N&8lY@;p9?gaSxXr?CAw3nSq^_sbbmJjhq`n5lOWf#B2W3L#O zj~a&YNB{hW)bs7M_(>O`nBXRxTk<@AcVuSS$&c1+GTOuPQAM9Fy+SKY``w@_P7P?zg^t}UMlzVk*b z?lF9i`oo*Oce+)0Frlx14WGGB_tx8{TtCll(Kp!bbs1H~MtpzYh2V@LFg9js#^>2t zxrrasbzQO_f$)i*N7ob}kewLxg*DXD+Llw3`EoX=mQfQs-^1cPoXDK#kF~EPm3x~^ z+ue|B4xUe@zDtR%YH&FLNypPXJ*y76HIJFcuOnx1)eMN@hG}uPlFIaMz-n(2ZiQL$ znts|_f~W;5;r8Li-q{su`c;_^*InuPP|5U|_)&LQ&!d0wQWQGeXTeS^>~?x(SpM!=VG4jl*4{Up6>u% znTlIjbO_2_)ZJOmz2^I2#Fg#ousOQw-oq2AAs(WdfUchMI-Nh(?A}95Z2QhiyZ{td z4xSD^d7i%FjvEkz)`Z3LtLHxK9$)Xi_|j_getI*Sc(M*TMF~H|*V{`~hA&v~-*m|>3*>gooZ_cbl9 z)$#{l@Yeh6?4!xe9Ayok_*!xtp9Wiq9$qK2^*kqLI57Ye&!^TDdse`r!(R$Sjr9O| zT)vivzii)b5biOrAD(@gNlbe8LcO~w5#`p+JS~?i1*bmb^FA4TeN>fKtqVKjuk?5d ztwqT;Vd6>MP~<;q@Nr~({e;r``3{;FuxU#_CxaofaJguMvF)iS5S4;n-rm8Ttr-1H zwjG}D`8}Us-K@?Q2H){N35Q#?muaretIheRo;_~eb!&pg_5}!EIE&UxBxza@u-fZ5 zTzk9Zh<&MsH$CDty|e^$e}0-CVqCVm9HpG!t8Mz)S!-XTs+z@QysyHkQR+$>p?>lK9*MwVEcW*c5J*Ygs$wxx;INP4C z91JW+M@$Z)HXJ__w7w!j3U5xe49!GK$0mZj=`0O~z^O5CJ_bHYpwt z*VhdAFRzQITMus64GjHabD|6#OyAroYPwYEF!FmxH>6*24vy9W2BAJA$5D@JyuKG@ z1=N1T@b9rQ07Q3|KMozNdU+<@4#5GP{2}v7$Okny>O1E~!8ORAJqK?uUr2-uyAfuA z$?w}z<{Z3wv}=Ew)~5Hw&RR_!E8nU{EvBKh*oF1dlqogtqUq}Ej0IYo-d>{8yfj;e zSZue)6I(9hSgsXf>-y)vIBImh@NSg$*nO@`O7ORWbskU6zEtY#RA=Mk#S3iu^*n~N zv)$aZ@k*gRykBBN&9dHIZoKY21C+<|i6K42<*eU3`}rRMsn-v)hRrp{o9C%yZLYVy zl*hs$IxY934r{aE6*Ha7U1tD+AG);j`YIZgqowU`cVzt{8bgG(*aT2@h0W;sJG$pP zLu68Py?bO0s$|2Tr?;;tD>q8B1^>y^tkEIM3o9y1~oxvKpwSSmi zyLQCRix7c@IkolNJmQMmvL-hAp4VTx0PlEHJA@#M*EdhRtof2^cX$@EVuPjq3s-&2 z|ErtMI}r4c3%J{oA*p9>WV3|g|NWt^Jx3LZCu|b zARyhEUdyL3k-y+}W=|{;Bebk>H*I zpS4vQa3YK-Paa}M){eKJz4;3{y(}loKo{5MK*XJG^Z#`s( z(W-OX%uwj_5%QE{yy?mq!sZ*l%PsP{*d=tnzn@$E!91?U|Nc4LhUs=x+QMy5d3)w} zT93EI`tnCez0kzcU*1=H{Skjk%V+ApGNZ=J>G_GoXI-W6)>CDO>97)w`>y*jHokBG z$Zb+fS4;XwXI-1I$qYT*w}&TyhUD%PCpga(I9SLgariMP|)aH>n}k3fHMm6U2< zEVj~#mMa0iiFJ;5tHntAKnw=neO5Q?kKe}(hLG%0p7x9a0L{}kTMAg;Ee-DpX2&Q~ ziH-AC=rQFib&U37n3fuSmLvOE>KvB!DrQY=J^Jkr_qdM-Z zQq{Gk+YBvPHwU}2p)O6Atn{wrHaKmMovZYLz!4v%MQhFJ>4?rRCf8o+=09l@Mv_l; zMT=@(m@C~+SiGZuqS@7&OU4uc0T-2C#lo!jUiYqbOkJJDcs&o6o*tUkd%~{;R`tnu zbXpaU$UQPWO>Q2_)620YGZ~k@NtoOggU>UrCE_o1SV$cer_^tAN%rzS)Mo_U6{{1^ z&FsW6`ms7ach=8sMU@+ORVglTYZq@k%QkjHA+M-wrryXKk{u1#w=NAAXzpZYe>>xo zj9Rmh<@qC9K*T<)a{o;F7B0MvAO5znxs}h3vvLIw=9M70ph1KpzOn~lD*sFJ(9>C{L#yXynAyfLnx({vQGRl$Jyt!0sY((^f$OkW-O3!nF$|0?nipyEUUEWL0esZ{YFlR?De5utBc{s$4HlFb{7|e4QS7z zf74G-n+{7@%hTLswYcYM1Htj5??J|z%-Ovi8OPzm@X5A^4*$s%rS4DeZe4y$RfA>a z_7I>4J+q^nlfz(VW|5ku#&LI^f2*qxS$C9L8)JJf&)l_X$ZvCAMBk@vy*{H&`cKHn zp3s{1+)~fbbLYp0`$8hJI)p72@7k`^${REvL9{G^#dq;=$$8h9&5vm7%=MtX;=1jK zi=B7QQJICqdvOtPr*@sdT-*x5%7>(s$-`^&?$xm90w9U)TA#+!eI$NgJYC>JE>F ztf}a>Xs#Mb-k;(N$e2brMRKzoeJiuV+w{?ldzLw!J8l;L2)JN!O@HD%USpzt+&P+b zxr$OZgK&Os+i__r4Am@I0mc;wSm#myN7GPq*|gR=vFmjlgD7G-NzgHL-MERvM|!l? z4Z0@O(ulZedljDLcyj17GHFFpo=rA9;j77Yd(?0hx#ZK;O@BSzt%)9(qwlqKYv>iJ zPs{7`Wn%908fec2+Q9J=)tSg8U^N4T7`r?ZiQpz<$wtLX>Arob_|FLO4h11gALFnf z=Qi(UUr;ke4TH~PDit^Rg5&P2or#?TgS;!F4Pa*NynE5mLLZZ6&^hga@H{X=4k)zb z5KPGUx9t_9a9m!|$A|5lG4Ih-OhYbi(_l=t>2o(>IE39&_jLytWQTP9b?l9Q7E341 zP_zA-XN*0HXXdce9hMdpfjG>#p3Z*lBV)_wDPI24K>*; zR4&JpRp#9T?=$ObHA6x~^BJ`0m+p?A?ZZEI&$SwjyXKvAOZfyplLn7caXA8Re)gh! zlidYkvr8WCZW~-K{>O)QTkq=-`%djiPo%Tjix1Nh;CYcN-f2D*d~UnH>)Mfd0`g0- zr5>)8*nCTl-<18|$88O=dhZ-MV|K^qm2FfCjTI+*`nPVM`sIt(T3X zhkEbCUa{3xjm_7`!(+={lOwO`lpIS4Rn|GX@*t)r^f4o5$+z) zg^Rkqoz1$TXvD^Pl=AgFz_%!k@E|dT?cFPh&S~{9Rbea8U00p9{_zxU(jeD!k{8js zp2hNA!uSOAg#GlUggLP(b$F!i`*qd3;mxvFyRtt7-!#*p>APq=)d@$xG{?W}#S%G0I^U2gZfL$ zbQ7oJr|EQsyPlz5V8p=n<=OkZ)G-;&GR<&pgjNHLM^Oi+dyF2hs;!I5PB&;m3f0!& zVDN7Z!aETpg`EQnuES zoZZK-3v#PD32$KLh2yi3Ea{Ufp@};jB8R(^nO%`M zq}?Ft&Xzo{j~%byPq)6a9jA}EW?r)nUwwSHk6p7H#O3YgjXu0+F~MCaZ#Q0bdCKqS z^wdZ>iweor8P8eNV3jDzW?+SDU1k8__w5g!*brQjuW-M$U@R?%o$!~KD9k+=KPwauz-FOY|00M2Mh1~CLq%y*n<@f z5|2-A3MT;h?D{1fWX@RUn~AT31hICIQ1Ez(q2-TeGv{5(y$}Eo^BO{$-$<+G9?&>w z#jC~SZ|UxMR>>TgENQMXw)vUm#of;Ec$y}YH7I^dx;AezXrwO&x=lEVswR~K&-8Px^Dl|3HmZKjqY3;xa`vz6 zr zkJ|}8L?RIqV-}5gxK8^9 zm`i2kiBl)=XP;wr2az^dJ4NB$|3Jd2!2fN-qQlFLvi&!Q@31Eco?mEd!s$m6ggr~j zxtTFqPG8igwoEaWb>&Gm6Qmx}sCi-QVer(bu`!y+05aU5FnoyHikb5;zVV$~H$$*o zLcWohEtKZ70x zmAZpE*hWWs$!fP~WH(7#s!o+8fige?67%V^77{eVZwU5%wipiSST?5{UQzjHe|eqd z8?cPy+h-;FOBh2j)VgpiARQDj)atmkParnj4KMg*z1^N9U<4Q=F;cxxp1LuEgAOvygL$F zvD6eF_DLgEc7a)g7S1~ zyj$PcqtJ5R%?#&fA0~i0c{A)zVyiD~ah<+)rB5x*crTyh2RS}JbV0M5)*Y24$1JnE zpj>-!M9N@hg@lFBLS=16sM6K`5;)?un-chVK}i0``MQkx76*fCY(_x+$7FDuZ+cyN zODWN}fu@-VHcM@rI@e@@kiCVCKWiP^oMDIr?i~-rv|5xBW-&a0_GSUh+bBFAggU~c>L?0EWg5*0Ep42d=kJ-E%JGokttdV+(Kpls=Z5MZa#q$;v#?vHl~A>;(Ap3mUV9I}#fQa?t&$^pI5X zc`R;&w%XI|4!M1sY=tCQS$eD9j=qAJ$1JufQ7y#Dg4eCC?EHxe@I2XQL|XHy*B*o^ zdfcB8bu_b7jLFkkUoMY%uS8=NihgD6?0DuzzDFOJ)l^!J7hOd%O^ z#}~8RtK_Oi0P#Z+3-LWP%!wcWeeh;7^&Q{E7==UiH!bbi=86n5+ZtL8IjC%4*%-Sf zjD1iG-O6asNm4D4Oy~eU33zSWZrdWvasDgWrMT7c_EjGQ(0%MMRwIZeJBnF5%ae-u z#TvORMl82$)ZV0heN((+K-#GDFk;nZTJ+;VS!P5ttu*&25bU@TCa1&dB7wSBo|3&z zeLyc_@Nb7WZdqxHNSr;$UCf6SR|?LJEve+GQ!4vt$Yb$(Ciw)+dT3tq^+hCtQv$lq z6dZd7*A&DtC$pqSScW})BzN|Xyd7OP#EROjK^g4VmPFnF%HFr zM@Enllqd^V557A+;v}d?;IN103cYuQvz`?pi3HPv)f+Bzp!T?G!PP(RDr%3TbM}im zGAFG{r5WiaFdE=~=-39>Kp5XxG|zuzmn*@L#_zDmbkW^gn$VQb3zQ ztO=<#3>#U`M8)N=?Jozwd)Bp1YaVNpl!~06=W0rsa?t*&&aef;8)&w{kMkJkyxpdA zsa|M%3ON*Qt5U%a1v%s8W5`fZk8$VhsNkNtqhyQ9Pb#Ufn zDp_uKv1(2_-utZutGx>90KA#?9;Fur``H0+mNNMXFXi=+OxPvAC@ZFKfNy9fZ+ox; zgW$?@x4A_AVDpj`C3y2!4n+2{`0^?D!nu{s~!jLP*%8o z?h%&tG|FAgeRC@7lGI>1si9oso3nndC)xM|NLkCpH@CNk?JK_bs=gk>PBJ&jE0~MMGTlR|%EoiWr82YLr&AQ{P-wC1H*7_!!_;m_ z)M4BdNYi`gq7?33HLe3wF%SHNn=CgZ`{Wgr?1MG@SfxN z*D;i3%0cbF-g9ovB~?Uc64qMZbo5}vL6Og9wZtfqMEy?eILY)eV8 z{SnDpOSKE;89jra>}HlpAWkdrhF-T2KCk`;`R|F&fDQ~lbPOP%l+XWHqVxYIaOm3D z;)=(A`SgBi9=yzY?M3ib zCc5+bZwrR}L4QK-o7uwC`QS~Zo+4*q+x3N%+4>Evy!osoEMD4bQSmn287A}7z!k|k9QMdtq+7W`YpWOHBSTkLQkNQ&G34r0**L9Ti@3XKpo zdM1zaUbl(S!ivEwY5DqFO<^f-aVg~SdEHjPT0Ph!y*3}GhMy&A_-)7dZ!Hmym<%#J zOy6=CR(ej6J7~mYx3`zetDrkp155hDAZfT}mBpR>JtpL@B;fbYmhG6YlUBqn7-W|5 z&zhI&ov3qIS{jRn99#eP2&wT27#;t%By zE7`?SJJ48wFjIpZ#$S~*(A*Ii8x^CAx!DAmi*yQTT*A9miv@1F?j?@|gn-id_s@Dy zW@K;hGj0B$zMl4AaywKb-P-b8-IH)p!|-%?x8V+?Nbw9gGeTrYxrtQu%5(C(HW(MS zU0zF}EcO{Y86m`@$D^P{*urqr-sDbnOmI!KezPaGiJH}oF_|LYtg!c@TnrN1qkTqK8AZ6z-M8eynAZc<&BH`&HKO^vn7iO{imFBhPTlmgYLtScW2j)*t#Y#bZ`xtPD0t_PvzRE%JnXwiBb_!9+EC zVIx0p&Vx;kSie~fGkcFA!o{LX6b%id4h-|2nfKMdjv7TyQ`_vW{4Lj_ZPwU;!tgc3 z>2)rtOUT~gkg=5c!K6mmD?)^Y>bgxd(|nakF$yS4#gmM09x}MyrT@_eq;$&~I|VxC zs#%)J7ofcVYgVbZBigGw9gyef1a;$IL0fo4OP4GvoX00B^~@f$JKUHcRdFN%c)*l5 z?U>TO@JC#mRNAm5;3!3k3K}tk`9IAU4&BwF=j>2u6Y<|imfopp6^NULhZzG$0#@dn z48IK;gnL?tCJP3mF4-z^t{c#u1RuU%%m(IT?1<@!AMF$eZ2lD$GF$gYm zhuBX`MfD@QqjRsj+YJdE7EEH_LAXgSJ#r`JPv)%$X=(1DfsCWWM=|i_A@DO&BfNy| zGz9_-i|B}27_nFL>qL#{aOAnLvLG+wN04(w3)i14T#dRTRfqtonWp-?fL<8y>F=GW z(D1O<>1-WF*}5*+qeseA=-G*I#`->a_o9PUNQ{v^E-VcyZsu~x0qO?Xx}YQXf`Um& z5n%=dkfBk~rXbVz$7ofT3zA#x*R?BG^hYthHh}pyGtwj~(xdajw!1y|gQ<9>d%dv{66x3b>~J z+Jn5=XO{al%+rx8;nB`*LX7i9zmEPyTI>R%4aX0~UV-l`sv|9J4*rp$`g;iE@`%z6 z3w+_4Uwpr0e8w!%W!Utnx&`N*pmy+=a6K^qrP|^#%@=upc{!}-gK3*Rnvp~V#-H{g zek&DxJBn6w)mJHq6s72&GK(*0Zvv_lrWc(c#oe9Rw%_RLOmr~+F$Zf*zx4K1z^uB_ z4P?m>lWGtw{1ucB@LK|oy0yeUQ(59po&kH2Xng8{p)(h~ET150xL;777|c(cVGl$3 zpY<1x->aY^z~My07#{s*u)7|iSh)arfn>YW+#H);*bnA3{f?R#y@ZS_X_SLstPg*S zs{i%kHsdTQAw^h~m{h!A+aO{AG0!Q#n21DSSOHSg5YHvh=eBcZLv5 z2H6T_1}JiquR#UMQm$rG0oOr}b{H*Ftv&0ln5CvVm}&s;BMWXE{>w9%KK_GD%gJLx zaLQHiX550j8@GtfFz?*QtfBI{9M95_zg8u?UKJ)M%Kwgrl~(QD?7o8~H@RwTbi`@7NBf&;g( z(8l*#B*vyj)(J&8S)3u7Uk}!rzYRq;0HT~F@$O9q9I0HidCh#OYptupQ@Sx3^5mH| zbdGMVtz3*+8z(ObY%)Aw3(U*YOv_8mU-H6;bEL?e0}7=_G=fqa)OT-5{;p5w`cO%e zy(+IY1mL=ragsCqXOWyR#h(4V6~_M@9R%W2hp&V{Y``}KwK`afDiy+*X6pV-c5Ukq zOVapNu1hCjpr*(g>6Od;p>EA6tYpEGypi*ptr;RNF5+CbzTfgcdO$8FZG=A~DHZm?mJX3F0L*%94cM2cgHdjTg2rAYy+#k;)aX~cDC5>@7& z?Ht6L(I`VPs*S6d6?Y*xh<&>K6K$?Eye0O&Kg$U|RYD%#Yv%MxXfQI=6h%gcTIeMj zt=X&UN;JF_%64v@NpVj*o7goQ7q8T~1KVS&&OS#Y`Fc;IY*;w&C=$n-=i!909}(WJ zOO3umS>NgYIa!6vK67H|_q#~y8c^}NJNSw;sc(Hx$1L)NLRqopJ9@ggJ#;mi zE6Nd@mp03;FKJINE+ldWVAN(a!G%S$G!Y9!{It{8m}MXFUI;j37u60diph7Gv&@zk zV^z2Yn8j61p*2hXMyFNBeLwyJN#Eg>qUh)^;G4j2SfC29m8rN={Y$%+>plHAL3rKh z3|vE+3U%|&RLID(&wfOFbhY{dr$E~jD_d+dYzl<~tb?cBIW7h{1~fEo8u2sU5@!iI zE)w^$G5-(d(uz6C-=;1YO{+;*)2e}Fwbn79MWxH3irR9MiO@YT2ksU7Hx=xr^&1cY zFsS@5zgrKmMmv=vOUe;AvCJvko^1Mx)2lngELmt3Fs)GTbd&g%h;>vV~8bfYc zTfRRWz7L)dUA699k@4*fawrujdBspS{;i=>Ez4ktwh&%K?YJv=Y7oaFPF%Ig*AafZ zZ3#4ui1S**^p0Hxea*S!$p1RSRQ&U;e_>Hb0sF#% zf6L4V@0pI+X)GJ^(L?MmOleFY?bqGk9ScViNU|U#h}5VeQHl;r+7=6i z4khiBwNG_gc%g5R9gI$+jRDX#Q@>y;FfhR!8fVjwd#VzVcbJM}smaVqLe0ecp|NF`OJ8<%V+Mf@HNtI*LzLe(M<@TBoi_c zEGfOG)G|+6*oIO^1CqrBXWUjs0!uJ|gOnmM@b)&8iq8QeaycQOSdU#r605lxL9>Q> zX6PTajH*8KSAb%V3HJny@VB9O%U7e@rrXlzHqQ>GNo}1%kWW^p(2w`ij)*Z14z#sk z9ET~dPAeKaO4WNZ0P1qkJuIy1;D+{v-q=v~aaJ+?{p`e`5{_~liK`%vKUwfw!b=z` zh|uMCdu!H@*Otl>G~Ug@MteOsl(|x731%#%E*UQ~u(-zge8^R2cFAYrLmo)B|3 z8c{3J+au=eM1^Y94qFreUDP^XyAhX_j_li`NEKVa98=GT;o)@3?6DgxTE?Xu4aZMW^BCOHF6u(7xc7D@U*d`kg6$^f#3Y-k`X+Ut%?>Q0Jdu57x(J z!DfVMwLw3&J6$1P1(gBuLpn=#ARfive@&OwX|jLtnL+w@=_}fb`&#^7 zhW(K_DW|v$?d4eG>n9r;7Y%XyZG89xTh+%nMw(pGAt!dDc1ZpbVMtbBy_(3<1+mH; zALfbb*nv(@u2zm9>&yYJ9GfF=V1u7|O(Mc1k_d8<8W-y%?t-ZtE{uoCZ-@0lnK)LW z29kP*m?m>>e*m}R+VP*OE?$?}&ubX)1z7p^zexNG3@HQ%2-UKA4PLY(;g@!AlNq)8 z&7t?dp!cUG$3bgnY7$;pkR%Vog1sfg;C$T#9I9i??trK!GcbZeTpEVg=BcL?q(?3T za>Nx~Neia&OG}wM+E8FkrYei_KJF&mgAS5TXTlwgf!aSG_l%^a-^HXm#z^0jMjMUi z<7K7UV_6~B?!iXk9%vfqMi_|dgu&FSn~3BT%FqnVO56BU?%ynggR6bHY`mwdgFG3Kx%z?~~dZr>Iwa)dSkERHZfrD-8~MH;5ZU8^+=!_C+q74i|B z5}4N_PWn*{g~kPRid?N0sRaj&8+Je$yW(ieJdIUSz%yKC(F{=(d8^kFou50>N!o2B z^~V#2>2q|*GcqC*wl+|(1USfCuf^9q2-tzG(HLJ?jEq<#0o37$?XCH-riS1N0xWJ0 zk$N8{NKkK-+2%g)=Cbl8rMX7(#v#}k zZhCi2nk!y*;xu+hCP21w?h<%~nis}(`$6R(g1f0bZb@Y&Kv`j-Hm|97P?W}P1?i$wF9$XVLMlm(w=2#Jp&*9_}-(FLa0Gr!#-oD~*42KsC^vjOJf|J*YqT?e58a3T39*HrY|q(FQGdi{ zx*H*U?6gkCPZa@t#>ryCC#El5jAk#kp&5{D{#sEU{Oe`7bhu|BhoKH&>JaJC{fxef zjc3!MKa8!*a9;U4WNmCKEKXjn?`bP1pK-YL8-`bkjr2ZBgq*7Ok_|*N&q_hN+Ts_1 zCOV1sy7S%D2PMu);;@?I>aHgMc*F9u%7zRBlQp6vFkH{g@$qguIU8aW+LOt@-637) zn6pequ4Se8_7}d+UFZ!h#N(X3w-1}X;ebeY{ftx;5_3r_U6rh`gp2~~VyWDH${*Rd zdPT8Fv8y;74sDGj&(Oi06l|lKS=bJYT_;0uJtr@FWvdKJdEE_JK;GIW0eW)Szdy>V1sFt=uFC znGZJis+#I8@#KFuj>?=i$>0=T`gX(lcD(5maX2+p)i$_qgck6t+G*R>#egG5kc_*& zg>4Dn-WHYO`+%?qFhQYymK%S21+7a{NCqf;!65^Niich4Hf>N-DiX zxlVE*P?SWvis^m^z)V3vaVRnY5xF2wTeTdu&s(0?x;0&Yu0Piv*EbV_O5Jkay{_Ls zuHV1D^gAb4(>AlxvVN{jyw*D1VPFU#KWN`>Uq}O%Tmj-8ec$ojSo?&kVS}zd==Z7L zlhE%6I&D%Kg(?S>WZ=SOg|!NK7^dSv<9ot+oeEgUIi$1-#$&wEQEo9f1kiCngGg{Y z&s?;U6VDh#m#<)ie$7a`bBzElBq%mvV8$Vn_$6Gwc8V3*`JN||oz`|lG1-5<&hndq z^djAtY=OwkkJKo@ZrE@+i$GZYBV^b>?7jo!?Xe0a++TLV4|a`&@=cYoIQ$K3=EIB0 zOYamIn|w*sMQG+uf!rYM9~RF>9Y`-ZB}&OPf9KkNWiizR>8}NUR+>s6d=?Hh^oqd5 ztV03?=B$xHH5GrK%Uk`M+T1+uyjZr|Pf?B2Mnx>7aD~S5%y^ejbsK%PubuERh0IZm zpPpuT20Y8Nu5(wo#Zi-=Z}y7ACuqmgdo7ST-IQIPx8w0OS$><_E`G%6(qCx2e>Etu zlYKr8BESwEB)8oJ%}g7b1CBW zhto(#9mRhMyo!MS*)ZuI>M$%Kq?Js_t3b>}=_0m4TTX?1H->zQ2}qiGLS^x;OuaSa zK7IbAar|1@!8Lr1Hs6^PVkhsZ!zYqG3>&@-dZUp%HoY113&1&tK3m39&97tegT>>C zk_4$oi}4#Vy61v3lh`lI6T-obHwha*%oXamUBSD~s9m>xZ~Kh)xdIwNTtTGjE9kgi zC4h_RK<6W`M?0Oy0>{)h3g($>q#9Fjo251)Fz?PK28#kOg^x8ID$&Gt*xB$S^mE%Wv_tZT@-}bSMA?%*ydHmxpj2P-|Bd{E3ZxZv zo^=x}6D)gqja2bvHJkJSE=6G$ER~}c&IMB`NqB>;!j&CR zV*Aw2|DqC*W?qDwRN<&iX6>)d=lTq?OrINoCPA+k4_kw{Jv_=9w1u$95|pDQ3o zg{w$z`%y- zpj;^MXMyXvXkUQ^5(Or>YauKQI|WStTKmb)7Bk2-4b+J4%FLr_*o1$?S3=2BNkv%o6XA?0tGR>AFO-arv zNwOWSN|;$1C5Jx|dtDO~gLtF~-$RFih#qmV?fqJn zDJ-HPU`u|CwhKl+Ol4*!5%z^Rl13@t5WfYrL#HQ7tS-D;TX5$BxM0%dDcV9qEGj)0Z$Bc z-xFhiu7~B}-O9ACBBG}*qEZ5|!wFM~MF8DH=kT>QO_c@3ilX5w{Pwjw| z*0=|os+OgI#)d_LnPbqQU5DOANgp0Hri5kSZY_#f2{E!6MoxKmf~1lze?6b7=7%oC z)DCfG7+};`jwH??CIEhikCh?y^R{EVv&9!c%oCDegsQFXc^?aPk(h$#V^sl$vNu>~cv z@4qBsrULwDqS_YAT9r`ncwUAZ=cAB|*BOmOoKk4`Tav2PwVln#C@w-NT4|+X@{t0I zS~bMF>IAZpi@qua=yZ|LmjCgT4d_%gW^m4fZT@u8Z>a(#t)iZwi`KkLL4Sy-DmD(N z8pw>s zu4}5VchEeCgtIGE2f;dn5) z!QL_`)Qf0z|5DEA5NT36wm!fWGy}`Y?EIJe*C{bWWC%zHE0<#~aGI%?^$iZDlg*-y z%=_BUSL0z7ahrm8LpC;M&h-Sk7e@NfLTnUbCL9tBw=?uFWTm8vOVBKqTYRM9BmkBe z*Z7YVzb2^F$nG6$Jybv0Pn^5%#yNTj2HXO9y#IKX9X2B&lBoeD>SOy@x&NU$t;+cT zV3Zxy(E7LSjF?x5a0FTF=+=NKC`1WyP%+-%E-GXb!@jA*ssYL~CvDB}4OGZ86DzCW zEcAdN9FNfoo6zOlpsI-^#O5s3X@kbaY`)R zfcV?setlG|R!sk)W-7p119Sw%G>j4-9@(TbZ|*NVhLAa&3)ZhlUFP2;Y)rxhSC&zf zCRlRpVh_&4rPlx>6;I50co`(L45E%EM$zObc6er!K)qrms7P=s5O#C(5aYItyl!M9 zkf}-%2|t*Vhv^ka^BQ*WFCsJ}JV8NW4h1;xz+M7F7zjbQMeIO_6s?5;mY|UcK7+E%lkAEn0~Myw@B>lQGZrJBiu2XEhZ|18MEC9iN-x;ewwqTlwS3qcoGE+ z*vU?kLF~58aUuaEAdVVMwJz8dRK!5r8cnJ9q{%>?%x&Wse()eF%?EgMb~1re=+l4sKb-mz(MDFphE!81y7k6b_m2i3xpsc`l)>#7@zYBX;^dt z(-r0LFDzh0t6IyjzSOW9#V6DZEUR3^SECE|I@~|ef?&hcf^{}ib0-$fR zUQx1Oyhr?DTs(8B;P+UypdzQqJ3s=7i(o1iwKYhnARHSGL<<)n55eqMxFB?H_|zyh z>c>ELr`!O7d*p{fl&DRLVa6OG>qdwSggVn)u>lh-mK6u8=GtyR28j7l*;ULHxhdGC_0F6Rrd`$VjCn_UDs1gsYZvMYYxcR7N zXTqD)uqz;i{O#o$lP-wJK}y(CF$V{Gi@7$Lqf~#p1sa>R(+8^xHv$EkN6{F;6Mgim z9k;vRfGTJFql?82uK(ymFsoV;2?w&9Zj(Dt-br@MTB7TNJ?5^`_P3pOHbMkjqSx|_ z2~91L#!nI4*;g7NLn7^1u!jb*Olhx!4Ai4{?nZ-yXrDdbrKa(RgV=Y{pkBq9TsGVs zQ>YdD55~?JKocfN!#g|Lv2EM7ZQHi39ox2Teq-CVZJW1$c+p+hNeA6gy;b!*p(ybN zyMJLTiHUkOa9A^0^=8>_>kF36s#apxz+{zDCg6 zG{5W|qj2SPFYT+60U`tDUeuqGmSIPPKTu(#O3$lAqcLFdf+a$tUNV5fP_)+#?9#6_ zG4|(&oS})~ahy#*{%s1yh_71QR|BC9bBG^M@WJ6QO@FAL1m@(g4riZJk(dK+d*-fd zeCWT>&j|s#n;?H6)hPq-WTUF4_D9ehx`}n15VG$#%rb@{WSv%EIld~$V8#*yW=%|v zel?gD2m{IKrRIndXc045f()yGbphCgEn)CSVX2pn6w7TX1O0+CqZrJ)=i(Adpd={-0}i~HGOb6)sq84B!9{f=#3 z9fP?vBZil=B!H+rd_>0idL#eo8}ROI^LC}jk7!Edw-l0t!$oV^29jzumrOOO-ln-@%)F+~98QvZ8+h03rMP%9VwoXCEBPYk^jg6%t3NQugn2*NUzL&kCpU0tuV8i?jU=>!&K0GhT`ylF!jlM z>j*-g(cAUO`{{oT$U_%0T>jcq3IXY7gXZvmeHonnH9<)bb6<4JZI9Z&m&S|xk|COR zdBJGSl@out2WqxUG6> zw=AZP18WZ$hH$_1wqW)Co)K-KR(o0|uK*fvrxY%J4R!oh*&6>g-tjlj{cf?mq~|Ig z^-3mTw*ld06ZL6hmtW>P(Y+aiyO*55&8899J7mGEV6c#IdJP7?>y9{tDBMNzqKbjt zZP~+Eu)P_u``*LEm~qDw0$}k++<~ZItaxF{qE_mlM-hgxG(g%G-MJ=yS+nvES&HYd zd}*Da-j5o;OnQd?Y)n+CYYY-Mx}FLYU^zQt45(T5xCrLvd8ba#4u;K-bAeLfjZ+L6(6 zL_K0tFebU+JnacHlUx#uzX`kNYCq}BYsNSI85_ta%_bP;yc#P9bdrxF>sVuOwnBeY zQxdh_v$R;S`VHztI_gz2yxF17M(TgaSkH%!=v>`}A3Q-UZv*^0m)agnY;zb#NKD#| zSbh_3@riTVWuz~HwmpJg5PdGtVI_Xu-oadEFk;Xvm8aHj+!g3Qd|hWR{jS%XpopTk2D#vS}$ z4{X4M_SpjcNR9A0{lNZ6K@j?k1RzX#v0j#W!0y(&5D!PB+;VAdy8d+x=r9!9c_h?; ze)-9;VS1#2KKK@JCVc7NS_GF7`N&H5_HD?QA@=y}(0k(cA!q?6!A7e%1CG#@44ct= zxbBM8CY!^vIl}Ui*G3i4VEgyn&@cL}a046Y+kNo#@Wk}S`s9PNKm(4f0n#}fN&8`Y zzR*B;3vXrAgGcbt9Y*BLgUHZlSP(}1d@{Y7$E?R@rbMVi=lz%y6{bG=>GfBuu$R%7 zP}pR)c-P>x3%#SgbAK7*(Ch4T8NuLoly2{)2!TcAP!9ubJ6IWaK0(0i!4Th(Y3YNz zr1!!Rw!YW;w~6h8zUF8M!37x(r2|mY+^8noFszMWzpT(6@E@obl8*Wl8Y9%ZG$#Hj zJ5?|5E^#iuF2yd^wI!RSLZA!!I!s`uepy)MWG%;1l8}dq)49G+F6Av3^y8>8@kzKjDQR=lGQ?rl0wgru+L&_R@`iN(cH5 zxDGDVeM$%N?h8JY@V60)#?V`XK0H+_B?_fT%Q_Q>8bzY<7?cxtB1r{zvYDzc@1HB0 z_)4OWGLvA+wgP$3ew2UATj2^Y2@=ZYs$M2R+A#{{vPH-8aV4$N-w>xR;^~qoYf`FZ zwp0|8|o^nEVATX+wY1OnN136@I0a(r;WL@(N$7o+j!G8nhEL6^S~bmYSl^b1?^GNC%qP zf@AVBCRIi93BVs;n?UO#Bvhl5bm7V6BpQg##LCsG<4loDjM>q~Yj2F@n6gOZ@)9WH z-X0|-kb`E=e_80m!)T^MMN`Ta5gNQTVuWj%Y)Ig%*_bF2J`FV-B@l{2sE*3?e6s{; zW@rUUCQ}V0=6d84kW47aK^M=^XepA$?;l9YI5pzQsH7EX{^J_K}}7Xr>!(Ir{Js3+$+b=12BGr+lvErSt-(Vhbg`I%iwsyWNBX~$+}l6qYY z8n8X`OE8QJC`kH9+ayKuJL#5D>P79UP>svZYyS)_hpeL*AI{6dCKv~6+>L{@5;`|P zG9IRNnc^%~$Jnn@h^2rMYiMBbEhIJk7NJ|CJACaI)`%A@*Ya&YgOrASUR1Wgo#TUy zjx&+U!)dAzdyXHEIDHEMzKE^{MoC1GNMh8{NfJyaS1R;m|6|cLQH(DXO$x16c@#X< z@Y-)L5s%5T5HTKK&Qzd+3FmJ#TZUUBKhBIAG*D4_tzMR3Jn{H%J&ZZAY=)GZmzIOG z#>iOITU*rKT+nf3a5M~BIO;Mf3jqNGWu1W(14AHzZYF{*f#U98W|86#2IK>X(Sx-7 zqXyy(&aXuytB|Hl9ZaPpf(4Nw6kAkkz>HniAfEuYOBtcGn4W^mVTxTCC&^42O*@&2 zR)F$_rb1~hS8bR-p0)oQUF;xo>25826pnG$QUSR#pVh$}Wx{K0Ke>MPz2a36LveqF z1iT;us(4muuRS%1|5-#bUDl`bP|?XGIG=v^!jw!8Nm@C_#yFU zKPr?YBrXV=#X1K0iaZMDj(;(2$0Rjo4BHe@sT8D~{Gr>LO%WrZlIi36!{sgaq2-OZ zj>jZ@x7(ER1PH7SH^@U;JU9*F+Y2`6!OmT?Z2qG6 z2y!IjP7+4vf8R~0sA)4zxH~L6O27AR)3l3lJ~P5O14xklfle_s79Ld*p_dIlky57o zH)tn?9KgiHNDd#3Nv_PkQ4qOqEtq(29_E4oGKg{_)L}f4#JE}&^J!(jw1E*%chTbD z2{p{XqmiF-I5Ph5a72lrc}|IgMO+-?&w4ZngiL!}#R-hhx;G?Q7L9r8$gs+*1WUxe zEho<#*ur6~)Je8*uV4wZfSq*$vV67Gq|={>4IBu}$kqVun!~Xq`&VU!B>Q6Pm6>c;XRwLu1bCJC$UMnwZBjS_Faj)*GL(8 ziR9gqL>rDF0kO4qDLs66V`48Sin;`Xi`^<@u3kO3JcAGuqzl79ZZ_9@@x0Wg4PI8_ z-@|zH*M5@&QBwS=GJ7d4-F0Kx?y0_evxz75=lW{QlKtI^VNG z4J9X#1j1ns!P@MLVM@*D`3@gx*kpv?K*~{U2KNr%;N59@653d)JTm49?2YK(hVN^+ z`6v0TT1+bt5fmm^R{Fd}oJI^rCWTV%#B$oK{edRi>+@gJy{AMu-2I~P3sii`o@4(| zlF6aHLA_Sm-`GSV!S?%8k=^=zb<*8aV| zqE$+{rA1sr=TY)P#K|QSG{?{le+0JfIl8}M4x;urb9UW>ur2cRf@&l{PDr-bsdyk? z7CjsiFG;egWM~i*@|+@$EWW!;v%)pzru-Erbt>sB7`lT2LaLF6ejGN&4-2`AgkA;| zm4*+ueAur@F#7u~t_CE}g^_=)2;N-lj{q$#gaH+35u^Y_m6#mGAQV5sHH4Dh=m65+ zkT6Im74mZU@uXeEg1`4PE>#vR$aO%5%D-|cwZ{jaf?ET@KmAeX>P~~LkmW@Pst|zO zUW-uB`q$rE@tc*^9a!?f%dhBwdFn0ST4jL@m{r%X!uH?|4P@}*0xsg`xPkgsFo87} z1R^{n3}kpe)!2HC|2*KMz`Cd!@@19^)&8>uPc&AXPlY7^)p~Zm9m=}8 z(N88LK(aW1O;6A?w`c%EH1#_#Xbbg@gbEx zSsW#?KQb#gvDzPV%!D(4lV48!@WdPJuRX^e>Qzus_@kiEf2Il~qC|y0;-G2q&+aUW zAb(G={n)vPGeg+B+l!wPgbjTM@bvdr0SEm)Bzt$KhI`@8=9`uhSfy$~g_D{r5353*s406^IU$|{-25xbdi$08jXDzD~25H|GmD3d4Y+|yA z#661}1aCz#wW*@{8I8KGL@<23f>2l>CYP!B0GfuOLiOG7=xICZh2WPAKxfosd;KS0H`hb?Dz_Zk! z)|Qj^$3~jTt1$;}liiVf3E=0QYa7mI{8G2h38DJCppmLlH@x*5-P`@W%Bm*xfpD)B z87J8pXFWq~_nK!x;!44kDA!vK}G5f$|^=M-t<=u)`V7HT)P%Rf#c zEjhPt&v7qLoHligU=nfHlGV`u4{m0Rh&AUU|C9lG9lh1B6$CuZ(oe>(+wr;5LY$>#+k`GqQ}iFkwL!T zBs(p8_Tr7=VGF8$#SrZ3N|RH-|LP`kKk$5wH=fqpDMAhG)n^=RS7t1zCV|3e<30x! zc^apukp=l)d)FD(%h|CXb4rqMV}ZCvsOuRQ=k!B0 zF~5hb3MvRpYa}?b$P-c|S1oy@)hxu!iyPhTx5a5g^U?)DQsXh=N0AmPYxpFF@H=@Y?*p!|)An6aZN zK^nbFAvA~OHwG4qAdCsL$$dbWh=eTpIhEIO9K!JDi!{b7Krx zx$L+K0elWDEL?s0j!Hb}1U6hUC8RcSUbw6l)ViQ;RREGHF?r~gSYPaKNKelTF!kpYTj;MMXv+Z- zWJpuwb`!c?w+B3eO@%||BBaZ&1M1AiC-wC^};Re7~6-wIf4%lV-~2=A(rGpPykI%e$^PV!(K-<}?Xd65ig zCS6tfveVAzE=h}hUMnINQQf6;l=8~9!W4g;0Lvkt9$lg9L!9kpEWjry{1zk5pLxAS zg5r=M&;w1X{@XdLL5!Wt5kbGWLJE_&Gc-3I(`$x8v0Q!%p6z#Z1~JPa3E?Hadlrfd zTyPdMDX*7+s=ODKDwtd>ZcF zcNr~?Q?E^|l%IAOW{f!tAe&fQzw!ZsKkIzoPulMXZJ+TcGfbL0-eCKH3&A@GbugCE zAj}m0i_h*_^@WEYpKrgrGufWT)vcRc)x&?saJX-*P-2L(@m(xy;1vR!&`vf&c4HTl zTMBVbQN*AyIgC0D+hOPi1Sok1>m001eZ*v6;=U@_lHU|mJP{Bkz4-hrPP7`ZZ7K z6ZIk6N%67_0iY_U(JY3}#tl=*gk_U}c?dH-#fmtRr=tHsxOr18-CEFs4_==`HBYhyX-R$M&vTfSH2$*C&d>nq&0l+3i(c+hQo0#2S2 zZt!AwByFl`yMEgBG%U$#kIbUc^l)7{iXZ|3Cht#zZaHXIA;TGFh{yBw# z8@$o77B9~2pH~b>3p3ccuIX=sr~N|x0%8l(;-zcR5`LBqy$x6MomkJh#E<5Nx+Dg_ zX!;AR^CfJe(^DqF@{|sC&A@f*$*z$>o7H==a%p`v{C!53{VilPQrPTo-|RUUD#Bi< z51ndfE;dzf9(2qENeaPa((0AHDBIg*Tn^)IwVT_^ic?dS({D8LxM(F%Ky^ht9EG1K z3-n?YJkClGdhjDi5j=~@tOZ>Ro%S$|`v$oCqVm@jY?|3cU?CR&oNjfv`TRB>@7b*? znT+q2l@^L9H5uFeZo_8$N|IAMSaIlVNTzSUyzRYr@6d)9#sk+5zNS7fhc6$y+b`B4W&=&4aV92f@4B1t z2#nV-q4Dr~!y98e;`LOUY}Tmu(%_UnoO@Us&XcT94jo9Bn810YHsnz?Y3^1La)_)B zH9dUi!lrMA+>UwJ={;>0Y>=|(s&SK(3enUIfNO&_;3w=v=jE!>UlKccMAAEGL}2^Htv* zQOTcT0l~l~a&+&a?@to38}9ZY}HWB-QQ(CWaq{ z+u)z7Js$IZcOCMP%r%qC+c(7@%O&0mEG3PeY&hIy)V@*&4wXAoAFTJ)dylQ>Zes4w z%~Ch;H0$0^6_*Nq?tsA;O_lSinX4HrHQgsXtLLlf;O=t+4FJ;%mq&X|mdV!Os_ntH zO3XzxQp-+VdKzk1o$0A(Xt9=t5ICEenH}m+WcT`FtI!%}Bwz^2S%jEK``R39&7(<*-G+8} zcoNHSK(}eTdvlE!G+YQ`pWIzEG=M?r6PA3%(_iRveemiqLc4LJepJ5%^+Ix>v)Ka! zys}4yq{GRve|MY)_p(ER33S1uf4&Ir+PPO=M7kA32G^LDZ=?84a=soKO*|mfZ?4UB zY+cT|D2-7#9zW~0HI6Jz9^PQlyDe6(Rww@E#oB7;Ik5RR#&j?@K&_dgqvPPX75`Zc zbRGYN4LUYOPE>efgUiJJa&21LkviR=WB5L1+WhX)$!+(HI3l2yBU95|p7B#4R(N#9 zWY$Buv8B(yfmClr#M=#>r4H|UX0YZ{d5+Q61~!d1MnMM>Rm~Aj^~|kVs_CxkS)gNc zyT#_9*R!&@E}8+5MB6@H_1qqJARzoPJh7c5Q2>3}d7^<>n>!pF80Ax4E&=bM;&tZJ zTK{^*TL6c_xf1X4+jG*i>>#Bs&35?Ep^4VB&RTSg|IsOh*bE+MFjya6hdtQx=G?v` z-k!qTvzB>uN}K4N3pAt8U%L&j-D(UANr5(ZR}e~KJ4b+VejvQh+dOUERYyZZM1e%d z-W48eJW>qTB!#9?J)ul;bb)|1r3ZRI4Ie7_Wyb(*Y6wFqddi1k_M-x#Re71U95=ph z!qwFwkIq`Hrs!*b02OgCqRTV=!8$bmxIC3|?jOzSp%R(v+f&a*J-r7<(t4gbj^*oI zO#gm0v3XQ~B}TWZFyDO=#hOK>mu)*uiR)@vPHEUX6j5pC+G)%1Bd&SatU?uF%W)!W z(PZwgn0!B8ael3~Luv99tc&5=MFbA}4B)Ol9}l2q^6b-WTS*T2v_o2?ZSLw!sAbFJ z^ke7Ze7LA5!cZs(qM4ey36U>NqAi)0fqNSQRf!B7&Mvz%gOiPvDtC4@31@5WL8tSv zUnY7`F`f-P(!MoQp1Nex5o3|^Ty?YPSWzhb{QYHCdz0PLYx#U?6i`p$@0EgOOh0Ww zq|Rm@Pn!f00euW|mpxX1ew&ZhbskMjuD+H*pFRs5DsO5HJVh}Wpx;1ml=gjYPP~8r z6h(fm-H4EAD|fYRSub8sZ~s98SCL<%0Gwc9J_0O}hi)8T5C1Mi&7`Zl#zS2EmgFUS ztfy`FkU;9v&6O*eXQaWr6cSMdTMLUb|9&&VsKeqpfg6mEJ(TcNpsoc8X3|A|{BuL> zXx6iYU&8ys1Fsz3pL&Q+#bvViP>Rkj>XcXQ9Qm5%B|))_8-W0 zG;T!VQnO}EsK+^4J%l}%*OCQKc|RQwJ#YzSyn@)urhhYz8Pr{TN@j*Pt6*=eG&|sl zE@Atack6p^?hTubP?EJhQ>V?H22M>BL2-;^`pPx(Ft{zo99u~hQ6M;RWxc+d>y{>6 zFpZA>sf_}tspixoqxq)ujeTAty#Y(_NpoHswsGppCy(YTsEc09TV& zNui}5(k-%F`&Q`=J_R<9=&{*U-h|dUnVQVM&sKao)^oEwM|a=!4;1b|hmRcuOlWP) zC}%py_}Wh_<~kQ4%D*Z^)!1w&PVc`LJF#;-1tQIGbyY)esJv6lxs8Ee%Fm3Q=~+ubSFNncDN1u*CQKJV8S*B&UQo>xQGDG zON-4$mo7=#J8x)6>v0ho%jm?~oys@w+UT>0s`4EqYMu$#`pb`HSx6h&9X5x{BBDaN zsX9H2B-V$c&14}*aLni1)nzKURaxD;^@c~e3I7Q=W$a)p!D)?g=yL8WtVv_H8s+rWEHM;VpM~^{r}Cd*iVNIzxwD_WsyD3blA?gYr}%^8CeW*O zW2lS{W4av2mwyhCt6oRvE}YA!ERPhxdi0w1C9jlwN!11y2y?WLxx54^T zH$ijxhN?@3t81~T`v~5V*R@)g zsTYhXH|EXxYSZaMuHN-?`mx1hj*?c>7N_lU8h4K4{Bg$LbPil_PISI$X)7BJm!dis zn$q~!0|$i;-2!|zlAqgyg1nnRk7Kr%dtxJ9-A(H!V%x*Nz}>c6$5);WU3h#|kKPIM z-yAN^T6h|oYW)!_y|0(aU`jinwqw^#(*qZMBYi?KZsH#7m1UHE9{iJUd{VA7&DWV{ z_lDQdXn3wSqUmA*myj9C-G_LNJFb-8TV1hoA2zK_e)a2aPXEU3VNItz?|_lSo-Pql zw)H>ST`G;7U}qpcbaf5&csByZebG&qtLOICWUk~w`5e8Pu530Au21N~CyX-MT3jYi z@7a%r`mq*Facs(073Q?3P`PhRdaOi`a*oHaRv!Og>Mlq%bk_}g@6{CB=w?uK$H1S| zez`Ud>?y#CHMmVS;8>=JfO%A%bGtt1e0X80;w9JIBu;YTou}7zT0RB*bH%F2(b_tD z^vgf&m+0;fZT6qn6lS@q^q@O0e)l7Fyb>+sitTvHjUo@ceZfw^?a+C5nvYAwPq-Zb z>nzX?vDUObj#;@{&BUa5h)tgOpr~-}>dg?%n zSSY8S_ui-cyzGE3GgAV-x9-0ztPE5U|6XnI)^;h(nFbc$2=cl*H|RfhwT?JvZ{d9` zgbu}Cxy<_xwiHxuPr%k}&0r+stvt)9K6ajCTyd(D0O)BXB&w!bXTL7u?zMxrY77LL z$&Rz!+mh>@^xyt=mE5GtY_Ji%Qk!8p`M&u3cactEd>vNS&TQ}yO#)_MEZmGO8r7;H zDp7LfvfEv5KcBi5z_*wbwDkzgv~MMNMzn99Pp3QnObDX?^lYPSSG19}$=e%LG|$xd zfEBK9ew_1`jjinI$@#EkFS-)_qg@SG_$PzEXR$N1+boqR5BOxe(wSST%eO2t^cuYU z1&ra5;bygmL={wOM~RY9ppa4t_FYbi@; z@+bWII8O7UMl1XAg5a5vF0FdPNz{8$fdmS^uv8~RdasGTM*HKQ{+)s@~PIscR zPCqN8ok90L4SDPD)MX0&MsAL;m1g8c@lgNwUqz3oc|2PQ7B_O@q6 zDpFFZeKBb&ojp9b+fQo>l}^+uHm`&ZdH^YSKb~Pc9V)YcUs{PPVou$B-f=BV@jQLy zLjx6EH4`Z}5m>w5%EjUg8IGU2cor?Y7LhnH+cKtf_i0XYPsh^Wnfq=NUe5ID$&ZKf zdsW?A$HG34%p7s(3iDUuo(j-ZB}D$Y}xD*}nJNxRJ~|B-CnS^aS$DF7XSR?(ulNdlvklQ^|Qfqc0D7AUyG>}+D5SLE%bb6NA|N}eiiEKCOStH zHmv(=RbEox+L_!2YO&{%g%I?8tice^;9XFAqFsRU6^Ci{`JdQk(f7vjP|ByDSatx@ zQk3g8X%AedAOi`ag>7)YR>Y^bFfXAu6*c0;><yy^4ZUF{+K4DwH|=kqZSIw z$8MFnGX3<_hrUt3Ve;WPFbu+5X`bXxrml^$xbwag)p4}|;zoCgWt}>cr@RqMP5M5i z>2REVZn7d;tSciL;Z}pyn7?%Nva@4c#YD%Ho7Udeo_VwA&%(=F3rBxq{f25{!v1{> zl^Em4%Y$n#OjzmQ(XF(*;;v+%K0-9&GecZsggljX&a_cHgjgAZ@u{<3<^8KkoWdt~ zFQ|t8+&0+77k7Z4P;C3t&hQ6()2Z9n`$?hl zrMWM&o5t-e=JUPtfRFw_TA9`ba1?ABHr!UD(4%M|t~NW_q|_+Bm%a6Y+cdsLiAG$z ziIFC=Tncp4)hFrTsYZYmDEP1k$qf2d_JO&c!mg8be-(q2(Bwc0l-ADsf^tj8#oYan z+HfcOyvg{dTfnmr7}Y;Dtxr*N{o9acfnQQE~A$00j;L8dkNnqt)S|vvZZjJY?WrhZIW@b z-SntV?5wa$^MNbQf+vN}4&8~j#BMlc7;E2K?YMf)r9AQ>qD71*fi+h9hWGsL`|a4R zl=*V@GPzFT=k4RVid&iUv#`nZz|d85^$AX+ORr7@DuWx*7&}wXCZ22JJ=w`Z?;&}d ze6ObDtCgX@anU$_?(ku1M^wc11>Ns+f1-MfM4`U1JX9^%c2Tr=C}UPc1#qm&;n3|( z?y+orGjW+$58UI^u7q;VQ|Yz{TY7Z(X<~y1M{|nVP`DQ9wyX-osu!c(^XYuj_EuGO zKZOQ(+S2!nyO7tccReoaZJPO9FIwk`ZOJeumQT*=RwkiR@;Wo*zNX%WMCY>uMH%=e z%2$j2kE30m}#v`_!n0jmS*={gun^QkGf6Jw(Gte~kmG0|B)~J>j z`xbnTAKBHmRY78T_FH8O=Rs{MCg+VDu(6iOl(2li`BL59IcQ^|7pQ_p=El3;g>a$Z zS{u4QXlkkpm*RjVTOGNYXsODDnbmOd}c+Gs>CoN2WVjkiT2F6dvH3elvU(!xNTHsGgf7@;o4na-Y~P|=|n1- zSdmsWIjA=gf0P$V#BNN_H8O@QaTez`+Tmrj`UzQDi49LM`E+=G?b(--ZxsnC-?-rQ zUR_O$jYm~>&@5k>dv_asfCI6R#$p!$wCrNYBRf0HavN@Fj(|rpI|@p0-0N3JpU!*d zk>OWJYOUh0uQ>tbu@S; z&xbEt0f}mMu@%#~p3lp{28GT5<(XaIf0=${Njps4_S7j|H}2~m*hT6E-ItB**<1p0 zG}O-gUlg~Gy8@vCCfEU=GTO)gbRm@8oGtBNai@M4k@Bs!dlkWvDgY!C`E3kChV9Gt zGaJ`%<=-f!fVJSSE~w(3-P#h$WBjAw$p{K%5fl{$T{B`iFlnUnWlaZSgR`&N=Vj_( zWl%9vx_?7mMIw|l+AcsS1xEaeysn1%)!SMF7_T(D-rl5ieSQxD(K~-q_Fk;!ye4u4 zH{M-$vQ~sprMr@~=SLqlNnB(XFh0iuHs&D~`bl57v<%s8W2pxgcwPs1kJ1DDcU)V1 zN4eH5)iOyQwnu9v-B_M<=t*=~&9!^t6(DfvFl5QOHp;rDGJEUd!%NltraF)&@0`;e z_{#1A9Yg3emrq|`&0a*lk*pR$y% z*4J5Tm71Eu{X6R>7RTJcySI3rWs)|c>8fRKZhaI^o9?$Oj%Q@`{ERv+Gai!4>xTtC zS2p+1GA@y{R=T-&9U3k!pXPu%13SCG)v7uH&-W^k1~`OVZ;@WCcFg)y8^?IItpMcl z(wZx7Zh(Bfd7`J@pUAE_dl%RmYa86mshuv`=dG)HU~6R5FG94ZcC>xUOaL7ZgVQLl zmPI6mkgcxA!(Ow=)Z;Ngjylcp-J_lPQC4kwGQaO~`;zIBWk?3|GD)1Zv(vSX!Rcgb zR%m#7#%{DTNA|6e)aIVVKA+T5?1W7T6}`#MinF?N%wpG3e<}*Jn#gP84VRnC?K-R5 zC)3xGt9-0s#s+(QXX?9-%1-HnqFFBDgW2Llznd1<3NAKxuVwCLje&k-Y zvRi&8jlsxvo0>K*29A@7iiFlz&BJmbgZFp6&kkCCCrdRS9WO7RkK9xpMmdkt{<`Qj zEEi*;nwqZ1MrSRF)AJ=c`Kbf3f{E=S+g?!F{63S4#U1VriS&CZTg?tG#FK2s5=!js zQOmP$9)Z#z|M-vIj=#s*4hyphq+Ac*&W@qt&D63MrZpF{m7xDjUWXDl&y{NSb?dXa zB=1>c}v)O#HhRuuZXZzDe z8JQKLV!@2J*81fe*@&o^8g!TD?ha8Z-vN`~pdgt9aqZD@tdyu-`H@!ilW%*aim2{L z<|a|db7&5k^u;p8zVU1@uZ-{z+K7aPM{H%(M7ol8%*(oA4XZmtC6Uu*ih@}z4pi5c zA8&4FJjU~`R)*7c))cNq?X>d`z3cvvS-z;va7kl0R_ZXu2P|1a)LZ9lPCmt2w2obabZ&D%e(cTw>qGWhmth1?%T-#b}_P zaDb$L0J88$D606ef||hW$ao)g^|l@!8H)_lTY&3;m>MQ_IxMGfmrw;;SFkc zH@VGAu>xL@qR9_}Or}CiQ%OrtheUDnhgvGTly!8=3u=@(h4=fA_jrdK@S%#wx$y!Y z>Mj4#?##@%<3@)W_Ntp)17M|O*BVemN0X4jBqAe-#g<|0HQ(zkogQ@F84^M7vE;Lw zcW6HlS)cjUcF|uWr|l~sQp{SJg=XRWe%HZ@Lgvchisp8X`_!(KNw6>AYAG@O8WnNK zQc5~3z1rw!@QxAgk^j&qiWiz>*Fo`y*j(CHZ4{H<5dRgXa@80@W?Uojv)&;wJF&Qb z#3dRu6ynTo#F&Va#k8yQY&(1y_Dv@X_|bH?d!J*8)O&F`3fI*QH;Ub1kGlA%i=8?b zTaX3ey^UCHKfP+M!g&bi5ey9Xk@a5d{ty@TWSd9_q3X7%VzuakqxlDKleoZ}Pq82p zKG+UQO%Y+?-Ob)Gu@@Nm$tik@2_1TS2qPc&p9_>=ENN)i~J-r`*UU!phZ?i5y*Iz9={S-vmh&0=FCS8h6h?Mj*|6p=+{MLDqpU1ccNTbE z8}GBv)8=)*2qzzJD|CQiVcoA*YNf0)R~97Kqvb#9?uV(E*%QH zUq-R*zxcVnUrn2Vsu8#%b#uH}wh_d!=1Q-Kg2_cPI<9i-q@SDr_83L_Rip%t1A zH*!zz-0vxX()5XrE#0xHs~tRDT(=>QhYS)mvRWNv)|b)pkou2 zXXRNbTRn#^sshQowv*o6_F<&`yW4fMT1``%Czatj#8bTqW7EDyJ~^t(a|f?g&-rYN z^2Gfh(EY{X$K&PAOz2;rJQCI^((T!U9XR)s-SN}2S;orfc_Ss>-8i*q!al-yA-NEl z*wqy%nmkQateEu`I()qCF*mcTW2^xuh=aH~VQIINJi2B=q=PBfh2M0qt*2s>;+01) zcZ7OsYqa1eOJhebM%~3@64CIv`jy86Mak=p7Q*4eW$JF{w!(J>_eLvMG2K4baF#!4 zM-=tv*TwkmxtZ6l@a*tRnMqUH5PXFsSxQ+0(B}LQ>HMg`%{C)P(@fU!;%n@9 z^_p5{(=NQB>7w%?=WMf)dt1uOPR-QT;gF95*xSxk!Vay+_UmhOR{*u?W* zdj6~R%_go+q*=kR9^-T-IEZn#X3_yv6^piW)oqouYF=Y@?1%}BXJS{POX!+|l6G2@ zTnZjcS!8XxA7$V^@?y zbxf9_4Xe&7q$D29|c6trn- z_VbRL3}b<(IBpqwT1{UmQ)*8~k`Jal-XdyCpgN(OY0Y(QBbjCs6P^`vHZ`=wD`^2j z1Sif2Rb)d9EAE$EN61P(3T6bR4T$mr}NTG8INi$rgx7gnx1OYYD%3g%N&!iP$DV z@r;-7#VCsZ+&LOlfqWUr7_h%1b@FwE@;CGbn{|yS%2dmo$M_NA)w`kL^yvxZEh(y7S^!9-e{3 zy1t8>%XgEOZ#A@KrJ+hiG;W*0)01$y6`{e&V=dORS_#3%nTxefZa0(?zCx)RGlgUF zMQ{)#WSsm}I9lbXf8_2Mvj&QMT+O~r)^fbomRzg8r{e0wb(IdUWA%8`O9{cSB>pozaT*F0 ztw-DZeJQ*yquIl4^!^XMjSD<4uk4Ug!7ieL zT}ru3kF^MJEsrQy7J2*p{y~ZceOccK-pavw%xze-XZ$(+(Qtjb8>w;H<`t=Q;xDvl zn{>#GS@sM6hJPLSI&--2oL*0#FtwrV@sNE_iWz;Xcw0c9;o&P@LGa`u|Ep@^39Xv!2!x==W(z&VMw4^UT z)@Pga`=5%5Ww6ng;xw#cbnzqtwp~{&Qq^5F1^*i8!qM2HNM>+3>ORp<7tCya!YBiDS zG%~xeH>{&>M+0)>9i+a7Y=x0}b0`0JO`$p0JK_J5f|a5fw_Sf72&p7GePh1M~| zEL!Y3EZQrK067->QPoWy3unai5E7e;e<9;k7iGVFX8NMtB8q5JaE=L5$Ps(n^z7|l z_d8-EM>`4yL$Z9l?!6zM#@y(Bz5!@JFMF}zKf3S~XZx(0nK$Q{L{RVdE~ikmZ_Kzd z#{miW#*K49qdP~DX6J4XpN;*$=umHANGD@T={#On0c44OF>1t7Gkn8Idku#Y$Eq$J z(x^~`%fS<`H`Tjt2K>chR}0$#!%n#3cH_Zl8^OFN%!CXuo$g&lj>_mi8Xf^?Gmn^7 zYG3WG=W`eaywSr8X%TdG%Zw$F&;^gNbzrS7{eGpFA!Pmkb})yfQ2icaYb}9Rmzp}?Yn1WP#9h*`O zH52$B#?Bc`6c`JmW81cE+qP}nwr$(CjW@Ra#&{cjAe-UWewNxemMM8Hsb4YIJ};Jho4PR-kg!Evy3V7AUT~~45meA-xe?53otUW z91--gQ}+_z5Gi92_PK$=ZFGYrhcu`PKTE<)b@4SvyhV|Cu$fWx12oS*Tz*2*j#%L2 z`nLj~dQc7Buqx<-(c+pEtN@p#uPR0O+*5;iI)9$pO)M=y2@62Uh~Zfj!Z?xQSU4$z zUZDFOk4AQOV!E5OFAGC(k0>WJMx>yiXgs+gihS`AnUEs-AFJ!}G^qJbz7%&xK_dwi{Kn7WIY~`4}@_l zmgANN1Qz_^wsy!vFX6kV-cL^w?)4r9EO!Cm+l3brae0q(U_F_F<&hYiq1!#oS&DV70|v4*<{~%r|(t z01c-~*OdB7gMbP`x&D>@I=yf7h@wqWeWp8Y36vj6YN2;2TV3Qen^vC7_E=QlpMUhQ zXU)dNP|)4!Nf++lnlSaTIKjZ8ENM1uyy3c+i6E&7d4!;0OproTETFJKCUwaT`^w!d zPLro%`SdK!M=d`Zvk9OuPv8T0JNw1F;8BuoJpr-{-^!zv&j;AI@G}A60se3%z_mwj zBH>?Zg7|DF@GG~GI#kuZuRB-X=yUCXB?-z?YLnK()R?&vKCM#%O)!!vxNjzjR0B&a zpTy_rK97_Dy%Uzk6>N1XBk zUDCvw;yAt6=5aWadI)&5B*EYNePkQnt+QzZMZ~&YXzLO;FN;`3oD!qhV;DU`wF>I-=FKuQ}-^LI~#T|CkClR4KK$qwK7+ zaCVwjEPL*E23S?YrluvTng3k%&1E=Qv%_r*Z{nm38DSoZ=d#D!umO!NfHiO>>Wz0l zNkrVH+b{AiuWl7{@yFIhVV4SCEQ$1a`h8COniEjhu@7h~Wq_GEAt-uacr_sv7x1>; z;R$Hom_FA&2LYd_bBcP-UO*HRAPkYEI>56PVOzyYosWLr+lm-6P18{qT_(LHL1BAY*QlCqFN<`K|2;vA$Y6?pnLTE!hf#NtEmu)E zSsGfbQ5-EnIBblvsEk-;XjT;vTq@y2u9mjOj;*-^Sdf~U8zdE|#ts20B4;Ju#+>&< z^MEIMij!n24JLpMGEsM%xDg-LGtbPp6E!K?PD>ARb%6+iurP3m6vK^Lu@>$^XP>qb*5)(Seq6X&fM8w z9MW~`k7M00ya?qF#O|X&OVh=( znf7(sN_fCh(i6V%kS4@x8Vja?-8j^hT-tva!v+o@4CXOOxFrwPp~e-4dtY}N*FI*l zAqQ!ymaR9Q)HHd2xw@D+dYI{cd{wvqn;*L?_g6Q+-zy${?w8r~_u|Xw>!w`NxNQip zVBWl3rn6VFNnPC2d)n-Xq)AS@Z>)QucAci-R0x0onu;{jvS2Z0FR*~apsylzZJv^} zssC$CkopuWJL3wkR(OC3ghqH^k%m~RFz1QBzcB0h|Cs>FAWZ96qAXlo&MX!{tKpkYZ z!{Jp3t8M5jR-{f)A##j}t(=-Ae$BJqTe0JWmb1!ZTnwlRV=e^o!0b5?3;~m z*R3?V+C>io(5&`lDuNuf7C% z6G;1r7L}+~!pu6OlcvXQ`EyGv>+YOJ^Zw0ef~g%R4bIcpNVe8L@J+M})eZf~zc_x@ zLali?N_E1Mt`2F~A|~tE7$BzW*%su~!ixJ1s1FovLS13X>!4l`?(sDycm0I1K{XkNqjVX**}lg#S!tWZb{74DJInu z_D*!@3)cS2Zh~7GqmuV^y_;3-s$IN<5hvhPepA>Y&bGpz;<^yuF|sbOv@4TvL>|_C zw;syVg>I}-`E$KhDpb}JMNblpJU;$2>ZH1H6-;Jpug#~-h2QO(`Hf|4%D&!0WHoJv zPV;MqAFImDsA%_x+tEWA^_VUDHqp|COOr*h9M9BZ)@s7+3*=F5k{PYv25 zV7iB!n~UL9*ytu2cA9oK`0}!ija*h-uHl4yNN|^RPj*oOyA!cd1HA3 zb9LhE!vZKhw!DAYI|FbVO?0_kFd%CwJ6Vl1V1$`m3AzXm*xT9}ZB(b@TgQFXM|dC! zXc419MbP+Fi+$Pjm|ow=JKWWh1~&Xcj9mT^OQcr8FjFMy(pwI7>~LR_Tr~}WhO8i6 z2rNQ_!Zk5JfBS)CHi(%OwFC>RRbaIF^4<=aMpvz!umagT3c}yz$oQrhUjVV$*E`0!x5RXI!90E{a3rZYcoQ=H2C^(Xcm%VRH zMwd4P5ASI#?IXDMHC=o8D+fztW-iRRI)pvj?Uu6MAUI}R&8>2R(M*wGtI0Aq690VJ zBMV&(*k}P=ionm4C^kTKeN2oW_{_xc&$H!LZA0v}iEI8GcdH{pR7-i*(_3xH0o+YN zVu=9!!YRfxfwZpadEddS-~m|VXAgEnqipaIY|?9{#NW_8=v-QX zec%a8LUz?uiXAU6Im1<<*i^%MwFhFE$Dqh5>@&oFcf&1PXWy$_Gf@NK><=4OUL2sCG%L0ThJDX%J&BwOKs ziboeL2l^OBxS)2PFiBw~(Mxw5(s8HEb1d>~m?QbZm|9a8d7qD0%X_8XnBk|z44xgr z2}=&)F^Dn_+3bwioi;QxR+#A{kW7$3EPmba%_0Y06^B_D zKlbNQ9LgE$6Pyf&^1qOhC@;7g6tT^j3ba4eC+l%fb+AxWM>eqLoa1K-*Iu=lC^eBg z_?7gSH2W1NC<-?&hB0f}lq*AD-DtU5U#g>)pCW{95K~2tM%vfg7~19_Fx-)t_R|}D zuUCh~(SF&BoSJ2v->`%($7XW-zTD+<*mP+*ftx-vz*w=P7O6VA*YCJr0Cbrx?&(}e zHde~X{WjofcKJh9gezzg{i_y&E@Pdm+L*Q*m2rtcNXah#uWr|7c2nw&`H_-RQ?|t_ z@=ZU;O@yM;+_!D2irtngPgo1-eRbxdw(#Vz&GoP2)0e6Of$@IA)Z+?e7@FDP@l(%3{=3=Ok4kif)%VNg)DApS&FovbErMtwbz*^i9eT3%YL zctalyos=zrQnuRu24fWR97fbsv63W$2RnA$m8+S~n4 zzreK*xW+%fz+GN4SRpc{lJKnqQWwx7XeCq-5ENku5orbpC?Mz+sCPZVOWk@my7z7G zYnVZ|(eLXOBm(NLcmJ*b?yukOsVo=^003@Z|39|?cY)r| zUcEl*U9DZ0GOmpppJ^LzG><7-elGDbn$#anBtbrP3JMB@sg84^x{`{3Y~=yixX8nk zXl9XFD=Qo6&X{!s03t@LyB{2kHL6#-ff*GBRDd@G#Ucx6Z=r$ETb2;3A||;FSb=jAXCRrK)F@Iy3O}%Zlr3Goo z14F2eW*HTl;5kwr&;GZR9sWoO=QIgYA%b?;O^A%U>lfmD{;yja#N)`&lv)cT2~AzU zedw=^>8QMAW*AmO0BLamJuQHOFJyh1bfi!9`c_HnH88vg`L7I{nHVPi2iwWfPFd_V zkJGgCoCfJ#rk>-~0`)vl!S74-crQl7ATB>IkC;&n^yGNcI(+r-&bE&nx8IeEZm%dk z2e%A07<~@vtL~AG4o&-BTlMN{TzG?Rr1=pra}emZotoS9{_SU1`Z3!y_IeZ?|KWCy zk9$3@=vy_)rJp{qhGT#MH>E@a02C?i!H0yx1_}4Yi>KI$0AY%iz!s>akh2aI^n;fG zVS@nJPXJ4;&An_mA1tP8bT<-ssGx{o6?mc!6?|53DiAoL<3j;wm9l8=95M6ttl=VB7uK?GXIQSLWktzcJLuEh!N03PEdv+W&~)r=%TjR~$q}$14W8tT zu_h`ABR`@jVoEmGN43|eqMQj4#?=&Dlu_}@PAU^>K008>hDPR#dRT)t(bQNNr1_%C z2>dAaxuncaX*%PYM3ND4OD?vMPAVQHH1Ij2r07kxTpL}`EcuI7f<;Gf$Sw?8bV){F_Pz$Rw$bVU z!F6A1(MYmt4(1(gN7-@LF=e6!87~Xk6w>fhN@dHb?v=ud2#<`7;;!+u%?3#N;krkrg1vjyc7LGjezy!;)2-BMzGoIV99 zBdaWo8_<|IEr2I8@JhZ`QF%e=RmFj80t?83v=E|*kJy|G;7Ng6b}bXD6DG_Kj!m%1 zYIAJkJ~Pk+3YK{xfIzf2)0@L&Z2Ggw}i&0UnFH2ON1;-+nLBH)#vKe(xAPi7QS-h#`#wkgX>krhcz-+R;CZ-gaN0} zTS(>}bv;!&Ud5~ns5HW(e`CprtC;SRI-aHfD9@tA?)>kFlV!bmbZ&WG>v9F7A8x9&m@|P z@iWK#r56X1V@OxYEjSaVD$!H#)T2`x{LY1H?`K{&tB5}-Df*LtqMo{ZOt)q#_Pl^o z$?};i72jXH2vpfZqWYqkqtB|8U#^o6S~`bx{_n$)uf9J=|1ke#4T`c|Y#vNddoiJp zf2N+xGP->mjd~Kz+RD$i;=NTgP4j!UiO%2L?^&N`adq^nMHbDz3B*u+ltLYxZqs|3ZX6gX3W zlfnXxh!-v;FUD=gDJr7GglI++%2@tlmB`gS`O-~c{#yQG_D8ZEt5RFH&KrP|ilI)N zK+J3;1wL5NZZ@QudVlf}jN;=|a2-fn0|t};817AU+ys$4`3S{CQWB27!vcE3x78g- z!%!r*pQh^-F8q^W9nO&*!-N*-@y~hfJJz;8^0Px*6IUjxW+#wtN^| zlPf?h2%!r9LZi66oVns-{A~M$1e5k(XtE06M?xJ?LTsC`#q~XobwER6D*r$Q+;u~o z4sCJ6$3V7-F^L~38-`I3al|jULb`@O+=pEO0SS;9E$IkZi&TW>=pcs(G$IaUL6?X; zF?+xuj$Dwih))6xv3SDfL6}ceT_`mr$*X#$_TedL5Uqi9!8Gy$4S|AMrc)%|iE!n~ zkdqlCrZgd72EfTJKKNC<(N@`tn%SZ+3yGpiLz*Q1j6unWI-^xVN%oBrv*b0`E^G{n zn{w=ckEv2AbOAFC$xMLohVNih%!1^{?+J^VnKbe0bw$_#T&9a{y^|$w(yB^w=&DL< zR;o&Vz##&B!X$s@FC0RNX9YA!d2SRmLF3F6kWB)mI@A{eI12{5z$AD;7@DX($ikD}bRZ0re1G!3^FzQH>g^NX`Jed2`X2TntEkf!%!y%*BiW z-3gE(u5F;9UI@G~NiQxtV8enW;1I?HWZ9fF>+Bd~pTQu$>m{J3wbZHOW1iWN7I zU)J0p_B$Sk+rv<(;|1Ge{Vk=ZU%hHBpK_eM(#_igQ8gLJiY&!-+)>hq>$G<4;CJEKWLpiE7=0RNsO+fc@Z$Ql zuwww+dFeRX0WiUDPg@O629T}ebtoGY2C(q02FU>w9oyj(0s7X~BAX2uM(c*bD%DRV zj$gi26gNPlS%YSr?)Vj8zWMgT2D6CHAVjv>wCg~{FI{Xm2#)}VEww9@J0Misb<=s! zmT^WlKlrymm~J&2_@}mL+jT+&fU7I*Mr8tsl2*fXLzZ5v-OX2ThI9$%f`+;`<$2)k z6ywA3Go`YEUm>C}CWTl3kz7$@C^vnx|j0)YNTo+KlkQ8^~@Gs!TFR2uB!+VW#^Lw}D zRMzf$+Tea3>v{&}l~}e4R?6|Tipy1(`3F`Y7hztw7aqMTlSRLTb5))7O0q^sl3QeLF{8!ybg zsCxoEZhp&pF3KO`o$S7{Nhmgl%@Xe_gK$_)!8pLA1_WZ_REapy1}PzC1sl)?Qz7g` z9KeIX5qQG(I6>+OJ>Z2*uUJE{*2M+9ki!xcFa?<#auxzC4N1&7YIuWO!|qU4AyZ=s zzK|cm{Fxkha8CC59P(8R*$mPOm_z;s%&8312Er!?y9c#`HQ-FJjHCjRcG53Fxr2nt zu=kK>j64nRBuwWSU^nC61Wyj`F*HNm!g#6)r#`ux`Pk!Up57Rmr2&WgDJtq3y(TpunY#-pT)7k1zZ z`OCnTkPw&XfK!y<;)F9f?*Rvbv$FJrD6uK9SMU+R2bfwud=J9VPcl{C=%C6zip1$p zdV~*QR$0cpTCh12;ml6uAL5%iHlH-N$s8kIR)fKoB=;31+8*o`^s zuyzY`9!7vA1f2j}2plB1hnsA}3OYE0;08KI7$eL8v_eLl0nH~!0m?xQV2MKXJ}d}g z%UBGic!97TZvY(RjyMOb0*0YkW@wTbJ&9Iv6+bChkrOs4q*5nvykDUcJn34|gP)46 z@J>g?FJKzrJ`%qGz=xOWZm57B=Rz0-O7&Ungg{kZ*o2Tutr3g2>&xs5>@MWdeB1~3&x|?2Vk%_b!lLobB3NAd42IjGe5!}qv3#nB+rfOShuYD6tcTgbbIB%NZs(Ih z|BR!tMpOrZW8kh2Q#519hutd8r?bHvlp65ZVi_!+4nFYAHLB!LI>*hWMSx)5p7R&_r2s*iOeaPZfiM}e zAq3KpMCYUw0Yy?!gI}a69FhYnu`m+!QZOSM9Zbtmwn$RYQ6&VzR8W@(Wa(7#(V0g; z{JSzmLcF;5PoQ&>N05{_C-ou6YY3AD`79VTlCwbc|?eF+H)PSm3oa(WVV#_3ZJLo$S z)es4;*2@MtgJ^;papcZ(28o`FYH9|#jL<2uaA+PmrTp-uACU~~r?rfbMg??jN~e%h zh>==$b9f4~csAuc<@DfW4xzM(*10Y2LdFlAo+cco=VeI+6mUr6^WQEn69h77rywd2 z&{0gFqe~hxOrx2DL_dgV0%b;kYjH2=st^PU4i!~~bVk!)3vP>P=m`F0kh!6)9l9L}*AJo(163BoKGK8TZFj|#Q zmIc*_2LQ&P60N`&_4E+1S{I8HG=w!Fk6N(~1AA`?U$;ymS?M5cYk$Opnm8EV!mg1* zX|YAWx1Ee+q>x^SKSV(sjRtF%9eP&O(}NEV9Y@%ts#kVZz}C8lgTY_wz-?)bK$|v# zii#FR$|Op4{B`6L303$R8Qs*h2{p|v8$m_z#2gLJ_Y(~lDyrFo zyRZEz9HgjL#MDsFq;Oq!e~nDcn-mpPM0&jJB+_v?#K$bBjv@G6896ab#nG5@rzxTVq^XW{vr_B1gb7 zurre6q_$i}VM$3~1{4NbTDAh~YQ+dDgBG;bmINqUZc++ZzLu6FP+M+~KP6C7R4U3E zi;Gsu2PQJgN=jhkbgs7KXjY@j>HL-{7roQ(`x|F{rFc4Sw48GvBUG_2 z`>J@oKU@cZ<#bC_35l-J0e>vg+4_g1$b@o<=Znxg)k8jr*ng5Scf=D1|A za*Wib?ek4}Zl&%DsvdVO#alPbAx2Cg{Ue3o+8A#q~)cU@6mlDm05d0G5EV}YB0 zXko`L!6BVHKfcO4M@w<>!{*g9VkvJ$$>mk=v+S9O$2@5wSZP~YGO{oNm`{StYdRF2 z*+670moQdhss_f81OlI;v9TK|IZy2YT}N4wp%3o|&xV3~a!_%A`zA_7kB+8PY^a9y zmFY5qwy7O5wNRTSI9KU1j!7UZp)+VRY5ADN)Q1w8Q!pxWlZpq0!R!Mp|Jy+W zvW^~EYI<-56JoM#u_zM&i!CJzL}F0Ex>S=vEU87cO9iN^^r-@17-l0z#1)Aj0iZP} z1Ndc%pv1H^wGlCi;uM_WOevQ#wGqmS!MM>7V1RBhB)WYWrGK-uGLT+5Y9pMstQ>#< zs|}DiV=S@(Wssvr!&%Z=xh*V=I1hTk!_u+5vmzBqOy~rdI0We4`05HWJkAx@R6iotzlwemp3>teX~Rl@m-ytlEmqFu_8Eyd@;-7L?Dpc5__UR_(*Tb1Q=3}Y6n18s?3$)OzAGT zi{L8zIeq05y@4a7=zb$GZq?3~-OUN)R^8c7mbQ88qq{f3Vm3|qDGsDNlHEgEwoS!0O~k2N-v!%pb=!5i9lF&H+)4?!loUxh8nse2%+L4yUHKO=TT1$N2^v7kzAgn0Cr*W=IxZ6g$5JA9E^HDh`!E53 zU@lxXfB{@!DW0<-%yYw2nE(R#z&0sG;!umCo>DyQL$P-*VR4pmfT${n6oIFmHnbi@ zXpkjEC`W%Nd75hBOcKfemJB|5NFr{ZT`?HEx5M=X1lkd6Vho7RGmy&sWCLjw_{ACo z6)vpGhDZYOptT+MA6c3;q#>@X>5 zjh)!D(oI`@-^}wrQ(bN7<*k2cr^4x>^7@yR2&qHOPDLXfjo0gl61ntB_w{K5-oW## zzr*)4l*s(1=X)tkrJM!G^^NbwJxK;fh78@B)0`i%&mkGqr9l}&oPkR36M%^b^WY3A zJYCZQyv%3!0eT_;7>I5)XY0UGBK=NG8vIEOaOzjcfIb=gqQ^0d%w$j(=~Arr(2zFE zU&LpUzi18Q3zA_jkYySdJ;~CtV5!vErPmqfPi~#9MzytAo5F}hw1o9>c$bgWH z4@wGAsKZF;v?W^}6x~J|rxjCc)g}g3Q&6kEF-ZA_N|X)dU;nC>F<&3Hkw6sm#C+gO zU;#WD54AVvxEM*04;c+e3h9dj{~T1C&kS&~stlsTvymQPhxY)WS0TG@3APxS|&L@!h#RKP*Xq*nOE`gUrc++n&mEQjKTmOq#uW`}5fc2N(cKp}>8=3wI zTO9{nM3tSjtm(U=K@oqM0ZmW&_%*iT;WNY-Lq1f&j0tDivI7tpAyK9c7`fP3HIGBA z{+`$ef)_LjtWaiH0M?gL4-kSm)a^+Qb_f1%oCjtPxcrg~`b#bb%ll$wJF6;}st9Ut zU`0`FUEw}PoU=|LXI;FF*h=MVL%jf67t(c@A&kY4feB(Qd+x-b_t-s02wEhC<9Z~J zC7TSq=>bq4S)m+~CXO1tqF7%CL9n?HMj{GZ`5{T3xmZThGt0l+udmO)V?`-PHco#u z3I>Wm=4HjBK9qVpK@LIRXN@GX0};=bQc?38uTdsek?>4~>G2YHX&_uXOdCh3-zJde~ZIhD^(SubsU%yh={8Fg(`=aK!|2+u)( z1FN3%ef;7nq-Nh;NLx&dRcDTclL&Xy^^u_0RNC6gq*t9sY6)KAm5T^US9Wbi#^c9v zBXWTG`+!-8N_*A=5O!wUdpNiHdq^*g{KWwWkI*u2MntCYZFrp#CsDni8%6Zq5TtR%H{$b(Tw57LaA71ua#nU0X zIuSloTfrrA7iuoewpQIU6s-yShduhXaU|Y| z2DO|4@%M357(AX1Vo;)q{sbCgj*?zA7uBF0s-&`~rJ#~Ty&!*ohQOB|%Zjx)T+`^T z7p%Ucl5EQ_8V1BM+FSqvusbVtyNuVwtS+iNqN^_ACIWH39@HSRKICTy&S@- zL~mXDD{CEWhmPs_rWohsZ&D+ibi*1RwnEK z2`tt}ah5V0O6Uqij%&zCB+PYnT^+uo$fWg5w;$* zGo0mWSFd?eda<6ruPe6Qu!H1SWoFkP<*Z~@thvM09{Wq?^k#TLVMwXNzxp6doZQ#!SN@n8d3Exd)2h~uv|BS2xNR>h(Sp`Chh46n`}%tP3(t;5 z?WMe~+Xv}+8$5od?WlRLIY!t!uEp6!VcUB!Sj~fto%WNH=&yC_sJtvVmdv-d(Mv-B z@ZhMwbKc!I+lfjnvhC`B9M^>Nu>ba9bRGBx$VDZMuTM8`IF@%torukV2G5B9!#r#l za(E7ZcG(~9R?f!OdHToLy7{jFPZ$4-6juSJw!BjB*vrZ5+;JWhd9A?KOK$Gs>EIDz zCp*%A7o;|ScY%JCU65)2YS?#b^18j+7F$y8Pf4}e^g4bR8&=Y?8FlyWWcpHL#(2B4 zf{FR+W*aeX-;5**^TzSDVmcb0?GvP81~f8?vD_(G8%PBcCoL`rl~RgS_W`Gqc8cld z&s4qf4Vm1Y#UuF*U>A{V){2JT8%a_iem#B(z!NHhjr~nMy}7>G``6Y;vdHTx7X+g& zPtG1Vup+q!s3;%rLbyNc?&^$e@`V5(Z^6s!=htk9f0a?*TwQk)H{NNZOcV$ezz6~p z$jSf`2lY-5DsVP6pInGsj^t2($axQm7bs+qBm@ydW`Ljq5$NYn5Aq}Sugu^v)~#ev zpL?d|X*sx$j^C{V6Q`v0R`r_;II$%)yZ7i0KdHyj>DDJT+%STyCw`r?|E+m_)9ZQr zp=pJo7Qb+=jY zx|O+NeI022yl8qFTJE*|>ix#{arwI0-R&T^=C{4o+r3hoeKq$;)pRYdkD2xR_ML$A z%Uf2S7p9}--k-nwSwtMq9BN5UKZDEIwVCubf8?fS(Zk449q#p~kM2TN+uTL-=6T+# zYO#qilfl;bD(v1467_Z+NZlGZrS{$r&bgApt0A>qD?aySlo9x{MmiXH?o#F?7E0u} z&2yg<5l%(NqW|IO1u5FlApkiwIg=P=Tx2_dNV82NiI`e&5Qfa4j)yP*^m;OUFos_I zo#aD)bfZ7YAe+QjnF|^7Gv>6+u`|#aY~=VIQx7el=l;X*F&bJ`leLEMTulB5Zxj(NX4QmQ|_i)(bd_D(p<5CMN{{iN;_V8=2Pt|HP zCle`G;pA%G;4YdYso2|5kMhSQ!Y;XW%0PZ$EA$+xd_$Z!mx*dTd!adxZx5OsUQUyW zz2P%ttt2EL_$o#DB3+AE!;gbV5(F$0lLNyQcdp?4o-m=8D~9B_foY9kxiCDAs0DNC zaXA8R%&b6=;m4NPuq37a+Mus3TlTeD&m;FiOiO^&bNgviL6G|{=bhO73m_0mVPBh*MI{1n@*zRuDUX$}+M{ilG#al6VZ zQ=E-1d~4^)Qdff^%5v~tIlH=VCZU@~n~NdcTVtXmeVK?Hzt3A`>hNNjUGFyX8Cy8! zjEjDfsS7QiOPZthH{$Iw6}&$w%`Q?;io=h|B+OUfCv(gej8<{oIj)Oe-ck3JBgil7 zHdKgYAoMq$7l+MVe30!Y`-FpZmA7^E-5MkGZ%rm(r~A=4vo_Z{;}7YqGtpGaNoeOMhGK2F2=GTww(IwQnZO%FXc= z{aBTJg=G4;$T!=k>1_Irwzql?!S&EqN#$f|^7V9$F~p=l9LngTX|*pF&W?)QpBn!t zf984=%d4%7>19{xx{8ur9NJm_o%JB+!}Yok`rDio{4|5k$NiTPx7`8ulX+~^|9Uw7 zRSgb$XGH3fPUw8Hsi^30P2n> zowGe3#+f%LjO?x7%~OW))-!*lbQS#ad)?SKxX)ZB`(xh;)XYp?qf|P!Pb3u?^yqEb z>RWBL?6)Fiu|JU?a$X2FAaPqawIErs51!DzB6iX5w&QPo(QDCWPprFLh-@qUlGtqE0P(jr2XU%TPHsn4B&AhesU$^I#zVlu*y35fCRo=tO=hYxclwoZma#ctGI=s6vHojmnm3lGhnkOav*xh2oYNlF zO|HDtbMH z{61bpzC>8kk-1M-5q>`-yH{T`tzG6Yuv^X4@3ZgC_1#AFc6PZVXE?NQ-TFD@PSvI_ zD&g~0;5$?t_wJwAWzrK{%$2WbXQ26i-;WLNam-ucYd%A}pNr9DrcI^IZ0eu$@{e6A z%0C{TQtY~#$DF%&%rWoy^NyY|{ye%SRN(mPoqhU}WILb2w;32cre1r|7mdMlAKlFN z+wDg098(3Bq92l&)khq5M~PBSWZ-otf4pDjn)SbKByN=doj9HtODvXqk@4s%aPazz zbvqvIpLV5P%1^RWXL--V&3$bLLA2G?*MRDgX8mT!VgiG{jS>Wa$Tns%kGYiJ+?9q0qyDm8v zt^SUhxcXw4Rw+4$oRzkd*SzO}exE0Wjj4ROLeT8{SOvHK$9{)nz}@DWVDKbJYqrU^ zx{KX9x-Zn$13pf3O6$#pv^W&D$xKMj9!hog3Y z)P==HhL@pkIqzw$D%@D4yz``+d$fjeyF)Osv3Y>O^E^A^wjy)(#r=DILvT12Qr)!q zeK3riecUY~>(P$O&gB}5*0NXa(Ju2gVsVQv$#3&x4)ql9^Be|lA8W_n_p_)qTRz>F zSKK|LNF!|uFAYvZRzdr2hb0zxQ&jFu+ z@e4%*p~L6N`7pUUOge|teUJR0&Wq|i+rv3RU^Uu0?Gydt%dhIdhh?t)Xq+bR*>jNA zxbjCJ7I%NiWt~5^m3pN+?^k|6>-97AuDv~Nlr--X3(u41eD&jJ=COVLSUatB{p3@D z3eraz!7Y32q?%zbIq!n{#A|(@*TMT6-ZBmMAofZry^?i!jo{309&Fj~EwtZo-M5%C zuY$9Z$9CfTS~KffH>=LZI>on;1Z(?EF8UZ}55LN)y4!i7Kh`|ND{`+^PI&gcO#f@#-TfNlrRhz3KC>ot&RjIf)Zz=d#Hg2A3SM&W|7J0@ z2$Uo<5#Po#PAG$o8Ww5cf(?{#SxK9_rQF@+toJf)weT}3&TMbZ zfUH&5c?VN^kz97AxU{K?tF2thhI+D-#c*q<*g?*Q(Ic%k$5k%2MGZb~OtMXe8~x$nl_wAJ9? z+FHwH&FyUWie=6#ZoW6^f}M7{xG$pWl_#~MUY4atesb7tEkBzvaY9C$=Xq;Kw7*2} z`?t`~Saq&zr_=2@**iIHq>Y|j;DzjX4$Kc z&*^ExGkF{D#U4%^3!RS2dK@n2Y)Qj%{xT5Xzw1`vd+iZVti*!1XPaS>BwkFy9bY>z zm0rX9rniN2qhNW&g~#9i`wy*dz3F_PhDAS(-Q%MKsSKfKyUQIfpXZOz7E$CJ=8D(um^BUZ#}7JP9PjoUoDV%b(M~SC z6H*tXPVV;h4pYuzC{JQCwf-61`1qb@R8J&6o%RqE6W$0Dol5QE;}gqnQvZPmBH!U_ zevWGfW;Apu#pA!HKIsl;Du`T2Ir4s}l6|1i#ZGoaFt4?Iuker3AU*q7e^tUDPsy`M z2=ZR}N-UBCtz_0@HtVYPdCYXSo^PGbbhlk2)ePl;o3~y2dD5-lIj^Yivj?wgm#&K1 z>jQ?}Yl(-O&kxcL@a*7c{7cO}H$FDg!##etG*nXZ&ds^rktcrBS$FI+iPPbFM${8= zBX;_MzOc|x?X8}Ih9nIjz#A?3&q2njE?s} zcT^Y2Q|4B{W&x!zoDJzFYTad6|X(!+jL$ z8aZ36R95Rz??0@1;=$9(VUD$t%}NVD9v5pVcdYOHVaDBLEj)4f)BAroyN4K2qAm~M zZQHhO+wOjC+qP}n)@xg@ZQHhObNWkWGqagw_LW-PN~O*{_tfv7$@6Y<9I&QWq4$K@ z;J(LsFkioiEX()7YK`@BuCKZ}Ul^k&e?nVX+qOaJ5Zy|1>9QJ}UQSl|K*Ox;W~>S&P!Aas0wwG%D;?jowq9fbzJ7A_wZu{{%6^opUuigJEoIA;1 ztY|M3NMqquaVv5?7uC65K$%MIR;Nby$;xaiE|_VSlcz488q?4E*=TVEH_9Q6Z<*=V zpp5a#Pac*}b(%lWv5-tzjE_-IaUVzv6`>)?+u7rWS0m-b08W(d=!(LYIRFmIglGSE&se@wDqW~H?wg%QLnY4d)-wRobadqYrKX~ zYZ8uHBU#lplfRGrsB!$O^#eTjYEdGFv_f4toJ!2|LMQtD@WGrq|Em*KIrc3sSd&js zp?>N5COdq?4HR!r()|w7&F*}87`T8ZP~_)MrxNPNg}-;~3n1(RP}`|8i(ir@CVNGf zR$b*U=26ST)H0uG6cFr{Qy%G1&HD5sQ-0VD&T_t`;{@|d-Lp!HX)XUT13S)Bcd*Mo zs4hmOY9gcO=_AWT=M(h63ID{k-}iK9tE}}%=+lZSR~2?)=lA$z_s9Ya#taiU@6k)c zva3gfCgrn?&uxpZ8a&rRq^emDZ^BQDv{dzV$83&U7t=C|aVt7~C88yV&TZcE{VtpI zm7>(xynP3`rI!^)(2LxQ&HHCBq2vM!RiEn}!kEq#-A4b1o{cq3Cex?pS;_pL(3MX% zxziVC>q&?p_GUUCe7WoMrs?LH0vq3*SM+m>Zfy4IymQva&p@b=mpMqK$<1o4PH3jk zp{wlL`j*C_aO4};c`+3~2^+o*tDWGpBDWj%B#pnnQV*|%(S-@?Mn~94MnjC!3Z@2) zUdEfEKG$xp&1>Ky<4g6s4nx%Kg^RtkA-lBZLmS~3T^bD@%Jaf0CRb}W=x=uftX8V4 zUa!p7v*N@O}yT zrc*|@>3gCYHsb|;vVz8@a}(o^WYd;&#C7fdzAAF$U_MHTy)C*mk%Ql4M_+4WCFTvb zB?*W8&1)E^m7U4`Qt)V07(ETFZPe78!kqH>+2Qa}I*W0Ie%NL33D)S*mOk2--D%)@ zHnVf>Wqg43x-$lo?V_We`AGpwqwj`mdV4R&~324bG zxVOK2nPH9u`b34PcOE6vXVGBmeq9H%;#vNTa7^h)t1>B{u$uafyXO8e+L_|}C*L}& z%vnlc@jMweuyd97$hNrmoK|D@(#npiUhUPiU2=C>{qOwZWOX_d_wRM(y_m(N$pTpS z_t&woTxk-zE!>MKzUhyH`&GMmR?XHd<^pqZ9J*hAOkZ8hjkTsNx9i^V&Jj2M2mf^ZijbLrj?Xeo){UX`Nny>4BJ^x~afgqYWHKZjfN zt)H^{1dT*w&Y<@|=4U+l$Eau{$xKK!vDJ;)vQrdPkI!MkL50=H3 z--qp_=v_l!_Vf~NZrzv9rc`4t()HTM89A7DIfu@QG9PCJljgz2Aa7F8kJ)w-tWP8L z&2UpgNpSr{tVdYreIt&@i2Ms@Pt(cCwtP!B$KlNe^Fff9!|{u+3=y@nUjEW|AEJxo zfl3P5mUao(qDhBm1{S-7#|(?bpV;x+nj<^BC6t|L4JB{hKMZdw-m-a5 zUA3(L$~>*WJIPu+d~FZ4v@R7hyUX+*uCkLe)?I3VwH1j}wyGv-pOrtHC90C&C(T|v zOQ-dm59%bgiqFVsx^4nXRS&pd%r&bv-JPbpvDHM)$YJ$tbh9%U*#wF#m4Mm5!q=Uu z#eo{%?3zE0nO3~N9+Z1FO6l5EPBAI3I?NZeh2yqa92|G{Ns~Sv)xFj-++APSLJzI{ zVsjkz1#M7E!T$_d^!(({G3cU>0MGk&{_Ls?BvQuC`F8!3^?PSfRd?q{%oS8}_SZLu zpr+0a9Tti|nk>}8(Fwf6Wj@$EaVQ;_8MzG)kJz62SRU4qqt$khr`$OB<*64oLYfVG z)SPb^7tI9JZ2N8<9bFz@r-=0009N+ayRoKlrz+cijr7Q3V_+a19!i0La@++03x6N~ zv#_dIlt)yV4EQ}1{pEUVwIjae$a{ZAN*;ngrCD-8;%1zl?A^#0JlvpMi2oE`@*9@3 z8c1qbes*B1j<@%;Z)#XnwRqJnx6*B<>2Wk}`(dRr^QxiMdRS0mE603ps;A=arF)j` zCG5rtZhSJ~CT6+pTc7eQ00;+R4wt5IB2R#b?8J!F4PP`d67L5o*NWJ@C|1CCvf50U zP$rn`sGt|RKK~l+DW%UEC3hdiA>C&SJ}7>{5i;?tq|Hpe2N@O#O7J+^%QxBnO8Q=_ zy9Z^FI&L6(Lh!2?TBa7#Fq6a8aibX6S>5$JD}5#1QxT$8&(YA)_ctDLMtlqOR;wSA zUriZ(!dcT|-n8y4FR#O>cA=|{9#bnt8A>g&e;oZZt(*4NvX%JcwFBMg{M?w0W{@rc z)I2or%IP~^@S(3)^xXJ{!x`f&Wlix15Ziv}lh&mB=_n7}lXk#TQbVxt9H->4GIl<8 zk|uTEnfC^ZOQV$L8)x3+^0K{;9<{%Me*Wn_TS>Exi6q$*@npZ&{M68Ye2KBi7+NVH zNxLGK0H-KLj7#z#)~5v53gJzBRJW{#+fzlrM#eae<$pWR?Ti{4`HdPLeA}W;c=D8# zu73@?JJt;o$=fB8t@gZJWsuTc6KJdSAcV zeoyhOwMXm;n_Ahv(CN1EVVQGL^E}_gj`*I@&C5;V^yq&9JR7jZJuhGydhdRjnC1n8 zLQl>-VxO$lx_q!uf13nMib^}m>tX*XxyEqLP_-9w1ZgxGi zW%xvKa1`eD5eoI8X#wN#EQizNzDsq?5mVpJ4LZ>*H`!IO?PEJs&{&$9XG4X*?Ol5z zaK!y(+&Gm2vcf)?8UE7Q4SvnDSDz|#aWA;o^=dH@S+|65D;)~uI2807<)vQJIqbDE zF+g6UYLlAH{qY)5(zGsJ$IPPv2YdO_V7s23Vhdxt zGXLV1h{cIZ95%Wl`BrKSz9o~b8zcYx#l|a99WmM4-NlNfo;=kGhHYUCLs&n?u*SqPyoxKqPjz zS8c|&I=eQt+uDBr6R;O73~fh?&*y2_*kg z*&heDGxMGIo=u(I&%QO{o@?1FfLu9{oBtT7V$U=9V4q8B&dP^7Y%9=`S`40R(Kc#| zwY4jjOvkaA?|W+>SF#HS#yZyKQLOE&IWkPjxIWKL{H0d^raq7y;Kj{k&T)D?AJ4%~ z?iQYC=kf5rAK93?lV6>0F?sW~B}>o0rbrWD5864^b=b4Gy6YH~nhz%dn@v?yj??#h z_3t9x8Bcn%&Llg~$!1wY>0ZvV*-5!&>x$m}C#0i%Ox{_n6OZ339XfRF`1xM=YTG-c zUcL9YJ}z7RyJikw)oNQ2S z5dMU`h?_lvH~&PzLqt`t*1=!tA?Ba?%jWv@@V7ine~>-t;Zw z`|b-g4UmQnE>AT1#JV2m$HU%jrHI`pEk|H1lJ?w4hI_z?^bDd!=Rav~a1LtE;}_eR z&+lL1<02DO^`u}PmE=Zm^MZSNs5wBEJZj3a1#Zz?ZK6v1uV}}ks^$GQY$OP?sHT|R z#`Ef)=x*wKPGy3KO3+>+FBk@_e)J^g9?(E(@Lep)ZnzPTPTht3sO~G$_-^HRsC2F4 zMRy0}{2wD26Wt8nKKl;u0#HcCl$Q92i@OGxB)zEYuMPKKh zomOg|XPdpeM}OE2?OwVV)(PCMVlCLIv&c>4XYC|;O%R#3E;S^EjbCzfqp;8+Y1}oY ztB}dILEEh4QN)+nbk$!n5m~m39rA#ch;Q;T)o`4tuRB5>B0M7EK#fcxvQ(eybZt2f z!;5b&R{cTmbfJSHr%`sQz~p7qSF}6)@b5dXbslry89Jh7`2STQ!YC^0V0+w@M5~4L zgi+tHYI-buuNCk8vzUr=GxF{ixFeFe`j38k-7e-lly(CIj?-A}$-|e7VKeRF#QQY7 z-ssbA!rssMMJFA=-)|FMy=d|77xv_hN-rObgNc9-e@2jR}VNC4?L-#H0 z%hk8qbT2wakB#xV-i;W=i2mf-doV2_PtU3sX zpYVptf_?C`eqee7-;>#fKyP2*=UG7KFXQQHOyV0PI-@Zr`{+~D->?d|k9*>9dT!L* z)LOdx?8>z{(sUunDUPTs;dq9i$-*FB{-V3xVCvko`(atWoT6_G_1}Ibmbl|{8yVwK zt6Hw+?aK?*_`1{jdc!xLx4T0R6-y(e^3rM#h>mfI(_)rDHk{JzWWJC&R+6w+^(71m zr{DA2+L4|%31;^FSi~ebW>co=-Kn9WJQ`IfKfm|tPo);$ZBjC({T~0kHl;xNKc)a0 zu4QJ#v>9PX&k*+5C5ewUJ1E4JGTf2Dk}b&df!sP~l8A9dvr(ZU)uuf#^=Vn28X1ck zGRrzB*HSidsn)&84EQO|^eN7;_mqg{hvJm|mRH3TfaF*Xzhpp*TnAPv$Ie+o5tPqb z3Di!~CzsgmIKZ@m)#SjzZF{R&hpYLsRXBl1=!$OfOn3t(po60Obl5p;?b+xy19xe) zz(iRkX43@+spw)oEy@t3>zGZb0{!H|B1&`+s5Yo!TqWm>U7i@@*Uh(UEpLg=ZINO=XesZhoG)6b@v?R**i zzyE|5-ktsPzzJl8pHGqI`eQu+I6J~U!5B&MfCndg?Rq}s&H6h(OP&c?RwIxLdc`k_*YZ`LfK4t+KBXBa#<3%np?>9q;gay+Dy_T`)gd~GJ6?N z2zU(fxqn5vD*eD~X+pEHl}S^JTA+8*o+Y+>9fb>h6bzIB!Zr@xqnfdRjQVCjPeJ(J_R*UL= z@%Gp1V@d&``sKrbvSj;(CQUaB>mYN!-m=D8mfpP z?oc@IEQRPHZ5Xy>fH=N60Lz7cf$bu9c6XIAU5r+S&lF&K?~&R&uhU} z2Mxet#u}Ee3soxq;C%(xr6{G`W$S`VvI@;dX<@jxSN`w;H(gS&oARKh8cS9))-6cK z3`jx((>r=#+$_tUO<9FBWkDT4JVfv>(eCvqp`}28V*z+nbCLC$S%fkb=C9xsZ%_VK zA5xyk48x90#GK3O%)x#brd&F9MctJ}TF6jRHp%LB16>N+C-aYyVgZ2ooAT#A7#*I$@;UmJJnb z3gf7=8;`R~5W;Ty6>1x!e^l7&8m1vVZ7!@XsG!?ZKBPX5;#$B8G~-MYfWorb1Zh#dPdC0+YI6&uZF|6b9@feCoBw(8 z)_pv!cWbm|U37iSg+YS>QuH)E6*dYsdb1s?xEWxp~p&R(+ zmtO!6XegwCZzc{gP56j-VL_KJN@~3njG1UidxcKeS^-!fevwGc;dPol+3?a5f zl1T=*j89-Rz2EAZ(^v8txtLWF&3aqCSg&r*Xg%WH{fb4m9mKuF zVoZ^FA^0ycEBs5axbVIP<5Df&c_M=w#(jKm*K^y-Cj~H_6R-=(=UU^!3lW}W0$Ms_ z+co!sP>zx6F=+VPtG!XC2WS?@sr{1_`Ioj)w8=K}A9L}tLcd}=np4_iuWeBoT3;TL zv^+H3$GvhDWgVMefjYSJg8;=2A=R5pUjyQci__i(1eMTd^;C;vR>q^5-6XU2jAhxD zzptNrGu4<#x_$ilJ}9L?R%m6y&OlQ+4MmbVOI}ZZ0>iI&&Oki*WS0lKgV)V{rR0N{ z?-iLUUg$wR-Z=YV*8^^~t%?d?_Om2zm=^?TtE5R!P>#W|u;}!*z_b`?Sr;~0U7($! z=~^hz7gi{8>bP|n%>b=XCGQlz?L^YE=;nvvbUQUtzon^XhU zf7vK$a*Ja9fN~ycKVhxO&7%p;+cj>8OuQxPa+fXBR>^D2Wsj!lwiqVQv^&nqnZ3NJ zR$mDVXQs5#6z)+lwlP?h4I5#%&-M@Q^Uiz+jdE6is!`k%IX};-RaWmHwj#4S*YacS zo30mx{vyB+j?5E2NSdp>Mz+JJN;)YvOK+}WM&rVsEd=nZ)t~>uXW*=R)=o+j?n-=m zLp~2mCda~YFH5LeT-!s;rVMk4(q>;%Mkt_0aUXx9+G}h%*WX8c_pjsvFN3)2sWs#9 zezcX(>YWO4K76Su8m+1RZZT%I4vknl%}Twp2G?nW-o(z=8`*lCZuk05+;hie@u&i} zJw-l4q?yih4TiDBr(OD5%=tjy%g)2i{*7*z``5kJ>d(l9+|f!9*Cl$u`>+uF9*N+O zin{(Rrm41}4=MJQ+2-*-Y)zb{%*~vMR&G0!`CR{+%dHMOR0L<9&X;+`9ZCyhnnpdP zjA}=NM@37IOiYivnNpvqP}R^ekeogn(GMFsjWzAABZuo*e=Gn%%>tjm9h&rY`4f6o z6$78^D^ReOr+3)6Ao!LK}<3ueuXohs&S;Nq|Y)+D)s-0s!2`0|1czHv#5k z%|b70VdQA%WM}G3r)=(MVqk1xYeuJR;AHiGvR{{7;M%|J7en_+apEkHqH-@mzOx(< z1O({sZg}-vPa9Znih5^9<{2~3if9Wsge15`RJ-_k2IESR_Vg0T?$d4(JNyv{w z?KUa(V&y{$Qc$7t;yQ%_G}H0m@qM9!P6Z6aJQ5lO<1wC?X!lqwJjeuqK?IoH7fu?< zi5E12t2YpQ{}zP3`6gRV1PE3kK!zcc#AR&%cJfu(g`Q{P-PU$^G1)mk7x}FqI^pgs z)*wWtCn_XBcTAYPB>;^65mHP5HopO~_Be%7u5bI0NBbsx`R1xPEWXBd^Wmk`COIgGWzdg~!yRi+YfU&TX>y~0qj8{hyz zdF!MQ%_Tn<@>X+GTU#fcmn-%MX(|a?$neGFZjcyWSsxNA?xSxGbrasE;CX)%r>E&( zY+vMAHn=L?6R5~8wtB^3leFUKycbEGZ_BSP+HrWBEq~1ImOc}7=q}Yiz8e+TNWY#2 z;b8Hi{YrE#n^zv>PUoikvE4RXwT^u&oiUwPe9UiuKVYj@uD|ugg@HI1JAnVmcqzoJ zb`i41Is{jEKhXSHp%YpYvBo;aA6mjEu%b2CT_}i4jMUyyK!$uw2&YI;PXQ=Ee*w^| z!Q=Wd-!f!uw}26WtO@+1wo>? zngY~>!j{(2It77}PSYBIbR`n|qEZEYAr9ex2T!~8w4ULxtNk}SJ@BW5^J(G@N7D#K z9VPL2-hTn+Y#4QpwCR`NGD;`pmBHqtb>Q0|EvG_%nnJ(C_$AG}AaZzCr`{X$pT9B< z4~SNGu?^m0%y%aR*~oh8aS3FP!iTSd->D@}OmD~h1FepQC4m}H zV*N*q9ynplBo4|81hKFaO~S{I@&!BYR&j2!>Ne~?+P-3ZuK`BjSK%r9iaH+F@L*y) zP#zkch%Dsf^m?^sgKG^3&1i9ZnpTPT|VU!3dLuz%bb&;N53mzNQJ@d^+yixXfB z0zTfE=IE<|C8iAOql_y*-TY20&5-<&yv;i%LGGk4k7xW}2$k2uxsf@DAR1AZX%xqv zck@iSX*>vvh~gH3?!z#5f%4b4C}lquvq@jTG9)H}GC3-td=TZ*q<83QY}o-t)-SEX zZ%Te?rX`q3W%jyMmj1dz&aYt0%=rOGV$^E=wBcOq`88xjfZc)SoBSB9^aAiaWf04t zWL zEo_gxdD!YX1m#j#fLZRTd;(F5=U=U&x(>|zYn6b#VWC|uV4C}?$+=+>4HK$^VzDTI z8K&p5eH9u&6cF$JAAWK8ne8;udSGj)n0~%#ka|p4b^&$c7VHx?_W*3%N>7Apkx=m; zj(La#2Au^iASBux;i%5x(E>1S6CQqjPk?y08XV|<455x5SdNP&;}kI z3S@>1yl6068XWwOwb|;~0bXS#g2qU&3pl7b>D5rj%RIRd{LLM=v@F=F(a;az29px#eb>s zSW};3>_ZUG(td*h?ou(f0_`M;JuCmEZ2#qeq7 zgeap2XB^@TcVxK#gcC@69mQl3wrSPxxF(snOh80xrUX(-2#%U{Nmq?DK4fLVJu#^< z^0g>FeRab2cWkUw;3sZk^PmDHxtD~leNPFLREE-|i2b5%wkk$;JWy^DLx5bstdNs1 zm=D_80h)pqU&5p{CQQlr8$u7bNNP8A4hY)W>b_TPOgKcdTxc*y# zC=H5ompe}@L0#EJU)hbBVQ6GBZ*9VYOrC{mi?U%gMPTmke+^>Brdoj$j$Vju-M!l_L&LOK-t8x30^Gu z9lg0_5ke7#wcNUa*0EuTFW6e3QB*Enf*lwZ)n}{Her(83=n~M`+Dw>{+YrJB0n5T> z%7BIwHFg-*D)<5?3o=|-pT(R!E-1v}6oSJ)l9a7(?W{&d36Y91imR2APvjU>DxucZ zr{GPTbk%79XG{2Yd{1Yr0B0((gY%xO3ujCI%auSGl?`}ZH0E6jdP4-&aR~r55c;9d z34a)pY^$)M)!@o80%ayjsw<+Fjx*J5qK#OuiWoHW)oJum!1HOI!(fB1Y{yk$M1jHx zUp~az5mhs*N&13>D?)`W!CSnLnFMPyQpkh$hD~>IBpHFgqd~xQ{QqnriMrtMuGTa& z*cR3SU!e$_%UgX_H%qG&MhX1Bog}ycO$YU}(cm%JS6m%@uJLiGnuWv(%_>Fa9R)Z{ zVoAu1o3QDTb7jjN&5TLg(OL|sMzc~Z1gJ&{xLY_Gkq+)diOzzIcu6r5sfIv8_06?= z%z%(?tiaH-KzGYr(neEj&~Uo?V;AtiL<aeia06rUFRI`v=Il_sWl=PE-3eYS$AVupsghxp1S364Ao@uW8v1lLFHl3#U>3;|1IBagF&Xd?O!X;{pW4SN0*=&ZlrIKsN7;Z4 ztVQf*#Jod=B1v0Ew+Bpt!Ac2(OK=AFkinbj4@@1`^pRdTXljRVAwpjmSy%*SAqNCt zxQ$l92ktQFMs5T90D;+dANVk6fMwlBfpU3RhB+Xn1o-G~4hbXD7`;OX)8c3c#NP)G z8lvMgWBZRZ(rvBPfk%)`!zplK5luP^=Hp?}1kGVwF^Hmcm_&$K8HI|jEu$$+Fyz?8 z9$kjZZfuQ|z0en6We`xZ2s)Y>L{p>LV3|yUbW0Q=qChEu*v!pCjoY#cx)Bk8rmBb~ z{Gm=Cr&qzvYuP}*2~do11O$ZG6<~aVdhraPzyx5HFoPUd?Ldar8M+Cqxzu4MtWO=l z5V&D%`!HreV*ujv%U;bu|1}`4R1pn z>Q4?q7_bS%){~JzAOnF8hh`E@0#YzO!x_m5#4siR7)W?4qyls@wT+|s!vZO{9O9VvE)C~Q8v{o&WA_Ub z_1Wjb*(+2hFwT#RxMM}ZYPSaMRY);l4lTF1?ZNE|%pAcTEw&rUNAsOdDr%-CK1kdL}yvnx6CqUv#ioJFh52gV_gzt05UtF zN5j^4OGy36jddlCK02)n8gyv@II_jM3N$sonZw(UvI5Bxss9W4vO zbIcdc$vvMA`hZafEPR%_3&5Ye1fpzFSBroQ#J=fBuy_gd7{Z2u4MgjXONCUcb^>sJ z#$}85fcQ9w6um`0%#bH&-2|2eS8tjxHekZ31eF<-!bP`3*dk0GAl~W^?CC<6uPPsi z?Os6M2g{IsPVyV1L|z>{91MQzIPW+Xs9vmui!L93sys4;Eb-Xt9zaye#Y;Im6VZ}^ zSqUx};2_tOa!Ei2RLYu;J~-H0!nws1ts>$cWNg+>7osB61Q28%O>G2A@Y$<+((Z8! ztduoJ8;2dz@Yx4vR=q470boDfCU=p#o9dLaOxp*2!d0ymU^nez1P`)Ir|A_NmR>52 zn`3010H7)?N=Dq)X@0jRFJKK6|l8MI8VGcHpc|wT3mhVz4!)P$w3K znqaW&4_8S-+^d1hmKhE5&w16k0oJ`_K(+trRU^np|B8GAu%;4?TdD9GGWOe@aG{0}0_kg`GMhzY?9+fYl3*7@20t02))#UN@*q zzt+S!KmclnHkQ|MHsct`6q<=Z^>1Gdq&Dm!L15trr^7VEp?)%$Q-C_WeQrfkF1YQP zyRPwJz(PM4BFK5Bh!SWq3s|Boo1k?e*o7@o$VXABmyR^+Z7Czef-{pi?7QdU5^9hX z7BE;Kf-NJ%T~*};Xw~n{5n)aWwbT5)Fvsn`IQY}Fen2Dw1BrnuaEjfRV^dBLxBRclUGFdo^u}c*==+3W*ghUH*V|x=y>Gj+MJxR5c;S1 zhf=7q`FlhFPEx(zj)ln!zp@0&6Th+q$|JwB^gUKG?6ktpYPy5$0S{Bd@Eb}XKw#-p z^wtrEK4Y}&Q}ig?$8Xis zxMeeU99Vn6GDi4iw1uem_l#%@x7yP&dj-;ZJEd|9Xs8pk%GCt4@r}QE?stplCqGy5 zs#h|LxDALbo2XA4y8xK)#Pntk?p|^MnN1^dbjX2O!D1uh_8JU)*Bx;RQ@V@hNB;$O zx8(?D#qnmu>3a_sXTcj!41^;XaR;P^wc>*DEXi@xb&JNk^N@}@y=b~Yo%=toOfCOgA;HYTprH3o?vT~7lHw45C=hSGus z%i;-as35?p-SbGu20b%hT&R?5 zq8YI%9Ftmbp7#75J}HSK*o512wV!n6GvlBBj0@tIVHXN_UX7CnJSo7HbF48qTVXh= zDT!Y1Sz0Vy{RVX+8}%v~-t16kCkr@as^`Z*a<1+o2$>*JumJ|jqp`;p-yFsj7MF1& zQP_lEeBzpR8R?3Dl-;Gnn?p1V?wuqE6?nHB(Xuov;(mrB$>qP z(>2!?_m5bESk~c~#|ScZk2IH&knn0031aDwa7rX5%*qOBn9m27GblCiIXo0)+93dV zUj z3j>J1@K#1Mc!U7cVMM_)hyrtl4QV96FWakm%yw*MN{lvi-j6j=Vd|rwQGc}xcNudD zjYDpWe+^Ez&^y{Y=g$<6QD>jW1O~sObbB{N1S}?xb{J&a!N#=n2?AaZhV+g?#}Lvb zvloH5^}W`=O=2JXHAhPXF2r~!6Nr}XMm^bvX>A1eWrhAg@IbSWeAJ)V7^&W+F`>?` zu6lWQiF^5VDSnA=O&yC{N?ZzVhGxcShHA!s!gqpsLVE%nHWjl!>`3ld>V$5e=EUyc z<^Tzd4XhV54L0ex4i<`~<*g61JIC&EnhKWyVK3|yHqg)RdkQ=v_bo-;f8~3rHU60* zwgZVNzrL(4iNmiZfL zNx94eZj~#{Iy0AfqCVvmddw;QP&LPcZjmd^GGmf?0ygE8blfKVu=#iH24IjoaAopu zZw4<&li^Gtzpw!LGsfqn$x82u^{WzWcO85G2_M2ZCqSOKe%4dEF3_FarJKN%4$K{J z9ekMkln&J07eW{jkP)iJ&|8B(0(BY{DwSxn2v=dJfX$4P;nW`@z#1(Bq zCGkg@NeES2p#o?>YKY}ukqR(LQmW>vUS=V>F-qmKMaS}SC9P5*$Ws@I3@Ow#Y1J}Y zYRbv+G|G;sbCEMFfx?#b;#2}U0%a9N3fV-;-^m%K6jd2RhXPGqf*>NO$iw)I8ocqz z)DskH6AcNos%jEuy%P2cztT#XH||h{KVPbzCh7|sbQ3cbNjhPcnqtp$u?OVH2bwuT zV+yh+RmBR4z#m_mfa{{9)T5L15h>-Q8c59~%GIjl%u!2BIWfj-Z%pM_a>x`4lBna} z9wjAEgJ#eEtPBz1w9{c?sb!0Z4c;2DBDKsmqzKjQ%#?|rh8m8Nh{d7QM`e1x*+R54 zbb=+5X$F#WJqn4)CR7xli)ZL`l*!}w52R&W8VTgoGKwhFe>FYL+1QX#a+OIa2hjj+ zj4gdW1a+Jj0?$@4q*%jgCg-_y)VqZ;!Fm2#h9HTcKL;8Lu(*;|bCu!Hjm^v?_qrN1 z;CK|2U>X-vlJ=3cNr@J8(l4Xdi`iA78JC^cLJTd3uA>?s&db3i8i#1yjf1ojIX6Ht z9j14g;x1Ol+OJZIr-G7bXkhX$BsTzw(y!4UzV?e~BnXvj`L>@y$-q4?DqG;q@k7PL zn@H#5HdTl}CyYm)z6Anb#8d;LCZS3uGwJ9g3uRC!6?t+%SaePNB@m7wgHfwI3K?p6 z?YEaqz+zp998V}`E>yvS4=|c7!>dskXF&@dsHnVFFH1C@c%+=gW=SfWA>-kr!Vaf;%lSjb}NCezRh zQNPetsLbW74GYGz_kl3P52BXt)*?pXnPx5jpi~yHIhdnPc#Z9+)X%n74q^JM4OK`CT|guy%dyDO zgHb!%{v=;(qh4zeUW%CpEiI6&_$NO@3Wr26TKlh9XF~%LihbOliM>L~Gxb$1N=m9k zlQWv~e%>c=l~OaoghGVp;EfC#y~goo;DHTzmOLruf`mk(E&)`+5#o3X=~)7W%MjN; zR4AiF5K4s2yOu)Gh-IhoDWJeaP)Vz2emD1ZWYTithNn~vxxk>f0nodSipGGb(MSr~ z^eFlP%GeaiO(snRB7ep1G)f-GnnfUSrKo}Co1tdG5@w|(-zO%`1~OI{1hnJ=MJOpD zRH#TvT@W?@>KGI#^8PV*^vALtlhT+mY*R#|{v+)a0MpiNiWCK%!Vupdp+@i$6$9ZXor)IknTbIE1O94niqsY;{P|~@1xC(c z^e`i@MnUS~$oRv<5f!H9ITbE8$=}!jwxdBn6uRRoE?@$-y&5x$(y=M#5RcS6DlA4rT`-}d-y({tb8Y!bJ zk-l4!YQr-oBDK~oWkd{bOzh=G)09ARb6ADW)vJe;XA)t7bYU9E&*phAo|oFRA;?Mo zE{sQi?KcG=6(vNK*-L5Zt{dxiPxalKP0Z;(*6w_W5CUQyM1EcZ4XzCL@9dGS0td@b3r>-kqi=VU3l_BV(Sx-bev$1iqG= z5GiNX;#xsSps*owGUqK4wBoR`sZ?qwmeXeK541U6pIjH+JtfK!?iWR0pb|^=oco7T z%nt1h>a{Wf#wL=9wjafa)g6||CcK;x_6I5DiE?U;GlMqG0Fg= z(+S|05Bn7fM}gkrYe4c{m;}~}5zMt91nKA?4X8njp#&kT#N{amp#>1HA(iw-2ax?k z!=ap1D9RDWlXsB{{qJdAsw`Mh>HrOu0rIG{#|NK6T7$qp1JLH`PD89v6hsND5CPp@ zi&4@0*WX(Snw8ZZSo6Wlujqk!>n-0}RM)V>_Ye#XWbxwzFB0Z>0Q*+3fHfBc zBRwPyWcfbT*n5p39tcq3TvQGDvr2_)n|B;08Y|AHLR0*;o}F)pa-yV$?bZHGV-UOs ztt8qQn2MwWvk^ctd(naOgUDG6Ku|EFBP#{gA-p2E_V!N#3#rp0WVXeZlz>ZpsA|TKZO0KFmBC>$<5H84oGhQgADaMmH`&eV-#lg zlgkQ{E)L)@5H`&%8o&}y0p*9@B97@p<0KH2p(sIs#KspukC7Fik))zc*@KZBQrnZq zQ;`Iquz{1PL6~DDo&}fyI0+z-Y;e5x9DAr&K|>Rag2F&d6-q{n34g@H&=H*7SrkJ7 zO|bvixk#`;+Pm9JoDzl)eFyUP_g4W2109mTyVJlw34~`v5uS^pgVrDOKQ1Qwp30_y z)YA+GM3F*g*BJ*S5u^q|X+H)#Ye_8JHZ}vdILpTz#v-tlRf>SLZ;Q!mif=YCTSVcV z#SenFqMF)N(f*7^UsocUJ^|OuLFlo|aDPI#e9uAzmxpA4a5M9kt+tB=s+$9&30??f zj+s*n1qqj?B$zoj-zY89zDs{tOztO$j->a-@!Wf9~N|kkz zn{n2oa{Bk>Oem34bKCk-;rCC4?1LPfwGq<*jjj<5?K1ZidE@9(q}3LBH?AunUNSu; zuWrwAFJFQ#ZH#adY1fj?&>jLWD^}E+>rr6J0Hcn<3Sb2hU$gX+=_{{*vab%fWOUHg ze_}x-5ex@RXEuxk#+$-Dcpbw@f(vX8HS^YZ+<-s|HwW^{X23WrWk>9|nKdfd7o2pb zWzSxsQ6hXn)$cDPhq}__6!7o9iNX)OK;w&I#184Oa7sr(a8@frbD8{(YK?Q*( z6QFKH7-&LfREQ2df-O*8Fa(fyAe?$uA_XzW?5e^9+1@mkhBEM_|gw-0`f|KKJ2kMp1s20 zizE{%fK8AM#5XQ{a(LYQz(92lakf>o1PZ$bMpDj9_sIi-kv>rzNGc#Kq|6;nNwSz- zO5r(dzcH{lL=h~&O`ZdyBxDq+&#C;5<4{J3FS1y#K*a>wnKV#~-0$!BAP3;B=Cb1| zMDRJV@Cbzo(RAhP^2BlP<~6M>vg z#6aqc8^8cYKp5dXl=6R|{p6tltblI&BahxR7!zeQ_|y)C-xPdv4FNKd{Nt$mlW$++ zsU?C>;3A|_Lu-@fMapVHtqa>$1)-ReQig6x^u_%{dwO1gX+Ede!vKn5EC)zg{4l}L zPJ1YSpE0slN&kaK_BJeR_k<#1COc%4pAxuBOTgeih1(4_bMj~j&9YBZgpE=H!}Go( zaWz}>gy44xtrC-xx7WAu`N3{LUkj?gEV8k3e4q_9oIGTIzrHsd$}1$wPZJP#(7JAT-|=)iE6CxB){i9-OZF!j}$c2eY+C2yWVzIM~}|LrHr!fuud4i+5kSjU4wjN zEzj)v?T7V_YyRAq`kt!DE(wd{KmH5i>dX9!ZqNLJ!G};1KpORDKqBc^WC;g%K!^)v zfJ&V+1AiF$*S_PdRpr&Pd@E?NE$@d0DYC0d!K^04=a{`$G|7v7e0zEj?nOGFnS530 z%Rx7vw<5AbcM{y)HH6^q-UN4dcL*Nb-Q8(u9D+9P?hcJZ z;|zB>v$?aZZLR8@=hXY1t6&x}T&44s3M;gt7C#@tDqCuHDQ(()}^ZiW-*H4VdN0hsVGS)Dgh`}jYZ`scx z+8#bv87)rZ4^7^ZY=YeefX`M{s=D zrZ}|7jlbNIPzx@{PA4D5@71u>CRu?sm68Tt-jwB3@Zx8y=u=iQ+ z&p#`ZRfM7y(=WVAa&iH(4%RFNqX$V20$9hnM!2Hr?F z{QUe#-}3#Kekmlu3Xx}eNfz-XDJB0>^+myA>?xy^%M-&8Y)JUlGfgB(l);&vrIPMQ zC+Cx+Tj#iN-Z?q?lInU5h}Vp-^Gp+B@twzxbJRzJ+~^TG11ipM?+yaDM@k=ux+jP! zX|;tXyDS5t)yX_rKgntS5lFY$QM}d+IeY0j3z@E%+E_hRn2HI9Mwfp8Vcm||yd_~gWlKf_b@!^wQXqH0kD1isZN&nW8 zuVw=Tt^5h7vkA7^4mz=N9U6dwbi>V_$P&bvjCIUP1>agPwU)|n_ZVv<(Mw+fBP=%{ zfjNc2tHLn~mQWYa3xo}8c9J;PE&cJ|QJ+|!sO0Q~ROxbzw7*qDPXlD8gXkVWd23+= zpfZGE>MO9xm$r>bPZ>kVQ{CM%M+DTQzi*^V8MHd7IFrw_mU~I)6pkwwYHP4QcMbqxE)o-_Ita z-CI>9WAR-Ia$=FCrXyQ#P2UKHWrr`^CD=&2k1o1RWtX!wB47{woi0Ttm(~hz!iIp@ z{rL7cBwlh>+JX=H<6IMgt=choxh^)dJ!~65Xh!;KW@@Z_+pXsP%D#3-A4Hm=T ztrhs_-79RqBssO6n}o%dYU1+M$H8ao3U6?BGJ(q0v@Zq z>S`kUZn8}Hg^a8xqA{*L-aw1yd~ z4u$oej;G)BpNWeB_X8nbRxjIGTdXXWYSLs*ZlHW-hU~u+P0XlQ4K7l5or56;4S1pM z?FRmxr7k2s-CpTLwjez7VHstY`8jQpm3wVN@9!oQUyKzE@daw}1~pJLt|W5oxDNS+ zXR6-#qLW`FgF<0V6Jf1Bkr ze<^wF{vwC2Sv-zI=JR?FT9B#L>!oe14dcy}BzZaJT6?csZ_d&>%ls@kK# z)abcz1Mx+p+jGYMs$D6Hvu12zH5DV zyWI`-*wYxSmd(2KG~CWQlm5X<8WG%Neym{bc2L$zbI1V57hGh1wuobi2CJV#%s+L0 z*?$l`aVLU5kqf6~y<;kbZUL+6ZV}(~gi9~RqT_nrRu|=dmRz27eGz=-hW1*99o|*K zpJ(+6YcT3jS?%BC4XhAcKBKdyeY|}@ZKh%iW#;HDmZwxh$E%EIsF);Kgjws%3q>ONPwRGs))m}ng&v}^lu#&mXw1RdTv(Qo;uN>Z}c=`*8Jq!A!vV(IV7r?BVW^1p7CBF zS-213Fz=>cUH|=K6|3HwLb&TomKKKFvEj0BXZXI@P?@~H@&FTz6 zc6^5lmQ5CcD#_QQ6({GKoAjo4p#TE6P6|Y{d!S(T$!HKWhgYvo+hTIqi#^sHb8}}$ zLM=}ozdx@4|IKMV1%Yxw2-EoZMVL})5_8FfJo@7Ryn0mdV0PJ+Il4lWY`Ke@X#`Jm zH$IE6!ve*Py2(`VzTTy|+V~lVz9g5d*OI$s`=WB`%jZ|~+KcR#9;^E!otB&v{Qs^Sk+6_vpPIep;zSBD8nXLS`5KT=i!?KIbb}AF>(L^%R-dJ zk4fGN2L^ifHwo0PT>`l>dB)nD^I?%yXtii0Gfx*o?D||@VA9ZU!~+R;1zNhu2&SF1 z2k#e@P8Pi(vwHq929%%p5#i7+aGOse$W3BA#NucM0ijWan<68$ez>!vyG9SlZ$RTX z!CyDTv8hyYOh82g(mk9;*YlmEboa;>Tflq1iCELM@8#~)CrNuEosl@EG`ib|e~L@F zPJO!y?TxEZq>S7dV6DGS);E9d%WG*u$9?V&25tnzG9KXU6w=?=M-1yuUt}^Pn$?L{ z7n>c)B<6{IExLaDtZfgP57E=K-7}_59|ezti%|H6GW`@Ah1lHZVh^lki|D>O3uHY! zSO7|sPC15$|ErA#epm#x*m!>FA|o&7SdYO}&g<@^ZXb)Xm~^+h^)*Ga@h>KC>a|bY zmO#iDBq_Y~S*}GvV8=S$(YL_%7C$bV!H3)?CsT*>^YNl@`$}$>*YMWk?_K39_`w55 zQB!7HbNb1S5fRX#<#fj!Qu%9zgeH$2_~`m=u7fzoOEk)y6rd4)!SFh^LB9ZZpyns1 zC$O@rVrDM513HeW0!Ah(A5Llu(JxQx`JXpFk5f~au^jqx+mklzoDZ$aBK)%5b+M;7 zCB+2tpINRox^~JiU-^7Nwiy+dw~9%u-K>1{sf{^~tSaBcViW?q)t@~tC?MN1Z}K>v z6;TwjjMo`hCUM{FuO*8)ArjtSE-f&iFDU@7RvK;5Vc943tue#aPt5{C!OTH# z>9!MD#BL^ycQnTPM?yD28u8zSy1?dgHC*~OpbeHlZ$kqN^^t>~hu5D(-AvBD4lgZ_ zG&?-|l8;KPM$cZVv;;U&tjKXI7_W!1&mSu6Wci4J^NrOiQjMu+4yye{S*P=F9mMbu z9GY6)A-)Vjk;WsrF=Q?(Y{Bi9c)<~JP=(`CNV4i|nVIH~js6)D#c*f24I+-xE@Hoq z5jOjw{6;|cc)jDh%G2*O$S$JejnzFbB?-wZ-E~s$v0bG?Et>JfYb&e2(S-P+wX$?& zcvjaT@&2;UM2>#pCzwsz;*plA@r0ck#Oi zP4JKv6O@d06P6q&C~LdIKyoo<-@<@@7z!G9(`N<_1f*~ z65hg{&2D5sNKr6wCwZ#*0VX#Ti80m>s;)O$2j)LEBnrq5+1(4;bGxgF9vrA$Yh_Id z8m`=ReQz#b)o{(Qb6!osZ}8F0U8GPHu@x7rUFS;~;ui$jLco+!r&nO=HD6ZH5ZS)> zxn`%CH>#N+;l;^P)6q??!TEjqf#q$Es&3OdzuiKbV2;zwK}JA2A1NX~zQ}}}wJo1( zQJpJOY5c>kqjEc-;2RIs`{iyy-bJwI0T1+=(ii|(v$>hAd=O9a?Bqpiht z?C6?zf1rO|1(M*rEHNP{f7<|1*7pX?;PuEXjsNEp1JuE=cX z;@PKkvr_`t8CdH(sVU5IQ}4!inS1NQYJZ@Z&6V8rQXIzae|$v)qi?eKbXbf^$AjH> zVfAO32e@n6Zbz)$tS4hrJSE2teR0(JH}mPU?GxZcd-v}r_rZ4tnREK&nwrGo#~FkE zsQBb!uV9O^A0&f#1gcNXxU>XwZYGhxl}^0cw&EhxWy3E>CRonvmS`+(-Wh7kNxk&H zh+C?qp7dO&yhAtP7dYvGZ|m2umez(Em;sPg;o45+X|v$si=V=7E)BnLJ6nfbve(I; zXTt~LAg(ih|5^$vH^68$>yre@WQ+Im8n+!M1Q34p5+Ey+v~<;Y>(uM%-)p_l^%_Ib zW}1U6kGAA`=iiS3oh28k@~b=)4~*tS&VJCqz)tFMg4eyu+R0TRiZS3Ms-?S$Wus;_ zQYB8VVm8S2^5w2`7IB?JSi3bjhAPG6@kf!Pg%TdAlvy8wSM1hHx>&kEv1$@wjM)h z0C0qihBW)3g|pw?ac7kK>>|8m-Vcyug}LDd3B=uoH_(seepgXlu0m0l=3f}c)>V_% z`H=wge30hPh*$RRjU+TFS6X#Pl4t-`NB$IgYNbVv^;8pcjRpV5x8oJ`vXdHzo$kzF zlYU&tJc;jf6!zHH0pJLK!)}hRm17si6I#cht|@%8Npk^?M<*h|qhqSr&zCeic$0(Z z1eR8oue{Dct<~k)De|d6FC9V~C!5JH=CuUqxzfQ=4C;%7p~YRyJ`N@S`oU+A?TyKy zij-7FKSHKT7f(+?&{0jH>Y--E8boZj8<;}&?)68gU404&qno%W>D(pa^S6Z~UZ}Tx zpueKC2ApycNwoE*RxHJq;q(F^vuxS2j3SBMkT+wwPIFegJCH-n+;IncyRd2{-|i`G zS9Pr){PIQSUVRicxcB~0$az=(M|^-cxsgN}9xen}OCv@acM$en(g9+V(r z(%|Imj^`~{=8VdbWzTee!TnN1&vEm3)721DMOb&SspIG~W0F$`UK;`07pnvwr*ohc zq4NkroNum+6}wpA&?wyfeP+&WdvI!VN)+Kv*Io~BgourBUi!FBZqvkcSAqz;HN(+F zc&$?xC+_Zg@mCA@OrM?l2jPS(Es{KFwDfT1HlOCB+aa@X?ks0SHmQ?&YO8UK)KB9& zjtAK%ri&8A0C|Z>_Zp(c{P}(8=B7y%2Mb4T8mJAFc`+BrB`jQv&U$F`h-+%f`*whm z80#-AMC$O1ywcILOLc3}L)B1gh+@chlCs7adpzreW3_kyvoeg}MSrEr2c}7i&Np;B zq=xmxF4WbJw4ds>!9^07SGa37;l`|iki)Kr=i=XHEOY3;8`c^cwG7SyC{2E|R!gZ5dLbaioT8H$hI**TB>q>PG7HoXSP=omS z%+CywYP!^{1fdZa&SbwX~m3Uk_*w zcHqyLj=s1D-HRbGu&2gcR>it=vp;)m{d?g4vhjv1S%g>HO|}M{U91tyHM>ZEGQGV~ z@I9OmHrC}A^om|T-14=S6x__6brZeHsHM5VtEudo|K^%jPz9-MDcqr1VgkF5v9E#5 z_Uj~%3p;gg1pZnIrLfrJI}4ZC52g$f?f7UOR4==hN8LoWNHQgG$LU=NpIp5?9=Mls zo=u%4*Ga#BkabmpYWy#SO=i1BZaPbM=-QnIb>b))f|w@6nFhA;0^p})XG?>dUJ%d3a&_64cpoCsCA&!Ls>@4cAXlA$vl5jGSqN4YO(eBw5U)$4w7Ic$5Zs=6M> z1KzFw_WygTq*L#9P}b8l`La^9A{5t>VM3{toYkd9#h~haY$SNjxPgo>Vh@kg|3;Co zA*bwO2Y$;P*{KJhiHZm`BP4n)bgK6Y>aFM5OjcW(Z=Yj;PmS?UAJD^$U_R+#t_ zary_gn_a82^upAe`Z~#t=6Gz*BQ0=sIg=w{;d%{P4eI!3Yibazjz{AzywdsgRN1XI zeCMB;82~-S5lf*uYAMOjvYV#RL;F0_7~Wo|WL~Q)X2lCEV(n>|VxJp2uYwil{2fbV zt*w{siK5y>v8=6a`QS5D9c7uggniiNn+zP&v5P!+J6>+Qyn#>KCJOeOl34zQa?aN1S;2F_4P(QybVfy zKZR<;CbUd&YEMrYPSpc-3B)A2Cp|p*9T&?g@>ktgE3?_FvUy1D&(AJ6x$^X*R86g^ ztC}3Onkb*ki=^XLC#DiJGo%J=|qZjDorVFs>&9Riey!{yyCa~^A(3i_jZ>a<} z-c*{yKW7br;!v-mHl4j4{$0Kzupv&c{0CK0^fGwJkE=^;_w<5F&j#;yBI;`kjhzgh zwE`10?c*vYa=q>sLJbRDfNGOlejhvis1gur-NyJ4OBdLVxgWKXfdTPE8y~oef}4sfZwlRlcC(NNITdT6@317^(&@ zNzL+c)Kw%-KdI;X38%pLhl;S9QGWG?Za={T)0U49HA}DmjcCl~e<|Bg>uGOr&d=2+ zx6Q0YF8v|g;|1^k)YKXq}e`dsDQ2!uU#Bt|E$nMzwmx~P~fIpi{G%o zij`(2)y>9mt&BU@ojxm-KDUKlcf2wZ2@8P&t-xwo=XhpMU3^5TrvG?5*4ULxx}!+h zRnQHQjkhNJobV_==GVE>+J2%NKa`CM$UWq^oN9+Uv(p~Hl+;VIMatz4E~Gi{OjO~R%2sJnmNAN$$Y;KsfV?}#(gEny943v&}RZ!gxH*ig>@~X z=)~**o;TagrsKBvv_>|b- z#H9UjM~=c{Bem@{l|w$YmE<9hDlUH0hf`YJF=Dyp^m{xSzM8^&^^sIi!2LX{%Qw@{ zN}znCVbYd(baVWzj=^5_nXXwe@|n}?X~|wE!u9zAZ-H+QchlhR7(7h#ay@jdQQ4(5 znZ{;px53E#Hx`|rgMo_KPt((CHbeMxz3(Poeg{{z2#c_=h_B*!9YMK}>duP9Ihp`_ zp{6FlbG4(E%K83`miEYzQrXmQj%PchY-Wc;-SUcblS=NXl&5Bs6zNVOV;(1NYQN>) zFYmkRzaOLT2AhGN$D3T7rpSujBAc5=Di`Amx`Z|YoYp@BC-d4>1%)6Q+2^hI7BVv= z2O>UX)Qp*&^z0AQ4;scij}y9n@_>xf)u-pTRMjU}bi#oaUKjJ3Vr^Tf-3#b$wT#9Z zQ>9?iM|b7yk!DCjQu9lv&ekSHs>m*f|G%F!(v-FP2XV3z_T~G!F?W8TN_7dqQ05v% z*nM~ojoj%1-HyprsIdI60lXn;ZO^#MXmGl!UMzIQsD|5vt&+m|EJfKojs&H1-CsDj zBc9-XOE<&$JZqfPvUbAdoz-n;z&u~VcCe%|f+%&6;2DjkBd)fKgvCF*)AJ=b;h!PU z)Ic%%i(ZoAy&}&8U}YwGj6I#BZgV?|XI!!kl{nF|_KW>%$z8EwBrK6mvmQn-`v#@7 zHDuOwxRuGf2ToeoF>!z^`2bQTb3?mM$%_B+zB}NHBK%tqS=|GQs406N?s5tf{xiC1 zPPCI@tz7?0nI$XsgImXtFsGO&$`F%bBfr4y>Y}xU z7Aup5sF=QgmCsa;Z7ON$ZkH}@{%8R5%G$)VKyjlj=zN|Ad`8<9VfWNMPfTV-a4&!C zZ%s~)I<2;w6EC?dHUJk(wrqekEKCU*9OCjniFh(hyk~lRI7ZJ?DLw^7b71 zqv|tX+fMsx6!rW>#f!Nsv+yikp03)tacJE5-0<8_Nbf+ZncsIr-K?Z19-<@nxJs!9 z<(3-#4W9@iJo9gQCCI{)?Az%cF`G-y`NMb?Y#RpO}q1$5CrRX2s)PrEb_=KS4D7JpB!>5i|a ze)(HX{km?G?Ch_FShx}lENQ7Z8u>4St9B4je?HQ;d+|#^vEC}x=Q&Ad>aPwE`r|&H zlxI`OW7&Ktf1ok@+-L2Lk%ce$bRnO;@9ZX}NO@?}jfZIZ)I&<@DB9XmV{=y6t?@eh zBy9%pNkge75sABpkGxk4 zF`n&Foy13>j)R;v`0i>RKnnPF+{U}z^!D#;cRSfOR@pg94CGNgZ%_7`&KwK7pu@xt zuRjFd9?Y6QDH64u(q*e#8PwSybhHKLBHU)K8SCYS!kgPqzF0gDysONw2BUZ+hL3Hs zwNJ~KE%l5Ojhb`b;n_KWQtxhGSM^_uv$N%%yby}+Ggh7HyhBDDz|{%jLB_KmJ^6Hi z-_~t}c&WiH(ZjV{Wex(*?7V8G6P2b0%@Unk2MEE(dH4bP%_z%9<|Es?Ju@$ zkWhNmS+ui69=!i)HHTEtt=y^eIs~#h9*op}JsA_;PK{Uv@!GFb9zf`+(<729+jFtv)t4bhtb$zaALoTR zV;iEmD|TPWZ?EOaMD8H-b25s{9NndZqB|aRIEHEkUEGBlix5F%;`}+mHTm6(_o~@i zIV{l?SU$BKtQK}RL!h@Vx3y|b9X+8`w)-$IttNsshZ?2i=uWRqvQ`6^<8}H&kKJGo zsN=gQ^wC`GW1&3sr$fBUtD87@`aQe-y?d>Uo89X|R;sIUe9n}2i2YP%HY%~RGgu;d zf}vO?>ot7vV8e5Ia!cPt8~rB<<`US-em;44*_1+`P_gq{)3u&~x^0Sg9;@O$?vb7G ztiJ-2J*y;Rr;ur6!^_fZo)8MXun%4spR0hGhrRov2n79+S+QaQG~IBV|IeNxsyF4K z25QjB{^Yfm2U5Owyr<7(Ds2dbV9Auy*8uhSpT#?#D@e1=Y4LQD^}R(J+aJ8g7kKmv zFPJ)6d};aHY!x5p^RiPj_4N6a{sJBBrYmwHgbGKQ?MeA=Jw-ek{3{w zb`Lj;u}$l+Ico6Dp{T4P0d0yr9Lvi&(cM|TQ z!>CH{@jLg_GSE)3aPzgYs#rH~Ko#KoWjeXUx2VrV2XT`S=4E!TxJA`)eba?6MpefZ zveK&nTVeiA4NefMh*ybA@hMJf@gnd*q4vSW-tl3XFBdO0-Tl&%jyX-!Va92VZ6x@J z#6816x9K%yT=Q;U=Eh9OM_h9rUO#*-t+}pkDAODa_Nq{{tzo8IObZhGen^~se%8*A z;(!>En<&%;9cU~`n2xHTY~OBt$j*2lKn!V95abO5X@0`T{atNvcmdV_eBE9CIVBX` zYsE+@E=9kB;a&x&{Xo;El)mMKqcB=lp+NGZ^eot?`|HvB5BbZhxLp#8&}fNBtcuk8 zm6Kr=+^eCyA@37bhe&7mkA|L5^Ufg^`D*!-SbuV|dUrgMUIVebIW;h-kvb8hO|=GF zu^+~?iS_O?r8cX)YTdc$qOgcjkd^My9n~~R)VUFCu3n`lHlC}o*2XcQkjdF9|Cx%m3xE z-$|OKW;-%%b#bmh=9)y$v-WZ{^I?)2wOii$_M(R#iEUo$eGq)~Kd>%y^V`|46?vU* zLE|Uwd}|d|$A879k$rf8Ar(bA=HMS6vTe*UGj_p0;tk`W z|Ml4M)N5iT9c*Sx-|eaJloUIBSMfNDKPekn<^em)sT3L-(*O7&SXoNe&nTMQ?O;IZ8V z8aS=`%bY$lWOkxtigRdOzzw%W%M?w`8g}7HX&)y@sn_6qI%v}zNTO8TWzk@3*a%)0KvvBa*2wm4 zI$LE(j=&SA+>|Bp;kETvuir!rmdMlv-YWXco_RxftfAc_)tchfX*BkK9*Oq5oD6AA zx&>hVZ?o;ZcPsA)CJc=8(EqR5_P=quB&$xV-1olb_hh{1Vk-oamM!+}mY@n_V2@g)PlJuHN0PM@~}tgP??OCXLe}!<+jb zaaH%5m&QIA7Tilz>ao~T7SD$zAWfowtR`jjq{v{>cEg_Zfre|l94-p^LMZs*qI%2S z@JF#EWOgHH(3w=qel!$sHB=aflbj8;!=tmvNe%y9+cOAn@|MtA^A*&3GEHD895XnZ z7Rh42z+MvdrQkNM4x!bx&%g96jHd777tBFfT>qQ6TB}csin0OWed01g22*rKAG0XU zB)|(!vn1@V>`C}6#?)8JpX>Y;eStcC3I8>)vdRiAfRUn=Ilg`=%CR7%mO7%;OLN?c z!t3W@ftv|c#+Es8J~%>*Qs4DrgW7$v<6=OiFX3YyzzE8uGR)LkgJ}p&F zcIPidu;qFD_28?}pHwL|SUvynfp8~S*BR-6Zx9F4-Em~qhmmoOaC6b!U#yQ#SvBk? z>=K-P6!(iHhFAUJhw^`3PW!`aMb<^Ql@-m|_}fa@BX$x~c_h9x>22GR=6ZdKh$#IE zf7+&hN@j?e){A;qN9#7Y%$Y?MR6&*@Wu`s@&5~?Vrs!>C6Murwu@6@qk+!4waR7NQ zBV*{*z%#4}dSbJHP$A@zaCTKBi5+`tQHV97US7d)VqGN7%njCe+Nckz>*g@1@lvsvWc=5oB@E4< z3nG7oV9J6W1JZEE0c4wnavrMqBC5%PcyA1j6kD04Wmv4{udjjW2xjbdo+p>VnL@BT zqc;Kp=aPB6RnYz$odqSJr?YQv!Q0Fi7=Eu2aYg~!H;H8X*SNk1+vct!#=M`-$#2mV zy8(7tF~)20v}|_qe*d-V=%4PsseSMKH2nx>#{W#v(WLm!^#}(OkMFUICMaC~fJ30| zy_EEDF(Sjxj@);yww(v4LZF zFBsua5w9<*`#b=DUps330McmCt1k%I(=e|tLP%fdw)lFM5@{OSBs<8jGS&*M#sfKc zm+xbqM$y|dR7+AW&S5pj3_m9Y9O}~}|96M7o1KIc!S#Lm5b-C-ar;d*#(7Ac;lCZF zM=e2zPDa!n-8y=z7J5~W!Yn;CEVCZi}VfFu>k}9=ePwPCz zW1x;n#HgZZH9tQZ$MBSM{3f*Kik-6S5IxLFdhNm)5%3dm09K3*%175bc9y@#O9tK+ zfn+JPC5byB=CQ=1!hZ!w`-roY1>(f|Fj3LMND`+fh~;3fj&QOQC?k0uQ;h4xP6l<* zRR>JjzH-P_;AZXRkcJrMpN8bu3iIzqnf@2;B{racq{>IQtFy+F7FRn*RY{Yj&u=>t zeMc{jTC*)9Z^TDvQLJLIp;xk-e@Od~kk@99Rc&n}FmvpJ32^!qD5`mbp(gHjB#6D0 zn}<3i(BsPlJ13Ux{-GZS*0a0*18wbO81=N#PuG7B97^T>;r>@h88b?oS=483;i`|< zpDyVP=^K(!PV#@dX)SA^K?L;DrCUqfswz=jsc&Cc=eb)vM|6@*IB1I*OA<8dLWbwc zhV^DRrl1AnE8_=}3L|t(2>xQf6>;%(4~V32-W_qPfs0Q1@&AeD8oZf`)m5kff!OOy zoP2GjWpkd}Z2?x5sL3hu8s=|jU6W}});wryVk^W+eMSVklG!|QHr$_wrV;A+;{n6% zw^DyDQtfAi<`z~9`9)%CB8iGcPiB90dHOw%`I>)YsNw0+RY^lIbHY&e!1rpvEX)&X zz9jvjeQtVJeHR3KoXRKeIdSq|;Wvyv>SPCW?gGNILLf2M&gy!OOC32;6jf}0mYPkf z4|=bFDz8c=)z&IW{(SktuO6~57|Ke>k8=(};N@&HZHaF_2TUh(*CsS7P9kcSRh)Oz z$#KsPmTt#`&sVm;4B5w+846Al9ukm=ysWF#P1ojrwGVF`;QmQtkGr4P=dS&t=^|gM zrgSjdH&dlNScI`#A8AqkXMwd*{fFpm5g%5itTjPIC}$maqYE{ZjR zDL-5fbn@F+Y4+maZ>T{gnr%vr|;Gs%e9?<5(p{{!(!}?UWh&9ign}&gQfkN8|wEx8G&9H+48RB77+8hp0*T} z1`=bs%W3#T)M}}jZXz)L74dxtcODke7j4-D=4SYMB<@$Q@KKgi{}Y+JMjP%WqLI8? ziax2$n6K07-)lk@fY`Z*?03S3p9+#Yk zb@$nAXy6(u0OrEGA8ZH#F!lctxEekLp`5VED8nU{;yFm% zG%|`0&mR&)pPR&`M6VRO;RldBU{|WHD0aZWp`Iyc?8<9vU@hKioev>I38|z{Qbjc3Ts`B#2-vGz)X7KKD&blCUT9mCY^%AaGeQT!jk@E={kPN&>zZrTr#d?b z8?xNQxg7!5<9$y(0$%(sH$3%LxGoH?3wKiVrWGnH?11LVK_!15$>R3@T(WWAHW)NJ zg8F{T8NuBCYEh0;A;zIMIBL4zk~=v&zvRwmH09rTB%0iMQ0F{GglTL2hTgz5U0K(S z^-k<({j)iTSfxg6)YTz{=$FY-CO(|$QlJq%yf9`QrCYRmc zV?Jx1E?-r(30a3&B>lGcH5R#iNwEDbyR1*kE2ioUH*LV+n>{q5A!*bOB87KqQr_G} zrE#=YyRO%oBDEOtfoL67B-Cc8mJ3=**d~`)`~XXJL3t`x90!@xd^3Ib88cE=DC|7I z#g+Uc{m$}`6L6Sdv&#(T3HspdV_PM#4S{t#XJGg{v z4Onr-s%|7dmz?4g58*D_vdm+8O8vub;MO2XZ6E2zC-LKb?JdZn~uxSNv3`7k;Y(tmhR2&?z0#ed561NGNOi`NYE(W5dNxGGED!KaO$mqGqk%cO{1QI z!APB#`V-;LM>8}&H+Sutaw3R>3#W*Xu=&SeNNghnOjIUvoG!!R_&~tK6#LAg8cn#f2WcYPA z!JFaMT;Xl+2ywLRzt`z~zTg3*s?im%Rof}#U=94HKCx+J0{h=615_3A^lEDsfPI9ryr}xl4O$HG)+dq z5#&NVT|;vELLsE2w?ipU!PU@I-MN=6!e8T)Va}ByJeh76bhW>OqlY!z%17ADl)tSu zSY}6%9nX1W;Ay}bP2U2gAnoDL237%el1#pkp5(2dIGqS58gvffTl}r zgl?f^GyT|x9kKk*qn=E=?&YOmxbQP3*|1jQnnLa-C<07$^!4N0aMjk?_bl5?{I^)< zlMR>ZaRhsmeT>`udLB-R{vp-tV1!Sh!~EV4?q)D6s48F7w$QA;aBHu$tzJR?jjKCP z3xisW3X{5DZFZnAsk@79H^jf2xNsk;r;uv7XmAx-9&J;nU!YEu_QpC_p0l}cxH z|Lshg;QIFwOJ1>||4Mk}Gt-vNNC5YJ<#>aNSt~ZC|2g97wcwg@eHq(>ONR?26wwb~ zDR2-{bC_`P02iC05 zjgXcB+ZL)RHoRdqd>0=RxM)#VZnvDjC7e#}sxcS0MW;b+tc4DbovQx`jNABhV!vZG zua{wx!ren?t}t1k%T`G3#vWUILYK{-!u_ks&@giu6F~y@3pS36#6c{~8FQw4(d}zvZXqSV`n7Q5cwS-Y_t%|6fS~aSs<$ zJ7-IKyZ^N=0P#W8`lt(B<|HEIW6`OIT{vKZKF`3HBL{s({vJY3l?Dg@3H}V;yY}0C z%~Cs__eCc(?037-JM;_*1838_`@(A1VCCz3$nqB1D zc66{!o@mkIFy%O_PIi;MV}Bt}GY4Mu^%O78i_I{I-_Oe5xdZOll380~yu6LLbx zQL7r>&V7K`?*PNz1oVdiO>lZn+z z{DTTt=SjmBW1@yJ@FtEep<)BstA^l+^Zor}TuIAM7a6DOq&A}Aqld6>Xktc)Kq~=k?h@Le_h1XEczYId*%$=zaE!ca& za$(h}K?zqi7gr$3&EhBgr?<)qV$LUzu*lTZJCjl1Ld0uVR*hY0D|EZ2*Rf8v)=lof zQ9b#h{N{>R4}*hMGqSL>I;_3x{3DKn~erW|btc}SKB!s9q$)v1Pf4z4d%{E=9o?dO#D=oXv6ec>2nxm zmehxHdKRUNsIV}u!)52QfE`UEEqYnN5rSh;mxQef%%cv{!HA^T<95zNr~2HqX&GPn zcf@RG--L*|I?Lu?QEFm!TC`IG0anCw@9XqWV?Se^LNoLZH7TEG_4F9$)4ckta*la7cxD?n-i?&$2PvEY0H-*Nfo+M-#ONGqI+L_3y z)Mo3|GOOf23*g)rMK0y4)%mOBOI94wZKBYUFsg(H>xGlf!pxbiCvuL#wReJdDvj4-`IRxjzL|Z#KaZYR}C$??dwr$(CZQHhO z+qRQ8&i~!%Ke<(R*wurs>h3}J+G{=A*>-0JMP-zt6Ghp=Ul}Wr@H^UKO(SSQPWhwDZ79=8!J_D>w4i^=0cF<(;lUQ?!ZB zg9~Ua#`p5g)NxuwwQZwOO`=&@`r4Ggw}_-_e9t!0`kDFOh_6UQK2-@^-cYVtg(8T8H%BAnflJPfcAasI3@_a-uKj7XMrjAASy0Y}$v z{&&Ks#SKT@Kscw5x)T5w_DR1E=fH+xO!Mby_@d?=YugX`#lE$XGXqtlHPGNSzgjSlKswL8h-pansngo zUvZAqXpJGvz36&{4-f|YbgCSYn^J%CQB`TE@=S$w+)u%f!P&=Vlsd8t^MesF)SCc>FCA=GNOynxE!At3 z`#-2Q>n8JH&EpKLzVL4WFkPzF@XxJLHtYWofUd8#8k7hii(3rR448W?_cj4u^l9Qw z`SrDLO7kGw$wmopS_r_3GZnkO#=N6M0SQJ|I6fc>1apDIw+4CYy!4t^S_&94705K; z(T$dQGwSpSgZ)w_v^;3`)u>l66fn+)NiI>oU{7cpGD@J86hJ6RH+D_+g+(~;! zbeho#A1C5Y1KgOT1xx748ljdd`5RH?u5Z10OvjAhZ`B&^NXOS7<y+uzde%d*EfN87I~V)D%)(}eqqKpYkmaCUIXe*WlK6+(8j0Sd@j zfqJxo6i8cPdx$^?1n$s%4$!)P?(l*p*DS$U>tg(#$e{`Hm;y}o*$e&_2E=CU)jWYN zq4y}OP$@A4U&v43evJ0qIHw1^_Ib(%too_>Ou@VUbIL7!ikvC3K@EK7&IHerWk81X*5z%Bmp29SCs3$w?h{xc=^{L*Dj3*h*9O@*;9AU<@ z0*kc+kNEMs`P+XE98T;Ia#d6d0APB_G#4I@pWhnZ;tfVxg6W_{nbDVE<)J3P>qDhP zcodXzLiU`&yY#H_@v#Z^IEC@fjyRL^?r@+uD@)Ia;+y>Y`5)oDz$s-z51{mY#8Y(* z_9|?nNF077$M}$@6{Sq8`I|H0PHdEZ!9E#d^NDkt%=PF_;6nmrsZ8^ukr}i3DCPZ+ z?!s!oU6`}>Yj-dgp#)fhf8#+4KmrB!ag(fBzy@XzT*1cvMGMjYSs^7#|H~^t4#rLe zWPw8XJ|qBY!%zgSaEY)Trw-;YgjPkR{5rML-pb;U3O1=Yp;2Uzc zPqN} z>PqeM?Fz&gOc^lU zgogo=rzDT=FPF?-L@sv>QRoc zDvR_{z?&|ig+eY&fxzL{AUC20HW_Uqq)5FcZALXBdN{PPy}z)Ba@_HDVRXDeJt2Q0 ziOpGRIKR0<00J~*{s$r{`S>_;2qg5DOFvD&205~nrdG(9KRf0%Kkqr1SAep=utco1 zFsjf~WbuYFgSfUj65US;jxGVR1T?6*QthKJMA6wMOkw3P7yFy&Nb z{+Zg9ytHQFkpDfI!XpEu2?7iU2n2K!Ade#@H??6~rzg-k$ij(>of3PIRy4m;aU3ONRa>izD!&8;1SaZG3phLoJ7V>yhW;{+BzhZn5ZtwC_tk{YC7eX~ zl0ZZi3rffqR1dKV90pEjR})6$A6=?L!GI3JabnN~*rw2(+pF(Kqe=+lR-0Nb787VH z6DL7FZbBvm238Xatk%f{I)Q3{8M5cha|DW9h-hd8I*-sQGP7$OJ0|~dryUdbAEY*q zkVN`-Zb~JSk&BX8bg_E~F?%#-KWBI2WDKITiqyI;?m@-%pPj`YrR8Qy`scGt;q%=s zFB1gNYb7Jf6VQ@RprcC|&`+b8fkr(FYy8OwhtT9&&`~A`Yy#!jY8JYahE1cCOs!*9 z0QWa2C&v#hN+;BiHl<_lEsQrTfaDMu1AjKBHj=rM#2~-PkqILPOCFYq`?}MLopEoGhU_&XhpO0bjdJEKy-EWn*{D zjhZkJ*371!Okuu7x4)f)WGJ6jfImo16om$Bn-y|i*xii}@i+Egql#|nbv|p$J`M(7 zi9MHv6#`A_2r4RCBnhJk<;mBvcLa37XGBzEN1aTFO}Ovu>{cvN2B?qy|)N0{ZvYu1y>01*z4W4NOuGAS7uJCXAKtFzq9 zOXvio3~@=jQw zmU;~}$vCLVh=iVn{C_MiQ5gR@+9pUvlFJE?=6{Wk$)#sXeyHW<6O+pkqAzdk?aU;ME-+YYKd-w3J6!5|mY~6p@OiF^=?8mg3 zi$>_fPHA-Rzk2ywX9l5t(Pt0ExsNo_;d_otSHz?9(E^*drhv`609>XOmR*Z$@98>z z@!w$oY<(1P>;E_QVGauC5LMAYsUQ}*vDO$yr8rTyw4T=!9VQhL+E3+Javb$L8-vg$ z19}q$W7C;padW%3?KupzutwO#K@o^Lm>&q*AAvO0<30~)oF5JWgz+0~NT~}l)jty@ zHOe2<0k{VSvLw8YKLG!{SSVNeO%9afh`7XG;g+3=>RD!(Jm`_v3Xa33+`Dvp$mC z?YEjvIZxp#SXaH3JYF9z{ZkS}d`sXbuyNT;E5=G|WKMNDogVwE+fR5nOx}%=!)Hb# z(FPEAu&de5=`8G{w-kClmrkQoVRAFCbT*zJoJ1swE}H=>PS&3#T(w9XSbm+?R99rK zp3k1<~T) zl2N0h$>kd=p}nO#3}CIQM~ux>rtwadIt*jt$cpInS`6yIBm;*qCgOD=gl6On3S1;& zfuS%5K+FG~pgw7Pw+s~>guF2kX_jcDF_8I|A~_-vm_Tic@c@?OqUx1AbYTj(O?juE>R@f18K$oW@)6M zJhN3tIBZzhfq_=*p>W2SW&BH_Mh%BDr8IMznHg{%b%TbaVt8hS%M%&V2{3U8(nd^= zlm)7gO$1s`Rqo|vs(BU#P# z^1ugv=+NTd&Hb=Xp6-9rFAOU+;2-4VEbdJ`-9JIRpx_G%AnEfygq$1Cpci>b;p^$n z2Yr#X0f0aH&|wwki2vJGrPyvSbp9`q9txbsr|P(+sAn6m{zu8jIp6-&v4BL|d4k|X zQuyAPRXq6s#vd5mnbR8BpA$UUV>Xy+ZfGh4h#w!sI=N5`dQrqflACQX=H59p)*==d zRT+^y;H<-%#+?uis<;s4c$k8_u?EgKfo!*U;MrXQar^w5UjMxfuGc@nmPiAmUu2%1 zMEWP|k9xjujDBFj!m3QL#2;?7)|0+t3)A}K4_VPGJBIO6(fDJGzkA+}X^^p2?zlMj z)U6$#gGP7o5i^r}i8R4Fii=9y+&k_R-fnhtC>6r#i9)sG-U^~{)8R@#t1+eWn&gP^ z;wK$up7-55jEb6Lr*mOPvaJr~Gex=2NYS6P&QAo$*b=o3? z&OK7Sy;{Jx@O*0T@O|{f(!XhWp7K-4=l-(2<9o5s5 z{w*r}@gnw5hm?p5ObnK<#fa~)AzdC2*+v?t5mjx`A_7sBSFO6$PyU8ZkO|>i|EiKU zTOYC(M-=eDeB_O120k7Su`^@89Eq0;9`#QQ?u~``98jIl@OQMV2&Bccmg;ANcL$IKd*y?F7o|?j1fJs) z9RIHSzV5q2)*UDFU4CgYb3R7r<8PV`O@R6aP3 zDu!VMq={MzjQhvvNCg8tc8_;gW60T5P~~!k|3{?ctLE?P?}GYiOK05G=Jw?JjnVY_ z_v)NuX0~(jfQQntNI~`78duopXr2nkyUPz`O(Khn>FIl|+uBa+BYXx{4XLst#+?UM zD9e87H|9+7e^C>(H{V6%!?3^Kt{H5kc3=H_@Amt*iFY()xg@ShDZIW)x~c19CNmx{ zsB5FzPi!}ac=mc5SalrlK;LnduXtyyC`ZIG)U^Y9SOuhz1Cw_Tn)s7oE?t`Edn$M+Ixs z7G55`cv)-Z&qr)(g!qiD`B%uDs5#Wznzb*`G{$Tnet6Fvy9Po*UOnK5a*XMVMd6Ty z-KAbKN`!LoBgjc!Ar;P+DaSSzI}SWG1@8Vo5T<&&7hjwHIj{LllsF|SL2{|rLF^6 z%M`tA2Z!%F+Wc;M0*mEIjJedB;%_-3`wi4266U&^jy7-Y9mG#iCs|k}TgF|crI*W4 zaJ$6DPS=|52x~XmInHvGi|0HEooM$iV8x~jc7P14)bs|ljD^&aC1 zQKw7Cfu1hk!i$4pTM3WL_F-D?2Dh(C8)_~f+Yo!lr6{W~bbB8Lt7)L2!)|gC9Z4}tnS=hbz)ouJ4p)224;uqKp?z1xe?dFbOW8<{x1KHaq8P}UK7 zDmnueG$ZyO$${=WKc(rr6YQh(l2q$g-L6A}#}!~xWI=H-CE04-;X{QP?d8S-F6yI`Wyr97JCY#86U*Cz>0oevK#+pz-@qWsd@paMFBwFXxVRu# zLLpq$3zA0CA*z!%Q~Aa_Xnc1bhveIjT}Y-;BNFytC_#?+_4LIL|4#vYY&YfX_U3l~ zKUX91B9Dh`AdH$E8CyXAio`y!f?S;Qzk^vf7bj%nF9aYta~>XF-zHo9>-4gws@mJw z@eXSx!T@N022hv)7JATF=yy6W{`0B%qypqJB>TD}jt3~b073mkLC9!QeFSC50AD{k z&>zwNWCr)KE=B#ioO4YNi-7}l{4Q;nSVhgZ%HJH|i7m<5{U{+t&A0`n*g(yMU%6TGS6***Bk4{6=1Wg%U*WPcYCX+Yo#XZdhUs` z@kUM$GxPWDJ09tmr?f0LR9n-nFK_R&kSLBR#Da`&2A838Gx2Ty*j3fMn}NP6%yYPx z_EJX6%vt01W!|!Kv5_Hz-p1%U^uZPi^=|!-niWWL&4VwTQw6zaeM*^TT+Zt#1ISgi zR1nDAmGo&0wD3u*#{mZ-oU*og-{bKsQj~$cKXOV^1`*1*@U}mpMyq-v5tYCI45@xC zH*enA&1Bd>G@aNx@rT^#Mqi|U7O{^KCo<+|^jWDxM}QOf$jLjVE?OS_%lfgBPe82`FBORr0b$+Gf%EAA8|MNLWTjd-`jx9D(_Lp?{t(7!u?9 zCe;FELhv{u=1eIkWeB*@v;2VuA6ueB5)^uK4~2B z_MMeb*uw#Y@o<6s{qPOaJ~Aqqet|R9VyfA6uYh$2rVn0i!C}P)>g;pb;APMi(CEuo zfRTn)3uq@RW}rMulv=o<0VvEQw8HdNU*dSeU()cz538?1hWWKEyL6ZH4|K!dm@gU- z-SRG!YRKPv!j^J|#;T>1{1(bRS#GDp6^(4_s2m-GRlArvspHuZDx_0B^6eHMC#i{4 z`w57?GvJ}vJ*AZ?js|DmwTmRl>w#b;S$NOvJ)Jk>kWItQ#o(^3F%jb43`F+dm#tDY zc+rf`cWb%yEgUn3MPG@Oh33yCjZwQ>u{P;)o}c6mnx?7LSqoz(?sJ7FCe*?4?ceQn0>LYY-jmF?-2T|E%ROno{ zJeTY%O+Y-N|@yJs$#hn-YVbXV7`Mb{TNn z>|sBd#zy^ahT;IKaDR73B(G>CpW=2A-WWR@eB~!pTC*H`6~N~HV`P5Sh_&S5yR2zv zF?@Pe*E((RhHk`vGX1f3#444^bg2Hgn!oR zglpSoIGy%K-SMDxvg5@#_X2~Fx%0h!PB+?m;j56UgkOHI9s7pxp37i+>OF;?naORC zOvCn$pd|e}dRMyoR+A<3tw2%aN9c>38;lK1)Y?TQKw9LDCwQQMUHH50@LN|1DBSFh zakCAUX`!2Px%IZ2`-TWReQpld@%l*hZ7vzDa+;bGsZBxDu0gMsdSG%MEW-wu)nVfb zsqckz%uBuX;7Bcb5Xj-}^0<~*Lat3MLhtrSGdX@Md7i*HI+H8BvV>P3#;yB7aTI;G z{(UiH16@S-(@tfhxr)4*nQwsHxBOWU(@8b1~>$QJ`h(_nW^qc-8`>Z`u0e>n_0*4*YKSE0q2U+a9q zW?A7>F(a8H6~t`WY6ahNo}=`c_eeMZ+1*cgxOKwisZ#Z~VN}_CJsRwiUN?IPe*xm6 zL;2b%YZkm%a1u`b!^gV0BmDgHw4xNX69*PPv8H@el_jOD;)3gI86*k(ZTC{ONUdI} zxlw3xwkd9&<3bzLc`R++tA z@{%I6aqBJbaToOccoqHe?~Gyywe3e!&=ia)~d;@zFj1^dZi2I)iW3H+)LD z@uVvpgXcQFo$s^Vi`qG%3@AZAA~vlHKkAAUp_oX=>q`1~zsfP~18gL0lIXd=^^(4qs?1P|;ke~MRr)w)51qVnJ2;{h~t=WZ7a(0s6dx=D7j0oZqK3U|u`UMsJotc>h z=W%jxz0z5i7>iPSM@?9LHAt_M<@_DL+TOYRDVefad zz9ASm4b+@%^r`A(vx@4AJvy`ba4kDqfI=H%1W?oC)#L$LcWo3@sk6ys$7u!PLs&&QLJA9n{HFmP_R7x73wd3_CPU(McP|&iJ7E0zgQS z;#4U3GM%0s2A)ouWS_2ktMDadJFraDy025o11T%6(@E_)vFwA;3C(N2fP!BouMa zs(#dbN$n0={*ssG8|j_~I%Pa(H7amp5pqtGu5MB4Ms4;%L`G)*`Y-crh}#NGS(gv* zb@f4ESV*S z6;7vim&0#7#P9Q;zFy74AU3%7xzr+)1JsFQ?=V$OSq|Fd`nztgz+?G|< zB*Lh+8@vJ1x~R1v5}M;CWIsj}f@An<WusXeT-5W0tYekKRgo2BtIUl{anR#sQ zVJpX#&YwI=Faf$qL%3!4ofK2-C8s?w?>Noxi&}U;gFD8dZp0o*MF45L=LpXH=HZsz z{zBU==R>m@(<%fDSxg7Mj}?=SRg=nWjAL9gagdhp7c*;u7fgkdjLkk!OANXx zB@o3AesAVei+>WOC*oR}$Nx!VqlQM9JLAx@5uSv_wT*if@A-C*d{)rpY$%xI1D3+oH9I5<(6a1#fH~GdwR1u|4p1a6f>cft)$X} z(>QQtYuu{0cWJ5NwBmBI1z?%+h?(tAI%B7vEglG~c;-s(sFh~wlARuPS;@_&Pn?p{ z8mY{6?sT}mBzYyJj=X*2>pi=l`RthFpZ=}!6r1ZDEGv5c%Dfhu zljUwCf?4+L<#l|X@JQOmd$ofT!$PN}v>J!YK3`I|n7<0Z_v^fq|6Y5-6D>C9>E5Pa zB#sjmcf;2TNTE~ry6tJ^*vMZVapv~3`yQszsq=aJVQtA(8qG*;?H&ADospEW4fIaN;f zt{VGb;3Ozsnhr&FZilM*CX_!I6%iX z)>j!nz+L=e9E`kQwi1J6Pa}~znZ>fIbrC(CrR!6xJ>6y7KsiIv@9JgSc9D4Jd%+{( z^Wx5<(y61Y3V6h@1r)oxdjBBpfXohj#=TZQaN%P!K0e@gNkJzj?c84I9(&+7o_EE( z5IY{Nr$;^$MX($Qp|hUfvBCRv{`+MB)aO(zZX>>rQ7wnvZ4`NVt?QPwl~GETYMXbw zGm}5gNo#xccSS}ZPCLCDDJRXTV6pUW6}y->N_}--GN+bknDlN%RQx5aeLMrLJ#g*% zEGsqldwhsQT_aU>!~4l%jRm;WS6yE$jM0-jqp7Ov*rITVZl}I>Sr1OH zAgy|$W>R*u)n+@@=(9|-rQ~@?2DVytj_tTFI+7ABLPL_Xv&RjuLCT2%o+{hZ z;ogaSDJdyl_=r1|-jf*W^YNtT>312}pXX7vx+kd`%8i?qd)+hIdDhjN+d7|W&|1^I z?Wqq=P-ys`to^4o4M(MstZJLdH$ZmMH2K~B36XoVEFMErsV)>wDe8Hp6a8`gWKNa; z-Hoao`yLmp$txh=uyT8s9lqrThIb(0{s84>cey$WQotQ3{QIC&1^w&7*FW(M6!r~aXEi&3ST$l!VY%skco@^|QrZ|c_XXSTat#(FIDWlfc{8oRLjXL7oC zYzYQqjuC?A1kkwZ>d~l4@ha_e-|DLd&$$$-YSzb-@Y^aSS##SppX1iUxQb%jj!svF zXvwZ~pSSwB&nk7JC^@lc-$iEWWyKx@kOkO$eD(j6SYoCeaD70S(7B=A8vN9=v4+WH z{L;KAT~r8N`(l+n2RK_#Lk6+6(E8xZ-d;A(w#*gS`0l--Ut08Hv(@BXvOIqULXQC! zpp>S!Yp}ZiGKP-aWY;ycHjRWM-?=V|s`!c9@NQY{1z!}o-LWNUl>Eo(;ju8fGGW>3 z3LDF4j8R&{)S%YOcvsZt+|RXn3tVOZ)O_gBN8Mk!*h?9*NohWH{F|UnqsBvdT{_3) zZ0`m8PaOfTlk92GEAx#z7}-UX>$YOa)d;>@{ZIKqd%WilG9K5NK%V0I6g}RV+j5M#Zah9#M~)pWMk%p%M7Jlh z^O@}FYi+H?yu-F8;gG$1jpDSkF}hz1oQw;hr-65jn|hO*Q=Gm!96w8CF|5&zx(vU- z8a><6MfEbaJ+&oqy-iFO_w)i5gJ++S`vze{HF2Zhg_l6YPPFyxfUu9vZTz3 zW$E~Z%+#VIN(ob0y9W5(1T>NTd9N@b=LZ| zw3&v7D6ThUdj}K?{}&LPO+7*WvH4>^I1@a_qWb1&Px;YkhsRlw#vlEKSOApM|Fl4X zle^I|ihI+mVJAwH)FX|jC0#r^D)`k%Elh_IlYxKdqIv#*XHGAZUv~URG6H>5=QTSfX3drxDKstL-5@}60j4_?!1%>eCesOmLd&AX)!*EMaIS7+<9nYbml zRga<;*CtEgy+7ZlLb7E^=(cbGQ+(532lty!v8>vidCVoI;y84_{Fs6Im^*7tTQ1jw z)9Kx1xBqt8{hd`Kh%cxErm5|v>T)z>JsbYMG}8S zpZYnS<#P6=jmFN|>TGkHtHpVBL+v{l7(P+sN$isWf@zL{4K2fUlM2DwqSs?Rz84_d zkLa?c)+RzrXZEd;#rQRw~4Q_;&0Oaa}li$?J{wD^PskF1z}m z6DHzuJj~$|c^{*cTf3?RBl9I2#`?r4{CPH%<}>8#ZsE}L|DW?-?2d(1IgD8x?Q*Phtnt)T2hYbbg1 zDA2#Fc+2Fy^whDmm3vx2bd$Dv_}U(8X{L(Hy()h? zi&rOqOq;!Rm(A)qAJvQR6km{1_uK`RsUC3w%r&dG-JNE8vDHM($YAwsbh9%USow=A zl|b0O!#AC3#QrqB+qHb2GOl@lKPmTZmC<&noMTelbeS({3&rg+J2>tgk|cdTt9xx^ zxVye>gdSV@#pXEb3)rBRK`4w^^!?^9(Cea(fh_uV|L&{vCsM>N`1bsk4|-=%*7W8_ zEEH663^ufcpr+1`92bf`n=IAC(ei)5Wj@)wuqz#z8M%#)j@h33SRU7tq1APfrQA9A z<*64oL79zu)Lw2G7tICK?)vVWoLryYrU>`j09W-lxUr;gr7GKgkM+r5V_+a1A4`IQ zu|EWX2>qP4Sy)vr%OR>v2mDtQ{SVe#rycPlOVWz8aLxY%f#G{5*=V3vCtsL{U zt)7Z|knUN2kgy*ou=T}=o0#QtXnoGT1SAxMIa-#&fjk8&ycZ)}KYG>7Ky(-Q9&KOzQTp&%9MXHSg0w>D7PI};&d^&0&*`ti;~ z)`)kB&T9R0`nx$}KqzZg)SJeg8SplWY8SfR*vN~G>3Ezq~@XdP(jxP!2f%@rsu{x8qN@BDPxL1gxK**m$V@@NK0|#p0o#^k{W`A z=Qtyam9h7^mo%;W!E`WOTo$FY*fjSpo0si<@~r(G^xLNQY9+-wA)I7S$esOG`&&!* z`7O#SZD=KrB;|@+3X-A}F)6`!+>jDnCx|!oS<|{6ZciBj8yVv?k^keous3dK(_97?6teg6#Yrn=Oa0NC%ydZK>oDu&vlo_ zjDE+_Xjrfk6xW6AbcCFOLLoMm z^3N1q0bsefuVc(S6xoW{oFqM^FThs4EY5q}C@N5Nv^q!t2MJ4lc=&&Y5rykZI_5G& zHy1OKJ~nT5KT>?_>=FCIX4ZDEbb4)km=|2sJTJGgBYx&|^Kz3oJO%;47eltVmj#R? zAH9I7Ssrj`^yJJFw&^;p>n98K_i5mysI-&3KDOVY2lTqCr9E8T$y^T0iQEwItMh=N zHoJ;+v)hp!!x!?SlQ6f>Q0Pxh3mAu2S)69~eachzn1)U+u&EZ=>7L46AKQ_Frn1yL z8%q3L@474g6RvOLrkNDbHMZf*a6or2#4YzhL#p)Eqrh^{o5fUQ{R+OVR4BCLNYHL0$d?C3*8 zrdOY~8g5MMW~$fyR4r%lFTU|kTo3&nTf;wfWcXq}s#|MxryGBgW_4-1=AI4M*(z3s zJN4`oTNyf)`IdKtEzVrxu+bICc2Z-Y)w9g8+4v9}ShfA!N!chpmDM_rz%m~?b}$dXr6kf2(1 zi;5cYnNz6x;3=^EC%$~ZFTNSRJ;w(dA6!G5=$u}%+2raLW_gw4sa)ID;&w0Iw zqv*QXtWt{)hmH0?q^Pudoj__n^5lJ*`QGK4h;FS8Eg5ay82A>iw%!QqiAdicuGTE| zDa*ZX4n3QS z?w)G_k=VUnbs4+rY}!TmQT>y{lun>Zfl1VrhLR zLxkI!;vT4_Z8ZWyQZuRhy4=58u+p-(Qq%LL-x^$s7=wul%j#)Taw zi{5i1+D1*Wu5Qhe@iaE`<6z_SMrP^ASjXBtiluWsN19O?*XPxVugt1#<`c;QUd&AT z5~t7e`4ar>Vd;ft5fA_8nU%3O`OWzrlP6zWqU`c}h9m*@sFOoohb@b+F(z^FHAGymGCwy_wF{dcRnR%zujFts_5rcD@>%tDEAh;d&3=mw3yCU}a0Y z>$Q4Tajl6o;_1(E6H3kFzI+WdVU@MRUQ32e&e_ma^0!+C75k!7*W@vGA4eyL{o6_4 z`EwrSWP@shpb!EOGkb<;`Hg~yjH+3$hriK7%)juL$@S^uYkiviBz@7vWj-t!3kTLo zw50qcpajrVY|AL$zL|Mq;^K?FB<_20f_Vgcay$g~bi2a^o!m1=XVUpEftR z1heP%i|x+m^RM)Akq)YUkvES@a-*{W;GQ3A4v{90n=(0Oc7EF*o)@{!+Ebh$h*MHsR5#yKtSC`dgwO^+-_nm*r>9|OyuV6BzQ~^8F#KV#7B(*Il56; z=up(|8ne~Nq`P1pR&pp}E3CTefJ{W@9b<<)5GA6!yi7G5XR6z-kf#Wbh&V7KQ^+jU zmwH`W_T%v4yQ_77um|10L6Ng4d)44_GU;pDU4HnF-M2c=xgYdhQFDB4)rc^PiaOXH zccsy4A$?&~cPyG7OFtXM2W=KJac)N5gZvMK(l`IZKE3S}bskB(`vZZ~RO89bn~Y&I z>*2)nGP>F1(`mz**7upfDWJTohTvcINI8d`VirD`Bzz+3Sr)rWtH6;}Uaijf?02X? z(DSM*@H;xB+oW1CtIUzB<#{YH{xvGbcf)aPqj{MAErz#giloLp#2DNq4Sv@CagA}- zY&er%`Y&qfnHDV5&a;-y=yPr1kKdHhLX+zx@AgI~pa|CPAs`DZtqT{R%WI^5BDibu z-4a`uI;`i>$~iTF@at@tJv`TUyMdim!368dqUUqo>G0aryGCd3l6j(fis<)UTe~!& zc88(+9(G~ZChd9SI&c2dS|n=fl$dm#i2oAZvCcScwQWLj_P2u3dP+^_K)25LE~IGa zsIT}u*}I%+1Nm^v<7_2FhVFM-DhKdzp>ie=HzQY8J{K$Q`)#h>Xg_vJ52Ytc!Y^-RG zk4xM*`j_F0YhP1{cii;EjEmGAPRwpeU4kZz^fC_ho*1>LeC|aIH%Av6L0AF*dZU7* zq6fSt2#4?A9i;`^@Oi_~>=wQ!lMR91A^-0yzfK9m`FTv@I}|#DF(%viOH@f%rQ7Et zQ8*nJYHn&B?PGS;#sW#YAk++d)QwO)eb97a5D#C`!+tPTZrbCh3~x@+4~F`Gawe9T z<7)>g!%4eZuI4=eKsmYTw7J>%!|Uzt&_~JK1f{&P-Uq5%kGy9Y?150Lh0B& z|4$g@t4R{jf=aSL^X@RpV5e6b%}p}XG$aG(r~B>tKIO~?yT3|b|1qye zAQ$wB0zif(p<4!`1O37?Mm5Q4lL`6ORDnWSO}RS=^<8qA6F6I1N%bUiRHiyi(jy0J zU1c--=}`!{4e`1D?2i{8kGn-hOHnphx^Fh+L!uqHqf2EItfim>3gPrH3cA_Vu zDyUo;1G520(2;#vUsA9f?G!v7$f$kPLmH0W7WC0u!Xg2jrlv6mR}VD{Fi zVK%ykDq@H`G|mTeA$mv$hOQ$+Af<(Hz^aIPFTJ36d*If?C=g#)c|8%RO(#p1BaBMW z5?T7|MzGaUBZ#Q6h9&G$wTeH)|D)_4f;0)YGys=v+v>7y+qP}n?y}Y8F5A{$wr$(y z?YOg=h}ld=E_0I+xykdL_j&sZu1nEMdCJy>mgE$hkJ2OXZ?6IogKoN|;Wrh)&9#QNY0E-7L3l|JUt&D#(ZWkXfX9LesOO^VwX=z3D=c3j zsotIfZ9b&EQ5lDwnMt{pHCaLfu*|vj9Ey4>i*!(7r0r5P>j2$~+b8pn(PN_2=evt8 z(%3~&qB1a1HG9We$!Sq;F8-JyKf<=(nbx6U>~U>noc~nKko(4NSP1C?YBO8D?$k#> z;3LMw0)AXANF{z;>-`Q$oPgn7=LAe=71H2-Pvby#)$GBN7BSj5U6dKE0rIg2Se*#U zZp(%mE|ux;vm39oOEBUdh7}q+lU8b6O)c}V-gY-OH+1mrDZex+L6bTjsvX%s7s>Y! zR+S{e@Dx=+CBJHFWS8u*{x?8JK^eFTgTPfTO8S7hokt;+n|f*hol z9$$-9DLmbw&%jhw!r0YWnvfPN=)|``6llkrCxS%eunWfg$k_Kn_CBmr z?l-r3^VNMkt@miPXJ2%G%tgRL08{lh>aAW5m}CB<)?T0Y)@M1(-n^QaG&Xqs_CE+M zbw8M=j7|GY{*`vTaw@5Z{)O1!)jcn^n@ou%Iib~C>8Yn9lkffmR^xyw(!;f6`Ll$; z+Ky=ykY9cQ3eZwahulmWVxI65^}&HHU6j&!S*GgF1YxcZ-f#=pqwl3oeP;8yBlnUS zJ{Ur7kEW0cavPt(YI?ubw`8c~H*vG5B$@TKd9hvHoY8qCxc%{jgYSoAOo179TZt+; z$|b(CpP@6*GeIz?O}?kyy9chpU9nER7VN9Y>IgMUc5c@=?PLLVCI}Om zWd>O~W8by(fl`f??lo%o+o!uxW&msv&!zj59Q~KBQLM>6tCgjAS#dzQ1H&c#vCqD! z45L2}MMeRZ{^MS?>Q^0mK!GNt>w_TG4l(tcTYm%ci<`^d1r)XLXZ2Kzb9UyVg~KF^ z?u>QWR-k`?XEXJfXoh3L`9AnB!R+wL#2r9WIW1MPCTm{rKqBKm?3|Hw^2s3&eutok z=Ssy7Io~HbO`_0?X1sCs!=V?_W?LN{vFv9_!Z;B;u+QF#@OfvsgYj!tkh)RA8#O=ArA^M@Ag&^- zI@kJR?VG+2jNu|E0D;0AF+_&Dyhg6muSzC4F56(PVMgo1kv$Cft1VFA!VhrPGwUF& zjc_F~y`hi?Bm2k7c`sYIT0+-L+^!6J=$GBTwybbajq*O>Mzzn_a&DlX#O`0I1wKXz z_fuP@;r$pJztuZ6(tN~Ha|}9j!`))+96eg`4%(G^RW0t*27`&6uQ!VIc>SLBo%rX@ z%i>W*Tt}*W#%K$@=Nc?it51iFwb*k&|I5z9&Hjykx98Wr&g##|h5XS<2=^ss(EG43 z;vSjMkD8|8EVj9>u^&0^mBr?9E3P))Qr705i8dYwv-#Y>n#-+D2XrJ?-maH<<(*$v zrnHR)Dw);JMvuzYURl^)cQd7azr)qT$H4yd+lhVH(QB>gb{{!i&j#WE0c#id1@F*i ztSg)_sH++IU0pKBSy;N#o7&nE6=DHV<)Z=pU)O&zu!-eUQ%W$XZV$L_$u($v;4`s` zKto_+vI2-;snfE+XmlENS~R7qvQ=F7A^K-}Lk%$6ks60*`M@&I>GqqgkLiHkoA`$3 zDrTGIs!Xj$^9EwqM_oZMpoHC-mm8oyZ3866&g37 zfmowRra+7lktqo+%s?R2pHhQLVqGy%R}lF>&=p~i(HQ^Y?wsJLL*Fj~9|Qx>1>1&1 ziywhx!}%iHibj-Xdm;;jKwG_g$vue8Gp?Vc;CF&do8o=bn0+VKEK0qTVeUW0By-^- zCrm-3?3ScN0Ky5vBi_9LT!L(X8I0W!B*a44H_6FYVI3zd)*^Y!nYKC zFtzH3Mjm(86#Q3#tY7Pm1+I-rO>5E-xJ<2V`gkFs!=I~myPGwnrI#rdc4-!s;!nJ+ zc!SALT~eFd8p#6{_v0ZCi^sode0VNyo~KDe2HR6@8{>M-Zbw2toz;9R7{5$o5Ou5C z{Jt&xRW9V>LHC-opK;DePIe+@TvOPmJ?*P?<_`V8ZtJvRHNc3oCWJULMIaOCo{(M4 zfT;WwxRt^1CHE@~p%8y11xg~j(n+b38Oy50Kz|elCjqmALjh6UH5YKhU}MKeB}yHP zdE(oGSSL889y*xfQw?Z@q#9{q(o_N(xT^S8QBLzk6DaX8$a_j8F_#%LM^^%k517*ReGFrZI&`ABwAcOc7# zLDVeK3wAV$cV49-DywMj(ZO93ShpRzsKS_@{O{3`FLsEOeyD^E#&+Gv!g`XB-=m|S z6bw#jLii1c1zw{=&*o9jk}%$_k&aQM3Tlf*d*(;ZRhS^;`|ZeJr&#*@$mt%@)njc| zFKC#4@g>$e0v7@M9nD?PsJZ-_)GC2eQawLN2z>>zR~>xB`Mp^d_$E)_0j-|`$e_S# zT!}!@?2Q%sQb&4MM6M;Gc`PWLji4~*XZ;$AAWL9?!<68;A{>YDqoTYoKvv&D zGucJk6l|DfXW5Lv3WAc-3_(-y^RC9@WU z!7q}Grh;12C2(OcnZP^`mQjPAw&c-lNZRXHZ+LsI)0HenYDdr%Gcl4WbPts@Fp0xL zCf0sN%teR>DuWv}WXG^F+;R$bErxneFP42RfxzS-8FLF~UGRw};m*7WKFIg@0yeaS zLaP?_BY?jBl8bT(iwAe&Ey1Wy+xzvDDKnfMOxEa+vV)F`A}as_Io9Ek&@NKfGU^G? z<+y{6SVPDLa&Ei2&ZvR}n;k7!Wpw5X6Q6)`lB!7`J=M>4bM!Fs?(e!y zp2C7p!W*=G91PTXUw!%CV2S}q&9a9t!9w`;k00;*P={}hW z={*w^c*i(HW^vNOz={$^LRJ_o_i)USN_ zy4@--&|DC+eDS_haWFa%a7QTG)mLR<=pZApiAsOkh6aZSZ-ggKE>M=f^| zOHp0;3-4VoS8B48#JlDrE96 z&E9Dx#;R~21L(spyD%*W`>tU>dh^&&V!WqG~5w{_O z#83*vBT!fxIOAOuG{oJyHd20I2RI~Oo00rA<*K~XW{+0>a=EJ`Vt+06HrqL0z(Zk? z3*c2ruxTYGqcF=e;xU721;M>pmhv$dB3NF3Lp73V4)CkuJR8T&njDJ@Pr~092e}X) zLwSJS@J~X<0b==SLE_*?G$X@MhX*ho-s@aX>l^rK5o@CeNw^e;I#12#o98J(fwAS#`zbd!U4 zgCZ(K%m*-XmFFX=UP%Uq#}5TU2jEWED$?Fu@XpH zkuLi&k1WhpamuYg0`+ksXxUdmq9utJ`Svp-p?bwlN$M5))#pI=jo>%V@I2W! z0XsB4ap&BPwHdbXvd69P?_gulW#hWB> zBL&oMcNA2{ypTi95pHd~YoMK+DV`w1OqY=!L&0a1ZXaN#2|#TY)CXcZ9hq z6i~-XWynb}NHWJXu~nt+kQfr-#pYp=F_Ar>X>|ha=Gl-4LRi=%9d$a83-9Y?b-}V2M%tHG&~aFL^H=GyG;-j4kziCq)?8el~^XF z8#NIPFB8ENmnD-Y(kJF6T_x@r^#LRQ7dMJb98?-4*=OCyBPkaxD-cSlMS@yJ8Ticw z4J7(DAwQ=A!t-m75N1-pZYJJY0WzNrQ4m++HMIq{w0{%&ddk!@OKev=CHRV{P7Y?$ z7^w|)V&D=kh%4q6Mwu{Y_yQ|3m!hx~Te1(lir5~8ppQ_4bA!?dx>|=SJr!W&6FAFC z5kGN40c%^R;$;f~Yre%k2j>s5Gt6MnH@#o#)cDG-WR;`K9-o|+L|td(#M$@TAYmwG zml14CSKquBua8>1-mBe8mYq-({TBRkGH)pu%N_@oMy%nD3lCUz$ijlc2}XDg1mZWb zp(nKAab60k;mdNoDW%J*Ebt;C^P4Pv6N%Iy$ez?$0;n-o4xYQK5IgRp#;~?z@zXh! z39KM3&saqA@H7gLfxSLP#DpRA3|0o&HX&nh`mzo&6`mk{Ht@!%xrNvO!sBnF6ixlC zKst36A0j_sTi_BD(#P{yxd~&ZhgX4uFMg07t54hTz|8SuU=Y}*2HB{o9( zc=%73hK#z1ITC^IOS@gbsBr_AV@!UMWf?K->qA@SzUn43p}jeKL~Mc5CLTfZ)(vY6 zU@90PL?w(4$0d<9`zRe2Tc6ic7}nIZ{@=d0xO*=J*0*g22tDHA(_2oz@!hH~|EMXf zayxBcENdXX9C+0?0!t{qd^kP;cGAF`$nYLGo{yd~b_8LF8kk+u2v(F}bZoy~Wj_Cm zw?K+Fp`RY8ef97(TZT(3xJkA}4lX-FPIFRj4vs)|Z^p#5;i0W7<{NvFhsm#P4V>5Z z7;$iX(%cmNbNp7}pia#0a~y7bKplRY2I8buxz|jz6q@tWV64ZMKRG>(4y!H>k%NYd zjyz%nD+9kjq(6{L5VFV%4udC|DPJdl!o~9vIE{udPr?^zcpCW@D~Degij;;tBJth^ zeTP+C8Y7)SGNkBYLVjFI%7`q=LrF3uBuq~9d&VRR9>kTSmf;!-+Easc4Nsh3fB&Tt zRc#PbAt5bgSPC@~-pGLUg7T}97^TgN5f!B_bp}km<_VKOInxKpQ(vwuIv->jO2>7&X1v?t8D%N?m-zG> zhikfi>*qZ4b%H^8H(CLz{~1**JJ3{3fCf(6N3YS#%f|>lJWI}(%81qDjugdDoRG*6 z&yUH6U-wVcro_A6&mYKqCjZr7Nca95@=$#&N7NCYz1v1g-EZ0TyO|96ZUpREoJ~ql zm%;L{2|#wgg-=wAIx!;H9l)70$1&Hyyd@t<^Z~}#a57j4u7sqYaSLek60FyW3y$_2 zc=g}3)Bx33uam!xdgxA<;mYldh0yx{k z%gm_}hPj>VQ<0bJ&dg=?mm<8}A=KS@BIBFkL;c;Uo1SMJ5ib{tz1`(^F8nGrz6M7y zqQ}3lmH>+)Dd;?O8hIaSD8rwZK(@et{VKS@&>t{$tgfpWrL zzuV>Yx??-q42v7W5iix*f zx5&#sX3e)DeY3#kA;i1#t~3)`9}6>r(Vl%it@vzYqs)RxSBHqd)e#sPz#u&QPNqOY zlP*h~l)6M_WZ{}BQvzt95YIvIp;8FP5B7zwTDjNsaAS)?)09feuc9HYLL_$`ODL-P zOCtuJv7ibxypl4AtGEnEQHyMv30W`4G9rkANqGuAry0%grjqOjs-T>sZ-T-A*L`Qmm(inK5}CMJE=j6S`lkS5{xx7uD=Nl`h=dN5Es`SB zA}wvKD5dnT)oG`|Hb~7GLtPm-$+NbgDyt#;Hppm}&J#O5A+#bNL|52AatTs735*zF z<{PZ4$Ps6O3=JAcUcqnj0ZB1*e|Z3sJ=QEgzYd%n=Q6qm41FbLYCY*-V1$cqZ-o;K zDR$J$iF30{5$kDTw?yog0!XgDYE{~`&}pW*Rj8n?%X+6k2JH|)L`|t4V(p*+)FQF0 z^nv0?&HHBV66O;Ip9-^4v@gNJkA5AmVjAJp_|A?~mX|$3 z8EGHqy)y=&z7Q_#7WiZu366AF+|;;fQ9X2k*>tTb5cBsGV^@zj!%0W8xG`1uUBuJI zIdtbW*~V(?F=pC0zYBr>!mtC!^tQ%p?=8%nl@nSho8G2h`!x~Wpw+!|^j#|O2K;rj z)_p^ZaQo{lStby5JRJaSRvdL*v}*e)4fo;85%h!(xqO@VigY{78sN30&_*@~e7Xwh zk^;>7jVTx8Tq{DmTd5DFa!d~SWk^QG)0pghveWtpOR%R74W;hT9`*sAvn~!k3 z-iZ*3&1jLTt6G=$WxvlEW|5?Cqi$qJ>a>|0B7OJwnqWw?(yIt)Tpu=r$umzMcg74@ zn=giK9_exHPtz8=A|xb~#)PRMtQ~a!^{pcfW1a<|elP0D86WR=uK+)Lf(W?2C#)(H zpD!L@7^V@TF$&zQUV;2N-Z9ZOYm~5?f9gHrGkB^Vs*4R{vZj9Xedgq%H^83jz~w>$ z*FV-%#Xta{e~R=~u7HOMpPY!ND)zh>G>IJodu?fuBLhAACqKV9PZ{ zhK43HFT*zw#H4|&iPYnZJDkshMAFuo0HlYlq9_~MH)wALHMR6AG$Ip{5_8P^;npO= zf=K9>f4Dm(%#Yme0kkrXuvd!h`~WDF*-+k1l6@!?EpTjPF%_XyMp5Z7l!@Ka0aeAm zsls1{_gG5GV$4ZX(;mhWZs;ss@JIpYg(vqD&TWrb@q@$wUvMljsm^6vap9GG7V8nkWU{|W)5Z#zu?)n+&~ONlrC3DdLd*Qq6tvx`vn8Hl z?~C5W!rI??X8%-Q<>cg4{prrZv!WdTsDSj(&@`_2y4^Tc>?+?>Aj(eLs`vG2vV>hrn643w zxPNzmulJ)^W}`v6f;#o8riEdK)r;W+AF4v{n~}3@c|Xga>u{Npo%*hPPH%bJPnZ`4 z9N9zBmJxoyG?UKG!V5oMYwzwy1j~$Z1WYtRFM$Cb&%C=yr7vL0ih~cb9ml&_CYxl* zf-o~DFO~VM=O^M?GOt2cGQdFyn-9CFiaO ziEyfc?#rtiHX1*BdDrGheLd2k{(!JiSIQCNieP5f4el&DgV^nDk} znaJX(iu5v^wSYG4vpl)8$IqOPcB|X8A_O@YOI8ZTNVI5(BB3SVCI2J-auA`G%4)jg zk@~Sqo)yOS%$7B5E374UomVrQofZeIdZj@~nSM4ZVqz(x1mRgDOGAb@ zk|X;&OJ|rYFZ?FGGGGQ>!xM zZDO|;tyX3k`SnqTRoiK~n_a~y-JIdODa2{mvTSnfd=95+DY+_%lwLCH|##t?D zdbBwYw8vi8UTfLj@wvGAkLx??8?`8}kQc{bsJ5F9-S&OTd9Uz#3@|>UgxAv;8`=I= zCN(=ABCfpNm&l?Mh^P<#k*s4Bh7bL%uah%ltWq?uTvuB<1cDuFuTZ+Nw$=^>n(0Rv zohJYOgFGs_Ke!Y5V`k{Rj-?@!`eCTwWl(6jU!uX_%#kGl@78_A)nnDNb+B6S1X#K( zx?r%)Yqz%yQOR}_Ee-M3)Ue#MOWm~6sp^mzs`i<4-y%6Fm_}=?;2^Bh@a95DyZiKY z9Np$~;(}cy4N=&@_gKF_9tsWj(6@F{w&epYwXf_BXO7lE*EqzM&(y{1k+8T<^KjcS z?@86eQ2(k4GoJ0~3E9QEU2382PI-mJt9cva-IoHzhr%%{Odc&(sdTU$(*oPwEZT7RVfq!K zB5;4IUpu#lr4t2qFk~ID_;PX=!~!Nlu1b4li9nAKa+QodW|@RKmDS(i($HeTcv*!V zhveogYg~xn%H!h$aS;LJDgI9hTfRCcg{G5dcRxS(5l&NrC}0`@!ipO}(u5Z=Y~Sfc z1KQIKXTg@=2SdAdW3}Oy7P&*>)TRXsFJOd<4ik*;#RLf`(qUBWD$<*2P>pM*>F(Gc z{2gDT;Vbf2y$8ofz;Ci97)j6Uy(ph>MemP38EJfq}T z+t+8|tpsCQACso{ZdiJ*q%3FiCGbRaOad|apgLOpv|8n}xKr$wo0rbyi2Goyl^auS z=cM*pdSx3cr>UXzHQ{`)&!u3)SHQiKZuGI|uIaU2+)d58qUlY-)F~as$wB(C1Td5J zYNMTb65i~?>x=sQ$IFys4KQ`h&>sI|BlKiG@Q$h}Ck~0>F z@u&>DiyNq8SsHF+Tc0ta2aYE|J9{fx!0c)2?My*VWI;2SPMw1a2&vJ7dM<;f6DJMV20!4Pc)BRs-7@ z#zij;Ysh*^BUdipmT@WKB;a0YvzU40oq281)Vu5V)95F=(ra0IOy9Y|ze8Z@7zb^| zH~zJt;7|h5eI>tzg`=w!kWb{Ps}^`zT}$zzaVXnamwUr==Y4j?0jbYZV;}Xn|HGegvpRNbNeeX@`FI@=q?|tTZ@`PYhHkDfHLLx}u}Yba(*AxN2{i z^H7^pBGjfy>dCc|x-AvEWK!`ujnd!MqRPU}b%k-ME$N)$(>RdLMZv^SF}MFEw1e); zm-AM<#9clz^ED>^>oy`_YFx&|JX4&HPFLWv`3Ibm<0N(CVgH;>T|GxB3-!R=v&a?X z&e;JB7nYA1N3D+}1SaVA4_Oe(o(QcsJeE|Q;onk0l74K>IO^oTVx>rIAW|S2a0@&9 zIKftL-ccCtYp%lsE#y%mIF_4i_8$(KMcRJC6;M*@c_4*?2$CTDeHRg$6utGdb1cKQ zcciGP3~6>LWno1GHR7b9^|Vm%f?pMW72V?z-(Q-`Bgg&av0+5K(PF>F>IKmt%<8F* zKWoXHSA*}6t-sj(iNP4hhfE5~0}fzoPSoGy9x?A*wBUtq49E^$!{O?Ct{bI}H!>}j zo4AV_hmd8Y;r2N?Ho`Bf?IN|d6T2N=o)N)$f<15ea((1@wciiFV(;P`m4YGEOT{*r5!L=HVK@%OX$gP*}U?}-{@Xdftqi?WH9wK17`eu)j61t z?a}v7Y_e~kmyc=89;+BCF)Mg|6Q51>s+amzLeP)a8q>G^H9n-)RI{#h*HkzyS9@ga zm=qX}8RlbboD>z>It3XlTb}ymo_jiK(UzKoKJ_A)AWqVAQvBJ({M9{6x}-CF>cw`Q zxBqhFEJPTXuMADc;~QuxRijGceSHh-!H6l|tXkPsI-N7kNWIZ{RO(2tjf~o%yPwzo<1W$@`n@Pkok##jXKTvzNR(}$amZkywJ?`GftJ*8WJ)b2h-e3BaWDbbU3fXZK^?_6M-{^HI^Kyy6%Y)ae8 z$~*KzkGR;xMV@)Qu~PfJj*g4g$|EMJ$8#Q+mPl^&d3_$cb6)=J`MLZ>xzBMPx?aR+ z%(Ggc$t+#EN5yL`@|eeS{iF7%uLfB2{&C;+o!E!Nt!@Fm!XHUT;D}yz{jM?3s2}*( zOw15wi;}PU7c)tt2(toQ?c8%_r;7}Mts9&<7X#muOHX;Po7YO}<*_kjdKFti@9y0$ zx@IZ8kaFQMR{*-QlFJs&tz$oV2mI`}2`+>E9mSHrEUPX5z-zaSaR@03<1Ok~Rq! zL!e8R9$)>#>0bLUklI;;S~8EsVE`%Z!taDE5HzKqX}y=2&lmj0IQ^xvyc@9z9v!!U z(PD5mIMayS&1Ht0$`<5lTnLGPA1bFuD76v}Z-+nvtq+SipT3Y=#5o-$UT+Z?L78-@ z5Qj6}rY7UvTOEMz)N8!L4D(R1+&LSd;({aWR-z|WwchAwMf9uJ%{8J&U6=R35^rwh z?z-_R``$i}0gFI-)tVHGgF;2!4Dc2r=HkAgt5owRHM5Bag9}w$ElSh7b+(bu-QZx< zti#Sb^gj0E-e9Kd)fs9}?W3OyElLGF=xR&J+5^Bb8Sq+6@?|}?HmT*q{tA=YL+!tNyVlEfVsZe+EKeF$qa!LhvATZpNfzc~hrjzlr8W zusk!c>XCXSzrEtJPU~^H`s{ka#uSJsfn+kwfxedzh(=BsI^bJ-Ns zQw&CGM{N@`Y(UfG04_0-;(w7HuU(tuZ<)jM`5Da)imcvw(X6UhGgj7o!sLRnqJ3R9 zTI|be$-@48)wwQqU!%LhFH{imyljf@$6=&mOK9y5*{V3&YF7$v?rQFCvZtSw6*snZ z@~mE+8-XjaVrCG{%G57lB~{WUGIN%OhjCL}*sh1Cc&Kpj2323XA4N*cUhS^0frchX zZW>wM@E)k1B-Zwf(yV}N)+gneI4a?_uHWgJttZ>K>N1;*V?N_gH;_*_%#_N~S9a-T z4jaAKZU6lGgVhO(#QNa4K&fH+Ee$C<0}Va@2Xp6_39sk=hit-=ogDkOtLayF@eg3Y z)ssj~ab=2q&2OFJ%-K1ngQSCgx(fJ%A4w)P&M*JVjojmw#fNgjyp0{5EP*Gm*1b{L z<4fWdO1Uv#U2FDIDT^Li52smx+QIbonqCSG-Pi5JCH*16KimnLls27Qiqb-&IUCMw z)%hmWujNKIsQNdRHHw(z#yQLz=MEe+Bdo`fUZSqt&l|=i!mn1~Z>% z$Mx+f#stp(?e4!fqv6r7cJdxw!MAg(&6&yaO;kc|uD;y9GvO(F=$EFuG7NCkr=q1~ zr#I>y?j-1bEn|a{>X**okt;b+N5` zny;D&IT98yVc@IDT=-Q!Sne>2`K}){BECgq)y`8Rad^b(X~ zbsx6V==}=QpegS>sSNRYhmO9h%Xy%)F$ZsmrJ8t{Vo53gRc~1Ds!hh^^MS8&;_w&{ zql;{QNH}Pp(ERWWokhk_4*Nru-SS#CE|^U5DM8W7Wlf#48RAb^UhbMAj;coru#$3V zC|z5)wK2u%M*L!E7x!1SwV~_0HZuzO3P~tH4LLk=udtg}ZpY*TxR$TCxk;HP$v-8} zHju^1ZfP{+gj2uWg~(Z8(ibX9tk7HgApPzbqEy3=&!hL5`~IH7&BNGm! zN!MvPKr^6X)8bk(6QEnUJ#BdG<@`9z6;wP}bh%$lR{x4IN~=`}JvFPP=Fd9k+o*0- zVfEHT#*vZMr7S$#$lvTu5O zr7V?yscRv1c6wI_1@v>>tc>bxX!Y?`o#)q5kN66Y zssMjSDU6@*$)9QH@K&rW$wygVO72h#B%(t-2q;$nNc^xl@9-ifl0^P}8V=b~n9=K* z=Z!dV7it;%x)VRhQ2H52Z7AaNW87LpmUGT;tj>IfC?|vq-Jv1P_mVgJ)7N8MjOGyAke=NNKo+Pm}no zoR_a@fY5RV)3e>Vh9&(-toT)uFG_=(x2M$n*y?#cG)=rU!M`+D2l)fjQ|J&;xmhxc zLi(rzx1-?K_F#yz!*nXzWasDJv`SurKoauNV=H-M$XGga=~!I5YQ@Hzd-nX@zrPYS z^r)m^h`*W77RR+2-P`I=t2!Utu;1m;s4xkFmJT!Zo326qj>r z$j5bDCN>YTbH~{r3YB74x$Rrl%MT`%Y6SGlIQHuz_^d`xb8%CYze@s4moIIJM!a^u z`o=Fv7S190RHQi@JGANC!p!5nlnTbpa|N2$9J^GZn$h({lXYB&E~|SD3ZJ?fS2|zB zF<&EUMDw;w5X3$17hAlmt9=!9tVrIDM1)Gu60c2PxRQJP&dVMfbP`Vj`b%P5i{Jo7Zx4ozUG}@jweFWHDv0f-3@j$+5o$uDN0IbEk});`}`A463vAEEgHnY z_KHbimYJf;H+27!{p!9nMBiQLDe@oxj2-T17?aAO9WI)en}0>5&~7C~2=oIVcoKMj z3$WhfZ?w%uYd?U4uOOi|5qGmTX1}6J%WN9Y#FyWhhZH}$YdzvvHIJ%IGVg3%2j90$ zE$ozMx1%J?o^H6!auj=r7p{Cwe|b&(O0NV{%X&FFa|W*}N2NxM<%*>VNfVI4-|+6G zw#FSgw>+3~3*o?&=Fm4_J$Ef^8EibcJ#c-FlwILIyDTxtt`C;Cn43|XmmkD%V+;dhP2tL>y{ z8RKO~d=u1gQIlWK!Oi1$EZ3pcR9&WfQZllvb*E4op|I?)XTo#7w@JL5eI-t?b95K$ z-yU_^Su8n~Akn|Gk~X9v-76njEt8}57;Gtpbrbeu2?aiI@3j}MFwK3?Ax zjn}}J!B_vrpZNnl30D&bg$hq>oY0yr#*gm_rb?XN&8?(Oe@`bXrIY6AT}mMg8@0)m zD*Qa=##a0=7I8wvmNjpN<=7J7*)sB5?-gFZJlOzIji? zdEE2T!A77PRGTMZ?+3b}!+LfsPd>x3k%<~-}$bY`h z;YTQ8O_zT=1M1GP=W-2{UCj)ET2x)jiH*WMJ+@q{gam9WR~u@<-crF*|G(wvd5%)Y ztpPPyOq(6~l)!cJ*|S%34t3kc-=d_mjP+B~A2(ZqUs3+R+8r<~xzf~nF=^_Be;?j+ zOhrPiNVuC?xkB^pUo?DZeoq_%a{rn!dxB5e_Q+Kbp*~%z1m-`#yH@0`+Vnxc+H~W6 zf*AlY@$)*c+$MWb_;W{;I#g^6b~=n-+`p3}7Q!~!(eEG?W2ukPDqEXO8=QAr`q~6t zZUQdBaB1QZCA`v^DgAgjAAcP^CL9O4xjD?+vt+~LpJR?RQqJHDEC?76!mqszRj>DV zIBa%Vi0g0OvlRhE=7$T<>pSJYQt`dLQt7W|H0gS--@?QlREKLbX);vro@0LPJ9wFf z@AoWSkeOC;s|fsEr>$ziv(98|nTl`O>Z)e9Yuk~u zc;{rfiqhH1@@um=l9tnHuv>gwq`h9(3ognr<;X`ad~n^42O zX=Q&&EG6%}w)8bsepBKrIoQAdXx;Yptk!Rwth&;LYA)ZM0AqKkl1<* zr_48MczN36A{^m*+p{9&^`P;x+QNYOqlDUe3el#15Ma2NJ@ho+9~3Pk1EB|oG198O zg!nYE;K4bktz)mB2Bm<43!- zU-%b)?UsVV0prAECSU_z+w~3h3cif&!#SezVUT5n>_u$MfdOoX5LcITGVVPW*@4Uc zg9n~MgxczRkCYn&fnJ|IOes->Y*VDEx){}#l2upWM8&3USyNc;UU(=!gHEKi-(3+ z1=5$&slaAT8J5sIQK;bO zlX-E>u6)|rAM$80l$=oY+1BF(BRI-D$)`glG!mo0N@PH#5OkKM=<9-o-txDPPlfb4 znVt!1wy~+ki~-}tJDNc#-cggkYI;Elj4s$0rqMJz>!KGc3u1s zysm?T0HF=f;>bkS^~Kc-$4*~0eX>AATH;87S+P=gRF7-f?Sas&vu9 zB_2Lro#>8G)Gzov8c6&+w5!`;cLoq%BJck1YA#ii_rDlnJlHFk`2I%_$+LW%#vOOWF709bqr7C zPx&3Fs9x5(Y|^_urc5ILL{b+Q4g2?ys=CY91?m~tst60_xsP} z=-$7l{c-O^{BfT=9(2Y=7Q!c*^E~TJEzdX$KcYKuKNv%e;SiD0Dm^=Gbal&EGi%Sctn;E$;4_^^E7eh)!{Tuq%0qUu!8S)K>5~;p`mn z$1OQ(8snkTp5CkTF0Jz34GylzA4niB`E@rLu69Yzo>t}GO}FHy__=Jw#Y9lf{5W+W zIff`1n25B({uz81a}n3N+<8k~OzV#3pS-+?6yI>*A)IR2NKdJ|bgw#T%zcnaKAC>c z&1Jp2zB6KekloPJw}!_Z(N!`{@N)IitKKM$I>7upGi8vxw%+ntw2gU!o9dvjsDhDN z%U`GL!!qVGe~nMB7Cya*PZ6)lu+wXo+lOaXsAzeBlC8sI&*v3B;QG`Z(=2U~wv~XW zsqXx_-`TusB*sP0`f(UVR&y-Bq(%~Sf~{(=_lKW6dgENzZ{V|bIBoWs~^PxTwAd_<-y zPlLCvQK`k#W0ZY;a`&q|)~I#T!$Hr(XRf7ryO|ENsY{qJC7?-Hy)-38f15HNa>oLr zTZbEIoVE`fl&;{k)vaYeHXdPfuO!ZcOPDyv&0p2 z!>|57rVi%E7j72*l+fjigX3eb%gfJ1tTiRmjispT2*23xv!wGXo$wXRf9Iz&)D<+s zCX;_k!%N&{(HTrwwcLO_xEg1D~E#exTZ?>7AL)PPQcyN7E5U^{1@w&=oZ280u!CvqEpQW1I^`Q zg1p6!6qi&jmV><2GsC>WM}Etld9&R*p9x4&##_Bd(R>iW9MVQw^i1m3OX8}NchgA} zyxBHPD<;R~+^3TV_CHZ4;Gd}T+CK--N5;Gcl3%8}`md<-GGl=Hxn#q~T*$G=_KBh) ztJmnb@)W8QE3N0fc>i{j*S)c&hE49sM!HPhrk#UdP0I7Mf8u$O{Q@UZpoCc3aBL~& zkkPSMHZ>_NS2Q?6$=?kfMK3IX?<0PX!|+%A`Fi?1p@=0MfxX>~F~Hp2qQSO54B)(# zWEQ<}-|g29Kc|}tsHKs(F~Am4&Zt|K`_00@mRMi9Uw0)_bZjg~Viae55L@QQ*Qvl@ zQ>q3w3PxvP-_m7P|9!o^X!bXcfbF%Z=6zGKig|N8HCHR$OW*GrdpJ2C6yMxq`8pu~ zL(Q>Kc8GN=$XzFatK@S#n$3LKftv#(9#wZ$?@ySm8W<%X18%k}o}Z+Jq}*fsr2jup zM@|l#36oA_c)#=|F6(C>RJa-%{JG%g2)Gbu^_cbi!vq#{nxkg|B5#ZVpR%+wu7;j3 zIE}rQek(rh`t2X5gMm+eNiOZt@a**H(Nglp&9eYegfXCx^Svrlaf=wLEP}ndvs(QA zuO}!bZ(CQ8tgm^xi>s`lMEK_}-dv#-cT2(%16dLHd_7>94B1k>j9eP|S0A%>hBxrP z1$1g^%M#f3T5UAOnj%d-u+G%8PUwDxnk6(XB!$%L{mwiDj^K5QE-CCR%9M)D4}p|B!Z1F`9&58o=8&zqV~p+qP}n#NoBQ5ohllhGc#)Z(9V zsgc{4+$qn6szaZjq49O1KisVVl7AZKxB}_Ham%Ng`#bS4OTfX*8jsV83p=EmQQ*q|9 zaB^)hGBYpM5{cnHsl{JZa%BXAq^V^|qvZum#~YPuM^=H*>^8qZW??yg4*i3g1OBqn zTHTOCk&RiGrc3I~Rdi|+wtGMGA53S>c0(wmHmGbljpj|)>TV(1_p*zSeffH?^Wlko zyLnHS$%~8Nqzo^e*^t1hr+G%pPypNnuS0QV-hpE+!3!C#|@mZSvNNL#^ z%ZxG%^UTIf?HPUnPLK4ACzTcQlY>#s;4mzH^>CPXEwSD~vUcH7>MKtkp=VuwSJXkt zTX|IFN@qI7FV(h>=H?%^FR7RUx)KV+YtQ8-i|JI^H)Cfg=83iiRJ;ui{+Tx<-_Hy- zPu2C|PoC}dfY}`aKfaekN4ER%aOLcf(Tc2ZkGz{4iOpK#U*mMM1$0)Ns(DivmJL4T zJ&AnxYv2bNOST8LD_U3Usz+!Ssrg=iAF>^74JpX#X|jGm|M!5lGt|}NFc=WfIQjo` zK>Pn9b+mTvH`$T=2BN}5DPh}jYwjp06ay$>ZD zFNYcuJsndg5F38|j9*Rz%9f2Mx<(g(UN{ zJlG5|A+)au?CpW$j?@AhZAXODzD?*~Qe}qhz@`1=LgIZG1LS@~he#0>{^`1UKEe_J z^N}i_u2A_-xK^PYXOT)cJH@wEoY3-aH_Vc+<}eda+@jy1q&XbQHO#FNBEhxP7-DoQAc@WwbmZ2oadxKCNrU{9uu#!+JT8svfsBEf2kR*3XQL+7)gL?#=W3ZRSA5;Qm z(~f_=Sn`VZvLQsKp0EfIjOL@qg-5J&^+6&|EyoR&y6jO@i4~iFAGlFErjXB={IsOlZ;cRshc^w4e<~OUZuYD6 z62uDXsX-a>-Z9`Pi!sL;mP>9{3lUtPQ!bbSiBl^P9y|BQB=Hs4)aOvL=5z4kDXehm zxJx=3@vSM6PW`ImDeh$7C^4Q?TRt*Mi}D^H-t9MX`l{NMi%rQ6YPDO;an72n#ZDov zS2byw*@cr{mJ!)(k^+t0N#8fWwor7EWnVR#p<}%7JX{nO5}E}c58@a3!_Lz)-q9J* zLhedtQjJl1=YJQ)2(U@^uVus*y#`))OBb`Yg?QM}6r3X^k;JSTv?}S)rHQqTZ49aT?ORsVsvOnEL_P&4X&)7bgK3(Adxl5vRq`c9vOT3F&YjJUK0 z?iuk#aW7<7AZ&c)5y5_iG&F4(j5X>m_$N_o{Wtq3w(Bhq(uOI5EMO3pQ8W^#$gyL! z@X%?o^3Q@FL}j(9J^_P%N3`;<{kMjRd$d-iCKO#++>e|JdwJE~_i7aw9kn#O+C+^G zbLvpm+nUPcuve2<4lysYYu2t->*aTclJxM$D`BLB_LQaeK{siqW9>Do2{Tq(eeI4U zxlNSu8~g~qV&}$cy0&Q=oD}a{?`_-p$O4%mt>ggVTt{9S=2g{A%K2M$BGzoqSFgb; zur}84vjOyoUO^`D5m%2mrk3+PlmY_o!%aX&Kux97k_O8bwtt&U5#?D;u zh z@vfVR3&LCZ_94ksH787u<(-+b>sjY${=c2h7tsG+I;HLGXH;c@fNtY~fLQ;>wxDyj zv@@}HcXqI_w=?BnVvw~ocCvT2H*=v^v2ZdqG_kZZr&lp_ws!u%OpD8INF8PAMaG_! z;>0-+C6zwHd>1(oC`v+I#ms-M1ye9k0*XvvWIo9APCZBc%Z~SrZe6$0&DX}$=5|tW zxkuiI&&|i@&Byn*{-3G!jP0C^oPWnQZhM372rvYYKlJaO-;f3@`TRtC`oAak;~bM} zMhv?9p+BZYrl3C#bvmRpid7CN$-spwit7~$Fw7=`C;kc*{F^gC&LgE&Fd65GiS~%a z#)nP-8bX5Gd*P&&oP5C`ym|v8@NY%hUud@DM1o=y0%jaGO}(*=z4a z6qB9*?JB<=L@(TP#TJCj{6vic?12TBw+sXr7$w63V*foz-WjJ*#`WzG^61b^Am36Q zht1ctVKK6ty7EDRvCW%8U4mxe62t|<{%QGQ+=cX-SEiI&7r)R+oWoQXtiKWRRc$7L z@KrqA)F%uRy9o&tl(#_!)l&L%A#XiDy}f<%=W^BIAWbzv8x^sb!W|mmo%JE1>M{1_ zSU>4w2AQXrI5WfWV)r7?y2(}Lkw8s;vE3&QpQIf}@3Tbaa$9kA(TU63V)bKTzx<@S%# zx-b;y;sEkLnJ9yr(?UzC@NDh5c(zDcJQ>zcz5Q z+lzQgw2&s=cr=4#+*KNn?^6OaZ_A{6q{Fa`kWn@%uL7|Ut&7+JZ8aVG(;WIG#xH5^ z4VA;QHvQg||NNC{bU?hehhz8_W3e|S$o{We4UbUvD1789_?<@b#O!w5KM?x@`g|2v zwXlK39~PH8S`wrYE!Kb3_<a?;25Q>X!vMO za)ZkHI?^iE6JnzsE0Hc|^!1NEs}?6A_lYIrOfw$Nom7k<+(z31`r_QUhF5fFI{(jA zT;9eE#j7Botj@qONCfz2T4S$Ubf%XPl zZt`Qa(+eQ;RKTo)lJy`NwgPe~==U-~AOegrp#Ktv1bt@MRo5|=-mbCdkVsDB2Y_^E zu~onfT>K*;LN~DCw{bl47T{~LbA5U*X|!02PPv0i4Qx zCXd41U@}`+p^ZGcl&Fju_|Xt{w73Kx>vJ`8gS;xr3Vn2W?i+v@;OkBvdCbHELs|nr z;}?Mq(W3VL{&%PZP0O4O!<=+{+-RZeE63sigumC~aZ34kC2@Ai;lXFvvS)^kY{DkS zX1Q{tX{mW-DfVMENwX_s%TjWoz6PM_@XZ1F}s1X zVn*HU`@Yv@ic4tl*;1ck972%K(v|^5cd3BwKzm6NuPQ}?E3u+XQ~V>A79pjFf;xP?kOiH&LCR!X5Z!VS-kdQ0v*6t?XF* zwfLEWUx57%QY>u!=n_Z~4u733Kf68=R@)$np#t!6hfwdxEayLd`s`L=mA}d(t9Gk+ zyDKe<@$f=#0lqDqP~{AeOv9YvPK@`T2m)!ZV_2-hw(SO8*QAq|3CJidR3OR;!BKOr z>1vTChit5PC#JQ=ewM|jug*CBPEAz`{3Olnp48x^_mZ%6?3qjkvAk(no%UE=V#Xyj8ds*Nvl7WjrWZW_cCpcZFX-f#Jb6!%G z{kri6+_BL8&y0b(URFoDN<56xz12iD_^{E&M^jwguK*6`e(r93p(cbZ4P*Nb$zx zXK<@II5x(C8~?B^sMYyc9>JcBOn2J{X}`iSUpC4hmajVNL@#OQW7IpzH+l1irh z&0@NmKe`}OC&am7pmB30k~o7HKlnW!AWay`R%ax(k4_Z*T`;JMTBvCbwS^%R9*5i0 zAv0kHB%35Q!J9R|t1q`aLMWoJj$1F#CN>QD1xFh^irTeXunS;WbG9b^n;rEDQvxYN!9M&$!2Vv5UCWS zv{p6sL;;{y4YjE`g>2@euSo+sTPCpQdpctSI#Z1uTJU09JX`i(sRGHUYQ*oRwdhvR zA117cO8~0<*J|;cpvahHSB)L5j!*#zl$k88sf=1a&eX7tHfFmjV${mlpfx~)%%^=0 zgAcm0n^1!j1qma1`4HCJ5Z1qNE7Ocxip$OU^G26qHWCDSV27}P` zSKLMsb;adft8HPlE35~-LKC)-xBjYWkyb5?68QIZlHvt4A2iHGL&juZadq*z#mAv* z6_O;hs1{jt72q<9C808H!KX*gm#=iSFeU9oYcrx7&q=Woq8lgRZR2J{I(iHzx(G7i zC&fsl8i5EkwAAgh07JX8fx^y#+^uj)8&9vpBIp^6Um$`KFGkoyWK#@CMJK?csY)H;Tig(;Sw#M8|X zq{o+=T*h%k2Ltqa2tfj?0S|u-oLe;_pKTjnQ#hu>(h%>2@|6pra^e;gopr$fkb^7UJPC1TEm)0K`$c%pxRg zOhQH1R?(EE06BKCN7s?^8#`kaZ_Gt_86>nU!mbuZ(bQ;mcxKZey;3EpC~zteb_1q-Qf0)z9nKej@I(G1HLNsGs0RbTn1vuZJK72zM2m!cdtRSZ~d$17= z#vVc&E)BRzn^Q*!ByKpne!whv3{YHtTr$YmD8woosRACs+Ql-~z#?_!!-(sM0!47k zNIKROAu>i3lk*(Pi}c{v)P4nWjG!DEGA*D$_!baqG=*JkJY5-%9nJ=(q|=uAOKwf5 zyRpDTnK348WC!ZdU}_l3kX<0Qft(x)6$E@FG?RD=n3Cxk!B|cphA9EaaC(or8S*;1 zA8CXsR5*PUfLNnCk`B6hKqGq$U3;Vr{NVIigT zrU%8H%x}O>cA5&}uxo)GWk&+ytkF{MhE+vH1hlKslKw!N3iOA$V*<}5ZA14 zc_e4X1T>NbXF#B+-ys*lL7^srX<>BK13L;{r#)!DQi>64c%{{SA7M{m_6Xr9zmXra z-%kg}`;a%OpRf@bS2qQr2@=jhCTN;mH(%85f)Pf_r>uBfbP$@?C>9uABRw)w<$&#^8{_0A+it}%<{zsO*xfeGJ{gM=y!=)g((8W z+xOCPMu$-)9@{+v zh|9Qmspe)QS~IY!AO!;)<(gA23CTgq*wQhFhWbi5x0$0=MLdE`%sc5rRE3&>f-ItG zjNu7C`_xW4J#Rskv*zjIa6%eC`w`4*R)iyf9A-M?E>ibWopV;``e9GFYP19FXIzaD z!B*(Cyko=C%cSwr1ojS;M#+#!yOtcGL9Eg`8z6)9=v{lz;2=8ZF7~Nu0^lGHTr{ZH zv8PrIx5pLg#lp}N4EOvIsz^!tH1XIoqruu-)?6ClJxT}F2A*CugM1CHC^ms>t1!5w zS|L}sF5$31*)Qs8OmNc=#Ee1Q=rVv(FX~54AnWDBe2Gv4Lb@;x7!&*K+`aIb*V&^@ z6!rvH(HlVlR0i1yQ6|M83(8SsEL_0mc;x0T5G-sO3~t~>uxoYw)N4gpy8UeOS_6P* zuy9EoOWIvh&}(Gvf0>Yf#;M%6Jj(j3Wq~O`d6o>OWn_P$ARVZ3&}8ISVbU40c_WaZ z(k>gqVktT31$7(LnVJL$z|7Lc@;c3B9D|s_G83wm^w&b`z#kF@7JhI#&M+PtBttj{ zXdpV|Rwm^_+MRjmnH&Zz4sbz(?8m24f;Sz0?|21}|oXNR(w4v?+wRup z9bjqJ^C>h_+J5vO>BJJ!#Rag}NByE|RuMg+AOSkbtD^hQIgbV$b~$--O&yS%xAls; zp1HZUCugig{we;UlR zBQ$XQMiNL+*ann+^+ci1fKCI-0Y;!f1-K%nOQ3z_P_O|GIL?6Am!UbJNou0l`{G+3 z2aJLJbUyr-OtJjS3uYUZG*7JXx5 zCf>aM_K4>vKUec=RI!M-4~ndqYRs6p0$J?F^kok1U2=h#&mjNml7p~@$3eyGGaUS` zKjIXo@(|6BE&=th`xVZH>%)ZG{~j*Ria(JUh(I{%0ZapL%?Do|y;=`9hCG6!3D&XX z!959N!_GHsC6UYa9h4HX=>nu5ebdi=^chp_LyOtsVom}Wz(`mjKLb3QkW}fJfW?n( z{6nLx=0;6mwBaGLcmf+M332Q8JrlCQ&n%V}`>b@jR!xA5aalC`@k6{-_fuK!PLB_q zSTk(Sry|I^GFy*mM{Ntor50Ugy#B?kl*SQmA?&+3Ou6ux^Ur+71@X&p2!*?>#mNJo z6yV7@)f%3yG9J~IMsM^kFBPtRgFBOtd6$lCb!l*r2OKgt@B>g>YPtzSCP@`+K|%6p z9dN|AM(~8iW!y;>wh)(|xMo~OyW<~a_vrEGk&S};rU*j?-t9-VY{R-vvEyatR@x;X zuyKLy!EA|0r||prEOf;EBi5l-bbl=Xf=oOjEo3AlyqiRVSO+4U6G@1&vO*dc@*(96 z%M5)F4@H@G34tCsK#3i41P4%?ka7n=15ksZ4Va0*Sn}h%t@1%VZ1$iZj>viB)7|v~ z>X`uWR6F@(v~2?lQ{f|wsDu4Tt&l8)G9cPSmyrc%%J&W(XqTZ5gumeSB^*LA15HDW z*YF0N;HsFmV)pSplxj@3M&@!w6r`?=E8!si-t)k{7_=h}ZUT1tkr zo!A3qaygU#hVT2q0TV2~mD3I#A;EPSQ?d@B!JXki8w>Eu_GulnADf$zU<{uRU{6+> z`5I(2T&*Eo#$3YUQrHn(L((tyjrGm@Gsgq!9rBnV5O4+hPm=0wEG1A>>rv7nN#t2{5m=A;xw2R3{ z1Bp$M8r_-!nT*3a^CXc~ z@}!un`SC$r(Ir%oe3YApPSUQzvC^_G&kcetZO$okqhDlGAJaPX(R?elFKtUs;gho@MOn zj*6D6LP|A+0c>kx<@+J1>#`Vlwg!-53#Xl0;L_FT5z2(*DX|Jc5y5;8G!kHSBdg&m z$E6>iolWj@Gi=25EGWe?DWoFnC-0CFE%?K*g5DrzUyWf>eqIMPyb`*BZgRLFhmdFz zqIov~)=uow2*Z4s-ff1rR1@p4MkSsKPO7Pi#lM)`2qMa`&T#lTAflNdRH5zHc?Khc z@VumAi9gQ|6BBPLosZXCDgK-=5qbI+2zn7y1B#x6E}6`%tD7v8L8)Bi^$W_fd$NR3 zIEEZfz3M1rxbbzsK{5fGZ835pp@OAQ6&o?Yc&;43R$+n_BY3c~>RO{b(PZ+GY7U1r zseG24hmW3A#8R@qmVWgD>gGD1I}onu+m_q1(KB%^E0GyNd=>IO2qy&Hlm<8#3@eh z7gC*RtZ7qGQ74+7(N+xbK0&IMnF}TqB0UFhX3*+4O|*axZX&YgNwE|pBocQEpc9Rf z#8XPo5h`4UxG7SjjS)jB6SeGF3Be+lpT?(vgA&6et)2b8xvwXemJ>HRrDn_p1;-13 z-E&eh0Y;BTQP5#PGYC+@p-gTzZ7vWg5xdhYeIRcUfyR@f0a<8)nS)4}la_p+oH8HG zSY;H@mJ1Z2qJmPTCL?o2)+*68EKuTAv~cprwi}nyoHgoD!k|%Hf=ywJ zABa$}`U|IE%zZpA<+szJoG(aZeYiEA?v17*yrNw&Ri!N4H5@_{DV2Pmt>fye3ht0b z`PM=VbA5%4)vG3kX-1O_zDAz-x!d|~E83`&!|;)UOQbBB;>5%GL?sm_E%~*~XlITt zeSu}rsFX-X6Tf7QVd2ya`rUcAxKjb**l5&_b$kKE#HfWP{PIx}rMCegEM(>=hoH6W zI&FcSP1{_pP#Nq*!ILZk5P089tgP)YOT0TQKgziG>Cm!|bU8D|J8P4qfPzakGZ7h6 z6=jqQIgwVOMuu9FMhj$NVWvci!KPICwOJUoVI!1uZV~Q^3^s&*BHU#%nasRa9s6nR zu)K+tz;My(=mk5%#H(45dN?}q@Nh(prFBk?heKKt8^C@v1dK+1T+Iba$i6=;RUU(V z>cq6hr;I@IYe!yzFQ}E%MEMWJ;=Q63@FH&Z3E0ZjcC+q45-w;EC^Pc_*@6ybje??v zQa+{H@Za(xbdv85g6L%jmO7l%UBkcdLe2(%10wm0Q5@(|(IS233N+McFQAf|RoVxN z6cOH)dHRf1(3Z*Gt;lo`nG#Xj>y|SjMm8t+bE9cXp}Buqht4->gj8e_V}o^L8OqP) z`7E86*>)hwN&b5#rxJ-4RJ|7}ICm9+WY*`|PP7~K_^oq&u?EYGejybUL-cHz}qT$Gv4_R@=0Lt57_0}#2Y{;s%juXC*WMn8y5FdDv zFwXd&X9D#=h>qZ@X2hRWCS2FD>p0m|c|IMQ;;;Seayy(8 zB{kxp-Zldud<|Mnv^6vnNe5*ogl6%khvWy7vk`!zWWhvL4y;FdMRMyKm;x2jphL>+ zh%YS#vm|m@nU}=46vr;wv=2o>q9u}C(`Z6wh2$YxlmW{#>tUxQ5=@T(*faqlpy7ZG z4>*+r7cT$`GY2SS1<95MaT$r4=a&rONv1*aLvNAC4PbE-2+Prwp}=C}3t-2|3ouAi zF{T|LNDpZoDB`I}1JKwZN!6h&uoKS$Oo5yQkVrRwz4jh^YE;9*5{`kxK}{D*MvDo5 z#KX}Op50j%!+=b3{MfrnutGa{I7pllg%5uR@(v7Cg9d{fQoMW6B0dR(XG9U5i(-N| z9P>XeCHtMqrhzrk4h2M!!DiQ+1SAor2Eph&2D@lWEZ#P?fVR5G#~j8Yv6okgfOYPO z$!m#kHM3Yo;h)71LAIlt*;dp2j748pA)7scHpoHgbI5Ri!nS_TK?PTYWPowA@RqN2 ziUn#|fMN(<2xN|1&()&1WfHb*&Koo zoq#HVyfO$t!YRl@BI7YmeKlt?zgk;3^yNEo|*>zw{N2S4OyW1#@l{7O{|H#_Kb(?#)<>m zELap{((kB>M4JgzKPn6|DKjQS4;jH8s38~vOiHANE~azJhAtKe1AGjONetIc?}E(M z><^FQq=B@+>T8i2O$uSqHPA2U3WA&u;0d&jUdtE#r}5s$Yb%32j6PLYu{zJwGBz{U zFDtTqnbzpSTU4Kcjhnzy+i12!36p0-BV{iE_gTY@IXLu8v+{7W0d42KXjvJy#AjKvM0 z9Kc;D0;dO`=7yX5L7nCuScZ&6(VAc|jd|zmV}}RtZ^xzs8hUESz!PYQ=oA3{GqI`e z*jF59k8a^DOi`@w1q96LoQxDQzi2yYA`VcuH)F4DAp!CK{(LeXYny3VaBOd@RLi0G~4#C^;wOCgR2;TvOY zWL}&z4%fzl3|kjg5}DOXa%NK|rv9@gcxBWr#VtyjJREi;=)>|eguv1gu;R-;a0n@? z{P}Rk=Xv%EgD;XyrGU1;Hj&@B2q+No@&f}keu=ZMVI)x6H!_iNW_nB=5RUeX;zCn{ zV54O2YDtpE>`@8Nllq*_?>Y`;g8Cwl^$t`@pqottx6J+i zjt_DK-EJvAu11EOhX{{Qm=sM{$*xGO@P*oIagR`NPa+QztO>%fB&7`Bk{XEnhxYcqfYN?WbA$mE z!&wcIvHr$_z&P!t`uC1ewMz#cJhOM;;d>^PkTW@;n|~`qy0!)kwJF?gvRhC@OK6pU znjvkL5gMKM7m2IeStJC%OK6vxmcG5dg)a>C0Q*@|m$1sl%JG3W(sJ^UmwbJ1I#yIl zRGcOt@1;>8AhpGpT3+3L;EQT*>?XhGJ>AV#(2N!|)_=PZb-LaDsfiw&jY}D0+hv8_xUF;7MZ4O&b>&vja!39*2DHeY8YPRm5T8@_e$f;!&hhQ( zLAW>BpjPr#mESM=g}h}M@y}}|lwz8@49+q>xpw%Hj}uUNw9}(2fC2Q`e&!-lq9TYm zX~FF4Eh;RhB#}ONa*h9=IZaaBJkChQrB!nH{N3UCiP%1KbgGq#Q^=g(M`zG;oKn!< z5_@N1_@ISnu~Q2Ax%f9|K8yJa2ULMqRIel;bpHJGB)*ph1n;=P8<>9|1UC!jj|K2gZw%=ITHimOAA;G0kRsn;pI*xuLv12P=A^x) zLHIR2eC{$^ou*%#*{MJ6vCNrs7s0l0wt))Tgnl;ozn^s84>~>*PG(uOc6}iJwp|F_ zL2E#;jRj+;3S4~l)M+d}{P=$VzB`laZCcyD$x}Q0cN&5CjT1%+T|TjgV*|QMWE=K} zgZP(;tLZJ31eX{}aJW2Hy{6p=Tq8290+UTHPL=^miXUlzH9{!}6%B7Bv}qrq0Gl(t zCIY2*x8D>52}*WSbZUwBmO8#yv)0pS+v{k&8*=^mwc!v9pvvQY|NgYT-l(R;iXEC38tMa)R-U zWU?tbB}|iuTQYp%?bOBWo9MF&s>&>5TWyuNzLz&?1sS;LK=7@?#LR@mp{!@r*AUtf z!}B$WB0*&cLJ9TCmpCg+;cI!W{Y-R>yaXCsS+>PeEu)TJGL13}Ng{Dbf}|r|k&K_#fc^2Zx6$4i zTvAF+zS$njfR~ySj%*=fiXkk?4m*;s+EHgO9cNzC4O1Jd_v(CkHKlt4#oN}>+0I%| zh8?fAljp=6f>>TD+Zy`rpH6*ED~h@!^B7Ehd^gTw$;r}!7KrJw^MjXcx!4IT50>-6 zy)|F;#w&!1_cpEFNvr+9b1T=;;g?SBFtc}pL{U0pEweJ7@Ag}bwTj0>+PX-@vd@4B z%blx$+@hdOz8E>n7njb@D<;&%S=>CgjJKiF0pS5b@x>X5vh^6r-&T!%jaLhQaGv!@ zA1#dZ$P9t#1`2HoByD3dQl}vDl@IpJA@v$4uF=3-G0SUe8*M-EM+xQIUH`^ z95|UO!(V6*o$F>Vw$yGObj^jxiXddu8&tfhJ3D1v594ojS~|;1($Z8iZZz|`=_S#@ z^+Y|LM4qS%_2U#h&q|Sd2_wmoy-Fx-gj|iB_pwd-2YLFV3pNyOTYiZmKrca^Zg;u+ zf|yM7?p2pgCG^P22uGHgj_-Xp6Jm`?kKMS7G2!=~-t?MEuV<@8fS&wzy5*l;+bVhp z9c@D!1lXhFdC6F5^1K#Iv&{swYsO&ax!5fBG3~UyWM*t;rNzp|{S4r9nofwPVciJZ zpwf&yT1}q*c!e&PrlfVT<1yHh&D?(ZIQZ<{VU8?L1g#%@O@CmITt4=6UaUvX1)0X+ zO-|L_^)wR@nXF^O5fJo6G{to#=&Lo`uG8$NBPxHm^s+aeC)=DHI+8E5K=Mj&Dqv{Q z-K`<#l2{*VdHT(V&)f{VAM^fV^s-&FMa^cY!B1gjZXDn|B;I6|QQG->x6U((@ zJK^G6sQ%`RPWcoM3;{KjXLuKTf6`<&Oyq&=b|}Rh6EPxaSlis>_D3+`<4Udsy#9z1 zF0z_`mcI4E$snqiOrvA_I?!**~GCZao~oilQHO$3e8?JD7%yTQ8v7dL_zpZ{6r5 ztMMo_HTo#pf&5hK^<4OU*QF4}T06C}b5ruMQtGqFR@&snfyYx$>nDBSShYL-!G2$} z|JZ)+F7EN%B7K8Ix8d_td8yd%(Khs=rFvdHdo_!ruJ=S>{d_eO(sOR8*~aq1?b%tI zZMr?QW_Pfo8ha6g+PYhxk&e+_Z!$PiMZu4e!i5^d-qo4C(Gon|={s3$ez}Tni2$mb zi_0~4eLHv@H1os{n8^dvu>Nbxi)aC=>~4|J{Ek5_%%J6Z-BBOqewk8{eSZ^l>4xxC zjuzHa%9U>gj5-qarl>MB`vA%dRzT~lZl7T9Uza7{N}4tCi0UcP_~(nqhZMygQ4%)% zy=5#}smI8kfIxBu5%@NJZ-2h&f{q(m{FA4fj;?J;=7g<4=@bYc-~S(+axZ@DHw}=G zerPUS&aa?A@0>AVnFvZ;kgn5^zF#m9g55}f&ljORdylG%DEGpskXo~f9rWK*T(5`5 zlMl!ZTkEr3+n4jM%Hvc{$Ip5lO{2?Ghc`Hk?n_l`HAx_RINP1P2e$v(m=5L#X|+;y zbse3y6FzHzuM@s-!N;d5Ns4Z4@mYSoT$`13rOh485LB|m96cm z$owf3FFLwnG4G|`+%^!{L~XDp;p>6R)+khfS4f|r(yt$uHlTJdFIh7 z)ACUBD%7>T-R5xA?_J&65X)?n!rVDs^V*qkBqIJXIy%jRpXt*)5 zfpDJE2Z?a)n0t=TkmlL<|=K*)zeJ8NpMFo$_Ou|EPj# zS6ybW#7}IPa(8zr0N88PmHZqIU?UGk^>}AK*oPM$SEf_X17g@cRipC!dK)-sXZ8`v z+Rw8laQs|K7~iiZw~iXF#2MBU7kW;j*|TZ%bL?iQ@!hN{sEzuDBdhG){@5}7NN63l zsL}-5ah}LoHd_QJrQA*1n-1WU0nm~MLdCRCv;nZ9&J7V&KuTs10aB&Yn&98oSxy28cH zG=ih07r@}_utM^nYBCpeq;qSoGJVOSE6yhEwdQWwwW?V53G!uLcaziFXZ3t)9N0h= z;GK$N!Z>3|qQPO2K%Wd933m*3mor`nxGli!K93=#)L74C%$NfWQ!ujuou(QJG-zZr zPX9i)ApLv)6is=p(}bL4Cx5kL)gaNp=?SXof32%2bVF$yY~4=@RIKzbLZWzo}H z=Orz9OZJvK*4MFrNF;ad;m(uFH`Zib4vnlvs6)V8c)uBC)@AdW#1A3F9Zq~I)X;{3 zFzu#1{<$G_vgi+9)cGBwPYTQh35IBa(Q+O^Y!c%k97i#t7ZO#p%Rf%(hp{+uVDt*} z-DVueBl3V7n?@!>*Cwxze~8}Xdi^&!!#%RqR_~|4M7a6h_x4~8Slk{*YdnrFo$B#* zNPaEPY2ZMvt7$U|pO!syQX}5U`XT(eqK+bD+UMzb_<>tE^A*faF5{bd+_3)QQz|Q> zMHP2*wZ)M@Y#GDmkp|L#9=Z`>%C|qi><@BOoq^#)sG@H%p5Z5P_UJJc&+ z$0~j@I@}wZN@nIfe>=}&s@o!y6i;R~d8yZDb$(wreN2;+m@%CAvfJY~{=FXEl!g$o zJ#eunxxhzhgVs@tu4^QntDi>$8LMWyAPbZfZ$SdoMI z=ZJ7PUKW!SF-+I%TPCwV9BritJ3(SU->$9DAg;;j-EA~J%1;KwYKP{WH?+r$S--b% z^9IoeerMRu{0rzYX?mhCK04)n2vkcT;_aC?tA?b!s(@R z_I3Ddefx)19*MsxFdBV$DN|yhM=`?0Z6JM}#D4rxd(Bpi>pMSKZ9>1*22cX^(Pd^6)pE%1ptqk)iSIez!_J{84&0NWVIObbPRS{zZz1_eFJ|+<#_QC0B=FJoDAg_}gek z^u$_GvMMaQ=LGj?-RCX-H8vvD9qT&JI~qqE9l>`oBlD@^Cxq$(e?$K4XTSOl=eo2w zaOf%F;J6w5YQqFJv&)1b*Xaeft8jZOE(im9gO#y7o8?qL?dar|s1wY1GBtB>9#vW9KNr zk@vNFx0yG*84vc&`C9YoL!SQibH=gdW3IAx^EQ{=N;*%j)53A4e+DN$Bo}~xM#kEf z)3vzXm98w|^}tcFORtcSgY4(_pfLX?$n%)v<(|}7PjAcSiPY}UAGF7A`}oSMv73Ou z`q3wG;hWRdMVmlVOMM`6weR&Z1wwfj+;053d1mmUf3#mX)?LE$S5-OnZ%=`#H-2e1 zx|Zv#vwNd!I7|Y!8?g-Wz)P4+m7YTar(HK{pY85A`48K6mfsBd``>#|q!Vf;?s%~!UY2iGSI5tGK5 z9j&fYr}w{(h6ivK&G2k1))eP;rZISKOna@xj&hI3aaJFpu=N(D8++b~5X2KN;a#2ekG8u6@BMIk(^&w1P)bU(at)Cf{)Z<40C2+lL=|5!Z*@=dO& z%G2Aqcn&B${4Le{JG?b;UR#vyrrHZ|S^6G8?Rq6y%oE@Bk{?4GeEUL}MBHWY`C~C5 znK0>o0IIu4Kg?d+@i=bnW<495>M1^T;)|}zwOc@)W1k2n*njjqdo=l^pS7e*tgenL zdX_oz8y-L`{55G&E`T?JiKYDBfTk9P5fpwX}_qPExXZx_$2JBK}?{ zWV_Z-u!Z6{+oL0;!P(%=zq|A%O?H!mkCn|vGsAzS3bVFuP^V*mb2tW(sX+{QW=l}`JVlYsnd43RAtaN$Bn_lN<*P_ ziK)-<#lLNwfC4|~wUu?y-SO`P`{hko>9U_*vK7jX+f@L@KDfSaEc=g=@_IF_swCIS zG@7=Gq?SM;(8qE5Z(7XqA8%;hS(&oxC%h#67gZSGkP9mfV$}EAn0r+4aNj>)ou7Zx z;?OdjX>2miis)wnKBu8?1Ap{b!oJa366$1_`7n96k;rR{{>6>Cv`t4RL4zZrDA_NU zwm5hbcT#b$ZLHsUU3RwDRA{EkrnPx#VcR&_%)*)1VIk&821U`Ru40Fj^w9e_lnxC} zUS93*%#K#3rqTLg(^a{6dh&Fh))pzBs8?=X2_N*fr4syjh4Xf)&b0w)C#{M*_wf6~ zx3VPg_E!uKR(97;rrt#2?0u`0NHAqOed-Zdw(eO*;l=LAnlap`JIg;E%RpxRb)WQh zVbn-@JXF}P?%6&T@r7aKj0Y$#TuFE-!qJeO=caEx`@DDG!_J7~;pl6+67~_19Syc-S6N>vF?)5s*hJ-sgx9%ZyTAS6iSJ6OIZJN zD>Pz#B>v{#)XT&}cOhCzj{#&*=sBpb!fqPoLgwvzM^V0((x`Nd5jtBL`Ol6V=E8qh zYG|119#Pq{|6Q;4mj2es;xSZ@JC`bgX6$DVfqsVUhTRwIZmU>zoY7eLiE9yiZ<+|B ze)@^~)yA?M?RHJxi}*)~i44WkE~G#^^3z9zkJyKX7Ug2@hpcVjW#SJHTpG_+*V>7i z%mwiLh!_r?8Y^pW!mq-0)~H-*<}Bw=47g%ymWQ{8p2nDJ?E0HsEk~aPlid2rt?@Sd z5~YB%3>Ji9L=K)S=ZE_e`5p!^1QPe(J`2~jedu+$rSf1GTVKcMytqc_p95^?kLkkN z8-dup>R|}{zpT?%XP%z=0h@)KrXNm&BVc@07ReqI8an7pyYI`?hKbWHfgi} z#o0Loi2`d0v~AnAZQHhO+qP}nw(;7wZTD-t=go3v^Q-Ym5&!mQ#o;g3GtFtTnZaI*ZkFOq{;mqb8&D50R z=M*|Q&YzDL&q0K!+R?L5d4J7A*-&GQc+7W>q|O*+Cg+lQt8@gZIt=qmceBO^phbex zH}oK+j^WZS)YT7fnDnX1MZCSB_{eP5jZO_Lk4XpJ#lO>7>dgNrtRpmjUG{n}Xz~el zil>C{Ur>mzpHCAnQz>zJK%4d<)zl>7*934GuASNzs`-kfaYmJ{_5RMfqtNhX!N_^> zs-L)$4MZKK!ZEVi-!FQb6Bqz~awhnGgri-QZtPx?v_F37bUp4*xt~sbs4rS!I8?|B zl!)?X>3SriU2r|?-`lexMn?UauaZ-hYpJ4aNZO7NMJT||MoB~ zT)DFFZGP9hyTfvMa2fPD6ig@Eu>_8aL(7iWVH|!E3&`DRFPD-Y!~c4)IeeeN-z?dT zXFoO8VxCWlVYdD(6FSq}ZVd`P>Pb3>v6Fjbp|7~_Y%^5DC@nlaoCdAE_pzkX)_t|` zFrq%%gRy8j`Q;w;A`C{&lpcFu6X(vx^y#tx=Zy_!_Xkb91iii=f4hBYtxh=K>@M@e z^yyK~_iUEWSeuK-D`w|x-`854XD@%rP4I74J^3SgU3K3Ifon!l%}sS%@gey-?Ueg8 z({`8HNrU)Baj(`RcY-Bv8ofP+GhdngXxb?Dp^y4$?S^Y*^kY<;IBgPJyv`lp<=>z8 zQ}=R~>-p={2Fc&|&)XUv6|S%17PBKGH?8$&c+Fn@22toN9wZZ-Y<=5A?x~MdXG{IZ z)Jckiy0Y&M#-ZkAlf;GN$C*7bQMXqN|F6TT+6hv{#^%a!^-#NIvC@&Oc~RB&Q#DS< zJ|7CtRhzr1>w-q$e%~%-)JxuK_hq>9ljAQ_TYPxhbF8M~jcE5(H9$7~IGz44m$T0I znwp0h^!Dc+1OJ381+7N6(~5zXxv$NVP2TvnEE5ui)SNyQQfg)I3nQLenq4RietS^V z;UD5cH5o-08`pPk@x3lxL6LXGAEQb3fPc1wKt;sRd4Hd^DiZ%4c!?JL1PA^AYrBmp zc`0S=In;EhbhWI}4;$a!#^mpuhS56D_%0Hfo#_|*KQX&p2Kj|MuKhj1X6bMA->-7U z^?W$@;0ppMZgw4tlB@GSsyn!k>N9b9?-cD@8`;cBs}I|+wOu`bY)$opRnf`a`8InI zuN2+t!w>(Mnd!l&IU>u|Mz5#%S@x3`duZNf8-v#cp~{@mqTurrGC*t|%eL zI};-FZ+8wdeh}B12)0ZC7w4{=_PVQq_P+Uy)ka$;ucMrG`lhx|YuQEJx?OBE-~R=s zPp_lJU3_!8&r-aA4aje%x{VhXVI<=W3vQ%YNJD5}VIzttNYW<>#*6{?^r* z^zha%_XP~q1Wsz3Wzk%iH=J*5*TxhU>!0)RS}Ks>x-?v%kH*V__}O zjaD|bCaY<2)Mz33tSpg?-s()qF+-tU%SmzQvA3cYJPz)(nZVUrq@}fFaP?9nC8Q@?gi78 z$<1u5Zf}09HV6I88S9FN{TsdK?CtR9{u_)De3l;KRY~4U|E(~-A-UVr>s4|o_^20L zSCe=8a`d{RJz3p8zG^n#>t!|6u-K(tWp3Z^Urs-|tP8ebcjlbF5AW>&>?-|={@YgW zVj&477J6?n0M-5TZ;@~jGu*Im1>F-HxH}P5A6Hw~cfz^}W|Cw&& z>Axy=wtA_IFGrj{q%!TWZ2Uu09ZV(Dw;?(TgR&s!dLt4`TGQBvS;>s>0Wkj8i8$4(7uV#pS#cxsj}PY zc^RF@`Lr#gDTVFyJRc8QO=q4?+vRC8oIX6eSf1q6XQvAXuXnGRuUSWAv941j*m`>0 z8W^3=X6A)QXXot4d-CMoo5^e+NF55vti;dQmC-O-?5(+KdnPRRoeXATKx>J;x8Cu1 zxZQ7a`h2tfthg&Dn&xbACiiB38mR4+KPg+~qdr-@KGyBEB3(c4&{sK+(f0J8FQ&%H zzaGXO)T;Xw<}w(K?RIJC65`;wn5jwW{M0?Ima_PO8h!WB3wu~=`RV!i_~boC!@(`p<;SlcvCZGf1lO%lhw<*+WPqXNmu@Gg~u9c<8U!wEY-Aq zwfpLN-l`zCMp7!8^U>bCekUIj6IX}n)!N@9PUk;j_WvV9E=f{>vag-xe48_aXIVe%^2^|MIAUHXW;c8Cb($%Yxnb`hntevR6BZ}gvL43%yX?8tFbWu3 zt5pYKkZG4h()wn}bi9MsdjLdI+c9~BHTCqSLh6xXhlBy+-+uRimPGn@oH4iul#r1O zzCGs^CqWoJwkF$2F;r7Sx?5QkK|KUn9h#E*6_aI!x)H|ez1ZH}|``UPn)xl*KG6D}>FSW#YX!;3Jb6a@i9W z#o)Q(yIyeYFdW^O{oQ#rR41?FCn#FVR-J=x>GJWnn+=uRjnfU?{SxoFOF5hHP|(dv za`r7I>X@~hY*c2w+28O3Gt#s0aZn6DJjK47@*SzQytCFgF0(1|J3{rQIgH$-PV#rN zTXKGC`S65WEMz3ig~OOB88?S{U-!js^f=;&UatLD%ftR-fi+tH)%7G&PcPCqevc#O z>a!t!=2Cn~4utPMYQ5|HrnLt5F_Kp(IMP?nXQS^^Ld1)GDiegd&$5QivKO9K=`&sO z3V$)pl33(uHzYkxl$CEkcgxg4aO^j)7hW&Bck`Wdw2H});^;~?Z^Zb7TN9-6}cj+k^i_FRV6{MkLshgCFEtnr3ou9 z;W$$0pU;Ujw{&Gq}C1t?qmRB8#GRD&6NZ zMQc7mtNm5rB@vH(kJn?ve5`P!Irr9Q`-g^}Gxch|X+U`n1DY)U=DNxENd5Gti1W~Grr%BHU&)`RRL0_q#MVSLVYDtmGwY%bC(UWWr&p zHc2$dc!?gfJyXwb|0zlCC?ZK@&4~%_jMLFAvR9%gHozktR3)YSg!SPhy=3Q^K zY;G7ndW+86UwA`5sr!d+( z%+fc!O3U$1{@H`)BdxtWbEBZpOV&>-8Mx1Ncg3i%U;8imdHU$Xzm}V6yBwWxIeM$Y#P?;b?xZYm>>H_ zD&C)Es;;nq?L|3PBac3&3fZT=hrz<`ajfg7&uzO_T}y{Io$)2iOQQvI+o4V&HKx~V z55Gg-MZUb(XqRDd#(U^mNyAVQyd7L=#>J7ioRU%6=tve8ZGj7fZgEpyfeF zU)46vyMRId1nu0;c*$Rm)}BF}rkB?=s_AR}yMPy(iq8i&u0~0t~mv| zR;sQye{=Vn_slB0PVpUWFTF1XSEsG~`$|D>dbW-(r$R!zgWW<^ULb*S}cbeCp;*h7An+DM5FNlLT*PF0-AwYT0g~wzHZ}-Fw2G11X8=Li|Q- z1w-qPl)W|;x1uL=PV0e1dP49N)v!#RoMz9+$JkD3pYK(FNB6*caC7+XUYR=pKfKh_ z|DrC#Ugy$(elK&e`%a%7tH*Df!{~BaE{sM~RfEvmh6s^&`MuiTMOBl!Or1w{lGEtM zx>?w8ygr<}#!j$hxs@f|!_8uCGkR>!n|$+#t7~w(_W0i}WM!NvpDllh%`EuqL{GY{ zAB|sPEpAR-M*N1xi_AB|NXuU^dXH7I;I5F-3N>fc=K9p5%M^U>2Y z-R~_a=`z$E7M->kCxXv$-Lv$yTfWm~)SpkJ9?f`tMAcV7b;GwaS{pjYvdyQaysG4F z>*z??NXq5C(HQblq7!tIvLi0d>hIda(p27@b`ubG!2BB_l_ya*2-SS`4izcx})O` z>I)Yvt4wt@lO-c`D%YXN4+EICFgyd1XfntuH{1%Y@$nl4S!tg?lP=&!-x>ku>r{K9 zpt~At>|W><(>hy)JbxdKGL^r2Yj0<=92=cRx7PRMmGtScwKy4mLLne-P?AQA&OrKD zH;8`}eOH;g?b(!X=e9nHZ3?c9=%VWD&+<-e^*v5%HP|6nlV3g7p1#$}i1)8oL$Y(_V{cN}kEBJe zQR&6a;F^9D9)$>-q<$BV*EsfRf1mMW6FVZDcsRvvfTEn%a;%cKoo;ld)@vN7x;b;- zWFjbg8;RxLUrFxa^2Ej$i zZvCTcdF*a=;9hNZ<@kTS4?9WH*BwM1|c-G%fX1~pm!S>5qKiv&bK{BpL z{EkkYheOBe)3yFwi)_kj_462iXck&4DLeitHH{iV*Beukmw6rkDSkgpQxUDj171{6 zaZIb?5LLw~r&?veUT$}*jH*--egFFTMUMSPz1#}j$-{lhZ(4R>`aS>EbbJ0gR_DCS zCtB?+P;A*b?U)_6>L2-o@HYH?;dtdWyO}vRat1O8 z7hWUXXWekA$%At(95<5PcCTIEY0F>g>XSOV7dl&%S!2dYzw<EYtOtL zSE07gqRG~4M_?o}q zbKDAVVv1X~*>_uZRT;PESsupJwsbFDkT5_>ZYu>qC8#aS{rJue#=1w9(52y?5~fig z4Rq=|IJ_Np$48HM7Yl{u_}LJ zL({#p;K`l_B@vi3FNBQmokW{ox<7t34*}4l-NTYi$CcB2zOA>DC;P{#lf=yNkER?n z9ZR07xpvE-K@+WpPQBgL?zfqpjxJ?H(c7;wl|{o8J;gVGb+``smtTjG5B=-N9F<1%e~hoU z0$h`q4hSC-mEzT(r!@K(nv&1yd4Z^xg(XN|hA$z^Ba#U1a8(TjY7HepG%+wp^R7-o z#wao)!j$A$V3A3jljvkP?nk2!v(tkthAN^+T{@qhgGZ|#c`?4)0ot)r!%~%TGK?Su zWs@4_voF92l;B&`(5Ws+RN_DT^J4CMULc+#@Wo(!DzRQ6cOFTzH?N!vMnUX_5bB zeFp(Z#PB$RIl0qD@kLrh9D(lpjfIp?4`; zUF0>JR-UW&SXAJje=M_ZzhRU14}HQ#OLTfkCXttQqX2>?mr`lrN$}-k@xnt$uyA3x$qTbMGQfY& zQFD_>qS)Wlj2nb6N44OUM@$(JnPsZba*p%xLJSM9LJI5oxQ?PtA!59QM|97XIkAqk zw%Ie{>z7HZ$#ZnMY$sx#sYGGx4y0s_II%2Bl`M93%8m-pDBh9^I_;5bt!=m$FI?P(UuRQRie^p!fniu-YxA7Y zN-<%kD5WV&QfmkqU#=L}S!AAnEh5^SITe?ipri%!7dDVb!_Yp(mO%Y=M5}FIbJ9(O z5X{&AF%@p8QfhBU*;!}d>@=-d_B`keu&RblO-ocW|GDm)%W$%0huaq3#7P-4!aNes zWskRE0~%WZYv4-M8}ELSh`3AtCo^1L-74ndkFATsE)~3766y2w`<(VQC!nrlAJA6H z05fw!Q1rm?YCJQW$hhe1$OfO=nc;GNpYHPaL$@HwTu zTz)ViS90Q4v8-WvUPz7qbg*>082$WfD`LnrO-EgHmGqVbh3#csqiVXnEYdx`dx{p3 z!4&^8d%{)^qwXSGuA*?dG_+WwI9h^m)EH$^8L`UHtSTV5RKkh;&smEdTXPSvAT>2N zNGec`9RgHD&Pu$EIq!$&0Z;T4C&^SAOaL2XqV6_vD?k)P4Sh@?ZEFg7h^Jkksg4}N zx`QcZB<2xweM9A#6s90lJ7(A6l0QyXGzGZ+ZF$s}Q%wZPeW69l4a?;P_>^X0-SFV(_^*mzp! z(F;%NOwZJ?HZ3lkxpS~Mr0don$9hnB8Q4`GhD_5Rvl@5C8t2Fy226pNAL>V#3P!~T zW%*q8q!(+@NKxLE(Irg#oYw@1-C?PoX~I2&2>v^UwgL?93%6kc@HqZ35ic^xcb?-k z{DJST)`@lxZY1lLri*7Y?d!Ca@PMVHCw%K6O^DSr7EA%VailA`bnq~S4IDri%wv*p zM;@$0jVlcIzV0-xeZpiz4$@RDTW>t6Y4ZMZeK~XdFw_0`s&2oVAG;^FtDE2N6^}mm z%k24k`DOHVTP|tbHiTC&Z(c6b*(=$kF7D|)ZFWr3B&Xds);&SCP6lPf6O;|1~B^eTJ2tagA3iJir7(BRsH3Lo95;FEL3#X-jeUGcL3BUk`HBLt?a;ad>& zC8LxgNJ=@ngVul>B?qw5e>+t636NS&ZU;1s4`Bp>9OQXOc8!apckst%!FJu!_YlJf6^FPHqd{YhKPV(LqycNYgulX{s;s)o^ zXoEuQHqHn7qh{x?z65y_NC$`(m8ez1%sQi!rYCLrb4x4h?wm&R{>|rtsU4>c&ePaP zw$?xJO|%Qu4gJW!IDXbbt$8>~b;6Ub4r$mTChOT4Ag1ft7Ua~ziU$p-4-{=eU17@W zpk5H}@iiv*{e-bV>Q@_oYdU$YLo8AZ?0t>-@4u344Wu`8DL90cok14#seN}&ti)_n%Pa(@B>G<2t2P}+=`wt? zeNSkz(l&|hJf=!5<@zS(YNt-HS*zMfIv<^LeF6w(C|@e@6?&`z`TJVn_Y_&#^@pO-E<~CQH%` z*es=upyLbsBPQa`Drm#hvZG}I@ zO(DKxWL;osS0>?zJgoa(J(Q;l-B_dY=X$GDsH`W7o+KD~eEetBX?5c&n9SCGn@^bw zzuOJ-8_U>~eZ7UqYT6E+=GP2AR+X7i(cTZYqlYr;30wAEqNNR+yz(eygE}bLmKG!2 zHg90Iyv#7P1~yp}8iO=N0_|U!Uj+#=_3(faio3m*)`=b)XzO!H?^01eszmx2>qF=B%hD_9li!BFiib9 ztCuX_PmSJ|w#E-22H0SSCL11S7kVD1$MKto2{rZe{JKRjDYp6sBZyU@nP@PYibl(I z5RC)g>$eEZmk)!V8nj2ibPqQ-7sIQt(QP#BH0@sS)m0lCxvaQc!zuZY;3{|3zJ=Zf zz4PR#;*sFFzP~l{#_|N_>cshn1yFiydH=F^2H-ZD=yJPYK-N-rvKnc?2s617bP*n~ zx3x3cs7}YXj{B;Q@IVsKB1VIXpz*5~`?Bc?y}prmxT_@%Z1|-Zx%?xRNUeflrbyD2 zw;bx&(SannY8nC!SwXrGScC?JYhr%>_5;am5Hl-k2^LnXz-aT;Upr(PUA3YzF1ho) zp_UHT{{0|_Gj;gGD=DMsru9~wW?`HP&N5$wb-TmaWUR{qfJ!M}!)VD@)MzZvxnq7S zXT0ETcqjhx@1rDd>L+u#pW}1z$qIyrbzL)^Z`6VJQ5Xf2ta`? zC~4;FxhW zx5^1dGev@}Cd=GN{EKCeEOa$sqXl#+0zXfp*Z|e_F)@DNa}&cq&z4)Y4Y4;SuK9D^ zt&Rv$E#+BHZ?z?daJL1CB?9mZXBf`}(z>P>eTT1thhUMPJtTI&nGb?xV3{8_rk8q; zvcbo&Nw1j_yP^BgxwHZYz!R2)?5e30J6>LLhO0ucsfP7x55zK$L6K9~=ZOE_hFiAI zzSp^Cq6Wg*A2zJY7m-ZS_OWg&I|Zm^x@V-{qme$v4lBn3Y^_raT{VS*w#8UR5Ybw!)N6$}U(A^f8QZLG3(YlEO%$SMD~X<4&0uSmfC-$MS_SwWcoe zJ|C}^f0cS;hMyKQcyEAso?k+R)5cVWy8k zGC=~d_;tfKiyU}W9A;ho*q=vnC}*foaWWXncOfNFUT`%iVw*D+Xn&|r*W;e*V4=E9o(54k}Jj6mDG%W7f1OSBAd2(Q>uER7Wj8MF`sC$onH+^P+v0_Ip zQgw81-f_PG=rUW})47mrtdx`cZNSs)@`tJjSI{K-S1klx#yVHEF>N<0;}U_8l3n~? z-EPe6rqmnrBPFG#Y>QRon|_d+2t}v4@7h!qyDe9quolw$>dZxL;mKi}>tDyGuT%vB z<97is?GLS1bh1p+*aoo7<>rdC8H>r>nBqz=DRa5f*hE?k4YN0pz{G%IP*AlX{zO)t zt|o6reLa!ckBr<|URkVoLmv*EmMwr%w(2V;=<`5#!2AEg|6k!iYn(XLUqJu>0&f5S z{{KceAnM^_YUgZeZ}%VF12;b48von__j$=+g~*gj!gmfxT|kSVl~6%IP=p~wq!}Qf zfS}i)-t`18b?e>e-gmvPVFukszpvMj2&jAB{dfL*zkYj**xx^=EQhzj&1o_k{C@2u7 zIxdLnN-6@fl?PzsB9Bg^nMG!;tZbw^W7ZJ>h#0Z%e{e9?s9xy?W>gqZ0p1W4i!7kM zg$6?JSVF9dnB+EK1wN6N6`n>mF|O4&C6ZFV_I_-<3)C@EqEUo9QC&iz@GI)DS0q)N zWN84z{EcNc^|slT7Nj8$4WT-kWmIT_=SX=x``=P__#-8p(}qYVOke zx1U|<$86Ks>rrt0hub+m{_1%}->Fe9{q%t~oB#~CDJ2>Jph$5KJ|q-2NVqRvKE+N1 z2ve*Cwm>C?oOh_8AHD<#8w9|90$6Ho?q|dKU@_gGyOF>{1w{m_z!P<-;Io2Lfxr=+ z90@q9ltptVx7O_}7p^q8Yz5P?g~*GW>cHqm+TIvQqGKn6z~)dz$RcRMnn%b=rbrjD z-!RHL*{K9J!QB&>X79I|m5A}@h?%cv4Hwb6u$Fy0!*Vq(D@x|tL7(jn?yd&43|wME z)3LWLOT}p5ny4U*{D`86DcRf{*WRFtawbF=S5t6NM#U>TsZ6N(=zyIV z8ksNZVGY_uQ)6L}=8GyL@T1u0k}^A`>5OXD(b;0?qAMhdw8&Q1xt5Y+1xN2zRF2#1EOvXK z(y~sq)=up~RlfX(`ld9nFknqo4FdsIF|x3~W%^J~7;p-`g=Fq=*HfkAb&SfTG8Jflg^S(J42tR~WfzKyWq=A+64jCR zSp0Ii%%yYU6?4H8CXp{#|C0EZ8b1E0`Q{%SZC|Ek%8mp?CA*jc$e^+k!e0Leb2dw8 zdAn#t(`d#MVX_qXOroh6KXc4qdT}5*hIEzOf^%W25Z!{obZe$!&kHz}ET6ej@%_b%K$R^dsxOK;`m9R%icu_ zkMd8~peWnL=D`HD7ZdvUXX?2uquaO9s3*~^t^8~&-djb}G{0w?=={z7ZX{MDqaLdT zFK?*Utix5-zvV*b^sC;6*)aL;mDZWLru~!%h;GUyF65Pz2+v96tfPrdy6Pl152)LN zP3%-J#i>xgN>IE?find-DJ;;4c;Qm=V%%n&q9RI6h-NgQjO8y^iCo>2uiO;oZ{#m$ zectg0xdOz35UTJmG>Xg1nJYfV&$eGmFlp~XlT`pe66$~wV%vl* zuJ3cK0~!)j`3EZCt{dWXXp0*@2C_wrN&HCJFpPqTBYwdZ(lz|yKI#exNPx^}Nk_<9 zq#`s&2RTBZ5pf_3xA;PgvB6JlABfPt>W^GE@lkqPJj$?Z37MULg0-_dU4qS8x|x1hcG4}1COQZ5cHHCgB`Gw z$}dad$9+?6Lkvk*thj;vvgQV{-}6A+9fd-jEZCmtZz(Q!_3l;h-`CHXNRZ--c8 z1D~4JW&q~=N^qvdXbxlU#WW~>05jreQ0I!?lm%Ffs>wiBWGSxWj*>>)q_txQzYEVM z+iI}H=+ihuWk)@S7uT93A+pt`-2^Ir>0-M< zcmz0Xsa>Po1EJcko6du_j5D(N!M_EK)xvh-T* zZN7Rlq)Rv#G}OH*&jW9#7$?4IBLFJRRPOqj@Qo4&CK_Mi_yQ{u%mw|qHO$xGW6-+N zR>Y94M5YCcX|l?n(O^g%8jv=n<3)3*LA`>ZgmE!Sc8&I{(59=0HXR%0+7@e!lQlG8 zsG9mJtP{{{&yqD-^Q-74ukQ}JM6yA>`cTGri@L=7Qg{{8GcOb}Ds+o-T|fatQrwBd zzl0mVqEgHa?={NJ@7E)Vp8#D+;;@6 z>vHMAopf+QryZT}btdUD#Enf}u!5?p6>hCoxDiw7{??zzbjtkwR;%TSa(ekuDI0uS zM-2Uuu8uoTd6DjKyfpWs?g{j`{VnUcEPsf1vir&=q1YTY`{%?A!eKQ9;{cNy5QvFW zCE`FEq=c9iY(N`Kg|HKG01pC3;0fF31gR(VfEO~oW(~nw7Z>nC4og(P6l8A5SqQK+ zBr)fx;SF*PyGL1tOpPV@LVg7EXL8`dIX&QW$X79BGe|374%rQuQyHcWgij834{8N# zz?onfNd+YBq+fz^2MLv7?;+0^c^ckHn9ei6ZpOb2o*dj~Xok3h@l+Ga%T6dK_ZZTF zH%8LLj>9#(4MtJLh&)6rr5`o*9U5lzM=LlX$o39WQ3DR?M1T`XL0Ybt0x2(`U;`Dc zH_pg)V%MTQEyWSjjs&G-H*jv?II+;cE4T(8*8-#k^`L|=GzDm41BOvx8#psyI>~I| z)F3_P3^$n-T&x>>z)#pM*akXqJh4Z}Q&lT`1=UZXz3_DU{MPi5Xf)Oq$^aqGin#=> z2r~s-A1))tqoj%#cHj!xWnfE4h)Z<9DN1m0!kL`+fCIre{)62AbzhnMPZsDK{lLKp=~^;ztMKviDYgpf+D z&YBj~{YZxs-iKl0*C7jSQS*KBP8Ws-M*b66KoG#;xN zBKh+5rS!%1W%dR3h2o56Oc(?xFd+*ZFmX4q*OaRvjE?3!NOJ?w_qA`@I#Sqz&Lyvf z_=WnV?2FpxI$})50L2lCvjyr3@4Zw7dASVSV6JS&08t@>iRDo+4{%_;>ksna|0GU( zfV2RgsjHa3s(Q4_da}NBVHTC=#++a=6*6yO(fDQ&EG~Tp!|hN$)kE!AKGnnRU_RDE z?PxyM!|dR>WD_rU^U0up#?e?Ks)N8WaMy<^nla?V?v&=!*MD@A9&{R z`EW791u%^9Fo5%w70?6ZQ#gt#V1G z01A;D`-o6kWsU;h^oT4K^I!@E55I5?Es8?@*$YY@>RpiCSBL_AgEkGG3r z5(FEF1d>Q?&(b0UEEEF~pdbo95XmUU$B{!Jptf8GXa_VYkfpV>L&pL*Fs}vp&OyBc zRRTmL<77log&(6zHdGiTbTp9Ye@b!m2#_VAKpd1rMwpbsB!WahPa{J+QP?BJPEjH@ z8$BE)0(CGqU?@`*ytXh;(8Qum2ozJ`#9`pVR76t2(IQKj=5^%5bDqog)QM_hJ&8Kw^r?rTnMRU)Ogahf+I9MC zBjyrMBK=6gqf3M&CYWB_G3^bMR04( ztQJcMv{XovAs#j%5`%(jhy+*bWrLhSG(n9xa_2dNL@z`&HG^D6=#*GEG>@H9et6Q4 zNd^wmT1H5t0=hP(Q^+aANG-cLJcU_2n{u9VdT=s_P})T6+!psB;|I>p5{}aIvZMkE zIHd9U@0OPd0vWVZ5ETgMC??R+B@G#-(ab@jA4D{PG9$pXxEFL)2!fhHIJa7a?_^-p zsie~CSrown3@a$`!-_MAG-b@_Ir@qcj0zz*1;@btCU)#9ap*8rfQ6vL1YIE^p42E< z^^}mvkrX>bv_+F_2$3LR{GmvD!GcP!H%_9(8kI*e6$Uj~rVeaOB$;AFhyx1A$&acJ z>gjO_WIzWQ!cY(xt;#3Mf@;JA0Ao;zR^W?zdI(spi$w|=!kUmrtyqVF{c8zdw@e~g z=^$-uf6RlLI2hi-u8~4%u|>bXos49pkY0#CL_r*l25XlcdS2AigAWcJN7$sQS9V>% z*1C^_!C&gYZE1}_n>K=qiWWu6BuaJib?g%fRrnbh-PE+@J6s<8JwP9va|*)rG?I=I zbu1iP#tp?q81q0N#Up_t>xT(3y8(~N=hw5WLiqr*9CgihQWYr5>3IxybVM#KD{C)W zF>rO3mvsr1h?FTI<(B?u$FJWC#p-7Ss|+ZOBG?9rK_h{f*jPy1#Y9EXs;V?#Xqyt- zkiLNVTMX_3B+8aYpb+2|00e@Duv-oZHO(y>K}GP^wKnR+x|x-=Kir`Ty&|=NQ<14hMZXVNjTug@)CuK(8(@QI*LMGWVGOGd`vzgOX@>CuYiO?o*>l= zIKPb~_{oDl1^R1}yyR_@86t_Zm$&+@Rg`R{h}N9|J7V)8PXFE0r%KQpPpEDG?`Co` z+~xqL?OY5(KXz)9%fQt$biFya&PBfiB-cLDM5o_5E`2et?nf(Z{+c2--vVH{c6d%5 zu7j7`_{G1${@MEI>umsZ+}}A!oI_M4L*>FasHQp-7}b&_y|M;AFLanR2q=HmW2te} z?;H#w+f1lU6pT$5%Eis?zV@eZkfK@Lq{dVxUv^Ah1anKyY5&LaX>h>2RVU>=8qVWxN8$$ur{?_r4- zJM8hEU3Z9j&CnF7y*QqxcMnOCQrKOka7$f(ZihfJ+OpEpqR7H7EUpa51f-?Kk&OjP zm_;0Hjd5+6HRjuj90AL~&PkG!+Hx6%B_)9wP#9=w*$S+y6(gt&TF_cs5}<6kNhx6Y zT3U`lZMi-Elt4*QsVHkKE?Oxcn#d?CDS?gCx!RJWS&b^E^IN81P{q3HtK#+ka2=SEEaqPVJAsYQVO}v&UL$v|*X{D$U)_Gh!(sMm ziu!YAJQ8CFeh0gn?|bPyIu$NI^FnXy^}$6rMwj-msfqjvTq_D^Q4Jj zrEO`+$ifIfT1Cg;@!dQu^8W=+o2z-Xd#%`qKJhcyW6J?nA@9Dh{>|WqD%lRwv;Fki9rSHQcVW2q!!h#6rifo zrwV{!n2i__S0sJ}fYzK0;Fl?a64TPuM#LnFQ*eeerCiF?Mkp%=<3>Y(0lLMI=niC* z{>{?LKzik;?XGv@2wy-ebJm>`vOULrgic};qp%Y-@ z5TuWo9jORbBby4gl1hi>K$2DjrKmbaT1h%iz$z4Z=yMwn+?HpuAT03>D5)EXg$tvz+5f(a_08>PW#Xnx;HK#K=8|I90AH2KSZK$^#Lv zi{bvQ63$m7m()Sh5X$7qsjQnNMK4b^;?~ZQBu>YR6~QUwi&+*Y0)gC?*cS!DM|w*p zz>s=WI|Q;)Wv&coN_W9s1Xnr8=_{Y;4ICjw_Zxw6t9G{RZcZS#>dtnuw9Q)|-MbAI zvuVOlaUgB$8L*6wAt{k^0BPNk>>kpxZ7Q~DB2L}`nWiIm8_3!6mB0ZafOmG}V@tD!ln*(vD|^QAGO>hX4Cp-{r*w!o zYY$wUdz!Y+&mrSG_{f>by(HQYU8P0kZJr$uN*{OoIh0C~j3nW@aUVr7xakPxpVinh z1uY6hc!`rvbFcfJ9VR8Mu~U0ix@n8=+j;(Hs_PBCy!8+5R5(3UUjMQZA$6$Psc59* z@p>ImB9~t2zCLZhTX=r;cldsW5}Duhd@qHml=A?&zVW@dC&}Q*kfA$snu}xhIV6L+ zG$=!eb5Q960x%I_9-JYCryE*;m-*~IKu-h!1JSMKY#lgCq~D22gFmSOPW=iQ(5Hi6 z^f+dbnGEV8U5eEn8q#L@i}+0Pm#u+(K{Ct*vP|Qmr&*e~5>moEB3u0I3373O5g=Xv zL)u*g)e&}S0EXZMcPBt_ch}$=+}+)si@OF0?(XjHE*E!qcepr{e>qcAHH+zOZ@Rj^ zO}~BK=lmgp^t=-$nN$4c{nI}cRw^zqA^3MS&Yw10iiJM04YW~uakVCGG6=QbY86)o ze?Q>kry1+SE<84vyBuH(2&KLAAvwhxry#3K5@nKH^;k@# zw7h@Se4*B8oHfkiZ3)_re))Z%Gd|#}6Tpb7afk+)(! za64fX=4G*;vT)d5=E_>wRe4lJF}ngv^Q)@!c5z~zb@I5Y<7~ti%Rsd?LRjr+m!XCT z7X1b$s8yU<2J9?>hU*2rK zLr%l1qEKj_MJoD3;X`zmc~h8|K7X(;;?g-a7|B{P41SM zB;c#8m%K7!I_3F@xjd|M&v|J?diD@px$7>XEiTTk17zbSC0uj8|IuYC zV{K*9rOqckk1Pq|A%)kKTb`2j_;g&2=wPJx6cH%%a=Ss(ys0H{pEsBYJ4tGW-?f z-35)Rz>+#w5DrV)S?n!0TAFKEFT^z8+elU*42g+y>$)`SA)d zcJ)YNj7&O?YxUlg6F8tg{Nw9p>Z}FEqwmh|m72ttM}Qm7D^+gC-#E4>8J=G2OS&=~ zIiwfk3a(#19+AK?ibrlt-$`n{Op@|=Z(aKfYaM)t*2$UrXy?QaawCEi!%9B4NKV={ zx>q+n&E4w7nl^N8GwhO00>O`Hi|ffTJobADwqhIV@1>|*mvG}~xGUF_YRIF&q|FFmBTc zBE~tZ=tgTM-5o6!d_eSw`~JPIu5MSE(9u#TTGGImJ|qh_?2k@7V zOc-66Y*=+HX^T7(pMnaSlK4kJtQvB84!pJ7?{Ak)$5eazMccahEkaBd{Hq(6gC{kD zXgBTU6?AU6_wv0K5o@H@wuy9zNbwUL89#E98a~>gUW?Btw7)d$+cf#zK(+;z)VmYX z%{E<*uf~RD^c+SVU7KkDTHI)FcXnuTfNq8n^TyRs{4f4kfhJr>!;{?~Nx1%X%;Ib} zzpV|VgUAx*W<`pqMJu`?QpnrHb#tc5p9T6&u2167e0%ZpDK)Fa!fuVEs8HYU--VD# z6ro49l8&z~uXg?oIsTmE_mmGrP*{u-xm+N*+NZ@S*h znb(LTGJA5S(>3T+x=);iUd>3&+z6qim(a1#)O40;FSPXUOAmhtshN0k$HQ`?u~NPn zG0U-h2~f{T=3lBvOUbITc|*-vEEHQ$TeQ9mFn^pgJq{`H+5mY!bG)8|);c;IQt_cZmF3i`O|U(X+Z(7yPKOR__CwA_1gw%_u};#fm0DH*2-ncLSAo@Wl+ z)GRugnJU7(2D=%~u_m9yWXKa-$-t=vegJ9Xz2$89Ml*CnctlVT_7y_>*cj zYb21-3ilyU7*z8KO1%7hRTy6Fi8RRg2~g%i$9;=FE_Q4SaE2Z_e8JVj z%Hg|x^}K4)Y)^N;c8N#iTscx2@O$}qA`Y0vO8L1H>P_l>aqGHq<36=&oljbxaz!11 z!&Sq3{;FQV`#o|vQRNaGLKAu-MY<5K=CN4t{Y*et z$=UOF`Pj~%U9v70pmZYcjA?m_-MC}hmgeEQO4{a!FvD#N4=O-=TD`=N-;s{}FLuX3 z=>1F%7g^nWBfH=p?xpqsD9fjODTtIUk@C%Z@0sUd7(<5w1!KP5@?!s$`C#QM~rkK{Nptk%h&9>4G;) zcxLApiI*#m)Tn`JrEtkFWCAe@)}+G{6vF6fp+Ljeb@2fyYJK2sKBGolhNHck)-opF zElbX(dRF+ft!$P19;5@8%(aq_$;VKn|bMR>xi^?N__%<{T@ zs_V%sw$WG2J3WM6X$M9n?AHxxQz>(O#e7n36V0|fpYz_LW+q)!magHFeN2ta!SoO< z+L0jDMianUW-QrZ45sH8d?0pPd2xcf&P8DPG*SAZFIZU~*(-Bf_t_+5&1h{dxMO`p z>}PixD%aQJda*jPcv}05jY8@=fjRS>uT;`(F-pi)<GOE6=n2hIRqCmZM#gK8CXE>Y5IXA;#x= z6X@gJs7y*)Y~CyWv)nRJ!g0_SD9F7_!d zpZxi)Cc8fI8a7u1p&sq4F|!hLVntteC4h)*HxK1n%OrzM_rb<`=RS-c))KkA99@o{ zt}%|d%&S8&LlnLC+3d+dzWYPnpz>RmM}dOc;)q^Gxvr}i#o4}{<<_(Zr2wJVZQxcz zLeRq$wgB%IGhvGZ;v4J8u;1lC97ql6`{t1JIfL|l+!o3+OM9K~?=jWp45w~IDBwRq z^Sw%ZjIHe63=4=u0D$s1DJjpUS*eC5fVTy!g(CD7q{AvKR)om_z3>6v1B@LcpThO>XHkbiE4 ztT9Mf^NHak{$lg>XwC^ahwZ16%t?P9c{w%HidZl$P><-^tjS7K?9R9t#x??kpirQI z7w@^0p?hX~xT}0EF>45I&OGi^UBgP*wssyp5Hrk`0LjwhcT8e75a}7HJ!!l<4mwp` zW&N$dim|xReMii&Ca7RTvp~y>S+~;;zT!E-=&|UMas;!#8S`{+N6Jy7?QOxSuzkNX z+@iQ>^b~yu#YKk-w$fD1db1P6AO6E--91n~NxZCS#O)=)MGtLgp4H?jXexM-dYbyl z1HW3m)hv@M7ppE68(eG)8-cu7BbpCA6lY&m1-t~-Q=0pDN)~-YE!nnuywAg@3E7G( z;^wQp2R^FPXY<}Nl(z2OrClB(zOPTB@1kre=)A{EC|_?89ZR4zYZo96ev_H{ZN{y+ zzT1%A<~DD{6qgpETMxJVvD)NW8FG#aa;u8t&g}!IY)X8ix$*`5)OW$JmqWu_0`n&1 z%D0e?#{z8GNmCg!o0`Y$oI{t=lGpo(zjo~nBhDS0=D0V4*$0m}gZHj~N(lgZCvSkC z8P3PZ%?3vINta%X`6I}@2UjyacH2>#hcp32*!w@tYQpzBBE_i3Qi(beUti9%%z8kp z@v9|UV~1lS@dffvvL5ZZ4qjV$*P~H>$rsv1fS zv*6189&Sxvl3`@jMmJg{i194)Z22XJN|u8Ir1FHb+?JQ^!^e5rscyW*A~c6Y2ubfP zbKU%c3cgQGO+)iLdo-Wxu1JkUslQ;xFFhG1mq`K9(~~!|8+JUfZ?mQGah1;(e>4E@ z%aK+F?Kio4-EA&^^c@9iP1ge|+BvPGdSdsFZC~9=j%VSpMp!^}Ohi>#0dG82*SwZ* zzZxX8IS8=r7-G$J5FBE4Spfrcdy9|ktWgNna)eXVEbhBCziCRPvJIMQiY*5n8zvZK zjbf(&n7$wg3bZ&?YQc2p2gknq!v^{Li|z_yY56uhQw{IO#EE{p=`L62ILEW@yYh?1 z2pV2jf&tjpjn6ipwtefwCz*rvac`4$3Xr}jo`UKv3m)D~Y}w5M+>jO_3$Bf={r#cK&+m|h6D zuHgRBWeYiV+=H4QonT_Cqqe{FnZ;_Vm!WP6|8bQn(ny4Y^SGOPl!kGOLlBv@_O;!KTaR`7)c+hSHtPmzK_lSjSHpcK z?F7Ul5Qngvy>;i~QOuenhvD5T_LgU_?kwzMqPb8FsHcXNQuHO4&k0z5+%u|(m-Tvx zxmq@l{!rt04;tVOFqHf4Ma)~Lxb-`!Kz}*H-W58^?Kn`?t>I{ab29?j3h7SM7T^2z zkW}7eST1H!3a`xh$R5|QL2JhR_OdZdb<-Ils2;(G4ZlO*hUM$$SV~vgo%zWzatuWy z43XBA7&@O-MJ2f?rroMQfUF*7HH4Jbs43;AF}27Du{sr(ji8ABtiI}+pkZI`T{9lE zLQs1k8K38t52re?P=Djm{|!8DHorGy;50D@AxnovXMeK$UJ%N8PMvRKAX5aoQd_5G ztVd!2qzJ20Br@q?JGv ztzJU}Gi!V6_B*pJS3I|k=B!IF?36KW!~knnUF!zb=@_TD#-BmjzTM>9xv=nUF@4X1K z?k;huyGK~Yk0MPD7a0#y+8-RCb3sbW%WuA2B{F{=0p}@O#vL7?XfI7~`qQapkyF3f7#N4+8*|E50wowvUe9X`Y3l{*n ztaas%c4xh(Nvqkb4t%qO-)}3&r_0RYGm$A`Z->&2*+~JH=K?4xCOI zH6Txk%*UxN#E_#Fh^m?B;Md8NdZo=p!nNNW;8y{I0>;BpHXj|Msa~9}M|rg0 zVXZKoI(9@spY3^VN4h)D2-wQ=HC6?-Z??HTCVD3(4?TYn>pyrL12#=_kG@xVNdVjX zO9~#|(=UDj<@xH#5Ei_;1)LtnJQFvFp6rn%@UR(ZtVfYDPv$i&XU+qN{o1d8e=Oe< zi5FV%cWyAv{frZrbSKshNMh9RzUpe^Ud>$?a^dr{{}`m#tpPlLax`Tt52q!!b`|%$ zUF!cAt+(obL5oJ0`vO!-yBQgSY()q<$B@w8K$KJhO=xR|f^WJ&JmRzK1+Pxl8_MM{o z?ijLq*RA8Nq}amm?luy0nUW($I=$(j>mRuuzxS}XpJ{Dmv)Cv|#KT_18v~fxPrVth zLM97)cuD7bH9ZPg)i2k7#I5((<=&sG+eMcXcw@K01DzSDt<2@e=qnu4SJbqvQ#(et z(p|W&1gDl!RNT|Cs<_+fa2{#)Sf$v}@ZbIgw_b9I?Zn~!=^D11Yyom@!w2cg)&CnX z)1kC`d!C9#&nDLC|EHfjE1WOu%;(AA5moXk@jMmOx}C$DN$*r8NB7CeZYj;1Yn4$Z zFPxY#&iL7C^8`1@qm6Hx>s4cn@heOoludP7+%vHKoU$Arqn+a2mk}wzLQ}AJAPlcU z%ZdS?DB0HK+l+iHDk_|PjXRRvmKx{*cro$!y7ukN@T*zhkXH<3$4x6dZ5wYs=;;I3 zPbTWLm-Vi?YJ=ky>psS-Nwg=CXf^+;*`*8iQ64sof3&{AWM3{w#*mk5{0gTL_d3^& zem%Iipw0d0#8ioWi3`>e5dK}acy*l_zU~f1v@7Lt3+HZswloZp#}_F2b*oze|K%#! zJN5w<_6DxwT#+Ft#TJvftVge*T7-Mpd_T1$U>5Za@zObme5iVD`hg`k?3!RH*UD*v z6;%7Anq*cZc*Mj>@Yo&fx(B6)Q=yi?>~-?MHqrU`ec)Jd;>z!Hy0cZzW+e1+S&gR> zKfm*He6o9F9svi)0>gg@s$X*RtkG@J%txx3_wdJmHOoj>U3JW4xp%QF zVVJaHGghElap~UVEZyyJ$XqH(kIgxBP+ECga|MCqLAI~&y(CieY&3mtwtpQFwfR^`x*PpvKybXD(8&- z;XM$31T+h$Jh@SY*ZG|#bm%g(rmneRC>;ITZBAU(PtsOk-FiFtw7~tEGf}hXpW?%B zX?$+VzTOcwl2#w1yo{?!r=RwsWWckNZTlR!zznK-)n$shId^rCG2)cbx^E*HV@RPR z!g!iL!R2Y~hWeL|K-Wlj)#;b`#_bMmp(=D*vuA4tUoZVjzOe3Ygn~>)b;r;rc;7^h z39McRsBVXE&QcV22k#cquRCS+8b2qh5Ys@&ljU@_of|l}KR4{SN8DEL?kXck_UEFM zIoqOJ6SxFTw+*z{mt$TKn-d8rU%ZD2S~*!fE`$$9e_^LUw~dethT{;H=;j>N}vUGY(AW5 zi(99pGTV1L$Ao!#nDejs^?ifgr;RG{<3(+q9VkhStn#f$#Y4VQ1c*b+Okn%2I@)-%<0x zvU=}lsR^=I+lC1*yEW~_>9YWw-GjX^{i>SDFMLU9TA*O%W5{VbLH&H57k{e7)!CXN zVJ8N^=a#O`?D{zO&1Hb;=6WW6Kj7#}#{3aICRIm3fUOy%x>#m2^$Hn#?dmqL zyaD4&XWro%2S7~G+c4tuXa{|mxSlE3^sWu0-a$;&!c{gqq-(FO;oSh%9 zOs5kTT~*wPTV9yXLwA3E9Q~3nNyN580+|t;eK~quwo7DGZ_eP(vlhl-`{l;;)y7=g zXxZ_)?H)~TEx7-C%N{Qrnn8j=Z3qo5j}>Rb5#uVW`oxc)TZM+=Mp<`%4ugnZ)}zkw zULU227Y*nhQrXX@A6w|{U96ASHh7y{mR8k2g29m!H18$em|<9f%$!(hZfmqCHkRF< zD}TB{^1Z08>*_6H42FjPBZlm2ZrZk%)Q%piJd_;@c0WE-|;+{l}c{XumwA zTfUO>S4L4Xey6=GUa^;c>h5E#pQ0ld6_RW<^h zJai_0J9VBx39FcfZTd1;ge!?Tf;$?F)DpIm7u0%53}K~ni$d;jte>Yb=PeQmLGm^c9UYa^?jMsi-g&=AAk+%hHSK})wfehXrD4J-DMR4?s68b z{qsTo#Go(ptwcmX1MT&2V|{UO-9)TsSm<2?f#`?=h`Xop_;^d9xtr_YdYyGYNZj!V z!P2#_}Pc*Dz&egM6sz;%rm(bKA^i?ySHH4;gyERDd`Dhvs8>7zo|a7CtAeV zj@DH6;a6mOQT36_dF-lTZz=V%hUuhe_Vl$o(AK_CO7AY!zrW1yJ? z#>^p9V5JPf`4PV6TqW_X;l;k`?TBUB=i^?bXT5}>P4xtq`m)1fUguZb7Mr8f_8xiS z+k=MpYMO`J^J?gUwO?$OlYy`;W(kbqkY&$T?ktlY<_N@`Z|B#JhEM`^?5uCsS82ab z8ckJqZp3U}1$Td4QwV1A%+Nu;#DnR4EfRy!D^mKs?IV}+zPYjc@bHM;3Bc;0mJ+L` zgEHyb(Jx0MzX8sC*t7a<-J}2*P`%~5d3bnnbd@C9YYSe{Tj$Q6#G9;Q_c78VhmV7U zc5omK3B`3A1o7+hsKwH{d_e(Kbu!@JPtkvrZ;ejGr#xlv*GTbw@Vg9KHe?*o`O(3h za^BM&-jz%-|3c8HjNMR5)9SqgUv0d-r+q`yva;E`cBz$NBSoL9VapFMnU!B1tH#rk z8eb*meM2Lea5vSfbT@t{PI&#Dg)kw*b91_yy|S}k8ma3JsV{=Of}?F_DT6RMTopHpgP+k|x4qm~+&vW`X8jcX zJ^Jq2Q{Gr$p3!>cZStcrt?yUHw73tw2OH>l7}GvR0V4i>wXE+hFdWVtXC-GwJb>Ev#hAD%)6YP??~%9- zos=AcN8~gmkC(Rnww*Ys_sY6ESXdIJJl6nxkNQ#f3lY07!yr&Amz(^ zuKucKeESgRkTtUYjV9xUUJQ|>95F5>cu@mAHm67E0~ffyO%JeK?EGP^x$ zWb8L;wEt;`HQ~iqT(b5t;BM|-K_Gdr`&-?bqS~+S;=p@ri#7Uc!FK5wB>(ybGue@r58^*G_TvYw zCc~lD7Yj`loP!W~`7UD2J(V~MIGv@vWKW@%ye&_<+^NejbhX>aLA&wueniCI22n+8 zi`sx`;%jqhiLYyyTdzsJH4dmfVN=Un=epgt0Jd3Ib+5Ax{D@DWUQTu*w`V^H{B*#M z@GOsI=(QU(G0hJRkNr3OkaMy|`{LeG<7E;&F)HOSr-$>a;1;{4Vt$)YZ#`) z8VdTi=1ZfxbJ%-%Vt}$*%{Doc#kU3U(@g1h)u9s52`WA~mss=y;<9M1sh-~2lpHU* z>t;1wZe6=av@pLpxX3-Yu3zG-Z>6?bdhYBQoAbbkZW2Du`r2iwQ8*f=L=!toXuSGP zb72pVnVrAcX}Ytnn5$j%(l#9$oYrIL06rLU zah5F(w(Hv~H8Z!X2rg`jS{}Q`;bSXNZYIaTEr;SyyXHqeh4ml9$EsgIyHD|0df;3N z#0p*ueA!5w{D>gjLwgloC-Cw(*i1gXkBj{*;w$} zPXxSwMlp7BS|=Co4H|Dl$k1wcJ3~~x=KKaU3ce^bkX>2tS+Ur;GYih0uRoL4l2N?e zo-bSJE6^m)wuK9#Y&wG&t0 z@w7kw!i3wI5$>v|tk;7=lGEvWIy^p_@KQ3@lT&kLpX*!;Sc1v&OKRzpvdY`h2Unc< z#=dUO%7tR^8`Lglz8u|8Ew*2KHgtF1`&P+%uH-JkvgIMK|Kp>IKLLrM-xt+gR1UT| zmcL7BGkL8>+o~(o)GS-E9L1);?ykOF%FXYa=-OCBvA3^e$+D;r0-l@&ORQU_-q0M8 zCCp{d2ztC8&Y+KP=O5|kh=@NQI9R&>KD*rD^5^PEm7IM{k;fzMw{vUga%S*!*D@JNMzN_7 zzqkMJ`aFqpw#BqXQ49e|m_NWYeMKR|MpdoUB46sG=AQb?WdnKyoA0OJC?53)+4hP? z!ohVDtZ2S|(17U6Hsn;Up3S{*35g{h6L!3Lpge=UxNifyIz5nr2^VGViM_{)K5ZB| zrG-AnH0)4bu+My7eZNhErQpLTkWN0buf_TCadulP;rGeN|1c3vd1{~_+~-Dng4Aa4 zpR_PMgL2^Wi|x!6^e+dv$_7bXR`)vH=;c3DjEOO{+fYMRfHccFJAe70jbJEobTxhR4Lhd6xBjTWp z&0sUs9&7dNxDLV#ug_Qfp>FlQ2SrX}Y*#`n$fYjpbode9bzbQ{WWO?XL;(d`Dp3)X zlyvbuuZyGALwdq!ui3Rc=Ra2qcUvr{;@pjW`h{*uWiS6Dqh7U(y9}jVe}f@tsPf_y z_={sZ?di<_IK0*XXt(7_>3NIi5mwn!NAa(?qXD8PnTL-jiXMu4mBcPFC~{|%R%)<3 z`0W|=bv@|`e+>`lHK>(Mt8iy)dmRXmz7I)z8cn4ZlSIuwFhHf-dsTB9zb(&x^P4c9ZEzbG*jQ}`6(HK*24p~`bP$5{1dKHf zMYb$Inqq5`2lYLhc_#W$zFdql2Z23TtN0mZtcY&x`hb&m$ESwwWkw6v^h32HRKJhv z>iIGCYaG3ouv7aMS+7gC8H>;60&z3vgv5&k;>YN=6_!cs4O8;t?`14D6Y9FVdNn53 zAq4~bJ%uNKeM(tZ(f8Ipj~7Ga7{4ZEvOu?|s>i}{Qwk-ez*tG&4-1`ohv~C)K)zLh z*`}wM!WAC9hf3Sa1pVbLg|V}AWVKp#dcE`9s3J_#Ji|2Zz0d5Djn4t|%k}>MlqNWz z{Vw?6z`*{<{{N+k|BFb~*>qm#K=Zqn{ep?kUMrL4mCMlMY38j4o_byxnbS3Sp14q; zv?X|ufD?jgsqubn+hhOunSf?G8ZSsI_!9&6is5O$Wdf=&h`8oHS~p;>3?nQHd)D`O zqyQ+$D`^t_#r)2@qxDN*)a=llm%;-{!hT*uiaw0uEDrPLCuTt@@KJ&=OAjAKRFU{% zwT!&13%V+ZK#=5`#*%aJq;6n(o!E=j_J{tS(ASfYZV~gzNld~E95%BFF6ZcDR8d&D z``aB^I3q7+c5)5FU1r7VEP1L3+!R;T<*z?XL6iAG{DK9yJHfQsDR;wi0$By0I2!-b zO*{#wr#1@a!&dcdts4-CW_-LPj0`bm(@dkou9awcViKgl(>!QX16CsMhaLop@M=wD_<4b0yl|&aUFIA z=X9urQd?L8=y;Y`QB#1woV-FfV;3dgR_)7lNJzKtPNpGGai>mkhrK36G~E{_?KM9uC4v2oyA=nXlDG0VaB$1PI@a-W?sNr7=;3>Lw?sO!ARuoGhPLbnS$DnOqkBKzpMPh<`%tW~<1)zj;&1a-^6&*6wc4JnfEQ^k=Azd5Et zmFiC38-ZK7vIa#hBJ-~<{y8u|WPd%Kpw0HjdV+CxgnL0V|IC3Hob0vlc~da&?|d(Q zB4JyJK+o$D2SE%j?S}m~rc{rz{ea9pwEBS+En`cSW@67uR&`mjo#3 zcmkHVG_4TlD^>kr`tq(yFiLn!*Mt}4em5Pagc06c`XdKicS$2| zC_tHME?NU^n$eD!&_sl$xAmcU*_ON-GxF(5gF3$Pks^blJ?bz*OTK}R1rX89M%HO% zkjR!>Ji}1EJo;O|NqeC)4Lh-raW84G2K(Wd@#xwYbXOE;qr*$v{?(`*==!~NJogYe zCQ5U*v*0X^TM!{C10PYnd!(6|9O3HhiyibOV)L116&%75+gi%?&)f{UYv}q8EuBYW zYQx`^^f2K6fHg5s7+dqLf-tt_Zu?uTpuug&1bjy&%HUpiLw`o)%>JS#3C1{mgejdq z>XAES?Ju;Q=5GWm;R~78-mFO|y`mHdl66OsK6XK(dsOaV;;^ zwrtjU;vKYQ1*r%kMP)!Sb#=AuqMfFP?WJmWNm$XCoUPz?oF~eg-}vyvG%iPZnhx`d z%-7Ag{iKqkE3rz2$6HJwd}Rf^ZLNhdS)qb2#O7>*#;VcV$6V+oS*L z=3cb;T0~-N!#4EGEjx!8(EObOvym{wG64|v#`|8fAf*jjqUuWf#!?r!?&`P8&_k2- z#O{4d?kO|8KZM#ANg);BIzEBZ_}p;?I^$yvvRT;xYCjO&e0d-s_Q5dy zg&%iajwn9NCb_f&((CIQBbm`9-qG#efmh=%TP0ly^_Hi%2b(53wW*(Uu!6hrb7Vkq z@TT}J7~CpT?8kv(ai%D|QT!KJf49V2p8H%u^QaYWKT;qK6F$7Q>$`8}l7pGe3fYI` z@~rX@h5VXf`L=khR}m4~kkSBeWuZd!Vt5jw(@uEvKhHp6Q>A&O|o( zXrF_)P1MbMsSH5P^^Q!I$oHfjZ5z_B3URQyLWUjp4819)jwmw*yi5OwO$I*iHervIfMLi=#(;(r6o}1&` zDyP36Tb^E(ZS}VL${KZvn-ur;dxl(ckzERJlx%=DJVSI3||w_Nl8eX9Inp?fdJ!YrQUyk2~#^uaR^4!{s2J z3+#Z`VG-orpTb|N8U{1CW;#Xya{Np4jiVNPErP}LjjV}QUVGEIZ2#(u%?^7^6c@fu z(45jXwWSGNgT8WFm6PFvl9gvVuIDYV1P~Rf7CHu*)n_aAX3Lix(1YBLJ!JW`%oB7OqHqGeHgu+yPNmhH;9{W08eEoMGtQB5q1(hER zjLQ)WOzi*3gZ;L!w=-ohv9bA)j{`=Pivjk(UH?JC(B)cgZ17Nc@|I_KZA2s@RfHp9 zsq%k7!iq`%fFs1rHxg6nWl*|^3}4}OyXe9m)I<6H^aQl~COQQ2?)mE323!NO{gN7- z$1}N|&7LOHRzv>GI)kBt2?YuY`hwL$z}EEb=<65VNXXl#5Uh~8YWcyS`Dh8Uu*XOM zkDQcRD`mY%X=$SdN+@ejH#X?Jw6HeaH6ZyD69=2)lZx;nT!LS~QKC_Vd$F&>^|}cC za~WeKAq=2VrATc1QD9GQD2XI6Z&-vaIKe*Le^VC51rMVNzhlT^ylwkkckHI1F5p82 zdvV4O;>dz!@`q&o4QRohk-zNOP3(@^GUxG?65$gP3Dwkd)6<12?&;t{$E)qi-!4OX&N*&iHOE)!l+vdu=GSXf_Q7eq32T zRonq^oIEA2;Vb*gsHQLOeckmASHVl;n zxTyu^+%@eSu@8BS>Jr*ZWF)sF{57ZE-@(+ip6AH$M+Joi!SWgPIS)d(yqbRjalY}# zJnE}-4^TZg$49K+d)g~%(LMs(t<5KtPg#%Ht!=V&>H0!AU?_P-N{t4(+ zT2@;7fL5p1KuF*7;Z=H77R@;sE`W;W(NR*w2aJ=(zzgx;_LUJI%CHVd#&IKAvgp7_b8&q(GrU8TrXD77^m{NFR&vMb2Ry zE-21Fq>WRMAQJH(B4}!H#%t%I%*Ts$gcQk%cTf(v8do-ve?yUCnD#E4a;ZzF`I)2Z`D`aAd z3=S8`O&v3w9(H*V(Y;Yr4Q9ow_EMp>WUwL6Fo&5C6Qzkaj#FhrYyN2^5&pn_k6Mjv6>mbh zg9a%H%y@0SjqWvf7}j5*2$AvE8XkDS$0TFzp=I`w7I@n(&AqOgaZj2t%0e`*;@|f( zau~BoI-xYI!ZfU6Cx&pm8Fpi};2Jx;Giy_0W!?4C{Vp|tEjFMkHux6UCan0vD^}Ff zQ-lLog6<*wJei*d%W(x3iX%pTqYD+Agf*1!_5<)6m4Hb`kI4*`QIw0hC@&{a>|9`0 zI&u(hsMRgoslTp!Uvdv&;3yFz06lco)>3p2VFdOL(l7u$HqjK$L>@9!+~|aUBMy>l zPKl-$b)FszMcl~!Iy`R+wwdPpF~q3xS}q4tDf&Fz&MYg0i0caO031_KAV@}oI}j*0 zA-!veROWxB?=#~t8ZLCf-3od86UQI1iCyQgjjJXVH#OAaK}C z2onfbi-CGi=s&^eukg+P9zh7=wk;^!qduQS>^a)7ju6H>&I>hZDRLI0^c=Hu?fA299~Q zaOtng5Z5e6E`l&kuF7FUbR^{c8zLldxF9^P#t}n4>fk|eA39;Mm_n(a@LZ626s<6M z1UF>vBD_%!8o&B>>;XIDt0Ly_br?LQNJM zy~ZgoD^c$tApr`R(;m6_AW2X>(Su;Ag3yPcK-8g9A~sw^n5bYS-w75yPQ;vuIdB*H zXMcdP3k4^5nN$*im+s@BkBrXb;0)&(q(aX0F@wh{1`x#-$rz*}F!k0&a8V#f2lGiG zC_@&D5XDkMI1_l2hZvSS*csqtL>iv;LO000(i41$Q`U7VCJd2-lYc!I`M4W5^Szcd1%LydCQ1f*+IqrbJ*kelyraC3pUgOech5M4;2 zCMi=o1ZcSWl(iHe~1EbANZ@ zBZ!e*En+O_5sCrHa41q^!>AX)3fBp8I&1ffj5SEHtEBY7# zO|&x(tr*h07u7H_0jFkMQs*uc1tR4q<*zYvBR=&Rsy)=gHB|Llso+y7!%il2$1z0_ zgg>P?6vi~u%2-CZILC$xd{O>GdoKNcx@oW;enCnPoK$@8bbHq`l%HlmlTICKwd}Z* zl&C(e%x=tOPn2cPRR5trtXwS+#{#_*Ch%$k&n@F21_-@d53i6j+@eT3Nz=#>MxYvXH4E%xukTRZb5ePIhTf;1wCBu5UW#O{(4#vlRl z(ZqBaK{!$jePSj-87hbYBzxim_1rsBi@&&_rd1hD%2Zeb0zl#5OH#HZ1`fo*-i6a> zp=2Vjgk=?69~6dMzk{6T;ZKx$&@25Rl0+N(-|%7c%h)uAE9*!0%kcj`{8-yZUBXTQ z4IKtKz8L6GD5(sa1m0>AM_5b#V)8-?wiLx;O6r!T8lb-oyz?%(ZO+KLr;|FZ+XbI!A*e|vWJ;+G=jvA2zJOmtpkHNZw5FRfmcB(LX(6G=Eu;O|9hkaZRebl!eZ5UyR4$_2r z0{#QPxQZYcw?`)Y{aYk^$6*|(Ch5X=z(q(s&;nu8f=T<8`gufncTt7YOT`GJqbcP{ z^hB~r-5~Y*VZKSbkiMb}M9hkU*ClY}NYY?h{XspXf}Q(?Ml=u)j&ewsA?nW3%-GLJ zGpSg6Zr(NxZovzaTSV3~Z{>&wr9}SYZ?HQxY}pM1Vje>0ga{SP^<6%MgsuZlO#x#& ze$-X*4?OJJ&{nt;f5B>pY#>T;jU7p5;RZr846KyQfs;q3Nw=H{P0EyXpk}k&? zhFjX5h6WGIOuB424I0WQ+r+=|;GG^Jnh}P$biOQM8LN!o;!bl3wN|?}dUnvn21BqM zoQ(AGQxK>jd;+}p>L0%`GBx4gFJ;Sy6xY>s|xH&=d#v?xl$?B1Y zWyB}{FbXh)+y4O*ZDM**PxifGHMfVQm@j*_g6!`UjN%1kPBfbv7V)#wT>}eO<reLySxhK>JzwL zI`wCKOTf0-^f;n&Qpb;;#-ANpYmG%yeTjmLPqi zEo;Km5Cz>)u_P9D`OR@X%jye(o!1w_Syrk*=7orzmNbpu4>dCm+KLF6MYWG_>AN!;@VhbN?LAu@{|d@RKnp9!yk_RNa9YK zQWvsI{&oQjz{7e!ZymtA2DK&uksu;c5+g4OCwWNH54)N_(EM>zG+Q+gL7o_|vFq6E z!H^qQ4sOsDV2rn~ixD(?WPJ)Uk`t2qQ85zw7H5Pa^xOWFW%_~bf;vEwy!0c``FErUi3V8k84sNPN3;ZPaER)hhY8t`^Upz5YFs( z(E;K~E^)%okU{=o_IKM?@6L}9knpqYcLr=;ou|4OpmT2qU4Q|h9rd8g@pTEE)|cq| zMO~^?Ck)XH0hs8=b+G(BI+!_Z=nmxJ2m1ohB`=8=Vf^HwK&>>5h)&r+8SaHCa7 zHqo~cd#0`ZwhTG;?dCTM5T?^M@MqT!ZxXTewMvc{#64;=O%k-bCK#L@e6COOl>-;8 z646K3KIYu`t{}~WO{>#aB_vm~Mn*YoZ`$^i@fjX0m(tEggw4!5P8pe?nm#^$6uQS9 zNy{0K4KQU8iAAl$M{q)7L&TZWT|=BYL6kx;GbyS625 z;Zh41Mm73y=wL{?yjq3Arxx{ozoUhI!o&x9qyc)O?holeM*IP#lKcz5+XM`IFG$qy zNJaq$4`U+W;y=6Hy*U!#H8Z+W zD&0~Glt@Zns=d?JY2SKGHrE~znO0G2KUG**96nB2G5+7T1t}~dCZu>0X&3a=7UMvM z1j4ed1PY7(FA+VJ$HpI%@r0lfK5*(`%X0}yKwzZs5^1QrDJ=DYy@?Hp9fcr)>{YPI z(JIN+2RR@}q&}jd%^-nLSdnmO;K6Xnkl{$l+QEkZPDQu`#+^Zk$i)kZ!*Q`dMsTYs zG&CWjf%@4JR@PtPx7-DJcm|^adLYLT+DT{qV!65>KB~mBCa#XzeUp4Xj{5B zegaZ< zqI=~<2ltHR>-i=UDE^h0h(snvf?Y?qDqf(ftB!>$=_8&{)CB|-YN7vB>u;&*CQD)IC>H@bcF$#f4AS62nUzRB`yvWB# z0;{i-w~^5tEjo#=Sn0bkN6Qmeb7CabC+4FVTsdxH20CFx45tY?pc2!dMA8qET$5gq zNNZEXB?1Y>CxM7?upXl(vy|79l&N?AL7(`82``Ipy=pFChg9C4o(N%V=)xMztDGD# zlO7dmkB?*y#3n9JWs?}+pI;aahR3#BXdJ8Jh^|@)4BfpZuPQnr<37Z2j@}(DB_W_9 z4@_4;U3>{52`v(Aq*UunzdcN>?ss5q8jpqqWL81P281LZ(o!A5Zp|hoENCDc3Aavc z!-QuCw6k-nmr}SY8}xg`1t0 zm@+-3e>UEDz38<(2_6Lq6ing>&WMpR)*6Rqz&x zKlfvBuq?gEZq_f=h#$njF_pui0u}?p)&B~uq=lk;l6Z+jFZK^nhmOcbiw&gA$+#)u zYXup9M=#`v=(DDHvaLQMC9Z1`lFME71D13+KK+e~Ly?D52hyumyfTRQx zFaI9+I3Ne4j{tjh7_cD$ieXT~=P;A&O{vQtIxhMUeyfk$Tq54|Nj<)(;XXCNd{y*m zu`dJL1YoB~fpis;p)ZiG=zGnC_^1=Y?mS1NgO-S9a9IC&vUZaY-1G;8dMW1|WvRoXK0HJka^x^gPSEO=E`SSuvvGkrVaGffv@4QlP3KvEJOS^xphm>D-)mtC1xx; zeoXFxA+1sGEch{?Cry~@03Wq3^pCH*xFGoB`2dVv5FKem#IbtDfsYJGgFne5wHEF0 zLn4h9LcOX)-=3i$Frg6Ii< zm!Wx72qh!@|H4@)M+&tj6aQhE0D>=-r=^5~M&>|9Qp|z846Te%I98w}0=blc4_5TQ zj9MY4v@)&fDPSCDnrkcDy?!g%547H)TyOzF1E%_mCj>tH;vxbf^mo4APV6QIGid8- z6NcIz_C{fYZwQHrg^-{voFh=A09j0g!MvO(RARAQfku}~8vi|;CKQA!44KsY&%t%E zw5;kMVT_eg3gyjy4?banm7zD0OizA(rvJ`dcmrl8rb|QK-SRrD8liZWW6p+!<;+V4 zEFw1wV|=KzR^M^zWKsW&ye+UPjn&mThEQ423p+LVEH)~v>2}x$<8CpKFE4Md&x~xs zJU6ts8Lw}!M#~H8#Wz7;C7O{1!NUXE!;qQ&!XSBY5F$|t`v2W8C>23*>0K$Yd6gu; zxv+bU7lSsnP3c7QrS$SJi(WZ$J5uf5GF?(s#gFNRnr0xs=yl4)D*3quQfi&@osBB; zMRc3X$F94orO)-eadDlTUplhowIrK!xg#>;2XJ-uj&OJYK0xQ@G^2{UD6WqsKtB_#39MjG!C64#^Q@(D^sa(HvPKsZ}Vhs zu)j#}q^eFzg%N5V%}L1e#bE@4=KDJdU3^dYD!hGLt7>eB*oVlP?8uYHCz@wu<%Y^z zHwM+LdA52DhQ*KxL^!Bz@}amQiJ+}!@0TYHU8eMLRCTK5UVPgXl$Sjg z4F?P{R(Kg6Bu2?4%gv6iMH8+5VaRr0LUGsWww3kPH{VU6aWICHnL=BOq8o7IVg%8yg)^pcy^{k*P8tcTmPe4u=H8zb5*g zi?~YyY2W6mjbYk64HqX*-SDQ!xwY(&adtU20E$Vc6MMAJ@f5SRY3-|y(TiLc^|T;M zb2o_v8O_~h8P&Q%qgB2>w-p{hz$)qzsU5%OnkT2`Kg6F#yZPE2#txOr13~iZSPmP{ zPw&A@H(e^mL~A^sGBwpMxMDO-)YKCk=?rZq>$25snLF&hx$6WCTunf2PUT+5E#D!> zaaN7KHrB(AW|-EB!c;GqP9n;-bFK1+@9#fkKh4FS;Gt1Abeyz`tBDI+?se;CQ9A26 zyqn7Oew7fdwjG`)%C2>|jP9Yquj`){ulnl07`sM64QLh6bkg3LMPRjR@jaP`NHQh;~gI*euoTQyZHl5tpu>65g5N^ zz}iCqGnnuM3oLhNP*hNf4-++(jJ=_HQ{r`Y^^FD%w^b^!NDeN_9|g$LoE~24i!va0 z#fOOqSS@97!W&sO*UC!nAPl9K`Gi3r4!97)dW6t^$38!5pur9}Gp6iehw`QtyrIkp zCV3vPSajHc0t&c5L&Eu^yO4hV^HW6BJ504En&iUkNjiG&kFTUF(mkY!%`~ICSe&Mw zdm4j_-0tN~&KIc?L>cS!7cOJ9m??~nST8A0!$cx*W%*@&7H*msM#jDVDO#DVI9f?85=n*k19HnT>Q<8hkcv#Hi8$t zF6d^#hG%YK9vt>rtZDmMRvanKtGxGf9fgDa9?!D8H=W&etg8n)z|^G+4&2rtFNtT4jNDq3$y z8yBCqT=7Y|RIR7spAd_3#QXysJdGVH@xPZC*dgo|)KT!FpLV3#gZ_OWNGe)R+Jq6a zr5?xk3S3+4J|sj_2H++mh733iZZbGiY2?Y_c|WGvpDL)<3>>_o0J57k4P3c0FZ#)- z@%#DCK~9&)m!{`CSY+s;RF3){9Dquw`%vwXMm0~5OT3nbATU&H^38)qt)q4D{V zDPFKaj;U}7?GH0=w~gBtW@``LOTVCzY$WvrWB(g+D%ddOgf?ZH{eBSU!$IB7^P7w~oHB z47g=15Fv`pI!<9sA;z+WcCONIon+Uzl}d+$V^PyJ;xo2_Y7wNoy$84sTJk=R;1l2Y`5Bw9)6$xan$5knmh;SvOf{KWy4!y7=i1D|0cg;oiTrd`!=?QrV zT4ms<+J4n;5@Y=cPKGAI(xD0m>i7%%22_`4n6V8Z__d!<3X6}u)T_B&B(^NVuO1Kz zZKUy+3+$!psp5$W@b%eH9XAuAgaa$+jv9p;We7|GH)*Ia{k|u8Tn{-aUj71j6BQ6> zjv5m|`8_?$9-y7BIm(^dFs*_9y62&5qjryfQOP5_xFgTgWX6VS&7@(x5eqM zGME`J0W`VYtv@!{Tm1zDjWO3nkl#*}m*i-7B-?&#a9!VzFRcQ?bk~!<-D9jl9Ztq$ z@t6Y(cbDDieZE^iPre;_z1r}IG5R7IvJD%A@^w};XbYZ7nV*lUKTzb%sn0_3*E;1V zY8u8Tvul;b-L@44V|l$6X58TOQlyL5XIJW?o{OpdCoWP$}j5hI|8I@8i2X-;zevK$I;L|u)RyUQO| z&|EZuhZhKD*-GW#sqwn1ZB}CW54k8`>@~L)!SV*#)z&K-T~185Roj!6hd7V?E($l7 z28W7iG5XYZRca62bHMa|W$bPrf7dz4FEDTV8l z=pJ8(KIjp{C|F2ozmQ8Ul^XM^^_De`Ofp@|D;rCD4mbaN$22lZ>9JbV$mNhQ&w9G) za?NM#J&U!x^<0t^F zU$P;rFk0DzBz3rs;^3&zn0;MdM{Smsy!d@BzY%XSTm`Qb(d!7V6sgfnSR62In@Hbh zt)KtNGW2zG<{e(l`njT#oiU?5Jvo3l8f;t4Rp--I&+>$?si&$rNcIPX&O@h&sRUN4 zfECT%CpNlhK^a^BXYvs*J?XUg-@oFTZ*OKZgWKy-l%#N@z#^8Fw(39 zW(dIqe!c`mykaSU*xk!Kan*lgg4mAyL+ME!F8-gkW4<9|a8H{Rl&S)U>wATwR{wLf zq?9keUaZOAY-^&#V5b}hHWT{&zqOqj?&p@lK&&vs@ZQ+AJX?#&K95p+cc?|fp*gH1 zN?|QOQ$2?hge<9l@J&o8t|G{?p^FvmMG7_-fHz+MBQCAMhitFb@~nu*5;v^ml!H6zayrpMr(VUU8o1 zjT;xrwllGwX(g1a;-OQ#QsEEEIvh#28c(o zRaM-}xnZ-}?!yC))<-{QUZYZ87?W4=VWNHt+vlc)ovK?JP1nJcrnc#1IR)>GvOd3v{23NUttk$` z#fwKZt;S2U%I6xqN6GLzTTn*B`{&NVm>E_p`JGNFvkGOzzU>aKPRCKe&rnU4EQu{; zIEmh4BlMPhkA=y=$7<($N9Nj@OvwrMI@6kj=}Jt7Nq1kZ*CX^d^_)vs3%xJa`U9|m zQ>j!Of3EA7!fMkB>@35y-#8u?iW99!)z7BcmZn@5a^=NM^QawMKnFM#13TegC>Vk^ zKRP}9xAo#*q>kEZSgAFUC$-4&cx3+QP>5%vML167?5aT0pdK_yILu_St~5x^WAg?& zYy!Sb#(_hr5{oU{X6saSJgiZ$=3-lGi)p_{Qr#ZYijTb9dp%WxL?Ga{(9{jqbFES| z^%EVpB(c@?p4>8?Nn)E?=Yv|vG0Q)f6sU9evA3lR4D3D4ev+jWPO5Uw% z*Uc^C%9M>La;>~n_|1=nUGqVU&+oQOv;4%6>!HeK)vG2qA4S<}>eftVFSQldDL3{- z6w@ASFXzx^8ikwH3H%6xwKd2IR!fl+IKFO+DT63zM0z?duPO8Ry6Na9@Tsuqae%f@ zuft+$Dei_)-lxF=GrqBml4?EH4_Q9Z&l~ERNS;|3{pK2CLeF#cQF~%E0QP+>n!5Ax z1tbZ&++Tm0KOHsHKOaOg^6fe2JFWy4w67B>tGl7R^KCoj)^97YfAo{XIJEno1Hr|x zo#EytTkMz3#m=|e^JIPF<8HEmUp4jENi2n(hZi8FKXy8qnMy3KlY88qKGtKSJKZG^ z<$~YUb)y*=U=%Z0froLG>gq1ST+}tTftU29+wwE~UjBC}tYAsbCw)!XVKG~t_mubS zYv#ELu)3m9_a;{Ny3uRWMkOSld%8AlhJhJJ&oJBGx5eOBEBU7Gwu@YOh={XVa#Hh& zU!#Snn@3%ph0UW@5$*|Cb>sc-{>+s@6@!+*!{F+?D~+8+uQ{HV7m{(!)6X`J^2I&z zE)?g6Rea+zs+#zOyaD~Q$}T1yGpCiJ!}uz_8auBRZGpJeDYF*58g;!V@2-R1czk{B zQDQ#*wqgoHrouDDgY_tp63396gbyVNLrn9rkDn6p1ZC#6J!P`)R3)?ppdHuC5caZ<%zV>sB_V^T`%5 z$L~<^q;LTY>xPwAk=oYtm4|2s8fpWlN|QW32hzzNJUz${m795WdT+)qg`7>0VljUQI?td{g4E0=up)SAQnLInp>XE|j;N|k#$$QWh4PFym5=k# zmlvKwxt8@{;(w;2$?V2nkMB*Ba9iQQG-zHf;*CRxK~~YdcEieK1>>h=N2YjN$ZyBS zm@9<8XW80VEPro)7T@yW%z}Q-^$BU1VvkvuONvG49zb8UOHSUe=U7la`Y?z(tn}Oz zNntnlm392hMCNSoK{sZBrgbH2Vtb9t>ni_>z_&Zbsw8E;ve0!o#zmc@Vt4mv26^!@ zXYYH(_;mLsmEhrLgfh()y=(XDgin;b=0;+&u02eUxq%SE#lfd5S%+F|MQKLb(c2g}~^;rZjMqKn8BWx`0RZ6om$w4T{< zDneIqI%l^4F`dY{!NUWK!GAbX>VykXtw3(Ij3qauVQBFN#RBqL%?}UwOoRV&jr{UL z@lH>AzDz*m?S9UJC)<)ZKGvEos@0urH)yBZ-JG%(?=)itgozK@yEbDR zwKt!UQgWJ&NuI{RqKlc<%G)$O@Y;L3=Zu9g^ijqk+)_?sGmrk{UXq4RArGD3{D}+F zDn+E0;Xqfx;3#;F{{RO4CC_3aScuEKlBCPc_9#@gUEJ-dbR)Y>^7iU%w!a;TYs-BD z>ysm+h`FN7!4u)k3 zX`}tpd~j4&5WexqIlKsHa_Mu&-Q+nsIY{7d=4HLkX-xss2~9HoSI$78Ts=h=C| z5|d==(qxnM!qzglqU6m+VzwQEh}oAK5Ov^gX$|GFmbTmQvuV~)>W5AV$760&pYe2c z2frBri8&yvyYNI&#qI2SP=9!qi+I^ul{f6R^OK&uD`il<vO;AD68$=MAJAYP>ka1kZcoab5POjR#kIjQO1$- z{#IW%alBV)^g1cN%ezza+Mt~R>{)dO)EoNrH&tX9LEN!k_?Fe47Jj#UzrJ96($)SY zPq}UH>@u(VQIH%uY@CrY>lpD)xQ#xy_Ue@4qk}_}KrH}q6uRq(-p+=7Qxy1ep`^%q zC4g>`MnxM{ed=rCzSTp+EJwMV7QxdFCg+Idm=s`qCeUjE3*K7;1!=`c+V=#?>v*Z- zb3$vj$*eW0L7@mOeN&a!Pqm6nlD;iq8$>*?21aXt$Au00OqWmsjWW7+Eg~U)` z!*lD1reN--mrbLU&g3fK+NCJ!V6(qiT5iC&rHfdXZsA(?_Nh4;C8{{BdMc6|wo1$+ zJL5G7&7#=g)1}99ZC!Emx^5X_8{U4Yu#+?Gb&07^yLs4KImm7%q@F0ySJ5f#ei<21 zA-LO1i0{EwYG<1NYPjy@(){VQ1l-aCXvL||L!w!%C=OjII&2Yfy=tna%x;UXMzW%& zT57$Trz3rseAbO;*k4)~5KrM6cg@)^$6e#@rlV>^0I4%GPub+!>Z+D6bk4`xK9EPk zbQ+Q<#ICd{c8d(z-i>A$4c&*r+f_~npJpm@J5B<5cDQA>tvAUP8BGsDX$7%nQkthW z%WT>`Z13PwcH6v7{U#1eTro!UmyjO81iRQL79!p*z2?z3CPSYa4Ua?LPg?weUS4cS zU=Hkv<;}M%oh(G>4N^T{N<;m;m)zb`U-->f6pmv}cZaZ`K*>mCFapk~mWm)M1;}9B)=ji|HS4=B72B zjIe2{8Y)O`c&je<5w{P6ihbfV)sOW@D?Vc%n*6xN!jaK6npaFy_V>|J3rjakVXsrW z%_F_EhI^s06pN-0gvQQ&&o^iPrt%+f`~H!0`rW@@&f_mz&>3$`V=b;imhw0MZ4LH=T>mfx3 z=H=^#XWxL?>>nY10$QzDEIINNT7jv`g~kpa*+#-a7UY*}n^^zy&F`uf)`+C>AYQ2{ zV+UB2CJ(lXFKK7{JP;7ex~bx;a33VxFu(n*fV)jt!qFgZ2lQT?xnZ|s`(N2LEb|u` z52ap5199Vm(wPyfFVrB?#V52o(pjxzUcavpp$tx&YYrUhxVW(PGiGw1y|edVPs8~i zLMxoT(jDn-yZw4cK^m{e><8xWAu;Ww3^hkVW{J<5EWq@=Q&w-u9w5G+QSWhF$Lge{ zhUvZ4$sL?_3D~BTf7ybo31Mt>DlWOyw;m2 z@VhIcQ$0|%%Wr^KpH96Z6@`F-Ld7npzHhO~#6P({Z=J9r3~cOF3^Xingz^QgUz2cy zi>}SM&!sj<+H>z*t^D`HjHN=MmwW;>O?V|I0#?5tuBQ&?i>7A58NCHM#rx|nHz#J4 zv(7v{HYVrwpGAtG4-nB(UxhY|mXW8aOeJc=t;;gnh)FCg?0vWXE+5HVOiK%akG8=R z8!u+&v6iqW^F~pFGAs}kUgiACkUY}muO-+ug0^5o?ins%q98nfz<*WncubM$kKZdN zCas4d2+%*@&VmP-Il_QtZMBZdnN6|2W}10sk6WydvGDsg;IjEQNJ9X~z% zMz1y4rH~-YLvw0dcZ3(}Tjc0GPir~P&*8WV;Hl}i#Ql#J+A!+y-I{}^Snzu>%hg&e zho}7SvBGCOO7^FjojF{1X}^4z=8+7>4euRu!^c>>iB7ayEtHjA`m)lh;j`lI)wN7+ z&pWMDxXWFR-=}gLNn(1Gb^Q0a8xT8MI**R$TxQ-XtB`50=92sI=vv9tYxZQk6}PU9 zIZs*ay8{kqN^Otym-q4R!42G(xVTn+E&70avp3dlIjWq#-mFIV%K<6g^EI!GJL)#i zZgV_`r#Arag}@H0)Cn`Qnd*!9oahp23FHUi_$BhK?iPz}cT^grBnaA2C zcymFy|LGpPv}A#h2i z*wc|EB^=Hkv#`Ox@qc1Zo~&NX4{U@WoQkFW z<~#lm$5w;(^%${(KLN>q;&VG2bEqd>0WaNnpO1S*EY|u0T zbqJoTm*ck+YS{<>{2o$T_jk@BELJYQBtoXBD+Cx$q|_uW<5jj3gb_6$pIW_0v|>F< z{uul-Jom7$SUt~9D4d})C|IB^ulu@svq&QLF|G~0wokQw>D6gDfI*C5LT34x$n|=) zmDsrW7JHahc=)jsgQql;T|H@1JRMCDZOyKM$z5}GSGo2;r=7YkKP`J)+;P*;``(gv ziB?Q*&-`G{3`#5wBW)h`omzA9Lrdv0xP!Zk9~hdOqAzhTmiA8b_UG7h69RPP+i4(T zs(s&nUx@pAhf$=s6s(pPGA#glFUb1@&O^bi2y*5Pwu8(0*7%yL?@F>- zp`B4D&C&d==;){v(&j#cMAk{`6V=;rKYQcmL%x&d#6PxT)DPyH_8YTBc(A-vj^Vdc z*jF!{HFIh?o@487soNc|pJ(OL@Xas#3CFJvZhO4GD)oT%OwFUuyjSNEaWP3v1dKN- zpA9U=D`mOv#prIOAV@FT4z!|I;?pH{*02yU;-I&kU6`>ffE*9kL(J0KLhhy=IvPR_ z4nk(m$;$2qdTK*m-A?Au{(1(0JQ9c;>V=ibo_kAFo3oE;(|fMfuGnj1DnnSNFUGv} zyZ7e6x@!m8A?m+5_5JvmE?L3ITqiJK4M@?G}>CjES+5Y z_#kfkOvkG$oO}fE7Vl4tu>xQ5Zy(6&mpDDHrRHeUwhWj6qKe4tpj++buAZ;c1J6@^ z7cy;;FB(0jV~!e$(a~g1;1j)@=RY(=!*c$M>UV**CX{{<#M(ji7_=6d+|0aZsd=$C z=dIksTu}TPH?%7-V)e9V&B1kMsejonz-iSOeatLqvF|>*Xd$IKwfqbwAOn_eMOt$D zg7Dv5FBQfyHohB%a_N><>|1x7Tv0blwOZ+>55(G%D_&1lp%FS0yKFgjyD`-~!uV&M$`zZ^wjeF*ovdRW8sHl34gfRI6nHEUVhVHSJ(`H z3hKu{yU?b~q{_*57}~k^W@mj=9gG;c7NVzlvjTcnzdPTY1tX7 z&Kwh^Kd4ot?sze<;CT}Nu5C+fZ*Az{p`K+WM`LEl-65`-^oVFJ<@aZ z8Jn&s6XKKO-)v`om`HyW^NhX9je6YTDIRUGE5S8Vjb<;p1<@3WC_sp{0#3Bz; zNq#MN$y*4?nS3f@Rg3MVC2bPQf#f-lwtr0Y4Xw=wZ{+^$owGAYUoSzNJN$MVv zs({_u)q$bPmZG_TINhapiZ^{rG z*;?{gnTclIzz%(rUWybe7QAZ?->z}X(%c#=!zCbSXSOdKhQ4=hbtz(``S`Yvo((?I zTm3U1y3xtVh{-ThKFc=dMcDS*dtSZd#oOF_TLWiFazKdA`kH1uaZ9aXYVqA_DIf{+ za~0P?FAxRB#qnMkfBPwblukVs$&0!+L+smJh7I>9_h&%gtJ|yl)$0~CXDA)yd-kIf zPzKJ*DfHuEa+`RYb<((Feh)c1cBn17nnWlx`BY235u9@UVeWy8iAH+;W5T8J$??Ih z#q6DvgOys|QJ)6E4@ji@TFQS$LVsOjz2L*j9)8yARrwn~kW%~gZ&^U6*Y9(z-fT1G zmY5?7ih{u9X3r`SDHP2zKv5K?J{rAL*I!^qVl4)D@D|?ZS6W<6eKGlbcbTb~XCI+iS%>w9{-aW+vZ-n=|aIgqY#{2%sP;>~;eG z?(k;S^XqsAQxUef7(;GCGl{?bPjTy9%Tev(Bu1i3u=sFf*J~_n8?Fn*$Dz{Hb7{6x z%cPD<$*jUJn%m}Ft>$-`-XeC0?(9ToN+UEH6(=I8lTPD8h8$MtvWw2vTjsT5)dq8g zjlTWqIT0jp3z;9zMwTwZb2w8qX}!m`e8RG(&}jR7%|LgGD96gjaSnaE5=hROa_uJc zi^6kt9i_94wf}3eiJpMH{*lBaGw^QbkQpr4?S8^5hTlWw*Lv}OtoiiJiHWR|(wBnl zb17id?o9VCDAq0wdLqlEESNGW`Liarn}d~YMqhah^Uocx$+ZA;MAEKVOb)UWx9YjA3r}`z9 zSgo%xAAZBTZ0Jh!tn2I|3!f=zlOgeu>u*`^GflreyRPS2o0#0EE>rFsBBy_Y0QHRV z8WYDc0=*9Bhp3{sF@V{D<&WrMz!BiHU9|_l!CBsXwnpeOkSRpGMuohV+6{Af8_!N< zVoSgGrm;qB3Av?G*v)wmer~RW7}+T@!?vV&!m4b&YbU%GQFmC!u1znf9ChvMU+&<% zJGQdB@9LWHnTzR2zVr|1=7x+dblRRZ3!#K_^knu2@x#{9xo3#BE`v=q z4v~s_fnmlTkv>nb*eZuI98hbq6pMzvaLOVRzrAly#$nrN;%oa8H>>qHDY_PS%W6kZ zdpeg#^3n7D3;KWOu|xK&y@tSmfQHEaf90|NUzCpKfbA9sQV)IoufSU)rTq9!i@i>} zMdJUh(nhv78L|Z5vN_ay(}!nR0smwrsNqx zoPy)e-K~9@yPpOvFgrw}WG7ACclt3F+?+^pih>eOa0CQCEGMjxt*x}Z zqm>|+2ue2jzrp-F_<#LB5Ql$Lz4l=DVx|?v&M4cIN}A9->kJNOq!UcE z>Dfbf<~mfJkb?}i1xYm}RWMuUdFB>ag|*SWd7(Ed#L{3(?9vAj+h3yA?-%>_W)8X$ zKZe)-OAfR$VtOmWW>DeB)rfs(d;6X)xLeQ|52)1-ph?Fn0WbE_L0a5a)m*Ekhi-tS zLlnW_0c$~Jy&)$FlazuOx_Uf-QyOGrA-;RYLioPq5u0 z1)s#_om5T~vjL{WE+AfqhZpEq=$y#NH=140958BM~mA3BARz^eYHGx>E$ z>6CHjO1{nJ0JSG?3Z=2f!Wp=FSDC9Ys&8Et{E)!DJae(X0kNL($5I8;c!vpXlIGr8 z1ye}1t&DRL()r7UnDsGW=?Ge;WGY6FhW*wGPp9$P?~L$#(;_XFR!b!f)UYaLCEX7*wK5~T)hq=9w}){kZhNBeIMb$fBwI@# z)up1WEI8U1l@!qz`C;+xjp*zWVl{I)CB8v3eY9vqZgAhQ2+Vn8fx;1Symg61(~3DA zFbkVVhNaQj!d0s}exs?NJy$lV-Q?Ge<*{ch`OE!H(O$NVVKLqitU%hy9H6gCpaexM#eEBbDBN{wYbc`%GYVM{KX=oNkDN8 zTL_V*dmOWU8#%j4D%^Y#=4^vd)XMRbUQ1n-@|$C6gYkns0x+Uzp2E#!2~~-VnF7T( zY0gq5ZF*%!YHaoK==45il067M8>5<1TBn+sbY^w9jvMMFSCx4zQlzxk(CO^>XV}G| z#8@0~7gxeNOz!lhUu9NWOhNIfZZDByO;t?r znD4SC9@`WIMMepE|CB3nC84zUq=KCBS9ghsvJdK&o&!2ciTVui(5_IjQbK(!n5V1w z3GsjLpi;JWvnnz`K=<)LK&1aiv~aWMpqH^QaNjLZjl-K}S@2kd&? z>D2WY-hFSrZ0#fkm%HbEdf$D1-F^Q2=ygwTWbEW*U@nvbreu6~lE@9?Hjm7tnC2XTS0eOUmEx{%)T$`n)U;ukxK zav1A^^)^Gkt4$>kzKchi`h{U)w;+Ln@-|7KT1tPfZiO-A@dXxXJ_dFwg5SnEv_o}1S+ztoqlonB&|3)?`2Zw`-+>Z zPF&s=%U^T5m9GRHx@+~%pC)-W((jjH1bF;tzfxVxmbE9@^M%<#9JlRutyAABXDsJ6 zAM^YFNT&50*Z;(H4P5q3{gp^m1R$1!n*WPXyG?6>(v?W;i^}Bng*b%U zj$ZZ~Xg$N>*9Y(R`Vh|v7t_QWPiB#fx=Q2my-R==Y#4P;wCPt6GRmgplpz+Qbr3tC zEoVZ1n?t|F_$AG}pmKQDXFi(pU%xXAkBHXyaSYyL%=f1S*~t1D@czo2gpb|?e^5)F znch$M2V!4AU#|W4=B{lnQ}tjeV)n)-@G@U z5G)$J96ru;q)Y?Lahnsjbr2=O?aWcKbrAODSy_<$D24c`BT|x;h5G;wFLDO}3HE3M z_kOl0rPptdXz*-Ce22pFHrguI8)B^$E0Hd1`2C-7RxM6U<{eAQnPxPSJEaiucL#MF z=$mu%7GA-P@$!Fqad{ch7q5YUvN!?9AQ9kSXpX-bSYk<|Jxjat(=G1B(u~NR$k}{g z{mq^BYm0kdurwnEpl&lL$za5ZEPPd;40uf+@4t@AHB2oeh0@RZxOy`0ZF+G9%!C>CjYM}#jEdskB;jh z%)i(FvNtYuss+q)-!wZnE~8_?bWto91u(<)U3ad-0*M0SKeiDRhhNyv5^V;yhl=Uv zn+B=J^kf%MH|@Z`;BXJY$F226s1^woD{w4AB{1kLae@4y%^_YmFJdvkthHjZC#{bF zgMWjE!@;aLjt}5e>NkEC?g5kD#tLoZ(V;+L$iR<=u%*Ez_}rMUnIGa+R+8_h&2!tt zi~+vwF1O4-9-jC1_aWY#QXGG_ndC8=2qVD9im>}@Z~NNzi?G-PNemZ&PuPcgMP@m5 z`|7b-hE;NuM^^1s@%B`j7vtfD-edZ-a6*;SLo$wVhC4Dmejx~?y^UkB2-~#lcioaq zT_+&_X`uvBN(hdccS%=`G(Ki!!8 zMmWRiI!{|hSey6!XEC4?ug@I|J@Cp9sN-pQ^0+>$qk!n8gQ%DU?0C*tW)VpH+&wz$ zkU4G^i3G~xHG>I{df`4G^Y>HBB5Vb#;Vv{ZL?Zomx`2 zNRnNI5195MR2C`Ti0lGxEeFTiC~)&XQ%h-Bl)J)tRte_DF8ao9!VFU*lX+(w9&Gv| zR9ln{yEy`D|L}VlD>m(B^oYt4DWmxiHeEGG9+ef77$Z-=ORE8`gMuz1dO{IX-@{rI zu^M7*C!CDp@f=AxQ|@jlUDY2=kg*fu(jd^Nxe`g7UW_075f3v>7|KR_G`62s6zxMW zsESIcX&$A8J`^5@+rvIHVHPBtI5xqHCBLgbw>&~9qOguzH_$pZ3>ko<1s+A^(j(Y~ zX;E{rF6GCD@`51&o2|`+6}bx~d=#)MY^DrsI8|$hX{|yaaJD4Ph5c2`$>V}bEKVUf z`YTDUC(fMzuRkL53# zQ3Bo$Zbqbo`$(d*AR~TKj6|v-h)_dI-2pQ&v>PiZ>^#WBDwmYe%myriuKvUoA}G;P zgdIdS`QX3k1b9>x35M;p4cs%ydUyDD)R{OiHdps{4!buizQ_rQB)^d{C06i^7D68e zhulzSI4MgEvHT>S9{M0%zTD(8_7hqdptoZPVpw%}_*)>KEeNW4Xs#ULL`_QiX@vrG zOAct!`Yz!y68p7~USUV`B}QydMt9f;dih3S^LL6hme|#FCR$~W`ER9fuq)3eeI@?!hq3CeSWQhTj zIrdl#1W2a(6eus96O{ocYBb7ML$>2=pa#|=c5`Chp+b?Q?c=*crl1gIgu$h_!v`pk zE%ZmGjvM-a030-RqxVpu07e!TfqCd50XS}>b;zLyOuDiAzyV-Tw*4nQOd3!b_i>P1 z9+puKs2Kr1y1Qe-h%`p;5W=)L+9C0e;iJarIL+9>6OD9RYjx1EKc?Xnc<{(3-35#B z@aTf(aITm{Q94W_#H@@$MYopG6egImY+}zYqvdzDM#^3oOYqW2s9ArzS{OuAquJn@ zOoDVv6``WQDM8rG%|nelvI=^Ukw9jui6#7D&Yx%3AUt8sQ2E2(in<`2_Xj z8^Ayaz^z~fIj-A*jjA*B{(hnuoKcYr|RhO-^OoCA*mip!5n1{oiNSYsuT$0Jz3 zTEQAzqN;ovbs3c>4{jMv$D00&j2^}4H2()6HS|4wP=OpHD2s|rgIOSaj~Qw>ja_Us zQyGpO&I+ce-ImHByDrqzSYWKg5EC}K3w5kNJpyIGCJ@^|Mh1lf0zMj=Ni+>i!T5?` zBr6cZm;hujvrp9wc^f@|G|Ct%oIZw$SfetU4!U+kErH<=`}Kgt#ujb30UGIn-fA&b z9m0_7LGX9dOPZ0~{GZ~xE);h%zdjr3c`Atgo;h}uEis6bdP}`4Ruv^7(4Klr`V&bi zP&ZS@B)UI5h;r*Ou4(_uXwIxLXe2Yvpg_@peJ+Ci{{l%sw!cuVkulQ8$9Nix4P3Z` z;i^h78O7GNci|4;K+ok4<)E@Z7r}m98++tElffXe5gc8W4zmXga7=^ECS9OKZtE}# zN_?-uR+AynyNsJ^v9{1NoHW=jvNQCI<{IoEnE^9%7mN+DzDP<@o{n}SjOFOCgT!^R z0Of8P>^rGO8HNVqGX_8(73p!Y1U+@wB#4cpG43eFA{YS=Yp`mF!I+4zQT7v?7;B&p z`D5%hu^VEIKm^7rKrLev%rHtZHr{$CKLh&Ee2h&5Jmx-#IXlvr1@joN14HSS-~d0A z)dW;&u&)pk0yo@pAk^#v^o2GU8v-qO9V!y9SLXoo={jy6^AYsK5{%s^#xS2jY_tZO z4zXsSM#E(}Qwo}cl{zlpA+|#&fk(K21A28XpjJLj=WD<`dl#)Jp( za?*0if>@+e9T!iK=v2qW6G-&9c!46PIz1`S&xy8~8LJ0DfpJc>mFyrU0;e^Y7sSNC zra9d*j8#Nv;c!>j4NXeApF2q=el|D15=yPEsq<8vi!jgXRX#li2!iU zxlZer;Ffcp)-Ayc=Q^!hfp5-rV-Ez@E?RqzhnS~J9hX4h<5I^Z5G1?QaR~xym%6bB zgI+Fmz7z}wy3p(4Dl35u2IF*CD%l#$*J0hsP_Raa6_H`!fDWr9Bfwc5HkynCw{+Na zvJH5q!&bue_*sK}VC^T{0j{eSJ4&_();jDA83Q)!uq$L7nBzuc0(LE#0G8{p$7Bbv zPltUW6M==h7UM9Iz;1VX9x~ZBjAT&YLDv5nJ47?7Yb-b~<>c!K_UICj&gx zV9iWTI1&)!RW~b{psN=xVKsXWBNHsuVG9{ja9)GGV6SClfj|n+Esi~M(3$1}W(zVP zR;9tN30w{2AcCU%IdRS~yU zT$I;E;r5;MU^i}^pU|_p2ix$lQC)eSo^9vpG$DYMfQBenHh_7F0n94+@X3cyL-;g= zPb2s=f=?6pG{N+%FyFWh&{}u|;RD7i3_oH>5C|GzD8R5GhV~e`U?{>c0K-rWqcQ9N z;ZueL!Z!>#f%x~t&;ZLSA&&B-@H}u9!r_=c9`~9?pzP~1Y%`a68HoAInb9DCzlm9c zYi$79K^+0gA(qfQK{@{f(;er=?l@bj0EmM-&XC=)EO(qUyW?zm4Kay-nYo2n!oSB{ zL%47*Gkbz9d~=pNKv`HIxK6HtxjxGIdg8uEpp^EkJy@$VM0dkP)@4}EWOV>&-;KbU z#Ng~Y0%y(HPFl7bE( z$9MrN4QoCPsEpUJ49F428(9Ro)Ob6~0Bkls#cD{NHU5K@h1+xhUySd;Hs$<{tb8mN zwRC4A7{V5j)+Xr~_GBZgUStH2$l8|yf@;vmWC~ji2Ae#BvZ^2)ui<%-oCWD<)YHIf zT)Wp~0i+x=S-~EKdsX3DMsjuBMFIztz;D*!~4`CdhlH#@xGD zHztAPGO<4x5_GM-Ace~$P;CPOpDb`2N8H98Lq|+^Bv9NB)b%>fb;rGs^iAL{9?=nE zguu)ohCupn$69TNyXYE_OwiW2NCp}l0dE9tAtcNm!Cq)wM}Udh2-aOV(inqec#3FD zNJx9LM1wTKiF1-8A)A|pveKXjPGP5EedOdtGT$Ho^EU$`aGgQI6SEMW!UKU5gb83W zAp|p^k9%sM19)uU3G?M9JWrT+UV*SN7!4`jpd~D~!cfeJ#xN7Z!4S3wGayU?TOsU< zp%hc{aJdxhhHxM_4B<#{h8Kcmg=5$q!*UF(G2D&e9(Yo%W!%QlocSe!s%Cv)nX&EI4(yHW3mhkIAMOV()4<5U(SS0L7_e}k zG6oOdQ}FT4A_GQG7UY9&yEZc4`~(NF1`_%dE-;0?OyP+U-Tv9a-Xw5@{n0HV2SPFA zOoA4ecPq@f8Ej(?{c9KVAoDEKl;y&bvx-=~S<6^ASXS)u>>cd=>__YuY%7i(rz58a zXBKBMXBB5R=RW5d=Pl<0hs}-R#&Rcer*ju@mvc99cX0^=8v|d1&IZhK+6IOiTYO*) z;L$gE=#~zV2yjDlhr_}*e&_?oPX0EM&Ah;Ks)eZFB3Qq4PXnj6Inv5 zSiv7__|s7Hz8e?3)3onG(sF3rNP{=fJS{cPMw+Lm<|)=Z2Wy@~HP6wS=UB~ihUPg( z^Q_T47ipeLG|y$4=LXGlljgZY^W3G;?*PO*g4fKYz?nS+v|`VKKSMw#_89!kW!J#x zZ1__RzOXmK=ROe1IRKwWV4L-rUIOt>>~}!TT@3L9un&iL&0Pxd{Sb#D0%H|f#rd*e z5G$7|6)Hux+A}#O|=pK%%yoq?RBq zAXHUSC{2YEzXBVmZ;Pb zvV2*NM6WY#B@nGQGbxh%Vp(!Y5u}DI<)~kNoI)+nEU|$#1;W9C@Lp8DydY zMsKVZWT@(|2*uWh+7)Ev(oPPNWQAGr$^^I~bg~LE$COkeaIXbRmWJY{kMtEpKa>vBThzvxG?3A1l z5g8TQF(w%qL6R@eiZ7BW@yzLlmVpKVeYcKZ3Tg;f1at>LTP;pem{crT;i4(&SlC-BDJqg>=`5+jJ@p4wr)NQtq7e3k+nFq1 zv&yvt!`lxupGq^Kk&+_4Koud!BakRd&>&Fkg?3RY6v!e7Qz5nBYC;PUsOXTD1p^`q zli2Bh@A9xFOHM~(=qfOt0|gy{3*d56WC0b75>Q+(6kvf=8z_{tWwfD0rAF~trt>DX zLAD+1EB3eX0T&`U}B%gkrPnb$BtTTX&RDJck5DkUX#5n82PVWCnzQD}028g9u- zS{-_N`BtCQ=ma1YvkO?n0pjdL)KfN z%&SvFyTyeoib|C7oLqH%RRwUDDEYM_3hwP18NXIW7iKGz1=uE%{NJ|vZAG$NoiF>9 z93fLlm2x~e^(jh+OG*9JFm7iROY0e6vQm;IE0EM{7HD#`1OB@4)8459ak65#8RqK< zF)&&bL-+foi(c9WLqcY8P7YetbS%~{5d_2)=R><>%ak(Mtd9I^aMjxxkuU4Eae52JF+EwKmgL9E^Yi5@8CvQp9UCO2 zj)6Ai!~qm8=BzpcAU5H}N~nz*=yEaGK2r`OINncCK7+P7WK+B+)ACVj0n;3u=LFX6 z-Lzf8lNw* z5^ydP6pDP%p;%Td>j;yyRJg*UQ4ac3JiudA6xAjAY9(9`F_IFvuhp4}#@ox`o{TJ} z2|GAzhS9NDg{hh%8U(!=VNcMXeAMcvZMhImNge68dBU&$C;=)d2&`xKr>Ed|HQv9i z@%e3y=(jb#pa_L=3S#gGJ5(Di(<56 zAhISorDqTN5VCx{X6J{qt5nCydINkCfw>@lYTO8w>8(dwgAxS|g-%TBwn!~U4NaCR zSLbTZXS(w(oqPN`>%PCHREc=&qx}U))o?lDXcFi@{^skrcpqD z(AZNy{%R&#liU8fw@?~kg?M_h>x}keUzoc7+SgmBD&1Qot}l6}_aizxO@z@gz7XXG z+Iq<1*JuP+^v~(;zY*R=_4gKIK`0_8;k;7gP^gW@hLK7o+*4vMrcle|g7sA^5xFEGuSaCI=2dV8Z13j^7 z`M6F2VKi3R8;Ic$Vqr}mkb>)x(L4dc*BS#_(?N=PNnuSs{8u-?WC-&h6%KV)Vn3Uw zL$9^pam%x+>dl6gfLr!-@Wq{rO2%+kx6T+K_=DGyZDD3am;*K-2{U^x2R{T(Y(NMo zGZzz6g0K+y5O%=A%mYGLEfAWykfx>tX(4dd(McBUM;fEsZ-x*MEFnqQShEo{2RtFu zOaz~1zBVi&L70gcY_k9k6dMG^!g8nqq|z9on!+bdK_%3~955lY(bQoLBh3P!hVT)| zU<(|PAgB~m2n3Fhp$o|-p%x^T7R_)5B;+e_Cy**6ffP0eBv%M%8j|UOWdL(P5G30; z_`l|PSgZ>RAjky_2+g8Nj7CHIkPI#$>G5f#3IfYF|8I3jGzoBca7gGOh{gVbJ;K7Q z1B3$PC;E6S5A{HZnTsLnMHdCJ=0Eh*lz!+qgmha- z)9|yk1GaQejpU9HHmIva1iIcvPg+OZv@>ao9_f(82e=hxZLBT-$c*l*5oYxRu}%nI zH%vSH3%35y2!yGHnFKpCJ*e2aMuJ#q0~SH+K$^*DD?)=qrJ^b3^>DZy48NKoc#!Q=Fx3<-T>6ibww&(ivvn|Z+$#HyT;K%Yw1NPtUZ94WK zr+2)|L$UFM$E>G!AKLF;@Z#aCth5-ziF=k!b5756Un+CA{d6Hnov!e>_o{!lRVMo< z2Q{-9VHPg478dND=o8!J>_oV33*e8vfsjd2=Cw78gnkDl-?rg!NV73&%*_J_Gax8` z2ccQ{J-G1AB3T^R_8lB{G#d-FL8Fai!Esd(ESdnY$3p_kOvpkm2Z=U6tfB!V?EKZj>W_B z@W{=9vA(Xz1(7QuEl?PM&W@IM8tpgf^md4~F^e?%p&v4sIWQ+oI4rs=iQ^O9+m7yS z2N;lK^g}S?pvi}rCGsd++81o=oW+d8s3X#>XvN{K1~tKoB800k7imi&Z^h9MbgIh-hxmP*)aJxo_=M`)$9 zcyQiGE{C9*LIjtQ8IY&@8z3jEfIb_^(LCXzgzJ-KN&wsh+Y$LXA14nTpn`%}I7c?v z7Lh1#vN0t&nt06PAjiQ)90@7{8WNh{T1h62;3-4V8-K|Lj}b%~0o**}B9jvoO8m{B zyXJ;52>m9GdxBDtEzg$)X`cT6kb`jp-L55Vw$~Y3=a)9z|K&-<0~F_3_WCE61U- zu>N)-x_0oqt&GUekCn(Z-!;o*_-z67`R)Y!o7T_af8vM0%3A;Or+(;FP1Qq3AN03_ zI>DO#jJlfr3?B$nKoZD+FcKufQZ$GMaS)G&FbbB@X9x4ex4PeSTdaGw*6=}T-cNrP z2}IylC^J_=K60Glqs%=U=J4p_hAzuZQt$@7HStJ~vIf^jU*Cq|1-^J0& zj=*OXDb}gz2c3WA=?Ty|N(p;N;OU1R1ET4U%urvR9`6)<)1cDhDT3`O_#*->fIluH zee7T#`W%GX7vl3z-RS;(Jv{L(2U-tCFuOM6QKKUsKu@tU@B&G@u7D*SI5XEL7C1l$|l0HL=+|JpzP z^<4Vnx%`pm&of%zdq7AfSOzu7gc_DW>-@g2Skv?Weg1#(=}y11*xm1+R^Ib2n_v=^ zek8%H4yFPrD?N${WxyanHFGXm4k&xQe#{0V5}cEamZf{#R~~w_TJ`N-mHYe;)s+^N zR3&pCRmoUZ%^(SqG)KSx?tQQMka@=KT+6YB-jtC}F@gnE=#4dEbY!y4$&N`Pb4q{^ zt~oDNqRNFCrdm-bGNp_Wkz>wDlw}nt3bRCZlntWr%I2{_^6(5&Ww#uNE9`voM_ap zFkD`gD^m(1k|KqXNpUTse8v7A-hO_59{!v^_LA=(jy+0ktuDR)x?fppC$HsajTc`Yb~&U; z%ch~V2F=Lo;K$GwQ?O*nL;B?GCB>w_4xJYT<(FYIVoO_qtn$X8IqJMJ;1m zW~V&&ql4Q%jZSIzbh`ZQF%#3z9G`ZX`NZhLL&8Bv z)6Phz*^NnmYO=tx?b5s(_Fg3PXkuO^VE`?{qHLi_ZH<|h%m$!SmsFYWS)e;ENfiZNMR{^W^(vxYk5PH)rV+m&iY5_yr6+7cbz*bj8f3x4 zJi&~i+EHz_I7JQ#)ClO^yLWv8WXiwbtftJ7zD`U-il=4C;Qq8A8OTe>?{`Kq9>3`C zzhz6=oK}eg=YMkWKhN0Qqw|Kxw-mz|ZxtPSOlny?_@T`;&VjgDjTfJEY}3Fo-naLf zncJI}j!lpM!X7zg%14(O??Y@8E5`I{%jo}lhSjE(m%BC{FKs2x@cn#neBkjH#?#7! z+2j4q`x?gV^uD_5*^1DEWsM!n%&+mjv>zd4*%}NVAHa#TkGqjyR0Cex7iY*yQFPVRSsmK;Sz&u2 zWFrh?Phl84uNTHv3s&()o^CbgIzG~@{yB`5{6~U?17%My`bPToSu$agJO{mSrWeRW zVjr>C+uJ*U4rD$$l&To`|3x6vG-v##`M(TI4_Bql6&ihTF5Av39kAm0lU~c6lUldD z8q#mw81MV3trv8#@JU{9YW>J1trz><_DFc<VFK%+}uTrTf;VeA6|i zvwAljJg6*wOXG2?-_83r@~z?YxaxODc=okR?+`88eD$jAQNeh(#P?cN>a5T0&l^`> z^&e~Y?aqb1>S0;8Gxs}rx~`mM-Ne{#x~n(->{jO7QL`!!^W#8KNgib6N5Ip zx}4gzgvGjj%cN)Q*A;0F16`gRI?(R$!{&p|^*m8qQa?}O}i4*jSUhrXsdplSgV#*6t;RK(Bo13d(xEOS?Hk#B&nn@_eR zo67VPc}TLn{XBdm5^oPl3yAu)$dppPVs9TGN!AYm@R;D?(X;C3FD*!@YhMo+aID>+FoybE>i6|TbyXb|$I0^}{H+1*k^LM6$;~Juqwj4VGdTC|W~aNC&az!% z`pIUs`gOcKZ}t+$L06tluD+?7|Ds2u6&ar<2@ zjbCh>)N+ykU8f1$g~PI8+Q!-rf%^KlsP4sh^%fQitXE34J@QJV8vxtV4 z3}|>!LzFk_5e;YK_NesrZU`t8fy<+1HYFW6DizUPcKoGV|QZq6zm zc510AV!*|Ut8aF^ZZZEzTI97=D}ru0=T2#~Xn|6d^2(~}?pNO`W%Y$#8FsxR2M+eP zJgw@=f-W<9!CJZ3m4^Ip6VxuXy}XjIH=sIyI6FG?>#-vlQKEz`&CTzIP^XkGrp`?d z`NaiQi-X3UsPShHPK!&abarKlH?_YQFMV*@!_QHA{NfcWJxV zQK$R@{b#T5owmSg_UL1Ru_=LjmK$U+&S@i9H)xSAlnIIq<^=Jb$)XtWp%=aCjU*^o z*_tq!&;y51W^4n^Da3+cvM^(q{_1EX;_~&3DDGUd5tD9D?cQp!NU<<*`y~&mp{`K_ zl4)qi14*D5WP)%I`a>);US8QfB&GS3drszGTyOJ|CUw3$pGu%(Sv1v#imVQ=4jt0^ z@5eG-HG0b)g&-WolJ%lkTM7ncy(s4Y?<8_)!GzOXe~n)x0Xhc+4`>#(>WLy`jd(+k zC&pfdi=*E^$tZpn)5_yw_zM2FV~;#U^Bj(sB}^^1PhTG76|;5j;*^5Z(nijz_2&sjYx+0R^m?z8*N zCL?Aq=Y2MB9T4soxVUJzZL{X!eREpvTv{I>Zg;y2|-`A{%o`+8F-85N5#3Xj?l{pXJR|0;UV zsmWh+^J?1(u4Q?i4R7zLy>nn%2Zw|eC$C$_Ihs5_v*=9B3N-Mo!_pm3hjUEc8#AZA9DcmXF>lAAvtGZ=v2p)W`e2yt;|Fo`YW6rJ9Uc8C z@|3~pZmUkO4r9*!xG;ZW&PC^IQAw+ZoWAEA<=K4skob;?hIbk6pL>iOM->iz)0vv} zssDv3>mJ%q>Hp!Z`5W%0q=Lltk>lpH1?}2o3!1xRFP?Ju9J`|3+>e763EDI;sGKwC zS;s!#i0QTo+`+(o23w;wU*6AHOPp-l zKKc7c*1o+$zBYOY_}z2%sD%Kq0x{l9f|hqgAIGGbpEBcjFiN9$MgzIw8xLoBhzQ{A&` zfuZ@blRHbtZuUHHHg{A(=H^uLSe(#2VcPY+A+@R7R&|g*CS6qZACn< z-8q)WIy|~+#Db+*#~}ZwCMAnU+(sq=4tevQ(Ls% zI&RjOJf3pW=9+++IUWZ(7(dQTYi&7oq_A}@r;+&MaZ$Toq98XV|M26Ypzniu<~R59 zBx7D)+-&tEZsdRizHZ&-?Rv7kA3v=0e3H`sIdybfA6Z&g!iv|x`0SMiQ{M${$?mky z!|TDv!9$LBNO?G`s49PXK+O3+OLi@_?wjfIV(ttVA9n9XnMZ=`3Yt{D0~1H}>=G5;VEejtt7CHx&k6fpUSeN9+k(n|7-rV3 z(c#%m?N5h4a(lGxZQJAS=P!xNW16|PbE%(Ok_IJnv<{Yewas z=E)n^^avVW(@V0xu*Q7huBB~Wnkl}H5a+M`cC*9bQ4UA4cg(UKYL-O?d93O@cJp2P zdmC0Cm9FoT%sLTg~ZghFVQ1jxZUgE{v!s@Q0oOV^e7&_Rr9*1uc;n-T?|EORF~?&@|OSi-v!n*D!2aK^8IORVOA1= z?b|-Dy;0F-gQf36K6Z4nVD!DX$8??DAN$jX#gFZE(tgCYqO0D^4zAtL8I>Q`_Dxpw zyy_Y4I#s5(FfB<*tj)O4{p*nOT!r1PVL`Pg=A3xBm9cYR`GCEq@0U&6HzW8gXB%^V z_kn@ECe0cBOQE+*Wq7JeKnobb|bU!?8d5r zl?VEqI5E0y)uvR#eVukMXlhtcw$w4eVfTQy$sZ>ko%psi!*_Aw$~Nrpho;qjUX*GQ z-gfPQ7U2b7U5+;YQd8Ni3sp%v*3A@KR7qMuk^uYWn13u6sQ-HjJ7y>s7<}l4`NF(jGl%{ZwUMt(GCmhQ z-4G_OqyB7|bhpinlL-Y65>ju~rnPW;BDyI%*xK3gdhEKmt*Kd-O_#TNS{iI}Y|jj5 zuNe=YNrQ_kRo5DYrM@nFaHhn=%k1sp-p|LXmX|Dk8ZE1Id3ij#=&qwv=U1xS?L*_g zx0WCOdWb!{RnWHpTa(vEbG|=(khU|CJ;ABP!>YZm%a-qo8{qy_rARTFa{OK&X|~{L ziye;MO=d6hm~&6{=1d2h;&;n?bTC+z^yEYkX~ z_I&!i@(a#K9UEU+bs)eYCFaAF2bKqi&anJaJ9RSe(4v3~$43n)F1MYXe)8TPi!|RQ zELX{?8C0dCXWe3D5~4~+J4kEv!*^JYd`RM;@32ge3A+zzOUM{Z5-v9??T7EN(1p=& zzsC~&)R!q-V-C8uFhA+#aL|Z=AxkLpUJ2{6Gng$ect zy$j(+y|<~?an4xM|Btms`m@T1D)s-5IJYy^jCSrOzYn}ZF(nddZiS&+iu`;;J|cW8 zEE4O`|0TD=_sYCH43|9ZyV&PeOzQ#B#zq@0Rx~ufkvO8+G>e`~GMjV!77U~+GxPcL zzOs$18nEx*T5){RWS+3g+{w3ZrBZ?EnKKTg4>vsRbMx}0Prfe%4kLGeeA4c1z!k5a zrcVUx-2LViJse^c{K7Tr^q50i+JYLtSBDNiIBS>J&h_=d7~7&bW&3i&#sogAXq0#- zSX>p<-}=>zyY15icQ5Q4Y?sfVRNId%Ci=}0F!`4(kmIR54fla7BrJsxmGBCBzEzEj}WcvE3m$0Nsm z&m^v66wRFKGux%b603$8{9W3td;qjaDSd_Egsw2^ZiRJz9>XQ{vUEqcprhkv&UP+V z2A(op7j%EQV@l_LW5pEwuM>u5?JRdmsGxle)tdq|vs>T>MJe<|RXE8<^8sA0mPJpz#w_-S?HOk1Gr&VRkU*+wQS` z@Ai_yu3dd@Tb>sM9B}BoiSr<4&G7j0%tNWw(fw!dv)f!2w`@(}RO}Nts6&x)$ z9=KzN<&6P5xo=LCmyAF6;o8ISm_M^gvmS5D$FygkDHvwh^-P7$v$tyn2gZ3N&lugE z<7i(|;B#!ktT9VN%)^!oTi^QARJOb8(elMt#=IEPWy<__g7!lOD>9dj@T`t^HZuEo z;KcYg4Bq}0N2C|8zaQMU)7P#;pJwlw`epR7%_`^E;4fJ(e$T7;`?RZ^o9! z8{&Ld=B?Rvsf+W9wnr_JHjiBIKI-xQ`Q~@0H0;pqm9RJQL(eBhgXGe)JCPnn$Sg6x8_zkalU*gdDd+2%j}@B1HXN`Qx)nxt9R56r{(1Q zWo;i1E$AAuquGmh)>Z*FUyfYA{B-BJ`K+w+%@?=z-C%!^>rh&;cIK$Sw9ow7q}n}? zwwh!lP?em%R3$4@d+B04?kwI47(Z_X6~q1`p;k;$bZm9`J4fHTT|q?oQT}4eH-NsL zX@OA@h0uR|*Qz9c-495#ACPcAfNO5q%TG#E8_yM&3YS)z#`dtKis*&G5RB|WI?pc1EZbQ=Dl}T1-CW!kK4}CvoeO&I;Eep zZy%hve?w|(N5;!DeY<-7;c%xY-K0ZQ?{y!*?d{9S%8aYKE!OR5e7nTQc?Qs z!n5`dqFol5J1<<+FQ@$eh|E42YrO_tOr4pwtGBcBt7irKoX5J44e^WLb9->a@cjlc z2hJ}D_fk)KU-+Squ#>xadiP1wgX6siU0FTM>c;H2x06?IkE+g}diK_ZVWV`nRL|gk z_^6(Xrn(KV-p%MQz8?7D2J4sWFa2#!>CuuDjSJt>fE9Q9@uEYbGY-Rjs4nz22X`VW zzB;zL{gCK?>x)phZsDqhi&eK1Wl-K3Vlm$Ay6J6piBtj=r?=UK{k;pNzu>Q?D&`>N zh0Ka6R7Dk4F?gZKINH$f!}tve#kr8YFC>j^WMm>N_RE&T`(nGHfUVG zkx>a9FBwiKJKLze&6~imk%^~Qf6coS%<*)YaX+Z>g7X_}dshY2KFT^05!9!z!yEH{ z3&*Jkj(&Tr85!lecZBJ-`Ab-aGoIys%JrO7?b_NkuT!+NiGjSZ%hbtt2fp1s_Dz)A zjW4ZE@9=$5=(O_Qs^-s5Uw>n~YMS$usjG z2Uo1TxAyW?i(wriJNb)yHg7aw&D-W5Zn(D;%BQaFJUq8hv1pTeUkHo6kZ^Slu54`{ zo6X<7F81B+u>))r7X2a@^|}}0Dx0@2Ju!30K3i#vDMM~vdGq15WzF>Fw@)mXa{76? zH1tka&di~~?B47%>@~$r8tjxvHoUxcurYJz&Co-}&d+biyq-?^vnFlwC2*l8YDecc zQx+JsZ)-ZOyvb?ca$wDj1+61{+xZ?mJ9qA!zI~g1YCEaPvd?WC%HPfYuq$s<`zf_g ziu*Kr`q*z;iFNz$7uGrC7T;g>>C4C`{PM^0R;#{H&zLb|Zr&^|kd6;JGb<%7eph*F z)0#d4v3=hcp}aM%KQBH$KYdTluoEAUpWeQKf zKi}VCQt!>yTN-RTG;2bE&!D?gJU#7Jo$k2yXiCx@=0AKNCM=sYDl+)d_*P>#`OaH@ zOleid|TS=`6tIlM^_BJTHxO! zmp|h(f5bv3NhGi3=8sE8Z>i;5jrD%It5rr`$D7kU?3Phyj~xrW-G4rxypb99;9Ht=?wrjYX|K+7|1fsq z#b=>LZN{dvi5r*38T$?=ypONG9WQ^Ky?OkDlEh)RWnWK>3|y2?_D?tXUfR-?%rcoX zu;1Z}H_b=64IGncuMBVfruC&^iUS*3wOkOvGTtOfYwgoz$ha+gzywKKag)V0mFDfJ zO7ke)Brq6+sM5Rzq=|pH=P-AGq$VW6`1PKnk_ck+wUcg2FsmyGcW7H@Sm6kLNyBxys7X|4{=0T1J_oY!Egi>Yy5lx#>jzq?7L zwfk3>I7@7ew)Yl{XeoU9#eB-UPXpvtdFo`-KNj#n<>1fH%5vMgXB^mfPqMeyrr>P1 zt}iW;nlnXBLK`=lWP8%Ud`y{y>b!=EFnQH|*r4Qa!;7(-{kiMHu1{QkK}DrDtDF~U zbo%kTHWep!Id&I!>K^sFQ=1{;L3V0M&iIUq)d(UWsFm-#Cox`>>DA>POQ~1U~SJ*t+QLwX7ZUi9JGtiG5Cd z*}nToM0z*NnFK4oX{x?`Ex8DC>eS1%rRHB5E@}OFHh`s;2-roBSZL6K?wz z6R3)@Kjf$ttR}CttS25Y?X6=SO=rpgSV!( zuIR}Knl-P+Ua{`U!sG8mJ5RA{mwfw_TF{VMxA#EyksdeSJ$Tt?$Dzfuo$h?x{wyy! zmFw1_GQ#ZhmZVX~-*z_}(d&3fNa&1fX;$CUK6bP6o$8p^zf=(0}c*&?bokM zYn#{8O4^N21grc_tloK*RLCwb*^qbl(8)iK_63UeRD@&Gz*El{3nq{4?6Q61SLW@a zIpTKBzjj>Z^=;$5G2YuUGp1in4SDqH{q`mba&w%e&oP$<6KGA6_1J z#d-6ZC08e}T@*I=$f<^*vA2eNbe%p=kWHQ2rWUuqDJ^|BZG>0jL-wmWZ&-OPB5+DV z&xqNKO5~zkAF1FuA#rz_EVi$o-d556MV0{FlcV`$GZN$ zcHFI3T3kJsG4_UfShN}3aIR35jJD?;lc;kb3_i_Ju_xWc-y529xh`dF< zdcPcl(f^&h|G(U*HZpqeOGv)6&D3Q$$1>|m(~Fb6y@N)T&MT!-oc)K!=H7YH&){8T zSr0-T64=XXZ`GB^*<~YL8c)3-wDMeERc)4gpfFG67U*tc(|=AaZ!kwJy**`$vi#Wn zpgjvJK71F3IdwZ`cyD*tKkX0sE>Eh?y3w-fp~P<^i@}!ouJ>QPGWvSlpt@1^arP>k zEvK@D?Gs9;Dz3L&I{QVu`>GzDXDAn1m0f#3v%C0v&DJ+uqwg)fFMTLFxouDR)u5f1 zn_OKvP>{E9Zqcfqi9MsrE^i(=^my#2;Rok!kv{BtWS+2R%kAe(HU=B?kX_3;Bp%(* znYSyd)NawOxvMT$d&zG&5|T3MN9{({7+S0-u} zRe~3`!XXphKYF+MMOBizWpl<{la?;WyEHZ&diry^$K@MMJ5xz_hh~j!n7nN0vVEQ- ztE?Tm-#_^2O-ynr^=bbjW@taIMdiC|^JDgnXzk{7#eTxbqG#ELC8zcnz2sDy4(k&Z zp;(-(FyHgKs>}A-DNK|8ivkM*HedGW!4O0tm&#tN!wm+K03WtG`bBx zdZu)x>lK%!*SF?QulRItaroIepBI;zckpQ`E|^zv(sJA}$%E(}cbZ>YwEdRNSM}ve z^JYDKMOW1YU5DJ5wXnIzn`g_*da6%tt}Z0kn1Vwg=Nz5x?7J(La0i5+lRduo#j~c8 z(Tl1iyWz9=otpo}2ZXs!JUE8BR{%BDY#Qb_;ta$&3l{b5aEIQkR3 zKfQ-QvcQFBy~k2btxf8Veyu#g>WJDqfDw9cBF?q*}oJde#ty)PLyN%~@GyJm|T z_dTTS{3;=IR@ZwW_u8jr{?bw&S+kEf)c;4H%9qZb6O9G; z+S`TQo*nd`vea-g|LFf&cJ=Ycu5;c#MXPf_qiMO!ahs0Te~JDO_{06_aqD`{+L_B{ zZ7RQcPWqIN$n~oE(-_Y^Kc&|adqDk3bVa+rnIylX+n4Q*LA+(p{;bSw+R5w}bMZ>$ zv!omY9*Ns4Bwfz>-?v|K+kZ;y`zxEh z3!6nVSj}=@x#eHgy%0a+^Nq$2VT@KUcUbSXnb!2Non^v-=toDIH!!Cive+5DJ(IWI zcGqc^S68kwKF>*voimsyFcwC~wr$(CZQHhO+qP{RZ*2RGZF^>4yVY))FGY%^NN(2-|2KNdCkN^Oj$Npbt z+yA0k;%+%@vAy`3zuN_~R9dyS>k9QXfh2{8qKlnU7Pq@?n{^B`ro~XHY%b-CMt%gp$-PZ288w!+)UoZU)8g<5#u%8S?-wNeJ zWg%jO?eXX>aZ5@Q)6ep$mcydMrfm5uni91gGN z-{EIdls9MO>MUc5JV;Jw7lUch*|){Z_X3QJEJp;r?9{!)H$=)9gne$Ha2wrV$srA@ z!q1X0Q(b(`5pPi>9&Bb5{Q%9g50{^iv?CTcx&E!dryf*8H>?W!V6?a<1uMX1>8nZ+ zKKIlhp3a}Ab`whrP{IOGGGcfZg)mN}I2KOIpcm+V$D@&*otW+>?aRUt+#|{fjS(p* zC>l?0h$3HnL?)z&{)g&%JPm5TlP|@c5qY-+Adk4k_LmDLDLT-{3wIoWvRSQUCrvCN zohwT8Mqo~}m0I5bMs7v?4$K5IW3uzSxC_qa1wNR3;+tSpQ6J6!t800|7Cp#0Z7E~IE3Tjt9(Pn)bw6Yd3$u(fs4fom@!mhPf}HwEUZe? z3mVGlpBg%5)aC}$w)zLd$RapL3R#Z_9gnPY* z0n1$g_;%riL|oqE99T~#Z|)TDA-d1nF1DHpWaij-iT#*_@6J*#OS`=RR-ZNmN(ngC zrGkQZhCa+qL5*Z3TsQ?6>T=xwQI2&UQ>BJDP3b2lEY{EN(jcIMP_BQazfSKPJ)&rn zRG;ZiTLR@rl3M6p%2pS7&8C&-vON|R_~#!y>{+vMF%)!ndeVjaw6bmS9kV#!~!@hENi__$(SUx>V^HIx>#%uy8%oF&)-Ohe7 zFL;z>TTg)O!ng8hz(yw5KV5qV zSw;h$R11xSfn(`x0`3XCib&C#bb>zHtM@}3{*)+#x<2sAX^RGojn=>ckaubxaVE)1e@@N>^ zC)g6Gzm90N?Q2fDi4cPM`ah<^4OL3*?I=6zES#OD70aIcodH(Wu&HT@YUV#zeRCO3 z*6eWG!kaiLLq?c~;<@bcHf%s+3t$agiF)JRPZANg>Gq4f%d1<(T>PS_E&q2WF>71gTvlkG>1PDW9 zsSfaLMOatG?KrFlTRV9!4Mf<{q;bPJDmLjp@PpjS97@@wdt11LE0rfA1NblqiV9Hg z%MQF#8@XnhVgx=Xv=_?{Cge&^{3@0;EYAz6@t+QsZs(()_qHO2Ow)AKMVCo$Nl@5c z)-|f8+sh)|<9|=kA~KlbUuKWl>S5GfWXn|)PL_riYZOOI5DpuoEGi>b8JblE1eZ!U zk*lSxv14oQ02ZXC<_1Xxs>K9FxKnglfm^I$ZL{$%>``*S{?f`*Ny@Ai2-A zNV#FTyk^uw>zI|FblIKDD0)6aRD;VO6YkNuBAL8rG)8g)?{d7l(A+`r}yl3oin@%EORp`eRn(PFdp| znZtl75c5O*2vfnR_@FGG%bxUN4H_xRyE3|jX`l0&0I@qP)iX`FXAr@E$Iw=Q!F}O2 zOaLCoA12~O2Kml%oQ6N}-PJnL?!b*?-O_aNY^Hskwh|t&l=OseJfsP+n#O`DU^fnR zC71Re#;}0{2!nY{5^l+Zb*OQL;ojGs#1@jvi*ZA79n& z|K`W;%Kg>N@AryFpZjI@{Jr=x`noBXG;SNhE0{Mgm+9=4Y*H8Z^qw|5B59J-?i=eK zs9mRNI28gQfTkkNv@BSR*$XV-FzBmDU7M#QZR-CT6Qn-H%FejLs}&w#0-+HeSfn8q zw&0hTB%rhDB?CdTHfKMr-$#IC!Cc;^oW?~y1tbH$5kOb` zEWijB0MH15>1y~E1bx9Mr3jKzj_x4#*i0ijzH(A3Sa_XK4zGgp8sBB#R7(5ua;tq& z24T<9E$Q5&LH2+jT3Au6EIbM(?O$O{)-WuZ(@0u-LXF z)mHsTYl89`E&7=`|Id0quxq~6kn++faL7gr%YG!tfcFd8#MBz0%=r9I@ebcqL%5T? zHwAA+anEbM%&WM;nKas<(7KKDzW%7$*{d%>-UQMUhQhk;`E%>;F9)xu)VKNnI&=F2 zgT#dfZ|);PoASFXj@j5~JDQOtdszAE^%>BFYaYdc$}TZ*#?V$938OfEJ2u`-ce!s4 zyBSllYuP$AJ7kD_1ydWJR(@isMUdK6A#eUsm#GjF88kfrQ_%jp71iI;Lh*h}e3RHw zKhG{q(nZq|nt;iYGy^tEY0EO(SDzyyx=Wm6>`^6gey2)`8>Q`zDSBnT-p_Zdwn{j@ zv({6%+i&biG+sguN3T`hvCpvYX&m#;D|dUGHX9yJ{CN zVZ;e|mERP$h_kKmr?@V}cZ{qHEbYo99Fd20->rx8bfFt-RQ_CVl?s*hMA4H3Bae^& zj5?`qTm_Ta+H3PEbK!TpW`1KCo3gLB5Lr#zq0{`D;m4{nGb-Bs;db;;Mm=WBzD=~W zVUt%Lg=|m48+tSwf0mJ|s?9gPxNex6^q2qwi= z-(Uo>Dl`)fMpMyfxeB6jz+5?k1g+C_Rav@MiX6b7YxW+ z%1%}z4H#i2SAs6W1NOFdMjO@X_||b>^${LO0$RjqP!TkK)nZ>ZJ*L+;@(y>kq=5~; z5F?j=#1g4hFw7K5y7ZPq9Xs5YBv(yCpdl+r7XpjWpm0sh&)U?Y84o5 zzPz_XrqNX^D&vwn+Z}4@VC~-vayV6oKe&`Kif&qO#c3ACso*U0MOe2xm`%pIC;+IG z@->W>d_|4M@|-*3w{pe{-iCMLAOAi~@}_<=m-{(71D~vb_+B{X3?6~3ncVc+vYm$t zR>No+5?+A9v^RhrnfD8}nTHE@!)O^6UVt+fXxp)fkblp!l5PL_(B}M3|H*oZ>)wyN zJ2x-(YATl0-r;|#PO>mgNTpCBr+Jc$C;-XVl8*}3@gG*em!)gDU>=i-KIbBxbz_PY zk4qoGBg7+70fzt-*n$$r7iS}HF$#_(;$`m}lhNf3!NYqROZy0}eNES1{>s4;nVAc7 zt`1?(cDtplHwcayS97bJU^G)C*lM!Ojl@4+_Q*n412$Sfmm=`NDtG`E`PoBa z_nY}3SO%8)VPkrs_b3~D1e^4lDe*US4?34tU>|tGl8{|Bm14)sOU`grC^prwUhRQc z<}oO83i}N4-`#M_*4g(e*G$wvIQzqfRrx%UDcU~PZDpqbwM_Sv^m{bYr`TcTNPw+% zilM8fP|&v6tg(3SsJydLPWFejzd!?lOqdjjY*=M!q&TI&kMS_Xzv`>WH~JvcQ;yZi zKwgnTj+IJ*my!pxAp*@=XOPwiRm!UhCCOHpvPszm%Yi|Et@zncb9nV}7Kh)Rb+pihR=#aucEGH1}ZY;*nV`1GZ!Kw$h|zzh2Ws}-FrlQgygEOWWJB5lTEGB>8U(hJI5t~5507DL1A z4J0rzU>FosEr>snRVS;-n^9j+WcDK?x0aU{E8frtLnmbmpp>opiV6BW&>ispzwrNE zo@$K~hq@O803h%N0ATpPlmen2E~a+QmiBi4(=KrB1FrGUE^wEZ3|5FtsU&>sfYb%F z2wDjh1O!DGLPVMY0tyIv1?pW-@KU$ljqZKh`x<7@ZS?zk1&M&V>)n6rzx(UA`}no+ zPc4v}`_C@$Pc1+qLMjW!0sw&9*ZimY+*} zj3)I*6G@Oyoq~b_VXEVtsIH_UAX|9=HZJn;B$`=d*2>C8x-(`S0f2}R>+S~!V~y&S zZeT`*0Ttj4L9xgJ+FNKK^p+*Ws)$K$16JS@d0F9UWE0~`eN!SS^=tRX#=AfrBPAL| zxD(YS6biqh4tqsXwMmu+K+NA*W>asQZD~Oo^1u+Pqgh6UCU}mN$Fu(}Wrsgf!Z}TX zREVG*b`v7w?)rr|pa1KY2JtvDG^N(UNJ3NBZy)+=V>&8tnHh%F5I|ZSKu-&x;0sxw zCLQThy}nh_dJPOOLjEhmW+sM-|G{>0v{M#)&EqufJf}f=m#OD?wLm=&RPg%}J>HAa zFo?^~%Ohq~13fw3v<_eWyR+>h$L)9JqT4G<&%rH24Mv}X`l@@RqeIia*H*o{8W-MR z8)<$7%p3%|ZKvioy?^`Jm43`NjlCWP$A7q;EBaQAa_OfJtl=17z)dO9002db zd+;HlutCCo@!~0VB0!j8C9nl5Ddem}1^wV9K-eGv_7lKTYjZCf&IgO>8r_Wq9x5mz zSOuP_Lj|7|oC*Yv==e~;S*0wRJGr%PXSr~t!DTC$jx9u9+*AifH`4anKoT8083ZKS#`bJ!`m#)`hj~+ZmRtX<1P+ z*ADu0cku6OP|LstHZ&c3+p<)gMsfr!NP{OiW2}h^!pM&(ikOnk^-=9LswihdgmE(neq?3wA z2@QPCC@FeVE!RdDG)w+sm0;1)8?p<7RvmP>vbm@nZhj6I)*qcMhAz57qDYHub)73I zIaYA=Zbjv|&CX)C2P!S=RBP?j9#rLve=u)K0}BJzMAa}5U=fXJA)L~YMS1f5I>C7X5lq3+{o|ISwj$;=V&8{|w+~$=Q%QoHp zWZ|{4t&apSko~UX5-6Q$y*eSjslBfOt!=bAKyclcS~QZZnuB>q+fjDhbxfIPLB`91 zHib0&lv3Gps(YodBElnMqquDpQWGea<-p-(v(1m>wuTnXHoy|vpN_n3G__8xZd#h{ zv{0K)+EHmquJBN6YTu>6KI4i~5yweb!ws;cu!ah$IHtN%n-RnGWaGk-)#u)q>(AFM zFRG4nb}9Izxh7bmHQZD2DqDtD9l-!00r`OncAa?uI;`p7gVK#KrD>dwHt$5gP$OVH zxwv4qf>h>(WW8A-d9h9;ugxKcNjh;|5T{Q;%E&4U;|4S)P7C1447`%BRa9OOdR1}Y zn!p0GAT5L_;v+Wa0(erOmR-xl>VyfigJTnHvf3P*KPBnOwHYx^O_<1$pM&2ELdJf^ zTFKNjNjgkNU5WIxrcQv=7{#$Ldj#u{g1CzrXRC~bHiijp>*KZyWj6Z?Z7xMN3xaJH zzq4pt{Vk#K=@&^^#u6dR(sm{?O7*!q^>j*wpWLV~B~k17Dh>Whh2m9bl)KOrxHL-P z!8+l1i-oV;xN-iK#o&5X@nMb3m6hp3Ibpyl^cIr2M_o^qj#n`%7s^zi{S_{DJ2NP% zqm*4JDwY8%SV>fe+GFv{a;Pnbl$VEs$tUuyXHqvo4`aI}4ymMJ?D5S8p= z3Lt~ZN(g)XAI#Y-q2=wO5ly2RkA=xn;4_J)V*Jc8f9b`6+JJN4+4 z2ETKm+WVQ;%_`zgN{asEpQxuUAJeUwiajsjRI+^LO2zjVF9KDzkf^>W=IFC3<(KQ^ zgO<)Ao&Wo80XA|SdhmpGSKQX)Jf zk+Y5_HtDL9+}x*b4>qw=y%48D{VGB6Dh19I;H0oXBjSZi$%}EDaf*s4F(I1Kgff=D zSS50GPrh_hn7@|4nEjD#$EwuUt@8$;q++NOClE6mNr4X*w3`iSrrw`?1f%#k6 z)_?&e0ET-L9XCNFPd-91k(7j^@34TL@NIR+(J&Or?WgH_g$w^=Sch|D$1tGoWtln~n{Y;k>$V;#_tn94s;0e9UHr$bxZ@G+1rVoc&k%7$SSL>%!8u8^+b z5BFhLKtKXyMoT(E)*=<5IXcK80*#0RS*seO0~8boU#T`-NjKtrIQmgy9UcOqPQGUQ|ii78D8m;rEdiw}MkZ?sjmqGq<} z%R-{4(vT*JKVwibqRwblP?CM4#4LHuwF?`A;-(xs;A5&(3SGdALoyQ}yx}_-6|*4u z@q5CeW+qL%dR-BA0GH`vTkm9vo3yHu9J;E~nw6@OA8?2OpD@Xv`3r|o;#mO=Ql1+H zP0%eGU_zGa?NUhESSbt0D=~u6s z%cmSC?=;De0eL&b8XNe;tTqEM=U0L=Ek<(~b2p|z@dKC% zGYFBbHtjl4@kpbI1$)XNWLjJK!@yf1}UAwBa# zA)`XKDAxrPFeJsDIQ$E^@k=Vj-0)tb-2C2cIhD0L;T=fN9a0tZ>jI5a8NCv@7;314TDE<@bdO<{>BS)FY2B^kDK4Jo{RE_cqhBBY!ZsiVY9@$ z${-w8Q!oxNsR4nQI8`DJv_VRUS-}Rh!Bhx45eM)fa0H&PJx-8%LJxQ$(<{~xtaWh# zFXXU91x!KahMa`}OG6TKjvC$|*RVU3Rmjv>f-mGpFn=Zo9-NbXK8Ji2LpFo70_Kpv z0dp$Dw1M!+!R|q=U=27EEF-Caq@DCjQ0^e1GVDF%86!`_I|VeiI`GCwn%Hr;W;ekosu+<6h^6$SroKbNjQ(f^#{}8lK`Ls%A)N?t zA}L7A^->_^1r%(cqV>iZxlZg_v?rxFV%m|QlDq03Ty+X22979Eu0#pN1Wj%vx19tgAe!#e+#yO_8pJy5%N^k3SU9>Q)tgUoj$)c zeIy!=k@O@ByZl58s0@^pi~0H#(@Yk0NpUlOEwim{pcBuNG|1L^!ik`G@#sj?E{{ zZL&0=JA(}ilBY4xk49zA7NArNJa~wx19oH1I;`EooQDx$2|*_S7Xk+f?%^ieu!0WG zAh>~!5yl8J0IiS_XF&4_Qh;($16ZOEy$=h5*fJJ_DPACK#~T0#xg*X2tAJr>mKmC4 zMo*$uT*XfcR^)_D3aQiy9Pd}?1W&qF^x&srE4$GH$j zfl_@IJ0Vb&7d9cJQY&&ai(*)H@z#i zwtzCpTfjN2^CudQ)eMn*`TA1&;`%cC0{cR7Ml&W10u-2#1rC_FYuGEw)euHUa~`C* z0qDEhH*Fm$Y(eLe*FyY4{ZjTt?K2%QCS!o&2*ud~b%pm{s)D>+25vA{He-OOkio?A zD3}L0u-^3tdGLRlrd>c!EfuAM0Uu@LaNqm)rSd&_Cm7tP#~g;25~;!xYUJ@?p11^XY6b z2c-r)wpa#>r-KhX^Z0zY7~ujK#&{UO`N|6D0rDvv#T4>K;6+X$NR28vl+JN;X%Qfp zcPQ65^a&?Yxx!JVML?Eu9Re3QiRs`HMmZ8p6yg*~K^;hyGAX~#$Or_qln8C@!5u0o z`FZL{q)CuWAWVV*FnCK#(I!P|fW0D_oU@h!~s$WGI zAdpZYMLj%#l*D>D)Kmb4NRE9(sH`%Ffp2<5mWp{Wg@OlPLp+F@*yMCc5TXrQbeT1X z=n+sR4gn&bD)C3#MKKA24MYM-q_(GN5ds#9fe26#1s{lH6yxK_p%748t^>3KniR;= zTH2vw0UVfD0(@tn-hnCsB9d`3BB;WTQ6(EHj1oE;Nc2CYIC=!gl29NHN+KgnN?{T~ zBA_Rcp`9q~kzyw(5u1%3juL@7m>V#ZDGFX&n8#>h(Iy0nDRAO2aA7JUso-dlB~0_W zB-W(LvIu}Hin&D}h)ZiCs3Wwx?N-T^7 zy%fyIMhDX}lr54JbW{m}FcsA00a-d#e01g!5dW@B5mA9M1c63_1cG{r5Jyo`n>w&< z(-Y{N1h?%v{k0KuiN}$Cq~OsdLXvWYHN$Lz2SL+0HAImGhZh=7-5j36ES^m{PdPm}nL{XTqIGVI zyO8k%r>6;r>3LaF0RAq8AO^gX7n6=MF~cQ5S)TzVE2g~f0a0N zm@2?R&|!iukr0n-6s&qmNaRS09U|JINj8K?kTCvGq`hE4rPmuL(PE9tqnHYVnk-WX zHYSoxF(SkPh2-Q%)d%(TxCAnwgA8FP2#i+clVw3Q;sJm$s6;F9MLj(Ptk%UM1r1?M z$fH)Q!@%BK!q+X6NLD&X+u9%Tpe7E6x3FuZP+Dx!?`}N29^oWrv;> z_4MF_L&p&|sp^$o6|lAL;b8EWI&fQBBhaReprWEhkur%=9e*A9L_!sQMn*R^ZTSwD z2Y(OH2j`rCFg=Z=qeLAE$ChzJaS_Hm5J>Szpvd}RLdNCA__4e|VIp+0OO%eHkQW&(_!=LR z&&ZPcP|qtMp^zs?^#aasBME-;pihDRnj|lI+hm4F;_T(EerpvaTPdP-C%}%_e2CM3 z_w=a}^u`lv+q>UPPKMhYz_gufavMMYH`qH}AAP+EfR4MLgTy&NRWejAjDu>bGl5YpNzyB8 z;PXORSLJ%_2*^?B%>`WEiH;H z?A+qgfJ{JIS{&I}poCe(!PXepmRV!It;i9u4D5^~IjJp|QCLzEm;r@>mX@u+x>_-U z%Af_UwIu<{mYb9UmanDd2-KF_<4*~c6qSmy#^R!t@_~trvXT)OeASC@eug5Ww8&(tZTv z1T*s=?-9_u@p_cR{QkySUn!oB8!hMD#|Txd%f2dJ?+@33Dam5~C9q@I_#EaH6Xi8> z=X%{P&%M>{M?4&6pQflkr^X{OhTylbt2r(itQ?~^l={9G&ZAS|@-r{=wq74x#H32D zn}I9NHlL;3bx538{#{qpm*j3B!R%EXl(38O3qVz zK-W=LWaz{D!Ly;@o*Yyh;J%4c(W9d&6&tEyePz0gplxc0OfA%A3C>lzjAIhWO6UyQ zj2eKXg9k9C67``(<`j&I+@#_`VKDmu%l~%JfUKiOmYN=1!GxGBTP(^1z+y{@0+AS0 zurAeP5KC%N?NR}%Dt)Q|7>3!15phN0M*wKe$pC(tA}BE}O>IO>qBsR-I8(}{Ol^d+ zVlZwr1Q?)O42f=EM(N)ytqi1Bj@k&PEh`5gz-j{|&KQeqKpEty(QuZuR&EOmBhG_f z@UV0&@2p5g5)(QBCJsURh}ofvU^TL-U@NI~XbvQ4MNo>WW2BX&;{>cik%vCF@xV=a zHca@gx%Szo1!}nlNLb>F5c(wPflgsEGc?5=)0UFH zU4jOXvad^l!--QNsgBD8!LgLcoeP^p%05g0Aeal64PXElSc>Ot2=mHVICnH{ou5O-xA2iOlelvYVsO(D%0H{IWeQppi0~4}o#tM5Jv&TFT4N{ntaQ^B-#7F8&s0|%dU@*~+Np4Q zsJ#AVB|_>@vs2MXN8|N6qC_se(tUl}fH&~`>hJLV3?(wZ>G@s?Qz>Twa(&~waZi%L zks(93<}~L=>~ly4b!kwB5NDv$`vhPj!aO)b3QyOx059{|eSn?_00yF4&DlC|lt{l5 zlLmiM1DyI5GN4ZezvywyA~PA(MY(6@k1-0x}>ZXSl0y38z&{7o z<}(AFtSW=(@NA?9*x@|@=vBzBTY_!J8xslrn7HSZ&z}3I_{_(%!6|O>0d)#yB_6b} zEQ!Y&5aL)lxil5nG9T+hj6Yw;wlG&61OXNYR1=6rF*sjLcEJQQ06izvF)!R>a@fWH z-mW%Mzs0}s!@rBsBxM24@e7TA*MDF2-y-Xcllv_{H=Da0q4No3e(}ILB^sy0t4rYJ z5Z?4#Or^Jf{nq~?)@xieFJS%Uw;liW|3;>N!dAxt7g1$rEo=I&Xi&soW!ScRX+0LrUr7D8j8(2|PTUWS`5$CK^$XOR}Beqic+E6cm z)`fH(W(Z?3WMG0=%bq(i=skAN5rP&;;kX_NWXUE2Z+ZZfM^-3@q=}z9ka=10s1K#yPLM;;_gN!}>_Eh` zrBu}X#%q*`RU|x9;drUY*wE*}8j2Q@feLblZV*ATbI^rgBcbn*F6Z7JA6=ZEpC6&_ zoewq>(Ny4Jx~>zyQwCQIO{0oq7z1dbmI2}d86T=*fW__d{nZ?HF%wd~SP}RUE&Zy6 ze)(O{IBD&QzuerOT)#G+UjJU5bIQtbDH-%sJ`ydgnOoxyA05qC<$QPjfv8Plbu~MA zuXA79X?uXr#HuAzal*Luqz+@_Af3aQz57t$6JW7U~s;UvP{ zbbTb~HI=ruGU-+4ky?V6c;zC3(v@ACk@5I(+=v`t{yt#Vq0*l90EC^{_8!iy{vOf` zBY*PXWIx@3gq@kAX~+B5H|;uzcoT6*c^cv@L-yib*{H&9qk3b@jE>{QqNW~7IgDtC zFzO%?yK>(3Bv%k$sDD_vHf`zc*@u_CR`GPmu1QNWU*;%4Wn(#TW zVY$>6YeG{b8KQR)vkAdBL&^b`34;cvSR9ErqCqWZK>U3i6$X!|gBX-(qCbI#n4_du z%|$h6hbpP;X(^~AQ7_2fpCRz2$FgEA4%alg>jkUtC^>XZbo1q((uJp=8c*1p{D#v& zEWIdEKGv=YPL!TO$8odCn|uo6brAdXwv94(nf?UY`Kv|~|N6xDj{QcJ(@_D#_AJ}e zYim_knk}E`YEs_y*T*AjZi4KY6V-2;QZI+FD$!fl{>oYh+o5B6zA45z`J2=TC*81y z$1RGTdXwhEO;2;bZl%5xS=$V~deV25(#r%T~~*% z?iTzfxQjfziaql-%gWnzIHW^zW2bvfZ-lJ}?F?tR+SO~GlwPdo@9TIKrwa5OFIsF-?TF>fR)2|xFsNN8Rn<8P1?Y!0;o`2hAk@lHH^ZqG=+5lrM{C9}wOM-I&cH5yc4%$WP(qpq%QZ>7M=Y8X=L@UK1y6DRjI`;|XtMqZt~ z=CrDHBkk4<1#a8RO0=N0&0&{o=f1uk|H8AQQF|$`>-Ir<-Ug4KX*+7(YmO22j%#st zQP}n#3|8}CW2gP(B>HRJIw~&L*06aMA@0@q{&32*^i)_34AICM}JnX-H z7+nXx0di4E6_z|+P5 z0>xE;sV%S6JN9z&I(M80MP4hg^^%*rcsh7Q*vXFc-vz17-(8>|Wfx@HzZ&+Pn!IkW zw#Al|`%_YFHocA?#)g%&Y)0L^JDI-Jm@(e&tYBiky4gmI+czVL!n|>Ot(cC6XZr-H zm;sH9Vk~zG)&^3+#7T<_LZy@<)qTL}q@7~A`7>2-d_yL;XYojW1K366nzf?g_ePQw zh+mIi0`P>2U}Jw%Pj9Yo_WpG>k}UFi$_2rw%agMQ4y;J-0V>MJyAbZry1P0fn|vVv z$XoF8`uR26;a_ExH&@r)#Eo~_C=&%j1u%lZ1hO)K#6i8&g9@BY%_kQkmm@jUA9CJ9 z;spvBBnd&pkQpGTKm_{v(}Vno{VOwgjCCs+)aRaQd0GzcqvLn$z{DwOy;c3@0#0m6 z&F($A!%ymQbh`CP4L6J+>xp0I?0;)s-}HLkerQ@@sKqawE4dk8pMMy8a`)m2Ptvv? z)Izeh-tOctX~g51y*Sh88uTbVCNF?(WM|}Thf>pu>)7XLI*WIeSOyGcMLdPpPrbNf zp}A36Dc_Bm(k+W?#)cQZ-%6>tkm9zI`Vk{qmNT=Y{ELx%cPqeijkOGlyD|)6d{C zc5NoT%^$g`S@bY6REK;0>7%=l)i!t0ym_9ts#n5Zu8vdM1)h(vFLv|dO?adbO=CBP0l1n z85h|OAku8pNFt^d9E2e=sN>?Fe<%5nAKmDWGRP+JRpvs*{ERs*bL)!n+%1e;2iDuJwj zF5~~Y;L}xd_Ee~v*h|bnN`AdAy~Px$`YZci+y1=&L=eUhdE9 zNW+?f-aQ=lIG@i!+_==j%71`)tv&pj>r=HF&B;W{RXDktH@J)DNGkSr)T8`yiLgs< zoidPL*a|&ID&G+2&1Iq*&t7QGAulk3n`1&RG9kSGBzNMHcIQN~wRHOoI}rbb*XhyLYt-I4i& zPe)8jo(QoV*EwEliH%bk}?;TNV1!Gh7Qffgf)vg?m^TCQ{4o!5fuHmYE zY`yf+>4M4H0{c>gKjaNMr)$`og#3*Xv#veeaJh_W2KSI(~Pn@Q-V z(dJ@E_tuywNna)+$M5r2nL4~!X4kuoe8v`zIpdi8=aS~A{f&6LOa<>xO0$d9 zlj87WG70k)_{kiz1*275caH1gmv_{C*y()0 z^O|fg>kNla(bC^myFsyf7FQU7e(jqHvvPBMML$+0Um=-3F7nOxX*!#}qwTGpLvTH` zRZ=-wntVN7V+=9r4~H_kXj<)yg|nj~_ov1`%AdI&#qw$^V|v+Dx~`&R7l(G1e`h_& z`Eb4NgZ?%r1wYN8^Kt)W#BFzg{bU{+^}imDe^rBn-Wid)q?3A#|BLX()Ya&xFrnI( z?bN3TI`@x}`Bf|4nvd_grjyP1>0MLjyulZ?k?_e3WaETYCY$A0^Krq`>}o~%n2lbK zoyx1@8n9F+*g4>FvdP|6>VE;(zRh?t9e}#yN#|_OhjHc&3L|^#ck`5Cy!FgqDP0A> z{9ZTq4em3S$^O`P0yQ&}*C>^a?Gs5w20eOPw)$3^E&HuVS?o{bhnyFJ4M^P9O)W@P z?1Lw?uZUgryY2W}U-VkE*%Rw-7b4qAKjnJkV?Xx|9)9xF5~1t;k>=M@I$G^KH78n^ zil|eIUL$?a>@rl24JN0{&K=s&2j`TZcH_yJR(da(%h&CBCAoxLmsX74Uw6r1GadUuL;(*O_Q0b%$7nMM+^jjQE$6gHbrUUp*V=jfNYt=E{8fe)yL%e78BfnZ z?M36u@sCsOO>RmxTCByD?iXyfHBL1Pk_A#>?3SH&$PL#SO20*~q$7a+-Grxm7hJv? z^*}pDwe8n~;a{?=7Eh6{*Z7z){tl|z1#ecI#N&VXSa%PEA3`r{DlvNrK#^k`sy8(` zGOB8Bxc=55(xBfCZ#B!bnw8pX#by`Vl9oAcv@y-6ezJ?-+G1`T>lw{MEG3IUy!Jd> zJ?^*B^Q1h*busgefg>N)*^4D_X>wclzKUKCA-|6okuMRJbY$++RfONq$nMqGOly}p z4D41j_5195bA7iFy`5d|$QceTT(^Esxl^_2i%R%>75EMn$G!U}cA50V7IWn*+8Jp6 z-}hs~dmQst_?pkq?&o53nQ2pLGn@M7y!>OAit>-grxd%c<}v5)9dpb({=B1Sj6aXA z2^BcLdS{=$B-zfV@NEW0kEz#Q^hIOv+($R_{dT+2JI7RkrRawwX7v$=-BF^H6B&5j z$sg~Rxn}*Z8;Kj`eEn1V0(~ zk-e9x&QOWtxaUGv`9Iy8zNdjptBr5Bi{oQi6x#AijFhj11WFbP=DMw|*+)!rby3`T zi$-dW2;mYvS{AtZ2Ny%n%*=xEI(xKT>aI(UMXSG~Ca%61rd3MLA!nuSpszrD4FU z%?p=5I3uUDX|kjyh^ ztuM3uKyNQ(f3ew)e=d??TRxD(Xsv0>C<^=o%|wwlr`yX(na>FZ;Bt6j)jvKBQ3aHC}cyirNN*Vv8=1;?)+~KGlAa!A}k>O>iTh4o0s|q(3DepY#<{qtK z-0l!eY-}E2@I23sxUI;XeR2O@-w+&*g;Y0fejf}YXCHTq$a=KnvU9n{qP6T*d$h~E zjab~`OY+#>=ZthtOXoT>qZor$Ev!9R0P#-gD+4<548?hQfu6l{KuG5XbfMSg2RSiNPj_J zb(7z4u;8H$3rs$^D~OoK^RExP`do?r_H)1|VEjVSKJE>;aOU}EXKJi-L=XLP@ zhPO<^J&3(hO0Q%cUL!d3n+IF=dkgJ1T=y;J%&Xw6<8D1Unz>i((H zV?hb2$yoBf24EK4UE(wLPtc5?g<2i1vY#Zizu8_d`N=J>f&6;Qr4ycgFVp`TcXz+W zcxigmp3kfaoii6rGPU?ZE-~t*mV%eu`@dOCEdnLUOvJabj1$UWqlQIVxZu#S6CH=g zw~u?5?E3YLd{)xtZYg(nIqSVlTP^%diZk0=Gazf#b>6|0UL==YDK2fQ;%Y0GvZ0>r zWHH>@DRz*vVf09=&2g1Wf1m3Dk7%j}lEHreW24d<%5t`!-ySli%inoCOc|Y}@yN61 zVZ-a9J-*qV{U%Kvh?~;MRZ;81Y3{qRH*GaIxVF}ES#vwvy<(a3ikt6Ex?rcBF7At{ zdgV#&sF!8wk)IrPTg%U8Oq`I>=6T-Q5$!M0`~EHTGgh7J+UazAPWDbt8+rT2*MIUj z_1!ToIDxM95})fDDldNe%DNJsljCV3hFSLN<8ykN@J!yud$ETT$3my0vL1)aIa|`O zoWJ}JXZIAG3llYnI=1cX*tTukwr$(CZ6`anZQDCG-Z=C9m*><}P0jRe-*k2LMfY00 zo)ttG&~>Nyz5YZXUTVqLv%|PVnjkLeL8udy#-QnQ+xwSmvv6h9l{diQdxTD}!SC&d zy)|EDEGxaEx4i%J`mojB-T`3|^X3hsx`O*uK1KXaz##vbpB!m*t9PsB)T*QIPa~iy z<@U^bbs6St-d)G?tVy}SrFyDw&D0MIFG=~*d^oyi)3Tq|{^?1QOqR&2-SwW2-|I(s zn>cD7d)0e?+=dqQ;|G&Io^R(3!IuG%csGy18KnzaH*aTWmpOMSj5jHT#^9WOV&cFn zx+jW|US|k~nP8NeUbSxN>6vvux&O!$ng1A2kn5I-9RpiN`SjmYpKO;a4NN|?0`)LV z*&#^yayKV3gwIBySL8=|kbz^ozdCV{xAes{6!oBDH4ep*PAYpUhiy&gB6cQ6->+VG zrrW-WdX{Ry-N(NDBKgk$f=|rv#gk91OHWlD@Q7s(DD`yr{Xy9Uog4g2c&&ZlA;e{V zd?4(Wfk{r;y}i&s@gi(K?~Z#Rbw1w6jD9AGVmlPUWIw;-K=kV(`egz%=2b22Ais~( ztVG;xmiYK==$ExuP)nEVT6Vs(Qa;Yh>iP_HM@J#gxV)RFrp&A1u=Q=1x>+{MeDz$i zrk81%^=(I0!IIZMo`KaLx_5t8lv@ToK18FhQ?SQLXSbg8{)eh39X+oe=h_(CuKpDu z;ASi1iSt`H&b*(hLnMiKe$VFpF#8v@X;5wOg5B(S$aTEbbcia)|H)>H1GqF)-&iV+ zGf+6At7+)mrgDnypuKk62+gb_uX&K1XB zZV7Pf#0BWdHUIa)Oqas`^KCXBHJ?y-=s(}wMd4~)cezLghoF{6nftY*(fta>T>79c zJ$6t|c29ZPLc5A0edXMgVIjayhdZ=I9%X9RLcbnul22jgq-wUu@`;|6bk=HWl4h3Y zSVp)614Y5X5kImHB`*$mx?*3CcQ^W_tgLkLBjKOyzSMBPpEo1lfZO1~0-w6gJz33g ze!`r>>%PhEv%bOn_W5*^&bt0>Z)0eZQq%WTJ(11~0*zLxx_!35AjN6R)OW`xWd6;H zWE@$wrbr~Uxc8M_?8nKIB~9UX54vjndqSu-zmQ_n>g`=_OHGb|6l+}Wx;~wzS{e3f+tchCzj+J@{EbTi*=YUN z+%t1w#2wyRp|$fg3!w2;EzP_^;2$Fg-b-Jo+Yz`vR*iZxllS>E>vYcx?C_bu^liY; zTu+Cb?Rfahx;l3)ZgJ1g)J)&_G91=CGbGbae`w`0DUjChHoiDQU z-+#lrwCcm_cj?+_$M5W?jbAm*s$emh2E|G7x}_? zycY~HozR;^o#y!zKEt#A7^Zv}yT8m(IvjaiMZN2h)&Ki5T?d~9K%A+jwd>izdLZ4g z=Nfn4e0;2p9zR}+QQ_!}?MUVnFxxlO*ij!|UK+_PiE4oe;syfashs z_ocL?`uFN|@+_0Xw9YW*Hu3^*@@&r#>(Ajbe7lg{vw3!>Pry=i^H`018!^w_5n#O! z#IqCoGg<*5plkc>OjF)5E0x=I&@(B-!_8ED$7kRl>M>_ri<=~B=i*2~Y;0X@O)MVv zo54>Qc7;)|-J!YdUaUIAmNqYuqZbf1TaSq>BT8fI9u#nwe_=3@ft(g2dEEItr6qdm zTI?*n{fBGWFk8~qMlHgmt3IH$-8?c(d7~xQH>gzfzXHLz^i$LyI}pdA+0c15^*3in z>W^jz0`95|!Pqb4BA~p1r$s8f{LRiW{F^>42XVSQKaReUf%hRbt@L-^v@C5vsLC1G z9Ib#sG532QeZX6L?{0o`g2(Qq(7}iw^xE6e1`sxF|TJA;M)RwJlHQLLbK;Il_7@~SO5Dq zl#Rgpcbs!pPez?t^^DCtV9GsT$z*?)zg?kYL6xiGkJal;#PI%2!87~H;cG^{1)zfi zU9-;T?_T-CbzS@A)!D{eHh$S{&7-*0wb?R6-_Q3y5&4P~OnU@?IidNlljlvBL{9zg z0`@XXX#!?IVccM2+?}nqJ&*h0znQ%ikNw0C{ljlt+@JN5GCPrKFZ?}dmp0eJHsFq9lx%TWNn~ZJIaB#f-!Ws ze)SriB>P5KiO!|(odt0s9ahV z^nhmhxrn=JmkV;MSLNrbX4XEw8sSR``L)i>Io zwx`h6$9ZzM&2k(f?(`4fFH210YEZcPGl=Xab*z>~zN=f#J+l=#the5Hv|`rnorS|8 z={3)4r4&DPUw`UAu!^=HtEJ-0r^NWK<||k5(%Zn+Ug>QE*+bsug2qCM3(aTtm(6v<>~&m8Gd3D5TEC4C}f9T0jV@<)&E<#$f%D#4!Y#u z^LwBvm`oMF=->NWIpmu~UDsC_wOCZcHPqA^hMvAKdQvR$Y_{BpKri@#ko{!$!l`m> zVd611Hg13JXMNI0fzi-Sk#^@4P@q}d0&OwoRe!l{S~4G0zvsVudV2luHcfQE4!CBZ z$%8G8CtcP4d%Rx`7YhsJ#uHH^{KA@t{p9_+BToYwGR57 z3iKovuujf3OLXgv=w17XAsEFE(z8Mv9Tx`YWV z+?>9q{q@1}zS$@-o7Y&_*vC6Bc@zF+2Ahq~neV?@gCaR|;=XjAtbn&MbcgVb7O&a$ zk}Q?BcqQimZQH+xo4G3d3cA4_^Z_0$Ci5uQKpI}!4^<4^07BT?bpsFnu}G!_YdLem zVdTzVhLla2A$qD~&y;0_RzIoUHxN{gfH~50=A`(ux?BrIz`3`GQ>E(`Vi9 zkl%KLR~s4jNzoKXV&2@h`rmqn&u?*dSz{YT6d8Baa?muDs3|Fdlcu!L24RBf&$_ma zNJr`@_~Z>0immTq4-1bPJjo|LMGYJB`hceE6Q8|3 zme^04en07%JK2?AC(5UdK%Tn-R?IuDX5*sOkc4hrmt)j4Ja2Vyn}9uJj>D5~)*Gh~ z`HxS?neMD&0N<%e03Tp89U8g0TyVDJ3INZ;dmU%trOZ*n;UeuVdjY=YV|Cu^K~;sO zr_)IWI80g&ARq)8K^AQ+>zvOL-&)E_`PjPI`$+R|a76Bpm|fqy((AMHV_kI9@V?x^ zjry6_FUU{f@)`mFUkuyhUluWse)IvR=lCFCFjKQnIc6GkuAi(l-)DeRVlqw(`Z<0} z9xxkfmiO`Xr}DY1C-cJ~uFivo+a0PhEpA75jbA8_Pa`}&!(l$Pt>BzqId;ZyolcQ>Nq|3lTxs9nyRbXXT)auMF0T)x5VmCbwdOaL>&aF85 zHDc%tCSKzj!ef@($`k8`KVIOD|JPPh+k0ZD`N2KBg~8<| zmqVdpagJX#k;d)biIo|r>zv<*G=`yv!zR7-XvAb6RE9>U&jqyZqd?K`ufV%P3(2j` zku|fu2a~|k)%F{4BMJHY!_~UAfdch9mTA6eJ;#<4c?vGF4!4eP&2)8`98>%iM;m+0%PHC>poVry*-klS7xrWAkX}1=I%~j;_1S@9R88 zsbGwtew)ZQ+qX8Jr*Zlg7Dwkh6*AJ^9RE-wW4jp;mYz-9-|hL`ij$GMot{}J`_|-E z!W>FcT+v9EmRH?{II6)&k0OQc-XE#-aqFtE_Ud4NJ?P<35#dQ*54RJsF=EqM#LKfn z-X2ecQ2bSyCqkdevL9Op4r#%kNlkmCcg#!w4}Xw3pbT6{1>%_(wylH!UXDH+W!ym- z`9G$j8Lutm_{Ur*uV6a#fispym*9@P0r5SB0)f?jZn7b@FN&5iDIN@V0Q~b4?P2oN z33Jw6NUPR5Gj+Q5l6|k*wvYRW@eu5i`ce)%@0&;BhuO6`S1v{e7^@b|wgB{(bla%l9=4$%MR+t^k3z zGIm!b!`4R<^t3M2>enyCF zvFBFrIsb#PJ7!*>y%rfxSy>O)>#jUjBdkAy=8jFgco z6wy<0?~3>}dL^!$%34k4=YS)_!QNMWq2IA#{TB7AIaRKF9q$vNiLWsUfg7$9JME*) zZwZ1ea}*8UVdl_oS%|Zak87;6zs9qfL98CH_wcs_w4KHakkdo$N1UZ2nf2G>=@4 zK6e{W{rrX3t+54dtJk?JIZ|h`ClN3{khVI{_r3$>AJSwLvxy`D8Ua!?s9XBi8>&+^%s$Ph?5Ig~*J8CPAk@KeExotvk7P~(NM}ohvf_i04 z=jUNU5 z)ZqdGz8k+aI{f!3so0K(0!zA7f|>2iLA2a!EXW!2BF^4n9Pz7?pPLRa$m^B(<0Iv} z(3ivcjVz>5Q_2<-!X@f|4OCB@f7jbnLVmpmIWi*15iH^vC1Tx(LM`eS2Y`-9!?X^@1_wlDjcHTTrxFXSs{@6zoAY)O z8@lDQCULj6ksC}`5^0G zWq;IDyfQ??LK`OP^)WYRI_C5yml5BBs< z66#C~tAsN5?v{=Do(wLXq%%3_28U|1qB)p2G+mL5axMQ2HXcDUYC#LiB+NOf5)^J& zH3lq4epHNxWVLE)>LWoql)F76^v?iw6$0#h> z5xo5{1|-m3*+>Fr*Tt6O45t>dOp*Dz8ESLf3@UD_WevYvs}=}3Sae%~R>4!bCA2E1 z*m{}~fq#D!h!}L&D-FM+0B)|eYBO)!hVqXQMObid-vEM#blYfY0SGyuz-ThF1Suckx? z6-L@FRkLxpS8?xb={b5*l=|{u#YGysBuZ2UCaV7MpH@nGl$(n`X2`Fw?N63@geti4mK1jTP;Y0T{Om{8P$WdR* zP)_Z_@v0UP+7w-s8La{GKM$}*5tM_rZ8cm<)0m4puZwFiqCSRo8atDAYFte%^RWI- zH#RqP@V!~TbSXiTMjpz2*}SWiM+mDLVqtjl+Msf(`g++_do5498@0ZQh_XpJJAwTK zFQm_asj=xfZ1(CbU8W70-+Pebw2FVXVzmk{59sqSwKXtyjg}@Pr3yL;Z4gD;3Fb*4 z5xML_bm+e4+u!RA`9(7J{gC}nTNFpF?cRKipD$Z|TAevpy`PH_un@qMgDrX+*F)x* z|50miuZLR;oR#lhf0;D4dHs$)2`zO$nP-hn2TcBJ+VRGzq#jxZvCXS{S!y?v8b^Fa ztGC|QL`N#$n+I0!fGX0*wQBjhion{5X%tXcbp<-CrI-P^lRU~i?I-Gk16#2or2|-_ z?9BpUZVKLZ3pk|jr%roi^LZfik{LT5Med9ymkM&5n#TJ3aj$R5P{VKHW>G`D;A;c0 z-PoDec_z63^@M{Tgk(&GnQ~i?DnHF9y0M?9Gte_ZFsDsQtrZV$#@>HFR8>BEI^S_fTjO@RIR0IWDh9Pgmirpq}(T>es>#e zMh3XK99}_D3xCzkwmIiyJzF@;u;|WPSMCP-2Y9wpPl{$bCSD$aQwipT*Cg!^|E;2> zOwnX5=pRaA{0}>4B$;_}D1hH5=;OIj@k1{3iB6X&_M(|;S@?A5hqT#KM@OvuU6n8{ z2!Xa&(PsElg~hqN;_|-Cyb^8Q7%@{`9VFvZ0j4Y z;%faq=_NTUQQxF#?u{5C!(CM`*X>s;lM+w&2K?O-C~)OBe9^byAgzsXBQdwFPyi#FXXSjDBU~q;>m_bii9JeXccd*V z98|A-M7Uk&Gr5)@=qGVdCbi7RDB*r?%QSWrYvZ@^phi-NSYeJqXKr{~Ce$?6c9lw%4T@T^D#tixx6Gl8F75Y`vG+e+o*ERMd!@aTC`PYuCjklV;lQ-SL z<6yRwA6S3A+wFjkb2fTbw)V=#_IjAF@QVpo51$0f8?+Pq zw4>MB)a^ZWx?Kpw0Rq-8@(bRl&D>HrV^CK!^1HoJhd!stH}_rmXz{Z8_0Y>K%7oMKEF5q%`s*VlP_ z5YbV9PycWKzTcf+en47_%Tz9xi}~wJ)@E4Zq6-i*kYKQYfImZ*7cS4^1$>l$4RSq_i@e zDA&+;V5C?ip#jXhNc~>?z(R&NNl-%wWGN!MAtb2tdkO*x^m}F@OAerK4@HX7gwQc$ zp)WL9w9oy3yY9mb6Pv#b3Zw%fa` zl=X*3ElQ zCo_|mFSwwXtbX@pV__Nu+{iAcl~U`R!FF$L#0B?UQfWFHHSLr7_FH`|U6Bx2Q+X|B zdeC6SS+uSx*segM!Wo9;P(ZDBbEIe@kjb3VSVLrJDMZR}dNL^JQCKPAOhyKll;DOc zK)`}Y70|0nRG|-BP0cX0IfGm27=p0>RfQim zQa-MTbv1@liRM$I;U-iSQzneV6%KshX!^0m2B|pWQVBn;G+{V`Bn9gX1P!h5Opyyn z8RfmzQ=u%3_=Fyy?n6>a0GnB&FWu2B5&DwFsjZ>BM@Mr>!rXD_r;cQ9^}j_&z9=ZH z2vjd-j@^Qx?S~9Xg1T`o&37*cXU{+Rz*R zzYZ$nz7!GNU<^~nvLvyaS0c=74kSwbr(yi612hv*ewBZoi<&YK<@}$BpwXa)!-(ev zOJ(F|BAA5x(g)~}l^vJm0GaVN3-DoISa>nt_24@IdH5tiCM@Ua1^jySX;uk;Q? zs}96Tv>k|ewFcDDlNm92)$0Ijp?zJ|IE;@Zhyp~c=_af?$pcLhDl2FfT+bHul!MJ7 z9wq3^BCL9$5hvJUoKi-{=+H>v!pupdxiQywVZD1LwNMtEdT&)4D|%b991F;4F;VIy zlLR$Zlr~apiO6TRe}Tx*qA@>%%fiq=)Idv_aii9n9(Y7~ig5T6%EEm$1A;<{2b@CL zllb7sc|%TPP79x3z=r>Eb+lrB1mO2Ca!D3p3E)n=<>`iWvuf8Y8NnRjQsv*I`LOJy znf@Snq*r@F|2mBAlw(9oVT=~L|M62q#$%Mx zXEaA<5anblD=G*UyW(Gzjvj#??QqX`9%|}4mOO$R{+EIlgc`nSXC-}3Z9pnmOeB>DLKF!G=-B84IH)}@?CJ8h!ni$>HvEn#R`P)W#NP_ z?i-AZ7F|UmEjthlo*#1;M4yLlL_>bU51eKQQ~(Klf)fON=nRSUY%XRNdy6${!k=$v zlHCA>;RJFQ_JoT#BPtEf`GY!_O}_x08ps>G=!S$N3_dAIZrcMxCCoa=Ex8WngDm^Q z?hNA$OoTe6gSrBRhGmg2R4Gy$=9cHgi5H>8SvzKgihy{0Pk;an9fHI8cif1VDs%+c zmsSWUu2hN?h7+uayaTcb@1Dd%m?y?jQ)KYK9#37$(2)h9hLouTT^Ob^X$zWehdAuz zoD+eripMD7t5OUKe5Ty^BSB?dnd$%m!LO7l>xGjSj0njKH3W(>1a%Y~Kou?}Y|BZ2 zjto=*i?`}|F6KqhFf`fQw3Yz4@)!$sd}5&hYplpH6Kr9S2{>LUh#QNlvfH)1*}|{Af5`;1Vng&(`?@A0lLy?I*zsN*54@n3F|G}WvkGUM?0;qvv5vDaHtcLeyk~n8# z5h3~q<)u8(iRcn~73e|u4|M!cn-BwHoP1a^5}eq?DCXU7gY%q8h%gJWOHh|tFfxb+O)Z$OFzNv>C_NI8XZ&Bqv^lY?8pv@N zZnVrCit$102oxokcI+7(ifB&)N;#Ot0J2eZGFHQsr0!!b5@-e~g~%kCF|Wn~k} z7P3a8ROp42Q4b@k)1;CxTw)~_xe4{03WjkZ)|rt4Z%p9mk?T-^UKW&RK#1})2PN+p z?a|!=#gF;CX^$?IdVWGiM$8~aZXf!(7t*>{X5eTd3uim%8UMhvDU3S*Tl-X)A>1Jw zPDF{zQ*^7v7_qo-KXAF4Db zL^Fy&a{Odg>@hug63j0tmXJ0l1WSs3P|P$WM-@JZ=tz9Hnd?AmRfH3KPL08|N|hxj z2oMRpCS^xt=tvmqQ#ywdP9pq)Usc2TO>V@g7~--FbFSQvS{n$OCi-{i6BnwuidA#0 zwt4)x3ODun&(<;W8fFGy^fbij-B6cYS#``b_(6*>%0^Oz(HkMuN)&@JtxuYAnC>C? z(bpK|HVY0a1KC9||5+P~LL^I)5pf7lkzp5%&BTuEkX`hsP9XwEI||1$#+4D8mH5LD zsR+3VnD;=sZIFt+5bJH=k=`-U6m$s~G~LROlGY|D3JE886iNHY5mOVkh_yp>WD3#9 z3+WA{2(dA=HP{g=NM&r`(NMP^5#iWLGkTaCk3IM$RBr^-^Bu`v4N@Nh3L*+hyy*CJ zkn?$v>cO)UEh5EH8egA3a9D)143uGid^#|&U2`!W_2NhJ+Jw1F8T+g&H zCFI>>F{p%|BUVERLlADVY;z&s@_! zIaBJ4S?OS{HaXImjJcKvnuC@WPpe$od^t^OiWs|;)Fj{@&oHehBWzlK=7^k424HdL zrQ}BILtA}&2tvbAD0U78x};f9U#uZXorP4o1}lhV zb;lrlbAD`L=By<>v@UH;cXVqtqDaf4q_d50F*wJVr3<+j_>a?^eeDl+(71bD# zL~QVTsedp$C2eXkz!Z#5VpKQH8%bB%_Z3`E7aN>-*`7J-p={V5x=9t_l zW*JrYJ%#{XiXBVx>?k?yzj8?o%@+p^9^nDn5IQSkcQXUD*Hwc)qf>7sD}>ldR$p+hccupH3`sfZvxJTDh!iwjbYvOR zIGOlkVMc$P0ujWWwWO|P*8=T>=;u$H1AKJ-mNlug@CXFp5z-iVh&af?(*D>tBtq~d z%u??)fQERXeZ+5LvW0@}+&a2L)BrI&e5^)MACU|y$Vg609>>H<7+79Xe1A(q?(m`< zA2mWUhp3&W3?4mP`%`dzp~(6B3wl!+8#A z=ZdOB%>OWyVFyf_fe`S}Kx=~$26HZkjF?$CKW;b$G$Q+?{!V;m(Zi``n)5>Z{Nr7_ zD;?C~88{7pD0g`@J0?vRfYYWtug7oe! zpo=gebYmX$IlnHUGy0R=zi7%;8bl!eLI5TQ@SLoFj}K>$ntDZPN)sVLyox%pv4=bS zvo^nkktXS$gBD@N7&4W>25W&Gn~%SoowYQ3KpT%cvlf6g;roL{+52D)qCvg%p?T#Y z;Cwa7AG?QB0&_IwgFNVzQq2tQ#GmQvzpcYg{CfmUf<)+bjRHAzBU?nR{cTdChVYKt z%~OONt_g?chMpT!{1w2(YD5h&bWgZ8zpKa!U^5yF)rlxHY>`oqI$C!8<@`p5DrIzY z5n;0nPSQpvsb@}39)<7mMlLpKlxY; zYh-nIp$K%3-!?prGbJIaQMolDMbJz>oH`j(F0a<02x!E7-|y(4pRfpk9%+G|Xa>SM zkr97DsipqF@3jEK-U|^AIFr)@HPdST6G4D91uo2lb3W9IHO_=OWrD#q9SEr9mnRLq zNQ5yHbPJr@>Dd|$@|hi5EthSr2TCSmDA(O>?{aKAA)oJviq5F2cbqORE{&X^s+#z( z6G0lQs2Lf)WX1&pjnxE@F`ykrL2 zUK(p-a9?s$a%V9}Fh>n+YOGpn?O`4W5}BV^_+OA3^c! zf)lPF#1s<6B$0U7AftG-lv>)5u|NatNvj*L@Y|k3yu3p(LA{XU2pwc|0rA{D4<9w+ zIg?i>9R4YOA1B)#m}x5gNKee<;0)On-ChgFqw5U&*4@2t!6b48j1t*buT_7|j}Cp_ zVbUbX9wV{@jHYIN#Qh%*qJDzXb`|s~M!}|4Tk8x=F>(xBBVzj$#fJ7x6dU;`lPIOj%tWJ;qrt9Y+mtWRG}Xr=RSXeN zDH}x+6~?^jBHT1|@+8C3NRi0wnj8637s>_Wlf&Cc@eSomfMXlzgE$IHL#T4-m-K;K zmzjjYqYzSELoX{-7+(|oX|*UQKK1#NUzB*NM&^?6Ow_16H`D$IoVFoQduh-Nh>tFP%tJ@u;AqhY}YIW z9gr$JGLs=pjosKn`BYPbW;0`=9SM*uf!HM!sqK;z2MUX0!SLDlicRCyoH5jkfuVcW z71hNiSZ|JwikE~iyL9LTiZnu@9gaar=XGhT%jr_VQ3Gf>v zJ(`Uc#BgqmY9QB_K9k+Jcfc)NLTh5+^AO}pkA0X4@awZ2u?;CUfeNF5(tvG%{zL## zg~MA9JG!T?dErUu?B`R9Hd4wkhK*~9jw7V(1wIIemmT+nJzq*l7vMpihsH-(QR z{NmsUZTOgctkg)xlAMPMzFvswckDuem?38x8#Ci1_58#(BNu7;sxUxA%w748XY+TC z##1tYs|LU`0$l$_1gdm=VEZ^b0cBJcC112L6vBA@VFc$!1*dvd(22Bz^|H_Zg35n% z4&-`0)Q69Ujwo2V0Z2(A^$F~SPXKa4`UrB=gaI2Cq#OYydX6x=-jcceq331@6R`QX z%_ru|oHF2#8R^#$Dpbdq5&tr>PXcy{7R*#59sUC8j=k4TN{l%r>M3wWI&6*l3l1B& zK;B^%hL`z(P-ulfAM*O$0tx*_kv1rZzT{UZOP-Hw79_kuf-$nu@rqPQg?xEB(8i^R zNr=EqJ{z`#w^QwJBOOGxvbx>Ikncry#BTO$`gF%_XNaispbI~}73w!&NlTf85MW!l z4qJ$a3kXs~6^9RLZERjp_xa)p-FuZd!X{9t)q|)F8X|;n1e^23ZrQ|G8~hp>KW#D0 z!8Rs%Q`oQuy)pwjRAIq(5WwOY9M&20&4C{WdeVle4f50I#`yTUO9+8KSqQ@11JRR3 zL>zBq8vMwDG(t%ot+(oc9~N!4A|`zPV7ls`#RPx*f*#h949?-Z0^)*qud{)4H{A~z08VVQ> z5(KIoSk5FiQzB6O5yD9NvjWYlMkEy#_y^8PHCnhWl>~)#5(vIrk&X%q8krLrNjVSl zGQ2uU=|qW&801nCK2$mIGG>*8%Er8|w}@$idA_}3@A|FmAlP=7YS9e@9hmwLzA*U6 zi<>Bj@SlZ72l1OYtdQ-iEf^X{*c+uy{$V6$RwBaoNX}rsu|edzGTNxo~(*6o)pqPwPVWr}FW#h+RGQI9Bi3HeXg&Cy48Tnqj24 z=yS=(F8jF!QfZs^pNlE+NA#F4#A&#yXUO-yadV$qSU$GrvnHQ+yCb#`0C0ErjdFSc zKEiJ<3t%k4J1Z=y$K7vzp!++;C3ML>b;a(`?b|zIzcGgV<;AiE{xn(5d(}?>YN+SNZz4)zsM$ za}1NWI8dZcO#YpfR~W8r+Z@uc<=yTx8WBe(6y>C`D}>^XCWbB$V%7o?k{mo&WG%#$ zfIhV^hIo8>g0v2t{f3?OO%30)kxdq=>ZOiK?&nPuwN0P!iCEQJvr~RrDXDLE%}!#T z>H^1SulzJr-GY4`Js>gK;ov<6Ad;iTpID#8K5G4T`R!hJQ*f5-lnb=+>7CpYzh9m< zb(=FJP&cSo`ta{mQC;?0H61d>+2Ch+k(#8It^9R%FPUr$j6iny5>B|zw6AWoz4>kl zSAb<VY>$&adZyOmN7v15i%6oI0X^ zPNZ41&*)xtj$P!tX=a32TY5+?%4zTYl~ZphHd*8E_gLix1g)VhlQ{@zuX}T8OC$a? zJ1o@aF?Fg{9|}=i$8*|wfBFt(d+1X$CEMcrRcNSp!@+g7aQ%H84g z&tE5L;b{Zv^Q!kdZ~2cnPjc!Eb+I3IwIg&^m8Sc^^pa6`To`gt|l++c{XhSiqYH7>wnm+a-yyqr5$T5Yd z%oGsvFh9ScE>B`o;JqZ(1D~WDUFVYY22l}slbRPorcq+l6}za%wZV2aDHcDEo9_Cl z2smZwJ1iVx=_G+2kHQ430M;LZSinRkSz&p?Lt;Y8{FrI5alOctA{rFK^{HO^;4F^duRVLQ~UxnoO`1j|@XjHmQ$JyRK3DuI-Hku+Y-=y4Nk9;OaeH z-9D*Hbz?==H8Bc+=b4 zz`lB*2W*s_jJ&C2U@GKm8-@Cxw+UoaE+6GFtI}Kc*XRP;aMoAn5M$4z>a)|~mf0T( zuw76O>(erllF zvT*TBg2->yweS=wd>E!;ChixyhPd1wUs|5;U{%q%Z@V5TtnAzCO#0rO&I&y$56$R1 zE|A3X{Eh!hZk(xIh9?$Ar}@B!IH$uUbv(?z-8S!7S*$ih%z2GmesoV5cX^mUL_ z4oiTu+^4-$BEBLjpcxbnZKCyu8|3QH)X6e z^S&>2(g-;wQTYOR6B88t8#6A7`up!JcaUzT?l^yX)4UG)>zS(c~UnQH&7#eIE0 zvAhO|(BDY;_KdRybvm7h$7cyH-dpix@cVB2JpFd&^J&K?!R(J_%r$NjF4SAqqAPkT zXL&xZ{XkW)q&W*GSnpDttZSN>)GdBj`cxZ9OI3joFm{#anAx)F>SS~(br`;1F34w( z$MN!k9-LoiuRj|blL0YbTSsU63pu|`&|ufN<*}nI6wl|gIO_plkS1HYF}KkplKb=|<)|HV7 zNqd?fkmFQ*Bj#?h(o^}citeTjJhDhQ$6l`ZPJ`cFYquINaKugZ;;6l&3|272p|Mfb z>~?Ctqu!CSGR$=xa8bOqJTzQNhuN>WyPBia9rO`q&fRe_Sm9$s@o|?PNjMZwh}Sjw zDQ2l*qkqU&-K$#eP9@TyLjU+W{K0@2LCH!+_k~<;t0UTd$fh} z9oNhxW58xhtB^;^GUx4~&%Kbf|1946)_X}>lD9k;ufq~*)cv;hjR&YP6dp=^vM6u8 zQ~aeJud}pqbs&c$0Fc;Ce#wWi!RX`;kv8BtOMs(6WA%6Y9JgCn^AYs7{zkpUaTmQ( z#%>_EQ>MoTV zO+VGlLvlPQbsf1xO((HY2d!%FJ+afr3dz|AK2wbP7|3QM{{E5BezX3d>P>MMSIOwT zkXmf}(Ejqwo@*H|ihHpON2Z|W|IAC{=4gB0A$L$7u292PqtckQf0wYO762^F?2oyM zyf-2rG9yN+8;s3ng_z6v;l|N_@*YkFuTgx!lKb`u`p|Up5wrNl?B|{W8=fbcim5!E zu)z}OmZrkny|H?=9wC`g4L(llk-+qk#JCNSRseyo^xJ&mi~R0J)RAOxTw!=JJu1+3 z@>nXX@x?T%Nwl3_MUdqru|NnV3GgQ&;+M(*#P41fNNWDu6T}YWA1ZH}NQwW&**OI1 zq67`LZQizR+qUiQ+jjTYwr$(CZQHhOn|Izni;0-kL`UB_j>r#Ejx9iYy%k1}zTVc5A|t4SI`>8^aP(UL^gzVdi0;zed@cWkA900wxX^_q3A$#u z>*J@?G$HvCDrE7B^E_|dxKIVm#CoQcP_0UYPVvcvKd9<)Cf#mO6-<0PM>4U-9RMa$ z_-4aTB{mdhs{ zF#wbd-e;{W9;#I>H%AI8lM3(zA0}F^E~5}>`!aX1Z*?jR(*MaXG>rfX6Kk>-Zfi5k zDBX$tW-VXU3Rgo445M~EeMazmh7#uqxFTdpyq0bET3kgxKFM#*tpFG)uHNl03CjXs z%Nm%>?_nLw>eB~p&>ts$1-iW3TWC&GmkaDB*7afHeoDY|Q^HQwEv>feU`kWlbh3hy zcSc#CUqt>4tE0{o=i9}LM>U<+OS9V78oWoz@CSQPM#IO~&cT>DRx8DwUMY(jRm47E z2UoA-DByRfCQF_aKow4^|JVqI`FyL`O%TNb|zPHg1yeXCTX@3lVRH3SL^i% z{X;Y764t`ti?#j$Z0J-f6DN@C`mMCuv;sTJIPEu%hlS!qCtCHpX}+bckcC`%ann3% z2N%!*PR+`2{12(4wi;GuP4r14ay%YcAUYJ{*?19-OEtSHkSwSN zO$rV(nY=3vQv2AVfgYQHf0Jq8P^QFk3(#zns)>g+3f5cdnEhYV^;B*mwT_T zPLK!$+!mU;!FH}wil%v@=awYCy55sp#yd%3TkCvK3poaw3#m}9B(3vN+;}oLGDBJ+ z*>zCX#=NG~*oK)_UBjI1=-rf6C6yC3)1K7UbFm~d|KuCcpb?fQk)>%3L6_=*;`!+_ zID!JHQZnoQwqD7%RqeXDWm1{45k;YsmkPi6xv*<7X!-TimT8`!7;-&S*{pumOE4;yUHVv4~>UW8>u<+Dxl-vpRtvL9n(4Il*QndIHDaZ8>Ea1&zo+&+Rp3 z5nneQ-2^@r7Cru^>(lG7m|BXvA)NPRxWIyMBB!EWkM&EQPyG9ix+a=u9>%b_hM3Uv zTz%A@82twOF&0hJ`S=2o1YPcLuq=>{8tR`9A{F`mobwY`0t?#LiImmdP~Q2zopS59 z71%%e#c2}Seb0&DV${xfbCWIpkKM)2x7+h%edF_PvOqvR_1H-~g@c#xO~zpCbTTuQ zL_#n3xI2BU$M)}Zmtd3&eplCxc3^;U%wPo`##O4TyC_Rh*VqPL()Zt%-{FsP!lkf+ zB?X`KHC2bjY(>6PzO(O{=cc#S6{Wg&@w(TIUeh*eVa43jwP|w<%s2+d+4jCIM!#CA zcTKllpgjQ9SkPp>uZma^Xa!0Qy6j;o+%z|M>*9T6DK9IpPnyZ%!T&`PKPHex2Q3u zp9{To<^7c1{~XAP-~tjjiaoxcGpEMU6KNaPbRW}UkETG8*b_wk<8ZK_ma6ElWiR6D zIx+i}$rie9IAv&0ykx)<)CWjlCYnhyj;W^hYrK6qI=zj zmB|XGFR6}9iMEh`9UEh=5dNNJYh$qjz4=-E%ZD=y207O!WMRrZ=3Oo+mZ5uZ2I^f3 zihe!ELWepXCQcW+V&9)3rt(p=HIcE3;f#VBfSw02206}Yky?a0g+ z^eptPZ`;-7NaQ{J><;;nJ&QHnCk>->9G?kr-)5c+q(o^GI2xS=n9MC}wCLAvs%5Lb zir~dbivGojm`He)k}Yi@%h?+=)}Y*Ixvstz`uQ^!GF6(etV&Krzbt%CPGoZpInS4IfwzepR?e}w2t^3$*20SrOJ?8^*@IqdXaXs(+&-m5iwofO~Y-D!Aj&`rJVS$7B28~OA%Rb&`L+_7Ew zmermX{UO*Ah~s+_raiSycThNevw~&d8W|jCd#9MxWbwb;|J5!=Xu{7JxVk z-*rT9XT!cL3x2y$QD(goK)1-EqK&FQ^)>O_>Z4(nqg+ml;^_ucaK>^@3Nk$t=(m6c z@2!D?wBjS}djjQkywveKp*7oP)|%F!PzJBxc{bT5|2o>yMLm}l4Xxhfb6O{YxXJO7 z7I|$^{gf}VU1-cgVkoiWxphQSvUD@Zr_sq~au;y#QWkZv+g~g#H(=b-N36@Xa4&oN z)SQeGSDaQo6)6l`C+3l#@fn6@QEu@6Wx#T6U2*feZW&@9-hQdDQ!wjwiK)=IdDvSy z$ZjU0nJ6$&(<|(L85vL`xZ6vJ@4;1RXP*CVxbEfF{_VATyJdKzlb|^diDtE?Janb( z03hOe)l^NH-xgnuWJOK2)Os~fNBS`PteebmytFPLp29WmT5w#ByT;v3N7abFrOwPe zWmD*Cs$0F#J0I)%Kpu(EYe}JyxYDKAEiz_%H=1KKbRUXrS2-PgnX4)6I0@$2;g$hf zZ;~rAnjVDH3S!M=v`=l9*>!u^Kfq<|w)vX+O&ylFV~iOtAw7Z#cCk+^MZH~mEuwEs zhrTu%9*2IObOZvuyx5Vz95@imn{QV-S&7dZWO}|;hWhy~dAw!5@tg4u(Ov8baCUa? z`pzZagl@{SlBoX%gB4b-&Gmj6O+TL2wQ-QSwbD`2+;%RaJ#)@`v(4D7Ts}~h#F>$z z4%@coc(YkqPXBtdG_C1ngiTY|P($*-TX%7cxP2N{?31Laf381T^PBk4=EpS_j*PC+ zzG9kje2kV_TDe(?c%9m99_gnw+zXGTST=nkG=J%EkH2g| zXS_3ywYZWop1xnJl85bjwSHnAbsso;IXBy91koUKSJM~Mm-F85d1}Dq>AWuwhPBv{ zMT*=UrptOa;Lx3|{k+X){|XBb(CNftDNv-)2~JfmG3U{#3QFMI?;}@ySe?IKZMbd9YV}%R1ZVfq+=mO%-2-`yk{m&rwL)^x1)pgxgyjt;-zBQ(bUc4BoeMun!%)MYEn@ zmg!U$DBE0K)^gV_j)Re1PLiI&?y>(3lH!A;-uu+q{op>|{u_2ndlZA1CD%2(<4d#F zJ#I5Fh{WY~!I8LBcaCRN>DJ3_{whv2gK&)W{zm}v?!R!ddwoDSeZ#)3v`fwJBWtVfrIe=BfBdbw)+k;W_!GSzS{H zz*`}{>AG@}oxMK6YrTmAzq>L%)d$tM{CN}a)2mmerW7<(s@UZ+@GUl-kXGpP)(b1b zz{XC+K*RDzC|}U|XBuvJ(X|=(wbTYlckZ35lmBs;u~aDhl24$a4X@%vz~=YM{nX)n z(bOz7qrX6}e1F~L=EQ<>)|scz&g{JYyGR-I2_jbNtJH?kGV(N)sX}A4by-FiF^PqR zz3&3z{))Mw)(I{qEh6SR=r)nN9J&X4-ick6WzIvGDsg zlb|A|tlzV|jEQN}9Y1~iMz1y4rH~-2Lkk*!JHiXiEpl|8r;UQ=*Kk|~@YM8s;{Im~ zT^LRHZq30{Ecm^+)oLx4!&CmxSm84s701)e&KxehtY5xM^GF8MhWCzz(PJ#$L?>FU z4$8_dLs@Cn@L6&9>RKj`=bcU}+~qFkzo&9rDG~;hb^MRH8xT7>dXJ9hTo%46>yT-$ z=92sI=vt}NYmQ{R6}PU9IZt`)y8}*VDqWBCmyhx8!42G(xVTmU9fp8=^LMsw1?rr> z-mFIV%K;g_^EI!GJDN7nZVNnzr}sC$3&9;WnG+TkbM+UA%Y&8zI}KL8;xbJ=JJ+0qIyO_fHIhkzDAh=uyqMziUVN9V>k;KR?2zNFFd*=i)ZV<7L4MF6Rp^ zB>RUfBd17GP{QrUZHuP;R)^rZdO3bOp^<$c?e~zT%Yuwa3%yzcwz-7<;9$D}s&+CJ6h zrB|=z00uFJ8JYESBG>B`Ah~hzBmOY0^zdsZ4o_t+zk1T7d^(yU)|y=dle^~Xu6FH# zPB(R3ep>dpxZ|d!|Fb3Q60Mxvp83g=8I)KWM%Fy+JGJKIhnCW1cn5bEKQJ^m#Zcm2 zEbE=-?a#UACj8csZ>NQbk!PXxR5~6w>Fz?3%!p(&O!t%eXdItJ?Sd-wR29?=XrCx03bpLZ;=L{tNOxf%8ys zD}sVW17L7D-v(b>{X<1wC$ux_q&Zrk6&)RwQr5y}kk}?^eWH3B?ssq8V#s&Wg5(z< zPV-=~X}>XBga^wv*pK$!@;I_x-t5*NE zo~eEGmG|mgA|WoNjezk^?X!W!bfv1$y%^oC5(Mc**MU~_N^-iS$rctOP7?IKvkNnp z^`^kf{SdSCzL2|VhmMAjgM*NnbF#9#fu7n>SGSY-yT6|CMiB`_0rkShY|pbLrpwjG zyy-pHYFF&FF_j@A*B4{a`qO)JVAHh&?GW|fo%()$P8S|?HTg!%q`QBOD_(Sv=g>2- zhMtnr)2z<%Ha9m6+&m3GJdMpzX{LA_>@F&B>*v&|z2WLf<>>bs+0~qiC%zTq>Byx0 zhak3L3&?st6qx@D9=0(4AjU~6?+(p&Nyd6yQgdrir^(gzmII6*E|Q$d*YU6M`7Ty@ z1vwVqjy_^wOEv;*V3tmY!Wg6|SDI(*w^_eHStT$QO+s(=kVlBl5PA$KK3CM3tx1udMeL?u|u9r&V7#lwgL%H-zEB38BPOhjMr8=$j(+A>h$rZ0B ztI!CYiCqBB-EK?`k1zo`MQD0X4n^RH{B<6Ps;bkEAZ2+=yb%q8Dt(PSKlb9NpIG>z zSfXDZcFxZ}rJG+C+>6s5R+5)Lw-3s9 z-_oN*-va;-E66Il_m$LX)-`SSkXo~*l1_Q57fE&Qxy2c29k0Ph`Abx2v%?;6*!B_% zf{wNt+OPMZTU*}O;^`q!yv3spb|tvR>d_oU zw{HxqdOHjA-aWJIH?hcr)KcHeU5b`Mape(oGGt}oZa(8W3eou9&OQA)zo&t0JS%>G z^&qs{ehD-%IDPG(>*xAIX#A7dCg1C{^?vie)-XW-T`u8SE@+%v`94gQ)>dx#vfYX| z8MPtwc<+Xl-MKnzNZjkmMZiDSo|cJQPssAUk*$7y;ssf-9u6!QOUI1AsH_n*W@yy_ zF#nyOpS2AnjGUhhDMtv- zI$GG;RZ84d;7KLs)o;p?7z3<$thsnto{{-v~{) z{<8GI#Y7{${xRj&`r`cL(P8n<$-zo3@2F3M5O_-GB@t2f__xh3I@f}$jFx!JQ$L<&W-3Q!h4!ogpfo*7YLULgos|=62z`rgd+y(aFOkLAM%x;O(_yAKGcY7c-OZ z!owBzT|&Zme)Og!CgOGi|Kad%-Sf}!4yGb(aWRI%ly(w-TUvSRT*p!4;v`10OQ`s8 zWY=pfY#Xi%#mAx2%yVhBQpdE8TE)D=FPg{pT%+dSGJ|F85dGPS-jr5oG%8L+QYXFE zg&YN}@MRZ0z+3LMV$~LNg`J`O={XT3Zwpxf&Q_j2!gDxNJ!!oMP(EQ*Q)s+>zGnD$ zia5vG$8ipQyAnvjnQHAO^qbOibseR%jjjKCv5A3zqyCZ9G&AsS=a2;~*zJD8D@MRW z?Vru!{aEwqnG-X4C6zBF`PWjwsNLD$yP#ORH0X&em$G20q~x!f*ltcX_89}!G0Z=A ze5U7$6wTEtvcN*2O0K|kJW;7R!c*Fklc0QE|5a3)tDQ%J|3%COTHo|kH|R;^U{oh% zF!&Jnys!K8mFOY*X*ty|vBv6rhxrH?-DN{pT4Y^k7g_pD$(jyHj9mZ7^PFk>?b&rb z*V@M9K6RP#+z>lS558$;jMtbtjuGg0I6p)c#f`n0A6Wg0Ee0IDeYLCi;5RrcTFll6 zUj{OVNYtoN)Y7j>iYKhg*1LAX zYZ3nr>)EyG2bH6)eM{#K&bwo)y8EuKiJZBZjpWPzf^Kfe0ie_NY*>jTouenSKS>_8 zj?O(pbghPQeh3=7CAgo>?msKVcBEtg`^uoq5Q<>I&Z?a4U- zji$bU-?&+w$4RlZxLY}&Ij>%_zf+KG+Ew6A+S$C8cL!x4urSFCCX zQld_~aC=!;%Bc_pfTrXbA)JEauidSExx1nJw>^l4$a}=0JYWupMyXEPx}Wr8EVwz* z;uIwnoZtuud{{16VE{nZ-qBi!TNEXmLV7U&4qm$d7vhj`h$i|!`BrE;i`O3PUd*(z z_!(83N=Xx%XPx2UjBJ9bE(1sC&RmDO6LOH@wh)=Nlp1F1Jn!5Bn}{yDHy`vyg?Jil ziCy|2V*5+f`u$?x-poNa;^*+%f2cq!6Q;K^Yz8%cT#fiowzu!;g1aTH$$&=v0Ge#9 z3h-htJ*4GrRn4_VdgumNIz$l+9IKA=sTQNr$wo@sZBySl!zKFy~dys;DenPzIA>PPGWi? zjOI91Oj?_slu5B*KhQEKTonsXc36gv8$2&2(C>thp+4-k3 z96j!FX}Z`gs;E~Y>X&-ip^&PLT5L}6oR%>4a4jvtLUTlRfSjsqf8Nl2_5u)e4+t%s zRWvE*e&`fN0-NT$-sJZol~cx@E5$au1Js_P8I;x@D_7v^U1hG)sDVvY@IwN}^328l z2E=;CA1gIXlO1NXN!oiGHB4dkwlc0sNat@C61K;Hr6Xv$lBpPdT8>+5JiW$izcZrq zP0O@cIvusNC_VaHGK_y!5Z zxIIimaoZDx$C(DsAPz~$PbI}@5E=95UZKXDe(>3>7zv>3WNJb zMPSY&3zUwCJ z@5!~^@9asxLn2}rL@opNn)OP)$~*v%$lQ5F2UU1^bZH=Vz2N)4aYA!qVC0-5a;NE2 zP>ag~tNfkD%ipY`+60u>u!Rs=e~)9fZzE?n$wZnj!kldpids2;(`#v}QvT&w*<$=+ zkGvUEHc#PZvWBWf#!P|Yn>J^ulQq4vAT_r7cyxN7GRq$XpN&yZsjO4aOgghUT*nRd zQmD&47AaHNYw2}%NE>x=sxTD?+{Kmf4O2LM8x)(L%7@u@3DqKM^ph6fX$1xkKUIwy z_wYcP^xD;y+SHcbbTPXvTIvvgkkCwoIm)NDoV9wG7Cr9!*|pPs3M5BpW-;4Ov(%c4 zooajFAi@7b6&}hcs^jREzQ+y8rq@k)N3@tpaM+4GOMeXm;%UL>Io;yS2&k!aTwX8V z9t|SM5LZ%us@qGXTvHbpI_AHuiN`hrL6K8I-aq9|TuCVHJ*l8z`uBHa^?V(+%WTk}WSSatW@)yMa{bkAk>}J*EfPn7ffq*FfkF&y%lZipj(%8|?$BdU{0@U=w$8m|B_T(_dx2Z$Sg7To)ss~gD9)^6XrY1gFsOd>M3RV8vru} z110>C4UEhOdEKq&sDIn_y3?!cF}nNNeA(Jb3NClg`|`f~`o8=6{nhWD-pJU=$;kO{ z?claI=#2tH0Qp1v_4+{?u;dF6?d$tZ9>h5$)r=bS3_yR)h)zR)9qV>TYZj{>Q<8xT zR}|MP7NDC=22UOe7j!FPBIl9PDw<62#zecvV&g+601YF-?Z0u+N=?0?6W)A)5%{+v z9V|8jxR9XOgn=1HOcPge{5vVu<(B$hN%q@25yj;e{9F`vg6KthZ`gv6nO~^?0J~$s z<*fi=4vvvw0kQiHk$1)^mT~{uhdkRi6DYJ)$6@m~ZCZ@3q^^EZpzrXdP?w-uI0tcq zuzy>=8FwMQ=ang^*2OP&66Y}01?z8y{8XDsBK#DOH1&(X#BM%LyIKT10 zK~=TESuY$cL+_tfDrGH_Wh{A~tet#oAO_OGL4Ri*Y|M@KVmHQ zr-j(b`x@{FUvnmz00cKvis`ziSfM!8be%1q#7vddfLE;i|s<=BX2~#n8gIg z&^Hd@S!|}7P;{TCHpaK;%_jnj1}}$?GaD(>!gAc^!fhQyiEuk}lxiJ>eR)RQKfAcSj2Vj8KtNfYfMbvd@GrE--wmy> zWYL~wT?ObD_hM;B6iyUuKd}gNr+s-n<4d5_-U}DT7NCM?#aw1l9s52lGUaFSp)4bc zTLpWM!`uZc-an#L{aDSXeSypWFbkH;Qw!&Vsg@;u!q(u(4Jotz=oJ1^3CJ+7z)h=i z)Tgoz))#X91Y2b;4ndQk)fl9W=GrW7pdbV754GIo$LORNK<24}Sp_Bkg=E+c$fcm) z&jf)8Fh++yBn%1q&Hz-`F_zx1v*(aV&EN-s^klJBzzkj~B1eaAV#Dv?c;qd@*DN5Z zmcawf^UUNEic!A${?}(*4`K1MPRP-?)Tt3L%X8E0+_;R61=B^jTok|p*LU5y4htj( zjQ`k1P#k^%m?ho}Y!4MT$TthpjOocPplRBHf5G7yf{$D4i%>5TE>_}Pgi2u4TjB=! zLzhFca9+e}h*@jRZckPp0S5mL4~K(UaU37OrP6QmEYbreyNwmv$g4+*!kB>{4FRCV zCHUHyubCg>Q&myyr^|EO#Eb#H?c`O!NIWv6HSjfl6WkOlY9AQ*gi6q|%-J-|Nyo>H z7QVf4C>}&Oyp@Pk&c`c>10;tBUtr5!7&fwrm>8So%9Ez0=9Q(`jn^d2t&Wq!pNoHN zii<o1SEp8^xM0N>HaI+gTV(pDp0TJm?_B!q$&2ffVKN*WLC7 z^oz3E21yPVfKS+mdPQbAb^GeGTZL6}mPc0YRq^#yS`_2qh2CTOv~WR{Ge9zpaD_WE zK7JzzroE42v5MHX8+6^0PF*J;|7oEDQAr4nns-T8k2E=EW5qi&tu^+wEIxmC!tr-( zs!|jnX=eAJ1}A-#g01^Z36xTW(WZ?3p=+@&MsYk+Z5Bs@Uc#!Bmo!`q+Svn{ft6Un zqBAT8f{feG0(X`QTmmBFkwrMe={iqaMp&Eol(rnui#Onjg&ufi4Ak?qI(b~5)l)+B z(nC~E0(LxSDzglvd+r{cb;ukyk3<4x^_sziN4;<#kR$xku?$u5;j|x87p!ZO5`YDRm5Bs*l4QO4%0@B zK=5oymK*!Kn2Xm1l|+J4X!M^HRl8d!o3U|1q;ib%de!s`1tzsxs7=i|WHT3iO&ZX} z3V|K}%LN@aW z5F}C=Dq;oM>V?8ARF{!L5p*zWwvQ{t1Ogci2BGJ#wDU*I1($EVwuKQ;SPy!GDq^8v z{ZrE-qgEIt_}}X!#S3UYYM76PjLE*??&5cik3-WgBuQvdE3)V+z-1OsLSfp5Pmf$E zU+rpPO4^OqVMH^Ymu4kIGfu$U!Oe(ta34u@7GlCrijhn;0ugR#sXJf+hIV5Eg`Ed^ zSml;6p4os!_-in6g$PQ#6k!LEO))4PodA!jCds(Hwt;&lRqqb}fjSch#_sCg&T02< z%^x`-ndCPzroslE(L&_I=#U%g3@2lSA)cSa+rtp_mp?bTjN^n32I&15f&^9*9{v`{ zXA6RQ9-2ExBvG4+VOpsG-HH=htiDTRjMRQDq*uhzVu=aclgS&NEb7oV=-u!sh{-|4yK#UvV+X$&fib-c>{5ef@oVV zE_TuF9J(Jy=EPEb9AYj45)7w1EFQ92O4T)Z9@9NB%5WM0ON3)$B+ah{YCU%F$l3@s zNQTrnptpU67K#qHOr97pnPZQ|NPuK!K#B6wIZ+vKqCu;AH3S%E2Q{=2wVM<74i%0h zYaiboG6RJuBML6X9X>#TY+*PubKEfa^TtVAH+l~h`o_e{DmV{4BnZc2ybd|^fJr}g zA2iz#IegR@9j6^Tc%qdK zu+an^`(qYPi3g8t+Fh_1505Tn0q2TI9HqxBO2Wn@Ty$#{O=*fL&o2J#GFpBIFjn=# zSb~>DLd_!VYGD*hjb?{uHVyh)stgqcP6fhlVG(N5kyX%(j07@MO(N+JbN)QL4rx)x z4*pAsYK$u=D9oV<=M&VAZwLb+2)BY2U7!x+S3w3NTJpyIOE*RTD zP7Z|v0zMj=Njwcq$@Gd~EH4%qS|_lYu3Lqnlozx8p(n)C|ERLpNn9xSd+lC zI5y^v9R;u39&}JC&4@L!+Uje4al(j(Z|IejR?3Za zC5b*cuMZk_X#_d}U|;i8h+~C99I-$M5};i;G=TBBtdoYv6fxaWjuK-6BU;y6g%6~M z*D1ZCWMNw8BYqfPvp3)v#R!6pQVY@=jp$L#@_XqWKq0d)W2*hzOpcsH>%)TUT z2c@B?2_6lGymwr5oCwq`R>8wih(A{y8$pqLZg&qLF5~8-nxBhk&A_UH6bf*VZ%(-; zBnK&DOUD=v)@@a0`A$j9J@Vhgyo3Y|x~6>^pP8V(DT{i>eE1ULOi+!(}_ zE(0j_s(#D_vR)y~hX^GgqznCsF|i-u=84a|!5(d*xG%JZ)(DD8Wsr>!Wl{{Xs1ilS z!VPSWM{e#6!NR7=;0j&@yIwayy{-+0IF2`X1^ z_p*U%IbaG<-erRsSvk%>NJnZMG#U9-7<7hgUI-*8v@3?NSjzT)gL(|=Oicm=Vdm&! z`5fmnPC?9InF-ZP25O;o;g1Oe3%|G=W*LtSk|CS|G!gA{E0b~|0T=FnO^ySW2DzcZ z_Y)P5WV+>$oNU!KG@yhn;F{SdiD3pn;8(GXVCr>(DhSoVhBH@~uxn#;4Qe2Cz?jI+ zueHZiz>8TS66M&1YziT+0K_3*MP*)kGHmx{OpHs;%o6aQp35s}LDJZu5P?VlCdP;A zsw?p7{|-lnJ1f*p^Y_AkN@3eds*~t6$a`~`-y8&6N|kvCqa&a(jrASZ9WsRMHBzFtYsBRALf?1GiZKgBJO+kmpao+$Jcv(tcb zkP&D|5w3{o`ak$Q6l{yg^ zV=7~T(7!K2E6CawXj2Fec#z$LAJ`J!+2}2&P9;!y5YKGJw1z8Af2~UDvzL+CSkjLZ9oVAAo z^~68R?bG8gAR7huPZNd;e%g&`+lF(RueM7!wa}IDkJx}( z)#F^m3^H+#w2+mQ^lB0fVjYZdN+co5$_i;*%!iaWEHm^uJ{Du%BLsTl042815gJ5k zLdqQk4L}KoHeeypA{I2v^0l9dm&1u3TffJvyH& zswjPHTnPtp_{a4C#?Qh(O-?-5A^@ zwGaMTpd*G9W;&J)L{E34neM={F-G{Y#&{xpqFqWp8BA=7)a=ok(&W%ozkayJyZ*VB zxW=%diNz};DT6deH)k?OGv_$tKf^ksI|B`yi8&l~q;M>A!mv+s;&5p!!3SAp-X=NLTWN1EgU%9Ak2dP)Ba@*schCOD%9_W)Xt80J2s2lMcQ z6h;hUjHWg6(P)4~lSYk3E!Mip!lgl#WHJHk#G6D`$(v%X?#mB#LzhrR@>OmcLfuiQ z2tJ4wVpSqq2_Z#B-BR7pB1}I)rCPr1STU)hQw9Qk?jo5XjkY19UJjt4nx0If>WaD) zy}%YMY)vmtC8Q@*Ra2&vOQia5+zWGxx~!2yf%ad*AYz!v@o9#LlnOGfKP{xHHR_WrQ7g#=CA&2 zj1l2i4#i2AO<@&za!gO==LZ#DbhEfZC ziis$u)Rf@M7Z~(Z$&-&yWaZpi2^2K4%BVCY+MX8d>?o+Ys-#rI=)krnRz6=sdd^FM z7weePY~i%ii`;sey~3H0yd_p4e?&1}1C0b(UCC;=%W>%^=H`<7T@4#?Jqk*(ObV&U z2FN?4#R|F^R?!;7?W)mD$}j7nMpi>N(M*mPJ1<~l5nh*7E%6rwU}EA;W%BWwD-?_4Ja3GbmMxJUO8(d!|YVMPkU|G^$QQMjGD-?WGd1*_I+F z6Dn8=)vyr*jOWYoYZWJ1(SwI7t8O*R6HTU`spfH5lgj7FdHLzNxND6~#JzRJ-7SP2 z$A-tl;Y6dale3YLvCuY|$g!}55*g+q84{@;{>xdU20#G&w8iSfSV3ukIYSES(8(*M ztI~$hsEFY}XNtrXml?9+mNzOUBJNX1sw`)u;&Ykd7R5`mlE=_br(qPL{a~n3TPV~R z6-;Iyf?!GRu!;2SfEXLO&q2)%zswC3u7rCu8~0&M#7fNs~mKu zB@4caNoUCWbRR1_nT8ZF?q8Wv=%dK0=GvNsFqi1U6q3Le5KGH(E_3!_*3EamDAd_% z))|JEVWq*!2qr5ldx2Cd zGZ#uIM0yS0%AnP6nrs0b+CpT_lV&MMNF?qNL?ap_iKmpACse!+aaE#59VdoTA!^yT z5{5-CKaWoV2PK9{TEFnSd#opyk(V$!r)JCr1;-13-FH+r0Y;1dqo~V(Y7n4`Lz&!c z+FT%7BL1LN`b6F$3XLaC1G3lxGY^q4FC+CiHElkWvBoHgSOLM0t0BlWYw2rx&JxxzANR8AzLiC?xxw{UC*{q1~M z+N}U_Xf$faI=zBoV$?3m^~chM$A0R@+8W+FPSCdMcqawelnjSRIcgBr-f!c2)2 zgH5T*xm6goX(OC;X%X&%3^t5*CemdxmCU?e9s6x|}5l5Ghdn$DSSqHPU;&KvSLe3M#2twSBNi3E@+Px8GP5b%pHHicA-gDe+Hx z-AYEp=+@LhZZvHvG!LhB=t6^LNJSflWz=j;*htP*VvhKU)ac!9b{5uDr8+j@3F`ePpo7rYY8xu$qDDd|=npu2 zh`j7&t0bKSyj&`^#+lWudFK;dj@LK$Rc~LZYJ~e$(GR%fiapoiu{4WAXQO7FY=DWW zR3hN37`dj)3dNLeUtLRr_{q)Y?%{84e>Kz@@S_Y5O zHxh0hx!?t+UZfL3ZHjbbDV9Vj7sdT2u$@M0Jt=xPZCs$p0`7eX{ z&@5i`kOE-xHiA%;EEp&%f%Qo5NUr^Z)1bndbV!*U@uj6;mPGce3sUIU64*sscA-c} zv_w+tnoY>8ki0}ovS4{;z3j9^Lg^8hHcdbXs5oFFgO26E#fzAQnS&H^LS)NBxQs;2 z3(JP^Br_oSq4&rW2C%pZgypCzP++m~1+Ww31?Z%y=ri^Zq{lS&6!Fxg0jTVdq#95b z*ohYbra(@DNTgew?|r8pn$@tdgyZ0FP&0*6(c&Us@o@Bn7Y~-jFd$PL|Lj~OS)uLS z?Iq8N!bg4s`3488L4!e#DL&n45nlwuGopwt#W27dP6eKqlYP(S(!d&MhXbO>V6*E@ z0+I+*gJ5)@gPnCGm+qTdKwF&^Vvb{x*vqR#!8&)v6|^O`n^`QQ@Gs(rA=}Z+Y^&-1 zjYr>BA)CE`HpoNibI9_1!?ym;Lj_laWPtIo@RhH3iU(?1fT9as31&`M&Kl%*t@ zfwQmI!OVNIu#fJAF)na`S@d8w5g{el37P^t*zALk9f2x=JTnMD!YRl@BID7|eY9pX z6e_+n{`zvwIn664rRc}t^L=j~U91=6Vf8#hj>={kw6(4TU8MbMZ$0~bZlasMnQ-tn z-5-0D0)5@PwdH;#EOYCg5@~n{9;+^MBiOwAdw+OPRo#p^6ycRB=OjPptWWLK_Tx+> znNxe;{#NPNrbhln0m;^cWr$ASgpPildycYoaxK~pfZdPl35b_UPsyu4a6HJDq)(e5 zn*OtI#cpH|g`X8GX2bm~IAe%e&u9&_hD@Mc_Raj0S3osT4_Z1t?CL+YB$^0;3!yh3 zMhfRm=^ng^=_JVwv4EC&Z!&2}D2+EmoGJ&E4Xa7)&C7$j|r*la_$@r|gB`J9Sl{5W(22z)oT4S(2Fy z)CSD@wF z0b_9S-^B1gZ3yg@C(2^p*(;XNi|0o706h)Q%iGnTVUN?`5slh3%n1!xtOkpdJEp=>^14MZJ0X|pEEX$xuYi#{p&=Ndz0q6fy)4Wnnxn0keK-EsFq71@ zw@e6qmeMUXD}8!=`aSoz=aat`T?vPLoPrQ+BLlAhRmt1?x>H4^RK;<^x9v1q6g0q} zQY-M)3$eKN8YuZW@BVtaf_|i+vHsniw8Q@_jCdClC?Cw z6R;c6H?H$>Q|5oHF25)$Npc4W;p@+Qi|NRG`%3af^#}TBAPYLhfC|TNcqg>@a2CYW zSqu2vAwUPnRkzxwb?HjPYD+Ny8$oPagN9x6r;u~@PSJ!Q!Qs{M-fthuL7il9l|K*D zT;8Ib)8Ep!}Jl-glg=H$_e9+MBcwC$I!3n|)uMC2Z)b>dPF?8Wc+=P;0 zF7YL%?|lB;9&Ip~_L2NEW1uh-x!?IOl4ruuHJsgB#m(b)KS6*bf1JJc z)M?G%e)zoyT%RcPHmz)4=4tHz`;0_=Cy1axC?DS@u!UYGwTtNDCgU-6GrOXd;*&rR z{jG>suWdj4wecI0602=4LDnzy6n~2TYLwE?wDf{e2xfiXe{i}mX`|5ibo)=hk)vlP z#iW+_Y-kdDH|yMk4N_iSQ5RFNQ`9J3NYux)G$y|zByvdheq8v~J^k?-2I~PE!ncwW z6j*~{)sJI2ja^L}C&%KX|7Dp2(Q0{_)eFbN@Je-*Y1m3)z9pDUNhh0O(I7U7xhEqR zUQL`$KZ!r6VW>^B0BWlw4ZVFRDkx#a2STru#;3-m_T{~z-~M7AFh5*;Rwk(oLn)zK zdXwZ}FMKS|b(o5YRg}WyEX%fBsAbVJNTydsBu^v@OOSSAEb<+CC*Jb+_a}ZY@MjcL zNQM?9%kq{i=1o>g5mWU;!eHntr;y7RMH6UD{N6W9AW4wPk&&&E;Y2I+?Wwq|B){al@|sG)N6OZlp`bh@L~i+Rf%aP*LPNfIY0 zV^_n}{n25lZB1QwU=fRBNbJsAEDbCzXn~s?J>7$3E5wcCd9t4lZm;-hHiA(qo&h=_ zp!H7hskPh45Trvl!u**eQJm34$GlA7z3obCrQ&X%p)Lxw>@_ITY6~2cTNJV`6suqb zaqV~ovtrCo6Xv;RJpDZ$5FHSaoS%{^TaA?tux{*Y1kZI5JQz^iSsEKq8bL7*6xtR@ z+r?(2PQc}>?rmGZ8#GW~V8XU&^=9WW`D+LHjV=XQ$!n)_J6=6G^0HR`hA`~A)J>ml zXk6avTl}Off|E~gQ1hYd=#Y2Y|8u3+(otTLmZp|*sh!WyB#i}YAnxTXc28Gm7_aPg zQu?j;dlc0-?-FX;pKiu3JNTykg980A1#8N7Ej;2V2n%11H#s!L9|Od^X5*4+c$cEK81%z;*1+Qr@9@Ra zl(bGRB4#_vsjD|%N8jyhoZ1X5VKe!;6&YZPcsRr=_>wL z5|X~irufbTLycy;Rr;NDRMi*PUarQ|WZR>CC#pquctP29C2SqW>y>Z0{UjDPc zr!I#)4h4BwyzS=gFtV9zh*LPY0P%iW!qMtgNr|2cnn?@g-N{K7NRQpXac6Eq&_!Du=3B zGKq!n=g71^MMqS>`;=q=%t_J#bm7lAY~o(NRMgcRiMciuA7>jyS7sgNzaEC*-JFW zHQ)QnbLD!Ur+Q!27=E|YYFcq~+{)FgctBG~K@+_U=^W7?Y?WY9^~*LQN>On9yNbdm5z z2s<`OLtb=gN6gLxxiBy5Oq*)dH+~*7Z+Uj>5^#7x9}&^am9Ooo$owdjEII(QTlCVc zZ~pqRj?rL4F4XfiTMNzo#Awy8>J+cN9d3$bjFuTDriM3?{y{*eOvh8hyHMZmYLnZ^ zuy=W5O(GK@gR^zK;=MKQL`wEyd}KdCsSFDN-7_Mr&hGym92M4BDuwT*7jhNWU3+^Z znTJOv0!wuV?6~MycTzEwEXlm0JlAs+!<9{Mm}5UhN9=B0L1)}I6jkNm-eu4FA*Hk5qD~)d&wHd`)odB0 zl5#U%d3vDGr)82CWl9P00`8ajt4Wbd-vE-RP4etxs4yUc0rvwk=>32vYb@<}ByWtp-f*W$KJ zU`j@a`g#a+oikR5dsTqbeHu$aqqUmJk}(4vp=53gJxTjF_*Wx~N&5S#CB^Q|eGJWo zUemWEdqwb;b%Rs`i{lF=YGpyKGIXMqmIh_XXY8Y+ zU+Q82ni{!vm^l6!!eg%&7*8RTE}I_2?*A5Lu^I07n;VMelV45W)$5+QtN`E%aB@W1 zi(IP$|E^7jlV73T9d3LMy)T(&b7R3@6qk2Uwg{eu)~K=B4$i>7If2H zW5OLrR|%L z-HwykYCu$y^3k-mAl>S;Ucg1u%On-KIrEVpmjiL*?#0NuES#9#o~r}-88JG5@7!vm z$*o(4>Du=zqV2f2ymf3+9jNNbw=VW1s=5M%!5|29Z#aKhQb4q00&zQ?7n2t;Pu3e+ zC3D>#Y@~=f!{a|(tt`=_t|%B>uQlE&0)ygo!*fm>+G0m-o?G|@Lzsf!Gwi0a3EfSb z?x{@>lwVe949b3#nK1POU>SKp}k8eK-dKq2(9A8_XsCT&!B%hR6 zj9E57 z)3MwHA}1xLz|L!ez!+IarPE4iit2p1x#o|p!8szu2p7360`{^VLjSHYR)>*-CWGF| z2B!~|=U?gIJ$R>E>jxeRBBD3io81G!p_3Yjrb63gf$M9@@)2F?GYi+?~_)9jsCvmDDT#jaM6X%7lINc&n!>ws8*=*Z2p{EzgrJnAeJzU<*A=uh?nzNl-Ay=rg>uSQ@qKNr) zrE~oNV?uS-j`u5F@*L);_)d!wt1(1iru!n2#@}+j?t^rn@%Lr1w_Z2bh*qu~He*A4 z^1`8e$urHn9`D9tQHF+L)y*cGpn|8yB!1Zu`v(CBE)O-4!$Y+jt?U^AqqX}U(w2&K z4Yy2tm-STKMqk~$WpYJfJ8^-!P2SWIK7kH9Fpwhp>>5b5;m6W3LUQ19q1kQjgKRE< ze|fsne0-Z{c=3>NXmyvXs@uHDXTOv#kn22mm>HPCOAOD4D?BA+So3iC7q>?-pY*T^HU5FghQ}=kp{%-io7`gHLZLKvWR3ZpK*l8#eFIvS z{~#L1!Bc&1!KT4ma5s(mrF81uz8xQ_E*o)4G{t;Tzd~(g`$1nSE z^#cNeUE-hvyl>vTS=ktApa+82h3dMMXU#)OE`JKSyEgv1>uwuy&DkV*nU5HX2fNMr z|7|U-+5)1~ZcgK+kSssQYut66;(__pO93p5($dwFZ8L9Ye{S@`HfxPUTBr}RJ=;?n zTz)+Tc9&kJ$**&hKQdSlxcEbYg1V_D@!s~U>ZaEP$tM8Q$W|VvR!y2U2vt~lia8x_ zSFiWo^YEMO%6f*R7J66Gf+KpD564rTUw}VxKYF*Ywkq4H+m#%RDqE&&{osn$HeODJ z%Ey*>3>E!2a~9mmo374>D}z$tpR;*bJM0!q)du}?+?g${wUk;HSo@41fq*d*YT}&7 zR*pdrr`>U`^UH|RMSp{2YxFI5a1izmtf77!*N2MgYBiF&G~d!BrmmW_&W}W>m&5b` z2AuK_9|XZ^xw7heq9j9zI^w6WGixm}jOW_e8w}XreqC=Jue)jSm>DkgwizcyOw+i& z$Kg){T?XtC@0cwKb#iP%ID(sKRJBF#w&|{b$(SSrSX6WshsDwsM<22dTK<)_)obtb zj<%W#?Ns?RfVU35t+Va)SBpA4)I8~sXnOT!{IHT9CSS+Wzk|SY@XprsNM&jogFilF zm8+MRK*w=yk?N6VEa}oC?E9ycJwdR)Vra0kyB3&w z8AY)Du2v$&n(6#%Kw{OpZ52%vwc#zPkEY~zVYDu+kCgIoFd04-K4Pl=RfXS;?Q*6t z5NSjbnT83FljDE0MI6lmqGZqr=Mxf}G*iu0A)&A+Ud`-9Ml zY9%|0D~Ha+O$Uy+Y?uj~b?6;Ie_KeS)iXiqXk`&TIdGi$9Z;#IWu|{XYsa;_TJ0nI zu9qcXq#1uIQ-r|M&lQI70N;(YBhd}0SazDyn)`@vk$7$zkD$B%i01*YFUGiEQ1zmA z{bZ#?x3Ui_(2aWa6%!)!rDs4toB5yw3_!-a1iq#TfIC-?G~~`c%??WtFlumc^d|5W zu5v`@%Ccp-ykdVXrenW-y6tI7n13VGX@qV{YnV0!UF(Q0P3P%}b5p7Q(UO(-1Y(%5nDv=HN{we| zskc}BB0DG${@_UDX^&91FwMlHIB|RQ)cJfgfOb2Le%DaE+-RUc@N)v@qm|p9oNoU4 zR6uvvsst7NOJ+b>^wDh{4+Hq(+i4eXomb#rlG2_28SB5%K&PhLIVOo&!2&c0b(Hf?Qk zobH?kzYK&h$+ykJV-YfP6StW}9K?R&Z+B2gPKyzS?5qu5r3*JnHxWAkN1842XmQO~ z?&ZQJn*cVj@WWn|)3}>CdzOaE+b*^P)vU6j6N9Npx}fKIwbstF*_$EF;V#@cv+-At z;0IASdbYIKtLiupF18oX?Z1y)U$@?|C5v(DdPz0_^UJlOdFGcH&t`YG3VugZLMFO= z0^Tv3N85fjk^-Q-d3TZP%sT2@oZ70M#qVzEh1KAy)}meN6-J=P1lvZ3`9ZzpNl~}X zE&m@Y!Bl1kTo<8IhvC#=f?Z$D!_|`NSo_<{`UK5OO%`~M@O3Cg~qoh~$IWZQvVAw*$6?TBd8hj@&(2!GhwRL;q zmjrd_i-DJp7VxIQM{031lsS_f+f}j0?>2BYq zEWI@IuD(fht2r5$`$Pj+U(I4qT)NqS)O2+HwKFpeQOBY75L)a0cBbrJ7qR=-+}r>) z)d@qPCVC~=->R3o$W!|w%LLXzr*u)PCw9#nC~V_plQbn!$bdZ#_T_?(u@D+|^=)~j;Zs&lxB9WKrf&zQ|Bfem);)dO$7I$Ijqq)>~jMdwu^sA%ths4W}=clhIlQXu7SkfPKjx z>4-%^EQqg9>h$u4NY97tb;Ijx3r?I4pSJ;$G#%nA zr}DfXmcopRTmfp++y4J{`q8Bw$n{&3$ILy%k2`Q@X=luDb_yr6iI}lSpt(RSkC*F0 z(L#2VLBDdQJ1%$+GP)kV){eJ7#{p;2N^SN#m0{8901PvwEj(k^t@Dl(JNHPn&sb%E z)v&j2q>|q4x>CBs?+0NMQM78}Sn8|>78Htbau^j$I!+WuCvSBROAKLZu#!~F|3Y2G z;&jt`ZlACUO@62dxf>VMZ0Qc-Ju+_l`cg6X2i%Ipg1)5gKx}4xfVn@{pWQ*(%c9tF z-6?u=qqiHBZVK~wuVcaMa|rVTR1kh$V;=i>hQWEk$3dZkjNl-Ud#nE_|C+UC7Uk{M zXq}7)=e<4)r9PLXUT=aj0ueKw0uBFqdG};iUwuMknP$LbC&t9JYlf3>`E~Fufvt}w z?1IoZANse2vbsTnTYsdH3ivpGpK3h3gAR|-lh!9$t#J0-1OM^+Y&G!O8fTqqb8}=+ zS3PiH%mcn>Q}97Pc|Df7M&a_xPx-j{W~=gWTEQ^Dq{}+ZU!+K0=5<@FblG}j0)*mMbnDf8+hIB zw3toa9Rd^?(w(2ZIymkWG^ZvC`p>t{+0QwLraZYUiKsH`QAxK*)nn;mTUYP!a(ww-@X#=zE)`>a0^3-EhfWcT=G`CIc>j5SW% z5srf<-|OieR9|RY6r)}^yq{MbbRykeE^(H4_pw2S_b0$n>eri*8;zfayZ zABLbHuM-d_hZ&+`uP_K?ta3TIq>FFM&tda3Xga@BRX`A|k#o`ZU@0?4bSUggLdB59 zLC5wu`>0{U{WPWPFK>`}w*LI`o~HWjhKfJb%HwJ=SE6kPv48EjUoWS&L02i9_SIcG zf1)0dkktIzt+NdxPZQo_5BU3&TAHHn;4ofR!lB|oH}>AYqe@-EU?gjUJp3Udms;*@ ziFVg?CQL|PYzSvWTH7nWDh8OLsuu@YGp^q@|T*w)Q- zxyYU*wyK+Q{a|t59kM8pup2IIiX=!I#(P1b?uxJLAz}{5>GpaJN&IUBFf&w)`Kp(! z_@K!BXs|YyGQpO?UJu%d=AM*nM4TBhbxIoIOgRLX%iPjzQn29uJMS*o;>duuBNmUqVk(OM$NSu(#4pCTElKt=ELHRf z9+tWmT039-qzAo~EQmwOj|z*7(~rDGYSs!)minyFi=^RpQwX?vi9zowsGt<~+t;)8Z`mlQ7b(o%U|f3F&TT0535($4df8-ffNW5(tKv!t)k#ci zALJ|8+A;SCqds;at<*m+TU|r-#N4Qld-}s$%x> zO+HIGuDP_ew^O>LND5pE0+;^+7%wf;yG1bN_^j;nnk)R;%+TH^%xVi&sjz_EVt4WVDyX^ z=~ZysFF_KK?9fU3gx*rtUSkrM(U|b|TOHgKPHkE%{jt_5Jp)|WJ>ZuJ9SV2lF=0z0 z%4Xlzf3P3k|NYLa0Qk`Hbafd97P4d)`y{=k7AlyVQAt_zK-Yb?vKu`truj6 z^lFVgQ!Hc*`xh*X@~8&k{VFWAKL$N?&o#}V53{a~__=@fQ^Y?~YI_rEs9yinP`z#1 zrnm%X!56KC07_eHkH@}ba@GwSG+c}g>|KiSD>hiC`MxCU%>2;-Kz=+V5OaeBJy$J8 z3Wl0;E_^rM8JKxf&Xx+;2F`C&iJQ9}mdPm~i|9Y}A8VsL6bv>NGAA zRXq5-(Qi-l5M0Q+>pt1*u6J;6x7W?Owa&&~YABEFb$7boeC|}#0~sZBeEY%w{%GFv zNs*xS9~oZV+OXc?u&X^N5AH5&!$dDH4A#P7`qlDf=tE_3Jp{=!DPjV|+Bqv@zS1{I zFmAzdk7MuHk#>LgwyytHl9Th#tN>U1kh$(c>k~TW2&_pI4>p-+#sg#+_;24uikBJQ z5j@_wSLMQS&o8QGIa6wCP_NLscXc4!3!yn3D%w67ER{|VqDHSX`2>ir8YY$}UeEvt_jSz?Qv4&IvtEh~=%r=!=SS~GITxGvrL0s>)8v8~&j{O@%zSiGcXxgC z@Zpx%?DV$2sW$3QBJ>rYwZme{=&BjHKE7i2_vRZtLv_1UpL`a@1MFjallcGzMh6y2 zhHgQ#sK(cow|qe)Iw4=2a9%flb5944WnnPt6O&@)RL5-NNx@$S^6385$6APCH`}xK zMt+C#gVO_D7Gqgs7#KsQjII`-$M+)M^-@WkV?l$XlcMh<+|>E#Gr7dAS9HnP&Fn|R z*KViyw3wfhmZhi9tMmupXg^z-8!1>c&g4MMd*^vxwgZ1;mmqZR{cqN{0D_O?xZnux z{^$dFDTp_xGXV6J3-+@$?Nv;gK4T6%=!tA6l3Bby~XerLUHoqbOsO%Yq5QV%F$RGB+aOXq7iWIFBr<1~k$=kVUCYV@Kh zoGH8c#CSMGJs78TfD~g(*c6CY~Jz9suB8TOJ9wvPby`l*A481 z__{SXI*^6EOI=IOu+mDF0f!28kFE|*kE^_SIB6LkS5~x4>6(sn&Ks;_A;&}>nTEQ} zZ>f`-_Xje!=7PTBnv1ad5gX|(_3a~B7C@kPrJ`Le6UB0Ruqf#fVa~;QCw;0Td}v;h zU=L)dsWfpmx{{)Er|B^#^J54;v|T}fC%i-R6E60z8pESYi2moB-iptuVW{3~#!B(2 z`jzw#Dp;L|nzm(ht*`7wF|rDUlG2fH0t32YPd>lNUf;y+laU0+ONHZ9q&}{ljjCbZ zjO2}Yo-w+FyCZ%y_Jvt=kEqDk$e+dqkdZWa;1Km2ismn<0Xv$glF-^!YcUlEq0E|D z?mts#v&gH~Ux+LV2^$An>mJ`z&Jsmm7(?gjRe53JxS42eofs4`x>$$azwHjQl|g)T zH!?W(jSr(+>bi1^dknamosC`)(Y~$HQbvnUBKX?WOFkFARa&@%Y|A!sTJ9v)M3#s2 zu?!8T1jp8UZpU@%?J=sT&u(juA4q!KPS@>i>bO9VfQraW46e0p;ymHY^a7iqO&e_u zdh&7mOu^p7^UWx2K0#Z_-jyl@ZoWK%H5!MZ)W~HzgSbf|vp3ScP*KyAx1!N%rykw6 zBY`Y(C$s}k=eSi^%)=UAwbep0HN8IMc) z+1RSnJQ^P&SbY9UN9wB4_;G%$#J9il~41y(}Kb!%jiBo-lSc{J9{%IdW+W6z;Pm7X4CK06Siw( z=Qu9cG6zk?gwVv1>+}@*bAzdQ0gyJXm(xjvU?NnlG~X4Y`9@FP~iU3U7q5TBR$`^9V0P4aS+QN1}Au#y3=+v&LB54 z%v_ijgv%ML0vd%}ED-2Rjn)O(Lp3j!kMrScvS2u{=3v*Rq+iNpK91 zKP(d&T@OYa$^U*m8;qzE-W29iRb_}B}t}~x%wO=Te4Z1yuXQ6{24aaAwqFX+MfK!A^4-5guY(` z$EY&+nbi_Z371dA(Nmc$dg7%;K9M&=?=F!VsDclrV$53DL=0G$to%u)S6ETDQ z)YwEPWltuq$TnGaSd3VHe&J|ReH8WFEe0t~^gmeF?NM;km0}6eq}Y=c6!q^*f&hgO zio#t(;s~c9MBAkbZpwsW%IU%cA2jwB_)8Di(g*h``lM3KJPJc27a1%i4=#o_<={emY!mU{GToZD}Hc3!9XS8dhVeJ2vs~{;c5G#FlNkVb)Ae}&7Lg?e)pMEJI_&D*z^>mc2bgG_3*?MXi=GO)qdvywd$=gRHBHLGZ5f;qar&TDXeFrdt`ml7+b4W1h zl*(!q%g>@F>8(yr8i;IMEfjF>{YZ^l^D>+*u~y~N+cBT2EU&ttKL5pgL}d!pa;|Vo zuB-SJSWc?YyVzT6@P_ldaE;QC?Mhb)^Ie+$=aY<`KE|?bi@+Hm77P0QA3p3}yJ0R2 z7Bn&L%KuRvt~nAX5>%Ke%SAvuSo<&*EHkEv7CeXtQ(%VwIlP}uQ+m~*0<_L+dRL^F zmZ^QKU4f12e@ek-e;Rv=*%eOvcq963% z97u}>W~@h zH+H#7?Ckwq;!vZ4v(SP%A-=t6voA5;qC@(}s=WAnIvd>S@pTK7Rn*z~e0F0o_jKaO zwL3EM#=Q8JB`TI%dZl{>M>LO#`RxuEH8!^Vb0@Co2F_wZBAT~oYU1w40+`!*`N$*u zeSVD43!*6=MeDjj4Qy_IJGOT-jr-c^W*bO@M$))`c>EDmMvvBJ67k(wx*p&OpiMqU z_>N$loAPBZy>%lj7>`c6YA%PUuhZA-UVA)we;fqL~;k%h=eWeNjfVsKC!P{AYBvm;cLzpT&3jTJAnwm2^0BXEbF`T<=EoqI|)YE8-v8 z7iRZ0_rcI7X}scIQ>R~wzM~CLr8uH;72=;40SGyF*Ee%r>&XbBDdPsS)ojyzQTzE- zc~r6}x7UdZ7Ap?L`bfT_DJvm9EjS7SS98p@CBFL}GM+Bnm{O}a3#(aGbKK9S#J@ON zxt|QbT-%8mu}v`17oH_PCL$7e+f=KYZ7hg&j&2=d|4wI%f0#Pps{5+xDqp6ibT~gS zSFJo;jJDShWm)liiKR*Xhsb;}FGiKD4MA-671XQ@aJrxJM-@Tn=R#^u@(sKhe{4@w zvb#8Gwvv$V$ib$X?qe4}$b#vS_P@*8nIY^F>*i}~VuW&T;z<}wc*dNA>6{Y7m44QY z*tfanjZzf?Kdro3?e%0=ksVh$1gy8O%z zz7n?+y5B_i>+~6GOP=cCut3(}5~z%Mb>&o)Y3BOYa9HcvjY{dl%vQfVAt{=%xidGQ z@7^27xl?c&)KM0W!O$DC6nDfK=foZkP4g`;%%3y`j!p>C>b~^OAof=SO<6~JhbZHH zZsR9{HY?2xQ~t?s@E;@Ci_q|XD66JWx1%>>@nZc#$Jx$<&m|P(Iug0$zWzr_C1H}0= z7G-kn-O`Pkl3qR&=KB&&6y9<@5aNDNk9Rp`~o> zeH{^@Kf=#SKPRpc?PG&s5bc{|AQ!b1mKy&~Ye#V)HQp00_54j@E+^yK;xC`v7l!3& zhY7=;@9387Wv!~IeAK|ta`3BxOhxxUSm6Sp8ouDU89fFgowCX(!z7pCI7-|$F^G>Y z9+rp{fd7=Cs$oLnI~*EI7#|)kbx%vbIPi2z`##D)6a^ED-<$n#{_Ly{i}jOKz5(m^ zZPH4TcPj1ZV~4!Ko>YBt+>oJT17q&QwfFYWMuPPwFI=b+Lg|2}2w#fYX}65sk6MH* z$G!7VPP;G&exzP-0Y;3Noq~oHN%g(KW0BLCj*IQdST~;wBVdbN9pAiDuO+R4;9~X7 zZ9SE#X3mqrV84D@rvPrdlzW4;$gViWPIF&pj24U?eb1ivccmBFEzf#Db$%E+bhVjd zClaR5=YeVrxJ)WHI`dw%DFm#Ka8~r85iBq2g5=3TB!3;tV)y@Cv31!o95z3O_LtRo{#8LFjMu zvn7{MrB-y@%`ufg%ycCS7shNQ%aWR2RC%W!>xQQFXGgf|3as}RkN9fSt6tLB&zfhe z*VXNUHldcuza0Ebgs)x`?S9Fw>eKLus=C0;8q)jajEreW8h3UO!#X!BgZ7ZAoov)@ z8nkAJEysMpTE~@%b(yLa0@f0CDW#S_fKojW?#eZ%VWxDyEWZPW%+xh)&CGc^#GqTwIK8O&HQ$oI-VmEZCye zx00Vr&u|Gxu$LN0qj)~rRv*nk{1n<4)1>dCJDD3I)r)I~QqM1ld;p8crJ~hec%CkFEoqYS|A$5Yg zO_#{~mLe@_oC+FI_RfG@&vdG{NI5-m*3o!4tZvKXDOHaHH;PuF{QibJrw27O#-w;5 zUx^RAB0Id=kMXPGRtQ2?Iyp7Y0g}b6gn=@u&QARPHug>)wk4D*d5IN$T0$RsIwGXO5J4A zew`G?uQWF<1ikY+d8%R^aAjR4SlMzZstzO6Yr;~k>#(A12nJ;-$_*lE5l}T^v&hm^ zOtX@E%9eR1GH4t?OCdEy*SF_V>UssrB4U2mow=intSeo9oZ9?qb{nELyZSkU@|NsV zQKUoB(K+oP;`VXkTcSY_ z(%A8{<>$26vfc%s^iLbu;tK$gz|8rqBn`^IA$DpNq(Wk79~&3!VZF9DJ&z?{(Z0mb zbGY?tA|?~@+lmH2AbPAd$)rfk2Fzt&t#0F z8&_Hgn?woAc}xA!R_u4DlJHOSp(Skd@i)BD2KF2o@lsLsNpZ+nS8^mi5t z@B7E_^lc4|spp<$X(g&wPmM+=;w8u_*FxERxpU6n>~mv^4pXLZd>>a3}pcA0|&n zF)BnaU{Hxfo~ikieMBbugpYE{oh?!_F0GH4l$b&d{>!Hy>xhyhl3diy#vzepg4{hL za{7Xy#Kd6jId=*X8+9{H^Fm2)D4hk**5Va4nZK4hY4vX=?@9hS<1E$q%j|ev}j_RGL#tK=?_=p?rM<{>Go}rEqF(dmB8LLc$n3Z zn-pyzutTLrZmNTfPMoR#2#VkObn38cy{MOIn#$FO zZ=o< zMIWTyfy2^SSlSjtvE5xwK{9Bc(*@MlEQP%_GN7}!s+=deC?-ydpMI&pk1 zyCLDfI*mUd=Ll$6AfMjL0MLg&==OE?pI#s*=bvHVpI(4Mj8Yzs0}6_$r}v*-fIr{h zeY?&O>#D}SLzT!@L&&U^C|bY_J1>X)09)p-HoAzACJhY@8nEqzthTs3FiW)$IWBVV zFq&O#%G%miwmoJA4T_8v|LUC(cbN{t)HkWdf(7-6rd()=t z#)8t_&>HT!=9*Mu$}8yI)+b*RH#r(pv>nSe43VU~mS9m@y-}V4N+Q5SZp~nWYkpQ1 zVb=(;tw~OeA!M3Tz^nH$c~dx2$|Y5b^5=H|^4gd5EARt(p784>!?%OTu;dy`V<~NY z{~e^))rqLw1@^C;Mo_YnPzE|s`L7s;3~A^unsqJz2T?$-ze#J?1|En{{FrRbj50s+ zZOX>EO&iyE=a%W5uuI=Eyye!QSDpny{p%NxdNE;wI(~Y1jK)|OlaFPtA6Nakw)&iQ z|JCZddWv3fc9>QSUpOo5yT!P;S#P~Igp5Bt0+1tijPxrRLNF+Tn6P~VrSA`8o_Lf zD;gLjpG8v;KNN4BB{OoCT*z4>Nr;ZqbZrT8RCuH;51hs&7qYE7*}4lfpVF#9qU87! zbTC@33x`u@MNS=`oH`oBT-z|ZE}`G2G2N%0hQ;yoXqjvHtT5FYSTa~;O zQ|du6x+!32U^S6dh6DptVrXe<>9O%rIP!E=r4VwZ4utPdq^Wo*3sS4S;GmVmHAwdw zOHxajh=7OnvYUG}XOB$}+^&~a_XHyzj+Op8G=>!7w!mLHU*O{XgHQih@-v{|+Rq%Hoqp4=8zxmvp|EZmlbY`HDQOG!G1g=;H)(}BKYsHH@4 z$_-)J29k!bs7j79uBB|nVV9F*p~cqqz4q<<_uG0Zxal`a50cNa4Ih|z^FG|&;TwP%!A^k*@jZg9Jsc7k$#0@171#!gEpX*GtrY?&O%Q{xe|KX!f?ti zM_mMR`#~v*s%T@d7BV?#1Im~lr2N(uJp?aRM+2;ZpeBM^5Q-z@Hglj4B?7eHX_2dt z$!6l^WE&=}oNUCTmy@lSjB>IW6N&r5{n0{Weq&mbD=d;+GUU3EFD+$q0V^1zjSS!* z*a<-$(wOMhF`;Z>kha*!ZPBJ|;ZU}8qHNJYwrKy(7TdqHg^!o&lA2>kgw#uJWK2@8 zom{UjQla}h751cx*q>Cee^Q}Gs^}@-3n(2dQip?FhaS?Q_d6Yqf2pGfUaF6Vu`{Wu zm%^Ne1C%dlNuA`n^r>;|j8y7VDh0o&bZ*_v6jjD4x)fAtfK(ciD&t$nkJP73>T{9n zGobVtB7FwG(?|SPA0NhN+Qb}NeKOQ3xR4Q2Zj7J_f~KS)y?^p&Hfak_Zi^9Ri!tRx zCX^4EBFl_^XBq!5M*>bTmsFjg=tC-`URSwZE>gk$oeHfWkiI|7uR3Xqx7-#h$`)&Cer>4vwMCX${m!y3e`kK}NYzP-^Q%GX?JC!6hg8`8 zPKD23s`$e;89wk**fToJeo`PJ?WaiTPf}7L=p;^Siz8&Zu1VVAE4PDWZdK|>Di!>s z6ndotnLs%xXci(p4wRmZcFl5%h@@m9%~=X#PwLhpb$65Nc2LmmPwLM8Nw*rQTV1Yu z04XXku16q7X2p~bgF$Z2gtIH*%JT*&`sYE|0$W%N1t0?s_(jNM5hs)66l6(B4llT9 z3(0-8cN|z@M4i7Zy7vx;`!LuJaW@!bEdukz>8<%1+N0$r4oqudeh zE5Jcsj-hgO0F4A8R6o(NM^8>?QS*<^x9UhTTiy#Mr~~sMTm>N;Y=+X<;5gU;VIwMk zflwXTVH~(yM`81UHi*Ya{z_~x#so(Z{0^Zmu*5s#x`2R?37E8(5Sr2|A!io^;}9%F za3+H55j>3G0|aq82@MhSKroFSLuY~+^eVa(tfZ6HUZrn`loklJfi8nAPe8DNL0VDSS38}P+0|zW>6Dkfl9bn(SSLi!MX-WJOnWd zgk4i6In{v`!Z0?8X#*RCxgty#*da`aFg@r!BsL3S`oM{ji7*4;g0N=@GXgw>X{eAG z7g|VSK?pMg?g-0Am<8~pWFpK8cq8lp!t6j-ggrr+J@7?XtSX5)fNs!dMU0&o312|p z;V2o>n801h1j0Jp0>Zrr9>+;~I&K4DpppZGF_04j$CX?lyr$#^;Ws5u)Jh+Y{VLoD z!b_;tb_D-5oq{*;JP7aOg$m`-ZRKCvQuO~`t2%tA9G>TrelQc^EC5Y{ow;O}`L(Y?JSTu}ZEOQE* ziuH%1uh)j<03FavjxE3jLH&7cSUE5R+vV5_Y!omChug48z!Y3Tj8+HhIfN=f_< z6>ZpM&;_)}F*be=_<;<&R%{RSwu^1pArJuU>|3!@APA(jVV7Yvy=vdu_j@pxNOPdD zuJ}{X1KgBjk@#B>0aDGW-hO00#v_4|W9uA!15qH)g2e7&pIAOHTI*X;7)_}YEe4FT zYM;$mFpkKIjbYhcri+-qEF0Tt^$HO|@MzM}fVPG(-%lx6PKwh_+ zO=8!6sJkbxyMpQxY!&PJQyBP)>K^=1_d;H0p+aJzc8Yb;6b2Ge-HspX4#?{&QJsgq zVx6D8+)h;2@I&1RdEF&cXYHU^=S*SXv&vrB_nIH-R>$d z#>stiB)VZ8jg!%83aYI`wX0C=MpV1~U(gwHng9J(tvrfy_Wo3+!T8t_h5k#cj_8#3 zOTV$|XL>8Vfq3r!ro8H>@{e+E{F@{w+QVj%@Tr0vHDv}k21>v{jE+?zI2OSv2+l#U z7QvMWZbWbgf(H;hhTu5_uOWC3LS^hVgc{gKKzb8~kx&^yGq9Y|fN5bQXE>}qf^~-Q z6xIoqjUfCJ^9Fx1a6BC5;XZJmRADw?mY_3)-hj_k!!3ailY@7HwFa;p$uz~40VTOF z(+YP4g-kcRCz!?b!`+a~o?siZAMS(7!Qe2n2=5GeRzjYekf$ej!dwqy5?LFL9cJ!> z6jd0B;t{1U#$|oN!!dsrpyeQ&dxBI}1BAH{4n&j^)UQeer=Tb{1x2r8n4NMrS}o?K z97bD-1t~XRbFet&XjmSg>;uSJ0WAf1DG#A#0J1g%3{W<}=U_7BnY1}rCFD7WWX?g- zuEFvjklvu&0^xDxZxEhUR-yL=Uz9EBd2;*xS$s&bV_QO)1S6V^>IJBVWdYd3rXwCH zDvv{OI)vUZHjt2xk#HQMkaTh!%FuWY1RT}V^bttfK;WSIh&}<8r^E3CFux?rud#4d zH^vei!18!R zR{^^j&T!Z74C#g-8bS+@1EB+gLEs&eY&8YJ%@B44$03YEFap&kBbW<5K_~?{D*$N} zBKgBX1Z^>+22tt|+>c-bf_D+m15^eWS*BrRnTyI6sO*o*L8zRD%0g7GK;_}6T!YGW zsJtJQ8<!DnCGFfOo}@(EvUkm3LuK7mjoxiUlhBqjC@`r=hYCl`BxW2EqLZ-lgQw zNXSLdAHg&PD-f(fa6f`~5d?I^Pe(H84)|W|HnxDKN$&yA8tL>bc-ELipHHu)FQc!f zZ=i3XM=@qH7$6i3gwZ$*j_nQXDb|EBac4Xd&%g`tt@vA9N*h6Qr1zm8p}_9%~1$%*1fJ8}-Ohgq! z^NOU|R53_gSQ0P(r5s)$6G;jLa8g9YGE#;}f;FIVXrDq;rzK6OUL!C4zj>V6h~( z-PKzCmK<_PPFA+8qpJKuK|#r{6`?tKBDs!VE5i#i#gcqvxghViT)(Y|&ynScekBKs zq(Vtfp{&C;LE?hUoU9^=pyTRT2@C|n4mubwfo_#A=x|uzj1@^l9js<*(xf0-R3wuK z^4bWIf`Y6fLDsKLf^!5}1!6dz&^dxd=|x#tf^@|$QZzVO zy4p*WCn!cGX}dUiLo|7^ob;T$9GSutwneUX(%%V>z~|?X zFk6%nP#`WS$rl$%VKB@VX9SD#L|FovhzD9b(Opy^g0loU+q6UPObwSRN|vuQQ3ilv zs3;$XqnILDOlB`QzM_y~p$Iua#|H6{xZYAYTr#Kzgcl5g>k<*=tWavaq$Exxqi~3} zizL}XBoY|JD3PZVWC1!UAKfw7S!%P|m+0)(8Oim!saymWyu7X-o> zP(a42pC+0Lu^s>hFjR|BK8p16fYz>!5`w}S$xjui*bEKvX%DW{BuS}oOKorDJQb0_ zhqO0XlqqQ2FW}sh5@Jx7p&!C1Ba0RdZkvVZqP)Bx2MdlNvQ=KD?4UNa;2an~rEoiG zYY;7##T6A6iX}2dD&_p-e2EI7`-zLPvfF*br-S{#FN2)s1Tyr+mlTTRLye|83OXT- z@*qk)NEA(e83@kV4;4Osywp@F@(k39>^9}9fkioa*t=D>I#t( znMg`@m&DzEziJd}{>2)m0+uL)Y!Wb7kRu~wLPvCDR8eZGrGUcRDH~xgpfmkO4(SAn zZ9G7s0PX+;2rMDHP7)QCcAF4XLGE>}isfswH8r4G_AZbLGDR^3?d0xlOXG({)4pO_ zCpj!9BSZ8-7t-X9ryAzikdUnX^(E+F6 z=h(*g?tlx9@y`hy;uTV1Q=yIuvaVzdRiu($rm#MG7YvpN3V&7PO2`%coERc)nF`tz z7}|6x(%RgB$@{);48@itH58OG`%+V?d-cL~w0m9c?pM z(6*v+0j37%B$JZ1oiRg6NdqtxFfA=Mplhp9h$>*T7PYjH3T-g9 z&EVpgx;mYUVd@MBw2H{0Qbi3QzXAZy=hNYcG08JC#CydB@W`(ek)OY@&V5Qexb9kW zo%4uQ8tcBQJ$w3fz{^RaKhp-~4Ue2N)nrrGCv&e|x_RK%-18nBGkmg&#OGthj9~}w z4c44=m^C=Y?kQh=>T|}+hfmG+FKv4IIwK`gb=rZ|b8P#iJFXHr8h^U%E9)nAdh~i| z|MeONXZl(jjnfVi>2veW{`8LT`|W<6H*s2TQOJxCBfnhWk|1uB4;QuQ9C6^f`$y? z0Mx<+m|!NjyiF@F2T)`qCYwfzWB_Q}QYaB41wpQrWWgFr(pKwG3aXdOpaTpuVlffb zNd7dt$33{AX z#W`&?H~|3Gun8Q;G);h}3C3c>noC-pv@|gs@?L|(ON~9wM5vN77a$oNAeY5v<5WSb z6Jk4lvQzwYDsa)4N#(ZUpr&K?x&j!hu>#g==*3Dr&t7rk@i9t(dq;z zTw9IB!lBKm(@wC%H0T{lEG|unTuKbmWt8*?j8650a;er)gTAJ%PXZ&@Mji30L!VJ6 zNn8?GLYX|Asjki?7pIkCJ6oJdBbOeHL>!?$jMPUW1PRknJ`85l|Q|_pak_! zZTAN9eJ>iKok$_vRw>-LqI9W9=7s^6KUQ+vQeSS6SOQahbf9qNa-k($bjcv)N<{E< zHb|7=41fU!bUJJSfI0@0dCr70&%?`^06-rDY?Pu$3erV+N<25hjqr4aj%kho6;u%@ zf#Kf2O2DR|?L{ixT9>uUthUbiGTy zzFPtA4?kD=55F*^O#hdkdQi)h=zvbX$ls3iNrQ=m!tZA+>Et)h5@4>D3SkK71xw)| z21G+V9Kula?JWTI(3`#ic@O|#MccERTn;G`|H;Z=#Fc<@zfhP9=E3|g9A=4`Fjqvn zQLA`ZOJ<+aA2LtswShi@Of#TOGRQ^dnpqu4N<%zE+dnsuPL2VH1iFwO1bOm7A<|I- zdnACE2uY8El7vvM7?8PbCe*=2+!DwwMpm_3BLh}YR;%t{l>G{kO@%+${Hsi7*u!i{ z5kYww@;;C>0p!SqZ)Z5_#gI>g#(a)=r-al=~ z|9|}xFZ3H%90x>IH#MfR{iv`}AJi}wUQ^}wji~bbgku;_g-~WP9MoyJ0Rs?`Otu3P zqhnQ`I7YAWBYX%w1&RitOv6A8eKB4E2s4Ft^iB=k58jS=8N3Hi(@YokoftIv(y6yK zRXSBf6}^F|qOGo>;TVo{T%kFxk8DQOsrRt2Ko+_Z?S^3tXu@D*5v@0!$-#Ta@i>GQ zi70W{i2`XhOb=z^0-h$JP7+xhRxeRTzPKQRXF?c}6gH>hB%WtRn3DB0j(&T6d``Z| zDNZKHFXYAs1rR2BYCKoMmG8+X2rs^C5=7kyk2aL3tpAT#rbeic^(q{CR7`9yo(*9| zp(X`EIfdCG2{$+{gc}kU-6hnW@8#s`>FMd@72xT?vmz|09vOAmBl#(VsKU$@M;K!O zS{0@N9Rg$HRTu`2-#*@1!*pgsRqEA1{zawytqb=5(OBlSx{vGH+{)PPW6aq7*3WX9 zoOGnYc~j&?p{&o>JBP-`pH(^eb^Zvgk~MW^=J~F7*WI@A51AURCRB15?|CbRHQ=WG z8O@|giTxJ%e$o@-hYS67nKveH{J`J&aNzEe?=2^uC3cgQK7LbPme|K-&3W||*T!7) zH|=5`a9`OPuQ~b1>hy%H;deq?Mn*MU&ontA9olvCAiZTvYieY@S3FA74@mbqA_`qi z*Ue0L{&Crfz%%{gGh8ZL&UgV0&D?v#ovZ!AUWO<1csV!c-3blN&n&kd>3LXn!4d9= z<0l3;aoh;m1uJsBnWH)~Ne}6E6_PlAR z*Nz=!i@Nq2zT}gI*G1a)0e!bTzbhU?dnfKWU`Cgskxz|ovJOQrFkErkvU?}X827;& z=kK;DozySp3v>LeSs(4@eegH#RXK4`7;WgAd3xK{T}w8fBJ9dfb^m;LiqFX=^*I%O z%qd=+A*zvkU2p7bTpMt>%+RuobCdlgVjP!YtUPv#H!IpK`gUGf;jY!Mxf5Gv7pL7E zKmCko@65>>HSf4V(`PT}8CJa3__F_2 z7{*@0Fm_QPjBU_b&mMoa>!MreNVDPRFjn#(2^JQF8MWvQ6zelY+_;=9@+%e!fsDs@ z{$a zM~*0q*KD8NfVd&u?l^KAsF-A1-P-|dHgCmmC(L$vuM6137 zmnFGIU7yXW_&&m9@92*be!v@|Ct0mUhw)-bC=vYg{6G&OQ3l7}mFMp5?%ezuj4uK2_At$V3I-zj3!_ZR0x57e=h|7Mz*Y@ zc*na^V6UC%T6t-~;TIpfTnvszb=~8xM?dkesc{{xwL&`0+;;jiaweQ`Z(^!ulX7+O|U0}RY^OMmA z*_)W0+=VMGM_g~5S#w9aq-lV`nuzp;ugms#8WwgcYE$sXW}j*KfmffFJ=Uw4mz}L_ z`w^ejq($4A)obm6XZ6x$=Y^+w-1mFlo68}A>r=EsfT6e#n-}|B?k28g7Cojz%F}m84_|W8bR%pC2Fsp}p#J(=-O#R$I1JCPB z=8XzO<+gd@IS~$2Txh@YONgkb9qpz$>5OTBfWIbN|PDT zWvZ8M%5k~gS>@YQnce+CF7dZI5q(?ESEqkHaV#~I7rVoT^U$9-BeB!8H9z7R?OVh5 zoqVd+i#akSI-$zep26Q1aV19hk!{3Ym~sBp|uOoB~P%9dpcxQk2j%bJbkHM3M*%GBR*5>^q%7(BMNMdUY5{$Y5oxL8n6x z97Sj|mF1@p9gNOEf?@jGM#D)dU(fNPFIbP8ac_27*A+bRGN0X7orunDOr3DLstFs! zfg+F&fh||zSzEOP zx;7btP!x+-h+<&`49W^o%rXED-#NtMyG`_oy*Z|+C8OsGBnl(Te7^ijj}lO!|j2j{CkS= zsl^la*la2hCIm0;dFtb{x;_cF=HVg1E~)RXue(^qFZi-#2It|6oF^+6JMKN|ps6mJ zIOoRu#hXMbJtD1HO)ADqSM~BZox*cG<6I>zgzCf zW~XN#QGPX2eL_sWIw#t<%r0!cf>%{-p+U@J{@}Tg5I-|gY?Z8K0Dqq9k*}|`!mPJ zf9=DM_f`%I-Nj1lE=u!{-VpdQy0Lyx$yK(Sa=uXo&-A`}{H;f|pC5JCT$?fbd#tW= z**=EZkoz+NY;qc=O`376`szHhb!sW|n-{Mel|5W_fYYu)xxjel+BdqTf9ejm+%e|N zfEC?&E^}`_80dQi3{CHT?(~>r+x0)GOR5jl`L4(P2Yk<&H}k&c3eC-)u}YU4e2FS1 z3&!uJ*7&WPP5n_RqkkfP6P|<{0VB4%D?uisd>%sKQ5&NF+;RV}qW7ZOyp4BmgiW)9<^L*rcX$x~A$n^nMsG*~MCEKM_*PCPDyusVzqP_8g8#UCR%w>3)vfJOvvh5w zw9h*h$655hChGsKqdOdH%~|6bQfR>*x1McYJNU-wlAcl6MrYZ;eG8mCvA7W zsJ(bXe){%A{6sXD6FcYD5dZs$yVm!aYjn>T8?|Ov@tg5yUv|Y_-QPQj%{W>ecE34J z=T^+>sSlr254cou;PLb~OqY?gXH)Dg%?m&O`Q>5p9A~u;towz#^`jR|%wgXBqH6p5*ly#PfBKs2qJ>==*&nn{($6wqRoOmF;>jqQ?(A z#>6`uXdfX218@k=du-$>qt%k)uxbOnADW zaC+Vv@5qaPmh4-lKP26*Y4JQeH|Ai2^kcpz`KDFPDn}f5oe8Rc^zmi+mIq5#$lSL_ z9~x+(Z9PcEr`LpmNufcVcGuT$h{`&;DDZnliCM)$9U}8-pmu+QqYKT=&IUbmc(&_Z z*h$BWSNRo@*7jkRsY%ZhnwH(3v*36a@t#T>8B^=kAhUh*st(x1Z{0Y+cWmt-!RCTm z&a!>0x;JZ!zmDVQZTfbn=g|ok$1?XUFdnU)f%`hG?>lMxL$gO)HXIjjE{vCK8WTDL-2SphEw5tNN!MhhBvNT|eXI?YAWS)=RdSP9sJ?E`e4#$a4bINvii&$f~aDyXbXMkY!&^Hm>Q8SzB@%gW?gNGUt zuFPlggA7h@j_(mQ(?||)OxMt-!t41qqKb_|FiR)E6W4*&lnxPHMrpY^+jto zpDz4*j`2F;vFeBY%eJIe&t6s*m!NXcISdscC+TxH{FR3Y7X*QZ5w;~2O$(OyE@@MGh4~-_Y2Oe7PMH4(~tE?qN6>ix+ zflOW%t^-M0$Ym$~V<|$%A6F@ZKj)bNbv;y-T_A)&2#qUzlF)dwFb9S@Dsf>66cWUyseu8+^oTa@D&2 zpDG1GFN$Ig)Og*MW*gIU-vxY+TK(y+4}W3rGQ+$Py-HH|Cb)XV9MIb0+i&2}x9&Re zv}ZHc2Q?>+xgULNGhJ)5RnCoakF+F%TYk#Yd}Eu#_f1uIZh9B{p8UWJ(RXx@nBnFYWA#F{aO|7( zNn8Ck_v=3=Y3%}jy{Ai%^?mD?-ebGF_l$a3doAhB*FxztqRKL~eF@VsUX`T>r15|F zXv@+9l1#~uwlv5gOdA!3iD+~jE;l0OhmW_&d!*lfyv6&eEuGs_ySj5;_RMP0{>n!) zZ)-3UTCTb945jLmrtDGE+EpD}Q>8W)=G~ew?`~1JCpH+oOIFW1r%V0mT?55gRe>fA z{f{`eEn!VLx9RWWF_%y9c=F3)=$1TBH=Y|0T^95BZRr1!%i>36E>5Z|Uk+K}b~m!y zuyA#?tvYKvb8hze{cQ7EnTmD`2IGvo>Rt|mbks9zx(XrwQg>24$&9w_!g?C zI^|B2M(;mgp7cH@5Y^hf+NIioDrqzbtO^^GGF3A$hlS@I5|x{zBU#iO(6;df&%uEED?v7cP!H-1rWBFApN! zoiB0{x(QsJ+}zzVoYI9nk&`Q5=q|{};CYI?i61Uo!U{4T#WF5bt50 z0ab{AF}AXjrAmQVzT2dAXtGQEyy`TTrCDXZ+li?QCa&`51g_zByZfi6Xn*qY ziWS!YhrBGv_Bp?HKjX^ebD2W@XDR?vb(xQ!DPv~+|Ln5ibK^DHw| zcWzua=2^dLmu@OO@st5;)^v`%7&#<$hvAlJ_jS1&_gzi0T^n{>CvN-r&5jeEA6&wD zIID9{>(^Yk4K{;H{R7!A(rwQqyNzsVA1y=wvU@e{EYjgtJZ( z%H3yPt`x~VPt4@0&Ae#yE;J;~Y0Akf%{${uLZcQEPj7G?h^-QxjRDK2-(5W2iuI+X zq|y41=1kv7!@qrcFg?I^!Qjw6R%`GjtHYj;&QJE=W8L&#U(eg<%duP6UhciHgppCP z{mQN(Tg(nCS(H|8nm@rO<+IBDxcdj5?bJw(C8}6Mh$=>U>s^fc&}#si@|f<*uEU8@TJbw9w#{Q!si0bFydn?Ff3 zjhxqBEm&2h8RfR~&DK6~bZ)^>TaS}FESeekw^R}VVVidJX8J(2&mOG>ToyU?9?y)xDmWVjbEs}X8AUGSgQ z^58a0?NUm~(r~*cYI|!qgZEDNZTkGcAxYCTD#3Q~5XoKbF5ANUUu|p*nlk)a>88?A zhS&TyPU!b^Y|IFQH?=N(A5QM-w9d89p>2NO_!sJFz8g2KpXxRA{DKO{_t6Pc%-pRS zybCgh#qFH0v9`0th!gL2(neK(NNqmbYu|+Fqj&E&lUb$e+ipE+W9wx#+q;LynX-*j z*BMzXUzzz*U^?KQZTN!JG54+dT`-IA>veETVmC`#^SL3(E|)AG6!z2T89KPW1>D=c z2CquJv0tZtkKx7M5l_5pHJ(|7@7CWQTo&^1K!aq+UC9&6JNrWC9BTT*DDlSd>X%XB z#PZb>@4QT2wEoMj4Vm{3%&IJHyxbV^B;0N}$9CEB@~n!-_O$oLl>6@xyWXGC}=6>_HpF&OPev*FUEDm^$lb6ZZC{} zH*>@8(3-s2=kHz~GokJBsuAvo&pNn&YTp1m+>HLkrv^VXoVwt=$w50h zF{1B1Uw(vl&SI<^kwk5Ca3>;SYNBc)Muq>EJ|Bha7Oq;jSlf1@RKhit&qteGe}&Di z7ZFQDD{OXwfA5~@U&xmcm5WH@x%A3eMCEj%a!T7EIn!X8NOWsehhw^~f3>$}h=o$v zvz&Z^q(oRKbE{1Kr5oxtQ2RG6Lxc8503TiPvTu!;NO^NSZR8ZyNEQ`ijC z)t|dtRJ>ozKnmNQt>>e>-sN5BRz8B zojXPO!YRJz79>Q+?5jvLuPxT%n+<6SU~la9dBw>k{SMTQnU^>)Av!E%f8eosgOb@5 zVYy#R79H4=pFiMOFDXZDNbD(Il`e;<($zqB2{ZobjqA5ZLWPrN4LsF19O0%94?%Dh4CkA|}I9=CNJ~^r~TI1`)J(Gj~XWo+y zeX}d?#$wCCsEPqw}|_<^I<6yJuQj)*dTR%~CboHgZsc2A>{6P(s9*E#oRpc`b*=+kQX*B|tjn+VRQq&Dtd#o9 zXZXCQ&R=xnut?pc=_V|_?}DdR<2(0gTCCi7bI!gSS4C$h4PR|uoS88;K%;6?12_GM z+He(zMzTGp{qH< zv9*O2me9rIqDS;))36RMK>7}v^KJDwQ{!i2cgDuYZs>h#f2w5mn5AL>0YnYdWu7iT+L}!2idl^Mw3MG@b;H&vW%~cPG<%cM5eQQKIZW zVyQJ@Nm*+AyBk)@y1%;IS!t}cd$88HF5H)2IJ4e=8kRFXR~D~%X(=02jr`nLmL1`k zdZ^)%;EzGu{4yPqn|0!B=seQ^LxUN{r$EW=;)7JLL~Zv{st>$1 zZOvsVk!W327ov9d`TOpbr}kN<@%yBOzUk9_6n}(?OprAtwK9I=nQ4(z4;)<9@0@^B zV0+l$XRpw_o;aOE$?wlW-zDocON)t}pxjMm9`h zYfutPb`z!pl~akzNk8PVm4vTC9?Sc!w%CYpDv1q>jdRJM{&dmb$YNuE$YSIEZWhaW zJf^4G{lj->cdHyo^IcF^YbLILvFzk~-rh5e`zybFO3d#})cVw! zq1A(ryBl-k6O|l#Rt0N+-Vrz9f9TN{?A^Yo|8Fw!uJ8`!)_hwp)$q#zW2+{ zJq8LFl$zx?%&%MQ^J!T5%mI^&m*tgAP z?#10=^(f=zhj;si3j11V3~}~O9JF}gD&{zivAR12%e79-y{g`QZpERqrDj(i_ zuj@eNJN;y{&6Nb#H^iEV_q@Ib?mXeKmQ3sNLDaqYY0HYR)gNw4h6-}UgI89bSgyRr zd)LduC$3g)mYgzvw|yjLQt{bvtbM%qrsV5K)q2kvGFsYI>G5o*=hb&zowe=W?{|r} zG5c_IP4so!?HgC#n7L_r;NoLvItN7E9re+EZk<*pabcH?A8|)m`hLzh7sDfF>-%n5 zcQe>$R_wqlwdW7@evorJ@xZy;#Qv`*A4h#w+t)AV*#eW!UM{=O^kFzRsnx`~UvE;j zF}hSg)ZIjB=XH-87g8tPmW>J5h8xaxqKfv1!siN(SL_CN%{pm#80|ieKkq*OY)Du5 zEe+3==dSQu8ifAu-2MM@quNRv+z=c8V3(%dSe94zPp{F=K2(q^b?|XCG8($*K6@mKFT6Kv zmZajuW8VWyD_g#E1Fia>P<^yN`A@SW?rY*|GH!Pl_#&_)Ci(H}*J@u+D%Tif zo@A~!+Hoe68xdPNTYRg_s)bE4j_U{XohMnQS9bHm{51ae+MREe)V_Cdz1mWEde?!9 z8@_w5nci48Tq}3k;==UO#vZQQA$*#Atd2Xd%kB#rTm6&=h;C*b z;a8X2viF6Snk>J&c>T2+mz>*{n4nDfv2~*|gd?J-uq~CHs=5=z*m69{|M2RnK#d!- zR_xIKad+ux-}=AYUEut|*(1O1P3-`lP6Y4YwY&UA_Rk*%{MA=vM`ujx9KU+> z>IUcW)AcRV9v}YnHZs1H_;m0YJ)m4kr|SL9C6Nu|x;a=~H=8=XurX7$%Hv znBu@-@rrmc=fIokNxK&&&^3lG_vxHBB|A;9qxyi$ON)JF`ZR2k=K8B~yIyZUKKDMa zy1PpFeBnC#>vpSd?aZEA`RUP$p!179uPEd6bnC*;uggEJJNbm*N%)=zHaC~=zH9VV zcCCtIJ;0rJLzbUB>h^+VHcoFF*OU#Eo!MSffN#_UNBl2XT0LlZ$QLLL3%VeB{^*Ny zZ53@0QHA$MXY>cP|BDX@i>=tO5A9zOpy_~3o_)VRw)4*WCiPw&G~%Vlhyh)aYAXLA zD)%j^+)Y&O_-A?<9Un*alHhwf1$l&eIq`zMym$_T9o0+oAA8BA{%kKdNUz9uS9B^{`%U zIOK?=@9Wrr1@T@BgNn`+->e2tO_eY$Nrm%sawIzd$4R}g@!@+!|0m1l^`lSJi4dZ&)oE>Ss~sH|8r^nc=D!M*lg zLI1|XUb9xI&Qv*`TYBU{$o$4fKkYf>ZCc`({YM_!W)fFC!!m@sOa|w;`s^6zv|`Pe zrXh>d^ezROZ+fmbWBb?90)NY6(X)2SKHS;5_oEGO@qwEKm%APJUOr=3+K=1WgcPk#T``*YP(!MJJpvhvwj3EyvX?MC~Vi%g$F%OcZl4^jCWELwM! zj`vC0>w7XIC#lF!_#j{ar* z;@;B~<{L9THsdC9hZDD3RF|X;BfE%0y(2*_DxZB8$Ia2jMi5cNzgn*#t>^};3Butg zyrr^WA3AFooY}$%N`oU2D*U-cgcYNs}V?1vE zldF06`bssi;k2>Q_`~Pz?$Arc(gdlpyw(e%V_fRAlqHZ2r#v^6FJz9DB@4fb0rNwubl#FS=&%dBeDUjaA6hOnZ z!i<ybq>6Bg<1OV^K?H zSr6q}#wIS+zCV=#Kh2pw%^CKQ64CNloO00mrj!DZ9LwRC3}}(-z)I!#caBg5<*QBt z^)KnOOYBY@U|PXia^TR8y;ZEk^}_iYoWK)wWsi6!ya5x?VbMc6>^!#iTy%$lyY!#H zL|J8K(?tiV=wdxB$`Iw7m@TLR{p7+TN^}sY4yX}aW#^1w3VO1J3KjeWQiw@WIf477 zJ(XGS6g<1=g&%k}3bb{ax%KngoWwsCfj=V=L+X-*(9@-n@(OIzp-K&BU(K^S`7-(? zZ9GSmKp&*N%WMxi3YYpQ7$}2;9UQ#Jwd36pRYBz{7?=$J zLXI3u`cgvWXeVIt07mU29x`wYwjhu1#KDd<(27Vi?=G3>?}?yN30mX*E-=VeOX~gc z1CwQmNLO;-AfsW_!)7$Vj6xja$^oJJ6(fMMWCw*P2o}r6#$Mti1KFD+hS}&EYKS53 zP&gkfh3Fw27`l#(fm9YE0V|^FJq$t;?SY&3BLMte<@LlMHl3_ljxef0i{$Aq>%mrs zjlg2Y8kVq&)vEsB{RKB=C}rH`8-mNS3N6QJVYqkK{_p{}-BPey@}Q;~%T}}2tw<*f zNJ0WLyLw>UEGwSPS%oy^L0v#RMDVZC?hPoRWk7)A0eDpNkqw$zgff-pZ{QT~&;C}Q zQl7{RBaTeOoGa?g!G0K~Tsn3|Jyk_o$WT%?$?Elk-3mLW3r~^bB2*W9OHNXlMG+#> zP!YBJCmKnq5iU-?=s~|i);}4R!69t1?d2T*WX+(5rfz63sRAk!Yu@gZr$PTGw8=%> z*gBvp+}O5+p@W{LfvoDe!(|OZlnL4h6B<3l6E~20VWhp*O;v0P zVQ(p+FF@qTMc)cYt^2zu#$0E8~)um4}?#@iIK?}Ot#7lZN@d}-#ehgl(Lf>(Q5hU zd(>H|>MAIkdUGS4f2DQHc#IA z&*zOEjgG9#?$7x!XfQyE{wAHZs{vE=f85&J%l^h3NBO%)Gvl949-o6xd~@wjrfEat zKBIrp9d8_pYQZI7n>^YV#WqvPF+`^{I;%Ymv?OxfIUu!m$ih9G%jUn!a4a3@27dV! zm%xJ>3Tfb5iNj2jJ|bRN&}B=KTCXb<-5Eek4S}03e*1L2R4Fg4UiYLP(j$k%h#iq+ zk^wFglNik(ce>{EReVM+W>rLU-d3;HYg@BgPk48~?l7?Z;0(!76E3R}rN_C1*S52? zdOAjMrZhGy{)QWeX$>2tCpFTSE+_v*c0Ziuw>_YOn*17OPgy)!mme1Mt z%)KB~Vx)Qv8cX`LH_P<^&Ehz1vIK8X2V zk*VT^9@G;}bDws-;8r_osPN^#%i@N4L6Ek}n)Cz}7#xdBPVb9MOOclKVN*2)+9{f@ zr4u{zrYU+_!>{Q+Wi@L~KgfINtv!PkoGsr+-NdIwYP&X%KMJN9*`2FJ;H!5@wNL|B zO_C;eDAtcC7oql()|%Wrn$W!66Nbpd+oCS_*)knfytZ8SXi9ENVe(9S6Re!sD_egW zs$k*FlsB8hJqpG*hpMw-BkT^?+TgzK&3Dl#=LD#l#66Mo^PJjc^$uezGi!1!Ki7Zg z`atL}1N`8~JmG_+xhiU9yL_splVY><<{M`k zX9GiP6IxpnXBJjcCLuQqTaN$S+5gwpfP;}<*22iq&dJWynNG#r(Zs;m!q$vV#lXqx z|8&8wy1}*oxnK-Er^ShLKuRio1o_T#KoArJI*OV8`hbkV00~Gkfsy$@FFW<@^{+c# zw>ov*hPU4v&zsvx!R79GpZ~HEzHUE%e)RtSqrv_OnEzz3oNb);2AvT=FaUo@zn*_K z7;`>9;hvt~#D1JZQq72dcR%Fkw8#|X=aF`YlzOqs5d|rzP(^XQLIIlTMDWCcP{CgX z48%MV8U^EVo|tI&SS&oq1b`s~n7vm{8p+95G=l4Q5Pbhug#CqPTTTQBRv|!!VUxra zZ2wO3HQB}97vjD4PIxidc|RBV?I1ego@>@1M5bpdBtUmen7m~GjDb;7OaL~&L9)&` zg)*)m`;aI5W_NqUErVaCv<0tadh5Gq|SF0 z*O#3*ye*c$=61_p2|9FF>YqPN3T&j`&qHvqc+q~Px|S`gk8)@8GXvOeTkTpWzE#ec z&Z|D=cmG~+YuB#->W@nUaV~ZM|I>*wh&k;dWQ`37uJ8e%h4Vruv}R(B4GcwE!e_9e zb=W;9h%1cLzA-?Cd`t+ZNKj7!C_sM!(CeX-hH>9=WNf!*{i*}d%WxTGlkzHH3(-38 z9gvpOp})K|g+|iOijVQ7HqehRMFlG{m6$OG=*oh|L6UX_2UH5A^ zw^{X@cAp*JF}^ndqws6+l>J3rkL!3av0bRVWQ{22GZ>)gdPX7K3(b_{3hr}MMtJ5u z`Gg?RpyjY}ro&|#n2uYVIIRQ75pJiBlC1;K&rd3X&NVm%?&TCo!8a)#gk>cwhtVlwYoQqDA^;oM2Z2!d^t zEr4&%jT=}+H^z(qJd4ZAh`x9g2$;nQFa`l1?_6{2&A<{<2K7nCm7i{5HC~Q*H(i!Xl!$RiNi6%w3@3?LA7xkHu`t z7qA?ONuXSgN+=&hr7YJ=FIyv25CJZWbjXKe04*tpf+2(==iVnvPxhy(_mMJ^yD+8pBfvmzD)j9M!;d(!#{ z5ZE_Z7;KD+qxb+$a z+vM=zb1d0&gGN?iVWBkW$f*{-0JHj^ zjuXf84l%x{D_HbyfUKBNSG&HSb(!K4YCP7|=NS7C#PhU&(E<0V7~6q%lEj`>iul)J zMVTgeMOr83H;~2f{uzrS~wxf>A@L?Il~BpIsucK%o7p_5KuI1Xq3b?U z0wqA^Tq#0(Cqsj~~`%bQIyebl{be03FX5%PazEpZ<=_ zIAo5QMIr#Rcuix#qMW<;%MyHQS%fWPHr$4WhDfB}Ocjx9*~BKM!3?$V2L;;{Sanr& z7D=*;@Bz}Ehsq(u8jO>@XC^r5iW+#dFs2{S<1#IXrpEcso1x#bZ;5ruW!x`EcQVTiBTTA)!>F5QA% z7#20>Ytnvf$j|5!(AnBdn2|dW!iNDX!e%OfhLg2+7}l!z0;h{ITv%VloIEZl#Nrf! zBfpZA?QWf{Mn(ydN-;`nRa4L87*wjE)-`9~&75>KX#nTT_;!5H=d1wdsKp9nyc-=JS-3ofc1T}F90JRYMp)U!F3`w@tSkZsrDlh_NCQEB7qn1xH)or4U zSg(s1H1pMI^ija`XoQWv zgZ4*E_i!W`fxx3dz;yf-w~<6$aCp~hTNrE$>w&LPgw5rxzH3^fRSTm8{;f_D+<@l8 zhPi0)nCxq=EQIvAfbkqx_xFqNH2+v0UH$P(cwnN% z2s^NB@&T#n1XvVR35KoJb(~YldUx1&l<7DSHdps{4!buizQ}QjB){QNWmeFP7D68e zhulzS7->s%vHT>SZu%fyzTD(8_G4NofVU$sVrX?(*c$+!O)#oCNUj{=L`_QiDa8Ub zOAbiU`Yz#768qJV9$`oGMMf-7MtA6YdWA+|^&TSStS;derBmx8YymTnyzIa8`SH%l zS;E5r+8Ful3qdoCeJmd^P=8r1I!JwP{r%LR*5P-_3Abe9Vi(-bAp4-Ck1fQ;z-A-B zL9qXZ#e-K%s<;NvVYnwo8BEzi6Ji@1O7Up`TaE5NurxvpkRmkp>ug=3hN8hNktGI9 zf>j?;`CIMztFwN?inMKTSiz=cIL`CG6M z4~r&f4&#bJ6s5x?Ld?o2RCHq*O<{r|$0qjVGE#nPYoy|Zz6dLWfRaVf)xsc}8qEgF zWD=xXsss@QN(sbfZXRmfkyX%xhyXNQO)TLLb@nu~25w%*2KqyQVuT|gAjGZ!;}g_} zX8;8z0JDr47ymJ@`GfUx64SD2IYbgHa%ShY@Nxg;i`c zT^WuQ&I+QW-ImHBw4Fem9)*Y7$sqW7yz{5G0E#4#I(-2bhHu(rco}hIzSQcD^X};K? z38yktW>5+j-7aCPFnNG@yFaj}3thgNd?2=a0eL?xL-qy9zo;ehn&6RO@H@u^$MHb* zVr5)(`S>%H(P3nXr*`)MqB1UC%DLHy)(p%laKQivx#pBB0y3a7)^zltp}tbiZKh~d z5%(Ztvrf7YRiS2pAoFNyBUpm3KDE902r`CXLYJ|tf^Il?Qw;Au`tvGgFSz^DiY#84P3U&XplDNHRncH_tHVN zf#)}kARql}@=d_nDl~4XR`3j%TkZ?(D3z}UL;2T7(f1~t&$0=R8+{^l_WdX^7d6x92Wn?*! z5Drz@sWbAc&}j`=z2JzEX_gJ3F_r9fgSz$WOpF5rpk`@fc^&66PJm3InF!QM`fDMz zVUGv`3qLs>W*Cn2lfj$<)Zy)OE0c1;ZO`3xjgJBr2e=?X_YxHjrT@wzIN7NE`2!(j z4%5swK?Kzg1iON12vx5YR6(EyGL*T@h*cY#t6u}A1;R*rcBMJ03|hlYf%p?x`;kmSo8YG1U3>JuB%gAtFU3Cds{qN$4FsFsuY5rcA z6ZYR6{ApUhAd(38(jC~NOUWP|?b^ZT-3}f6bnrhFQvk&Cf3Vs~w{97-1NQfJ`#dn{ z`f*nFAMkiT{`M|i`{R9e*<2KTS%v|-(|q8V*TiBi&x+&cE(;=Qj~tV8z1=E&`38PC z+q_@v2_Tsg`z?p&;&Rhjc7UW=&8JXLY5CH9rV~j>7Z*U^9QTW=Sw{4P0tIL%uZr%! zMFf1k{lC-Co$&(5eIo58|GQ-)^9B%VzF6wDy2yjPT3o2vHyC9n}_Yx2I$F z3Z(URO63;NP$y`Ys}1Pjn|Sv;=n>CPeyQeFuVNN)8x&bFQJ*n(0WjZ<>B}72yW#>e zn?dC0k^{4X#YV>MGZ_4-KjsvsbQjH!E&+D8eWXZ6;n2I3l%4|KR8MP@Kms)h5@%%TPQW{6F1-I{NKjqA4 z#y|5F7sM~aE)?#(7AFsQT7WC(SZi>;%5Yp;8oklGyi~aM1L{OJ=2bef)uql(7I4JW zz>k6CT+>YuGD)If0}PZ$V~;JqHG(TFF5^a`um!*L%r)aO+8zHSyGMsNk7yX&H$@OC z@L@NqX%p6Uh7~U}x6&>FhJ^!Y2Vz4=GKJT#YpyNsAF&RxqQkL(5oGKhX)Yrn;ngG( z#4-@!lt@gNl@-#skPj|rP-ftBbR^2OO91f54oqa9BRGKEgpfM`9Dp1Qsn0|R!ki!H zWtk7`ZoLQjcudA4pYEm`P|t_~OSzLzO4Bx=Fcm(+fIQfb&AOoaDcokWIqWoar zfpQgUPrw1QFJT{w9%vF`w1zwA2vfzl6|;}$u2f^PH8Phgq9Ao+R0#ui@W2D}s^1Pj zxQVgTkHCOH!eFdVF*FA_=*Si*lgpWW5WepV1Bk!)UQRP~i~!SRM8PtI0&|WHX(Yfe z+oyTLc4B5qj5d5RfHhfZ>Z700aJ>e16>|lRLvD+I15UTtH`X`r&lHbQZ=c5m2EVI( zcRx)8EGCb36lB}Q#jsADB`BrGb(R@oHh<%QSmUUJv^IzyC}M=zz}!f>QqTz1}{jn;cOtkumJfB#@Cd|YTv2#n=))q zJ^R2ZAHoDDK%TgM)^oZp(7oK1o4~XV%sp^De3<*R4%GcOLKqQ{5vs=Ud!s%Abs7~a zm1ye*Gv^=5B;#>tC!QqIN}d!mHD5l6Yubb=;?HuE5UP$s1<(Q15X%ygN-#-Ms+Q_L zW+A$9N|o{@$BGGMtui3UGZ%>rDb#gowQ^f(%BhJo%C4vjk#j78!q)WSR028z6;&k) z*+j~Jqcuz^YBGin1)919K}1lINAVf8coS2przq4W8WLvJH6+Y>rRWdn5le3jcI$@TYVlVTthvdkInmIz_3bH2E#R`eQpWj=68=|DtV^j1IDHWs| zNG&8PHEI*gQOis@F~;lfOchvi$P@~as1x2ErKM0qW-tD%3=!e9Ght$>-jR1}~~=je2l$rBHc zq~%;13FOo=N+{GNnx5utY{)3NDkPLcXn;1xmOh_?I?juM=W7^Jtl>0M3tT$tJwln_ zJSCPPNFwMjfrbJsuB0_w z%P;C6hF3y2P>qikjg8-YaW z*XfVm21GOxgetUrJI|qH;9izgEb!*}pjuQLcQ!%Tyg7D!f7%+HX* zArXw$E)o0N*ocH;AE!9EUr2ebzNSSV) zxCzgaC&gTlkVw=mfJ!(@98V!VN1$*O;;Kl6GDZZUOxUt#DFlsJeioks3QPo*w07=y z`%q6NEhlbxM#Yc|42l~7z2~T842T+yq@YcYq934wO_AJe(p(@?B6hD)`bgFy0*Na{ z4Ybe#H3yb3CoTCgIb}AOvC1HzB^M|{NeQ7!MM~;|s9B<8P@u%CXzu8bWjijVF>BbN zghs6>?Gymh(PD}e1)ahWKMtqe#Cg4KOeqy6E&097U~7gdeTk{xsFX-b9lvCSX71Pw{L^{AxKjb-&}i6>d2$KC$e@WL z{Q6lErMm$pEM)2+2dBC0GHs5PP19VhP#Nq<&XX*HA@H%6SXtX)ns|Ryew^{(-Jxk0 z>3nX4d)_8V4gr&DYAiCQD#{=iaw@Gtg$S`EjS|Sr%tV0@gGHgju~`_kVJ(z&VIJ;+ z2r`6vD%@o}nas3S9s6Zvzr2Z=K!4fl;0Zm#$g5G1dNexm_;^f(sd+(#i%n7z8^Crv z1c*X+Qq2WSz_vduRUU(N=E%6lrwm8Tu_Ld*7u3pWto)aJ@j=lNa1kf_6lCRkyIE%- z2?sa`n2BkCbU~YF%hY~ZaE`jWOH&qH=3ptlAFUS zbiP47q#~0D3#1# ztn-mJ$LovhvZuFHCBpr(=o?gG*`D*@NQ&8^vr)ZHCcxN4GST+47_p|y64`{8Gs6Bb zrD7?QOC6bPu|;m_>aVki(7QxF*|AXKm%j>sxAJ%Q_~UPYcprQ^NclO5Qnk(mI=T|f%K?)-B{l7|w3gs~)p$Sr?Tgrw8v7s-i5-1XTE3~WJ<8CV7 z@zQ5f&O%|km>^^t`4}hR;{tF{d&n5&fYIp$@GD0HN`zxT@A0)D`7TTX>%|D>S`dPC zbdUzrpv6#vkk#Vylta)0h&PbRdSipg{-NPePO20Y2ouSBNQM3nv@X>atSI$>hAIGg zRN50m&mrwW;9mh~^Yv#TRwxRhgw=?EZg0h?=mQ%c?F20<>JF^=;1$>Oz`PBX@9lDc z1}tjp*x~yKh6b|u@qw2K^E`n4t60FAi-M6Jk_NJTUw_#9j3FKgP~lwE4EeLlgzH*% z9VVM9FQ!9N{Iy=3?}l@tq(*Er=hu$HM>qFxt z5R{`RLx9A_7eJ4b6`+x%qD|X_ksMLmlgCq$1fZ~ill*}&$4Wd8FadB9Kp@%Vc02SyXT6v!MmrxpqlE=x%=1!Y^SgPQYXW*gZJW0+?L zG4IA`B1A~86ELy$V6_iEas;RZ@XWvm3MVHEiHt`(^U;{ekgxdsqwC8#>olj7l%f}d z$NRN$c)nJUhuQrAJ|dH)-`2Vube{Ix-g^4+)I>XVJ?`LbvN!r53H-8qW5e}AQ0De` zQn=whc(l6A4S(ZS_wHc7s=66tFv2TU)=6&GS&z!8?c149BB%DQ{k77sO_l7E9GtZY z(*TXG2@UNk_Y8US_)4VR7J4tPJ0M;%JtePx-*G=*f-Y^Ga0+S9lFiT_0xv68)SBx_ zVA=qqp1}%W6%k*v?2G9;uYj_@9=LRD$kl&xQ6v!z2TW%!j0DD;!aaBc!%2b*Y#uf9 z&UnIrKngbp^4ez5I4fmW?4*S?D%cmCbhmZiUZP1Nd{ND>1d>Btd1@N?-**#*A9#Vr zJ8%2lG?50*+6yj@D+@MsvtUt-aleBq0!=1B{ira|q|BHQ9e4y=pt@iPAPJ!ws+jf} zE2>x^6yOOUIuT4eoiie9vp+1hqdLL@i;sC~Gzpk~*Fe9Z3lL&H22Y?>^jf~C?4;pC zyp}S^g$6`v%5E(q6iC^gh<=i+@xea7)nSc!+Eh zvwvx0n86U7dR8I{l99MRggvM;dEoTm^W1QAKd|GxJ@b%}C`uC)x)JYueeCey!`;|) zKtoUM7-#}DA*}+2|4eME8`d@Z`IBpS3u6?^M*%)lIwu3U37)-7S{vxrm)XP7gXP2v)#k(dwP39Mkwn2&jOZ59gm%O8@Gf&}3X^af zIU>3%IdPx!%2M#-L3l=J8=03E48ygtK*Lsrm4v3XlAPHTiK$X+mb@~5EX2)An%wPo zB>3$KIWyg-4hcs4MR6dhfUuA*$G zM@xu6eQ=&ppbE%@yu&Jys7x3xZ%HQuIh}}s)R#7a0gQk!!g(m=6`}p)p#ZFa?gk={ z-!&K$WiB`t`Q*MV9WcB~0PF(;)A z-;wBx`-k@Sz5>&HO|ypq6vJ2!lCt<=f}x%DQvQ3!$XcZXj~>}Ou&_OoN{E^4kj;L| z;4ZBJLv0Fon{4Lf(Gr^FU#19~Wdw#7{YBz`Y|RsbKP0qDO-kS2-oqD$dH{Vbs7hF5 zW99fj8)-Os$V$F{HXSM|B`VGm5ckq3;Sk#5OD(SNKJi2~Hg=Og@}BQ!E2u{c8tZ>t z2|Hcy{?Msmd-3i{n4F1#$If zen)p^e#78HC<`Es`7q-Y=Ts#Xh+^I}G#vb#?Xg6-_Kk`NK^z8Cn=bHyF-TNlqA#xO|J3(JEuW{lgAm!u(V1Bo4-3eKM~t! zhDy0oaR#2_cYF>x$0-HrC9!uNh6h}D9y_I=my36c;=P!^a7Y<=P5DL)MC;E_N9=Q@ zkN<%ayn%l3D8GI7WpeQcD4BDh&FeNx$@%trNPhiS%?y9ly{y$w*%CiJ_(|MRT< zaoF*da5~GZx$6yf&~_VW8`0MlIcYiL|+qAZQo2Pd4?=S-X z2Rn=evV39>+ZuS4&?f9JI}wMmi^(0O1eX|6aJW2Xy@u@wOd}$+0;6>BSh-y5I0_jr$yYwgK~(4FK2ImSRx)w38@Lucd0>G4=eA}1+-gj!B| z)xwDo%u-E73Z{~1!~~-m$z&5$3aBO#*JRkjyQ$0BchMIWWR+Qlw%RIjJx?!^3Q|zf zf#5rZiJ1wBBUz8A?;(_9`j;CZMf}PTxDu+BZ*dmp!ng8VyP4=1c?lHOvTXCES_W<1 zWNKw7;zXj51W5ER ze%kNU*D9WlXzC*2%f134EOxE~a*KjC`C{ZOUY$F?t{IURXL0geGv0^J280I$#TREJ z%GP5f{VW^%8m|}rV!!B;JeeEnk{STe4is7!NZQ0?q)vh5D8RtSjcLmvfJOi+jBBjhQHDrIn~WxZmHcq>X-?U7Jh|~b#}_S9L3*h zw{(`5q@}53+-l@=(@CO&>WX?eiab*l>cuH~oR=c@5=4?AdX|t|3%M9N?PD4D5AyU! z7i=inv~Y;RK`ud@ZFjl(02xp8?p2pgCG^P22uGHgjPLz46JU->kKMY7G2-=}-S(PD zuV<@80H69f-to__Z52I+j<%r;V%VYLddgU8@VpgFv(5yxYs8@EIa@FGG48azW@c<= zrNzp|{SM%9noNkNVcrT`BU6t&Sx%n)dWJ5SrlfVT;nLfX&fI-_+k5ZbqmL|31g#%_ zPk&;KTs`%4Uam*Z1)0R)PEOU`_cY@Z8n0u);N$m2G{to#=&3c^tW)o&!z+I}_p&u! zBwL>zIgl+ggY!ynDxhi7-mf9%5?dW zN)KK9L5liTW5sjRJQ<}{1Lf`AZ{#{y>w)Cd>X%Gn3`92@lTvhEUedtbc+oKMA~Yt3 zF_JgH;I2a-QG-^y7t6I}J>}wCsQ%%MPWciK3;{Ngr~eT9c-CMtNaO+Uwl75=6EVbZ zSlis>_J=d(<4Uf?c>5J4SY$E#Dt+&Tk%9kHGL4GmV^6m^Lxo#^@SdbQnUkd1_7`ix zZX4tFv!Vvwx&BU4*WU7bjI;**bNfZY{lp6Mm8kVr^-*_Ft*iGcyY*=NI*M-C4IAE; z?{FGCZoPnZ>y0qat#zZ5w8p*A#PG9d2mDK|*JHu&zDpsBrFLp%=eFc?rPOH_IeikkM1+R z)ywrvNY90VMjP`hw?}7fw#oL;n(g6^YV2hUa_eq=Mmkz|z472k6*)gz3Kwz^TUTfH zMoaK;r_W@u+0`nl1st$WE)Lh+&E4Qh(9APG#!McFy48URFT6RhvYUBA^9LH0FukVB zO-Fr{+f_?1HQNCA!0AG-uQ|GF&sR+6lV zCu9$a#=qY@-XutN@RHEsA1!0aNEoT%SK08XV(STPX$arRHh zv(8>}O!(C)gWL)kY&6&y*?>FT_U78TC)t_C+P9W{a!Q}Dy3+vShl_8Cm%E zVNlhmppl&Ndoy^sDCr7kSCa_#mR<~cANv*JM^)pwpkwVjGnMHpW*u=>Y0ot`i>_70 zvM-=-v%1@y);`OZGo!!;$^fraY-5HQ3u1M4^8~tN$ViwIko%nRLX5it^zMro5(@S8 zOoog(;4lSKYv5_hp+Nmc2BY+!3v-f#hv#UD8|@~l0%PIk z2cNscIY4ncY|ZgF+H}gNw;}npJja1Uxvr+oC_Ear%t`flN2|y1mx?;_kZJGdli^2h z;mkJ>Te*xMrg4M%%P*;{h!$0x&D9nMe6eL5AM+l4@2&k2vr#JYju)Er`Lm$u$zo{E z(JWv2CSFFjrPvcI>0(MmC+_UGH*?*x98)OB)L*{4ja9QT1$hJ#O`%@amk4z)Ltb#9g> z3()zhPuE6Xw&&R1yZ)i#J?O}ZgP;kWjTzPK-*NuVQ;Ye(OOO@cm12L`Z70tjewO~? zuX$5gjPCMllIYVcC6&uaVKG<{B! z5u4JV`movIH6GlIZc2lR*c>|B5ntjVwQ*fpY&E%bOVQnX!$4V2h{{^VB-QO!y?fWi zoJUqy>>|_fPP#T+eXhts+0gB>J6shL7tv4G>schTJsxkR2s?sfz1*#>P{Xgu>E3TN zKFLo8#A=1+Tr{-Dj9GoOaPtPy1^#5%%w*%Z8aF+Y8y%nVJ_f2K5c2j+n#t6%>R5N~ z&UvV`FD4 z#`T;YEjJ-+O+0d8?QYAvo%A)q!-7%C>$FBWGkN%%&Sa*bSV>WM_P-K%#)&#B9oB+V zlo!iQ{|M|1F5t?CImzr`Gne(?`2HPdv>PpG((RpYaQIdF&`-ZU1b29}eBmI$#r>vy zNbWzkt&*#QGn)BsXYeze5k0k1l&lKN?m5LdUiW^Fe~XO>b;G>L^NPk6M}_lQ%*cGM z_zj`F#M_WR|J|>C$G#~o4jg(;I6P?vz1}c}&g?R#&vkso=_=gbiVH%6++blS&t^W; z80FgyKW~NH>hDXA^lUv36<%un#v6B1TYrW`edgmkG_49iwjwzK(<)-s+nH6D&bHp* zd;b()>FE~gVe_O9LeqHqGvBonbO%4bslx9m43$q+y3pTdh@;Bb`E#d5oJ0Q}*JV~> zF%C7E>ADR456I){K2Ga-fprA zD0pv7;+7t@ec`cVb5jvKIZ=5~&z|Ek*m&+CY^m5(bIG)I+Dyf0^w!E-C6?#65#_1d z=1d*s;_0-xo+OF7yq_f7@?q#4#Xt7C`O|Ic1#8NKb$hYaeD;{9ck_~QV)2x#tkt~D zWxJBjlk2!}lIfqpi3iSw!9OEoWy9%GT<=0#mhg7ypxC8bNWf0|dv{ove;ed+!v6X| zVx+6PW&KQId*lz?W4nEF?b+Ck&tLuIow)GB>Ef(~uc7&8Aab?u?J5OKc^A}n{HA$k z@UnljUpUrH;-AV_PUYtzF!jza?MmBnlXd=Jcmsou?|LhiAs%=Im8sHmgzvcPO69%X z9Vh>3)6VSIu;J$PZ`>ZvblUSC7+L)J3JG;b|FhGj%E$?B7V=Y9*HDjdGjPHe!*r!) zet%u|T0V^5(X08|X7ljols;n8D6^y0W$NsK<9K)gd(jlvreaNTUV9pi=hmdxO6)lI zWE^|-2?9%ZQM$3Ge#Cpfw!}s^ld>lk;k54CwP|o)5l+0(ZK@I1GF24Jqxyo!^-<^3 z3tJ68rS>*yiVOcDqyDeub0FX3imE)Ft+U5~!s9`y?!oZZz(s9QwySC{hV#w?kl^MY>_O+K#7jD_5)8*i;YksZ$?RRj%Cv zsvNsS5W)WAm)YaVXT7W?9il&fa752DNBm$hh=ji<&C3OFN6;~qKU&ZzFqd47BlQ(7 zJUjN{B2=ZrZgFSmZ|c{`Ev$d3>niX(bznp-RMIZ`9#Vf_cR^QJsM>zEAHFTD4AhYP zuQ&PXx)tY5gGz3N_*|VE^`E-iN1b!F@jn;ChU2bX7JP?V3#)b};cB;MF;nnYUu4yu z{$5~SbE%fLG0;j%R!_IjeP6~uXoqaq8VI(KpJcmtq%=6`zx#KW-loZJvJ=12m|;8l zz6JzzlTBlOA63=OZt@aOwavm>xEWhC{i%VhLd}!U>2$gKdhT8X-)2_S)+032zLVq~ z)xLc>o9Tj>6vFuJ-9g={>>%$@us5h|nXUB!E85ulyx=PzU)|S}_hHRhawTrMyBets zNCE%I=3wl!SuRx>^vQ9hH@8$*XkB9LGkEoH8^M8FX_vm|(lQ4J%#t)lIfU z+Ht)OK-&k^(}`vKRZ?EBhE|p2TA4=CQjydYNCfyiN%x~cFaPy|TDwr$(C zZ6`OjZ96x1CT}^jd7D}G=|!K@-HWQ~>hCY2o5k=x3w;~x)@2U+Mrlc?lV;*W=iNpi zt1bGrPIqpbj!uFEg-24fTP|&}_af?~G1Ku=7vG|F&msyp zc1OmP{yyDF?&(AtJnO)1(#x4aJ>~I8e!seR`$X6WiiI;CLt)`s+*1LDn)D(!ee2o# zz2_c!Mhq8QPs4?vpOExqC>cBzJZz@^Q<2++>2|KrA9_>_mV&M=C&%}G2QP|cmy||r zyaH3Xq{wXB&;+SaQjA;N>T$?TJ=RrIv%nM-a={&LmG*Wo$5O5wqY)0-mY&H z>1!#CQrifwvz3AW{Mddj+^mrMfAOCB8=+k=U3KcUXFIXA?t(h{=-O$WMLappcVP)EzC#cO-+Mz zIrl@_Huy5p%>$FhbKSLesw#a6I6oqaO{>bn(wD$dxXu!lE5(%M^oa&jOvU{0_R!lH zQ;k)ByQ}Hoy=yZaGt>oR}9b2bM5qSUn18_4+2N*=I6a|W7CgXms=_a za=G<&g360yi26CmdhwVpq_q)<)u$E)$IoGvwmS3lG=Q;L$Z7K7I5YynS7n~;POh$v zy0rVg9Nl%j2;xS6g>9WSo3FeXM?>~Lt?6)*b78V7TB0i>8tGPx-BhrA{Ia`iT+K|+ zoR{9&(V2C-6u`>IR|n5N87H zYlJeLeZjn0GK^FeiutLtQSA-TEKcbYvL9T_aA6zb;)^##`q=0!)|Ov%XgcFcrwW$K zq>b+E*I^`i>US909ul`EbF~{d@rXLfQ_S}}Da6;yqluILZM^N%roKxyHVXST0$hY? zrL=}aVvx8$%Ny0``tb# z4%X`U*lOjXgW}kqbw@l9m`>ll-cJctEYE+L-8SuPvs~<71bz$#(aE$gf}`Tlvg5TI zg&oHLa(CFtCZ|R7zwB=e-KFz4Ni^ZvO^!C39LTl~5FDkcoUC!SRtBrJHESOAux&=N9fl)K1#oSfLy0I~RxbOXa zWrNxIMiVPWuj|9#YFk{b70NTc&3HF?e311yo#8Xm;^Og)-ag&)u@d9i&0BO8{Fhlr z{(xRv)w@jKl3rMSUDaB2K)yyh={Ci*)oFTMFLqwkqxrxcZ^4^NZ-?Q;S86wsI)Z)R zt#(qg?otu;5ZNk5o5&WYeam<8@B8hKd)n6bi@%iDY;Zj(?{A*{+$i4Qjcd&` zCXr9c?o}qGR`NPG_`(YCps z#hkcuzx7hn+5OkXL@!7Mo!pIYqX+R)!L=^z;IFBvE_|v3vTRM%TC%T2A9<0x#!Z$H zsGVl%vU+dKhUX-|m4`v9U0%qtB66G)Au|6~#{lCyagDKH^CWOl&hkl*n<{9}tM_P4 zltt1S%4vsBO52pCZRCyX`FhjcKVbT_T3XzNSI4_dg>(3@QFzP8&XKBzZHF2jRZlmr zddkShP^W|EJJVu`rTnfWHB&}FWYye2#R z>~=pPODnOFNoJoe&#!&^GK%eDA>~^a{Qm3f$?=KksxI1np%SAS_U`0_7Z*B=XdxNAEs3gn2vN#Mr&1D(?gXR=tuTwXB_Oms9h&7`@eTzV2t21 z^bjwKa-Mpx1#$IBT^^n<5{p5HJ>WVTyi*q=SM6;{YIbpzGkKoRDzulrz^X_xe0HnQjQi6}A9y9@rPZXf>&g$kMBhJ4ED9@)U%h^TtG zT06hu&-^Z<Po3j2#!Oh zA}N(cP*oUp%}C_Hq>(FDG#y9`&cEuOS7<_%LB+`Ee>Zg%i%`vKy8xmV8VM-!xf&MK z>}U;PzS8b_dy~-*_&o^5>_VjOzgW$CP3HdDe0SZ=UKK)aS0TC{y#B?n0jW=bYidU;Z!f0o&S34Rncbf(r?8sjO}Y`@t7_ zv;zFMKUj^4dEDt1eBSydr5?(hd+a;$l&yTdvB6rW)Z82q&|N>dH0}o8yUqJ7le`&2 zUn6^a=c91ee7{q9GApa+XVh((`H)=EFe3Q5y0wpk5UMTGv;iGDzp)ke?D=rqQsWf4UwWUK4(u-{@b{dm$QN0aXO?$OEe zD62LzRWNY1bH#kcIxK^Al`PKI-R)Y>=yWOGxLj*)-fkKU_R^~%qtGaA|M(9p%l!gDcGlhXOBc~~xH z@&PsY?4lQRv)1s_^YQWf$W7N{R`4nvY>3{#aWfUEsp)!bcGrvvnAk3{ z?+2GJ95Aa`{KMNNm3}W{uieFie3H#vMva?0ZhiL6Csg_?F!7_e8{l!i%gSN`CD+Hl zyKAU;JH4WXWzEfE^(SC9ze|aS_gXdQrv2Gmasl^*-y5HdCX0oN>2>~9)rkFVM$1=5 zH}i7y{o^}L>D>h$Yq*ue*=(Ui!{){Iv-4@QoZJdYv2fN~YvbyTd{k6S4W>tPZB|+$1LL_6J{jR*^ic^7 zkGQJn$qXg!*q05%S~hpaDq^RrR0Xp*TtxTtz>}foUx*6vm2G@gO zvjS0@k(_$U4I7t?DFm_+1PbCJCz}T8C+6V(oJ0ucT*NY}&?X+I~AQD;*NyDruC)eeY z4;0%Z3>d%nyBoAP!ms_5!Og#zjAY>TDYqyQ!tkLb$ySn~iW<_*T+2*-AHqjs$Wz`7 zFR1*qu*fj|)Kjo#qu_j{-vX&f0_-3Ko2?IT_gfKuH-$OZ&#pb%nEZ|Q`g3q#1Ec6YLgK*2WjOT>75nGks?pFO(GYKU#hpC7gRuJ1t~YOM=fW$9%J_|h z3KO^0qH7S;C%+`X(a&0Q&O$fpp;*LUqFc1yUJ9F+5(WHVMUx*ynJk6a=F--_E{T$s z-$)>blyyw&3tF@}rT6==_e7T*@R5qgh4CUk+MU4h-t6pz<7Sr`&YGKCW7}%!o^@L- zJ#Atpvxv+eZ1zlJuZ4bZ>5Slu?$AgEk7b{={3H9JsD`Ysj?2MXIc;A-krKA5Y;+6f z_kUe%sN}AkuIO$Tcu$>5S%e3Iu9gxruhEf5tYu^)(rZnA2Je^=9t95rqWEFSc3qTj zNG)X@HAb-+jR{}jD%VY+VbCXL4$K0a9!=cU`ModY#+01)7&$c5+;otPK zZ9kgscJK47QF<>f#}T@^5x;y9NA%@Kecbeg*rF^5-(BQd=h<~jHSR+M@1LLuA6f79 z-VbqMPxi?S5b9owYBq}=cv{7eG>J?6g;Wb-;lrKav{VsRzP+4H6MMnYpWNc7IDVzr z7#|LHTILsN`Q`RnbUE3!ogY0PFS#`3!r;XFd`yA_nPM5=XvKwtlapc6p^2l+P;Juvd{P$vafCH6emA*@S=^Nw$j$x zvvG(_*18ehhMV!h!&_l)xdzKL?~i27xp>XC7lG#lJoa5)_jR+;g5jo|8}F@e8hXx@ z%asDA!K;VVVujINS9a|AOLuYcvuG;|)!jut*QWcNi}VHEFQTc(yGk8kI5_v~)jBDw ztkp%yjTkwQs!y5f9gh^{F*^G7c(<3iasIex(8y=yV57x;rCAJUvbgK3MxR5qlj}mx z1J~(3SMB2`o5LQ)olPd@Qau@1kH?Fn<|~Jy-j^{P`!50R?^n|nKsoHzOUfJ-OTBu# zlkSdyJg~>CEhFu`5KuF_*-!J2;UC52%^+y^q_C-7#;$ou)3yF->$G5PZ}ootK}`x?W=0Sx@o78d1!ztJI{M+TUo|r*S7BX^z|;jE}q-4 z$3rHm8hM=#3fs$AMQA}oTd22l4xe1SOwML0T3a6_tq;3Ru-c)}a}}4Jx(6+hz2u+S zC{{Cg=WgP@gwE3`Sj(5y!xtld>}$z5KbFbbg1*&fr5yEK`shkz@49XVbK8f}&hK8= ztr|5=ZQeA-=TJ}eX3Q=7TKSad9?xC;c0K3wZK_lE!yxw;haZoZH#4E%1?AE3ZjoNk zKAfQWpPa6rzO8aLCeK?b@!qECB@>QOrc24isHC2rAkmZ=>Jr85udtDm9gq3hJso2W z_&>NvYm=6C%PC{)Cd4{eayc5bWu*YIz2a+Nck^Nr^Pf9;5)22x*ZU-WvI-aWVSI~ATCo~g2E z%Nj$jktNHhYTLBAK18}dD)Dm6D9|-ibiDYRx?a7eSJ<_SZfSeyeJHp(Y~}r-LJ~_!B1@x_^v#E=lW)o*Qe5KVAzlGI+L6vc-ylX zZPb-Zw(~U|Rdi}z<8~ZKiA?8W*P_c9ntvtjw5YfhJeadv_RZ7cgC?nlq-$k0x`*FK zw@Z3`F8kWM`rm?@!gh8`-2nLEB_ID|?uNe1rhWfhe}#e^{BFR!t#5T zI+t9crj@L=oygX`I@>wCu5;$0r)9X^Sy0lYtJyC&ZZVDro#DD=>S;B9rB16o9ZNo# z@_LJ?EraTWZKb!=cZ_D4O-_1N%GuP?k*uZ%3K5>-lV>ESq49S9gHxQy?AMDWw0C>o|lM>asOE8hk(@Ag)uAMu|*AdRx_ty%&B}nz`;;mu=;=Jc@1zt`6&<>gmn!j&Jrp zOla2IB3F@LKGd8&tu$1ri6?9`dHWKt zwj(vTc&)|y)~X=cx$>|#DC~w)BUY(&W2bRVz6cM4g^W|aipHuPdbPezd9sKd5RTm) zW7k1ZPHH$-$Xid=J5uV@_f=e-xUVx1l)MZ@^X@Jsc5!*)rp0^cG1(;E4K2D%qp)6h zi?2SZ2%S|Mf3EHhlzeJqz~Haf(t0+3buIUu&34?&jm~Vp&$l5*3HsXo$n?$Cr9#Pj zTy2lKyNRsVSu)r@8LP+Jekw@DW$~Yp$+Q2+yL2tzSHc@InteP*?-~VGib@WDOH3jM z(RD`^<)mN6zKh-tQk6w&@PHTOl^s$mIYd-&%BWTtu$S6gDX+n#|n0v%zjr-S#OMAp*#JPJZ>t+ z0mh5iq$bf>7)s6adueC;xR{0v#D!N+^IkJpY;@;b4a1FKx7lsebKLZky!@cf>VeJ@ zVOF1Z)ay9bTkb*NKm29*;0>Zx>D|{E+9Staq`?vxAx9N5>u$M1@ z1OVVP`u}CR{Wp#mchhl`?b*ld8K2`uXaiHsqSda;qO;PdE!W~8x~92n@tlMKQesQd zA1YpTN%q@kb|A(rvY0Lv_k=K&0;#`4&))v^pertFtgGlxXts~nz4znOxEuY?cN;q3 z%YGdAk1hh``2m||*6jrrG4%Vr%NaD?8w;MyNnj#@anpS8*zWOfoz?B(vuO~39_l-s5$xjXcROR*fWjmVYF9zwt=oMAfBB8V#CgC1mpTwr0=GK%hkIdT}Rk#0gK_ zZXyJIGlUP7g@_Th+r6jQQ5oY$!y^!V_7TfU?W?o>Vjk0gFJ@#hJ(AvTg{d?OrtmSY z9<1GE(68(&lzi~_7tIkVG{1+qI!nM+IVu0JK@mw_y*Wz5-?=LJtga`BT4`v!)J51L z!W<&WpKY$n!2r#{M2JQP1}WZ^NyumgW<;3cTyrck@iP+bbcekt^dWY7kcAKh6v+#x zlQZxrl|xU)7h6DER%%$PQci|pgupCPgFNb)hBwFTS|(#AQILt%CN+x%<_a%PNN9i>bW2T5t{qA<)B~#M29<&DjON#* zVEMQ#y_LyA=N{_BQ+adLuA-^_idX=Oh73<45Jm|U$3lte^a5RPcr-FI<5OLvy_pz- zdqmkG(Zc!pg=0zek>m>x$b=M8zm(U*X<*ZxTnX;9@S6nydH5~1pKK6G;ej4rn8PrX z^-2XhX+kmSY+-^I0&}X3DKn9p8ldZ?aT~HP;@WI3bxBrb;K1cP-(1YfR ze4B@pPhR2o0t^6`=eP(BH^sMTirrV-;HynbZ!t~&AE%V>XyQYE+w2<po~2+XP>T zc1@kj!*6B69>DpxNjeN5%2jog346gz`^Xk$-!erEp9L^%U>)bli(aFcr6Z)4}@_thU1n71Qz`Mwr0>>H~y=; z&R16g?&Tj0Sk64amoqOU;?f>x|5_4xQ-@eL(Z9^CBFpIjW{&menD+_zu1uxU)Y}_i zwJ8IjWdBngDkz92=);_3)Cg9>`BU&eoeuloN-<8OD%21M@^9)q_B}MP2U_)1q^(p+ z?nT+!%E+ewbX5=QWc`!(PVoiz?l8m5=rt~?;Eel^L3njQsel)tLDESTlq*)>g^bc$ z9o|%-nAloKz+4BQ8+R5ZSzBT(%4heY0jtdKx&eUxV!p!D`KvotxFpwA==+xw%Jwby z)#`qshZk;;>M`AEiKBc=Q2%+8w9!FcwQk|LY>Pn!{{F?qo-`U3LO^$?CY-r{szcRA zV+8{WGo{$D@rG)j#{(tDQ=(^!`7}=nG{8tE;l7x}Q}ivcyc3?Hdfk)#bx&9tma)~S zkgOIkH@N=}BbFE`>z8d~nQdvA;u!hM0PDnG;>ow7%xk_UAiz$E#wbCnw|u-A#jsZ} z>tk85#?IMx3!Y{tfAyk{bNh1Jw^dG!$V4|d^i=#Lhy^?rcS;d!h~e~Ho5kWx@WpfE z4dP@gaK{M^BEiCi;wH_{;79}iJ44M$B#C5yOEsz&x){-fR~j~9L}Zq(M9V(P#S1nl zxC}0+fEts>9X;j$TzexeeAt=*TDG33NDFHtn# z(JnnKIHh<^%J z8kk)EcJ3Wy8uoWk%{LGRjHa;(xW)4-AVq1=33_j>{2S!(qfEYnB!D!`O@TN}Z`}$B z#H5la+goE(QjB6v`-WjyW^45r*Gx8MrYNB)O;oK99$P9O(_UbndnqK^m_8Ac9jBxP z^ApmSL&MNI!4^mTaX_nSTXob)fDp{n`!*4(uT*SnL)l(q;p{LeU-H=R@VBgjO-W5q zHT%BmolSSNVu#xj+Q3O3G{ig<%VCeRW&;|X2dn2w&>ib~6c4{mvs>U@TG=e(;*Y6~ z#4ZuMSQPH{@co$bF(aU^W$)KgOb0V{L{M|X#JVbK!(lzx+|G5bC&G>*jUCEXwodbgAK+HvP|PCT+r%wct~e3y z$A>{skcWC(vge&#&oR{yCGb9>y;!<8CRcRiSGK5Td74j&`>?lgJsH9`vN*Ug&ho3NX|;Ug*oSo<_=Hv7%Rb45<~zSXsqTs zej`8>NDX~NAZ23$d4Q*tuc3w<%({&!YAEU+eRWOckQgfer)Jc)-8pZJtZ))=?aSh@ zH@k`mlKWhflpB`Ib6Pc|mRadhhux`^qWdFQC8!i-7+3!mi23?X#D?!_8_B23YrH*q zrkBMGR+WvXGWye*RZg;*4YA>**1ZRw)QO&{esxMrC}VqnVNl1lFP3$`;3A;2EEJih zFM1{Rlr`3YITV-zF)zfIFa?Z?56a@H^ielPzk#BxGrd!Y_9?d!5WC$%EyI|58WH?w z6m1z8+y`#m7~o;-emqWifbT5Zap)c2O|=8<4%|@2HB|@CddkOfGyWb+QCH~3U5XH^ zaWsemcKuLCVsZa|6dTx|Fo?%E{+2vQn;KUL?rqI+OzW7*njECDN~X?eLc{p&`RZc& z=zhBE;YH1ECog7Kc1I_#&od5v_J`Ty=i<}w^QKI~sC5u8f6lB-x}!&;QBBOlYs&QK z*MQgR9qsC`S)-{x{R2P%O+}hvk-reV7m&}P-&>xtI!8&`*!MXqNPUWxm41a+Bh=3X zLL=0_Ktn8K&M!VeKxspAEI!d2D*lcrx{#Cc&+IRkGz87+tlgAeF9DJ{b6KlWDi`@A zkTm$ZKV8w203(<`Km!D(i@|Fk^aZ1&0!VThy1nQ_6OG8&@=1wc!F7BYyfVs5T&G=Q z3GMUqt=2^;gdInhg!ik=b5S6k$dieHBaovCDC!?VnFiGGhorS6&s55>*G?JTL-G3J z*kL{U2HM=If1Z28TM3rioM6H7kfnoaf?O%e7d?_T0=1A?_J>!&tTrJpSP|NR1<29D zHnOS~_|;FkuSE{ynoic|<2_tXv~4@gDp;mn+AV1f*f;B6E}N-zH4E-Ex<~b^ngw8c zrR-aTMK;ALHfl$j>UgV&o`_9H<0y`IU&Cszrj$L79^ zw)rOO!yM(jD0s_@x?l37U&Qp!q|gTbtXVtl>y4P6z4#F1jw9_OnpdD!3NdSsOqd+E z=FKiHueos=&iOT+38u84)H_XKBiUGe!#C2-SJn3+|KRvq{b|X?QLGi3aIsIt7B*hX z!T>Q@%Q7dY7E;)+N4=+L{nHt$vMjbi2v?0 z(MDftU5A20NXZFgUXR)*XLMXu%&@By57e<)VfPT0+`&ruzCnEs&wSkbTK%jtu`W}o zg2z(SCZ*I|U{bvIg}rjaVT3N-C(GxUCNp(|*w%fr#6q@reAZ^??|O_`-t3y&^TEq0 z^=;no&fUI%K(RjqH~+#z8uL2MkJ;F0+nbOjx>@<^^cc{DsvpFFN-r^RM$uLp2qQUu z+SgxAcDZj3yBJfjYuGw8+NFtn1XCIwm%n4Eg^}7+Aa8zEW-7!41`T(>WV9XE!n#{p zDBdseFA`hor+A1`~(YYHaVpc$a*zUvQ14!xGmm*EIH{RXmxC|Ml=Q~ii%lAVt1)B_e2`iV_&w04AKW8z@iAdqSGtNA*k;=xGri> zxxA`ojbQpy6$w6Xw_AL5Qec?6GgeO-zVB+?O)d3rKn$>fb`3T>&QA1PO!uQ#cVlYm zr@1xrAX03#bw&`&0#lJ7G-dVXt3Voiyq7Owm``s8UsY&#|EX?nZZ3uwA;X&}*eTlG zpv%ivHgXv;+4>XmLBSR7$~|-4b$X|X5rsp+Gd({m|V|qP9 zuP_%28rZN4QF6HlEa4h?gAC!sOD|c}(ZhWSa+OpB8nXPfKVad%(b0swysdkZnLuV% z)M6~G7J-qb%YU}WG&-t;PD`5<|ka*;vWenay3GIY%s%%hS~ z=Uk*Su1pbPv1$Eygm@&%;1GZUn^0o-Vr=BihCvZTyzITB(mK4sczBPasqaBGFKJp! zpV?T#)3c#YRl)38uD6tR`a#iSs;(8|jHU_%n~fGZ5%}jz?wRPSz=reak_5gUL^1v< zYont4z-Pt=f1fNiYwBaJja~9)xmz3%BAd%HA75*V58!U{6N&}k=T9-72&8mO&U+7D z1P{O>KDtS4e=_a`OTjYUtxYa;A7p}#U=v?5#CJmWpmS&i_JPMO2-#IqD7HO4WeryT z#H1M1sooPyKLkchVxJ-Yjtw_$oP4fwOhxpCvfiy(mChrWqU>T^m$&m#OLb03zeXaw zi|m(=1lU?889J*A1Z|2;8;bUh$~qckWxiSa^3@T@gh-LdhLjhFi<0|#84rW~DnA>2 zq7E`VWLX{cL=QbKr1NYOj$3dDjY5=i$YiCjUE%6J z4_2U$$YpO>n?N|AX}6-8vcgOqfna zQ7#XDcA@2HeyWUEdUSCbyj(#dpzeD0-TLkR z`0hS@&i|$fa&ms_1ixtl5@AvqFcts++}^(5G68qK?)P4u9_n3gx;TcOyYpIUtH3R@6My$JU z9E??}7rOpwWd>A$R|JJZb7-$W{UNt3!Ip(gvg@z{AIMAckHZ@nS85yLi7B7E-_~CF zY8c5;C_){m&LL3v<+a$$5-N={GytN0M$#L)TWpK-QjiA*Q0-09$}~ZZ zF45yW84Uutd_CQxN7T`i;!JAs)xJ7f-?LqRmM^+IBX#Xv(^X;gIH<3>hTGdU?0Rg} zs;Y3|^|z4bhQZ80pj)@AZ`1m=o?PfhZBp6mP;mT)+Bn|->3T-ps!}d~_kz_Q1N6Hp zCg=m8NOBL{#~0L#yDeNi#*F(5Q7i{ELnQ{EwJW0^Jo^jj`@?baBAZWmvh091JOBJ$TGs-yHDhD*e-4U2%?X{W~i}GiSnyqCH71BDhmVP@DedQSGZF`D^~UF<);j>ioak?aAWmTtbsgMsXK9v4GtN9or7;hWt1?AP2vs|5ttd9Fbt$*ew@bFdj<$6dpe zjuK?N%x{%X#ZNAgDWm$Q7+OepWMmk-g+gi!#j+GIv}C&Rp43|3tkDWsO#9uQyM?CO zq1i=Cvy~cR-9bAdCBYRIVnyw<7|?4}ULx!;0c)@hmKa)JE*Z;ITVg$Ikd|arFud~A z^L+jBvgt|He$FllpE%nHOSFo6DpqO3(4sBq|3^Tsznoor4uB48D(IkOJydZDr@hrH z!8gPZSXVYSh%G;bc|J*Z=8v3c2a@N;p#21$m=1{JhahD{rMXc(8WX2E@I*RZ@#hLE zF9^Mg7;tq!K3Sk9LL~7Kn^QhKDNysSMM72lxaq;MF*aFEw)NlQw4|E!XvaoOM zh1T!;7Xq$b_A#rIJiJ3;?!AnxM#?p#)Iofq}iUl9ssL#cbYkA7`eu@QRm1mT@ z&=j~dieW+8VR#D#FWk7XeicRFx|MOE4a^l4X@l9Jz{&LH5;;emj};DA(aIM}RG@w3 z&bHgrC@LeAohZr{{>oU1REJulaZ6>=7fuP6%=wR)L_T1Bi(;Ru`1m7c8-H=Me3+If z+v5=xZKLxc151kud;IRr*esysY@-lOq8N{b$dchRh$f?b%`kuH#eifP(v)-Z&xELo zb=5j_=@bXPa-iD!nAc3p<4%eT|K^>jr7RuOt(u5F&Er(CeB?;R^%X4uRWy^RJS$}D zu`1@3Y3G5K%p#rtey-%J>&wL`tx-Jtx zms33o3;`(Rjub703X zrUiQVdtUQ~wdIHWWZ&Azm4T|!0i=_hRJ4V7L)|Z^8(ZM$0uTd2sLVg#ASNekrtlCq z({>@wq_qQ0Ru23?s0~VpZ5_I>w#TssXh2Nm7a)(jW`NVKC1&stz!p9#{w-I*q$u#5|Jl*4;aLO3lbLbQGg)^Psl6~ z^O33(rMft2MYqH*EEx@=C4er7MoyqUKv2_UlEf9enBIHCQhxk5Zj;2WTCZZqS#eRMNt-AMRCteF*W4 zfI2D9jl2eEtf@S*ae!pI+Ppt!{y-;~I1dOTbg+&R8Rv2U>L3GKgat5ma0ihz`Wm5h zI0Nq)F9{p8!Fzv1Vgv*5USPc$1Tzp%utj-12D+xWp&$e^@D0SISUTw4?;9`$2Et{CK8>40jVdjyHA0+klwE|4l>BK1vJ(~%ovXhJes0S&|P{2w$Dx~wNnKd}3OY4w(HT&Y2pmF@(7rU9a#C%!r>(og;Ex>Tf=x zDh*klsj!ASLK=RZ+J+tUCNz^|qs|hoN8<#Q75NlaRJR&>41hZ)6-(O>CivxHqt3|y zvU$7)WsSlB7PeV0(T}2SGjt+A-_lZOy$-`@RXnOi{~7?(rD_fT*cxTC zMu-4#b*0syL;z9TVvuIQ(qp;1@#4jhChnA9U;C;w2fUSRl<=yB0H`=!vEysZH$ohc zV04M&1FS$W8~FFeAWxl-LGw~e0Yjz&nHDU%(K2sZogrbcU&@4z7tOvJ^%8~>#@R5* zCCay4i>?mZWORsYOSBbixo-JAB)jOeWNRMq&WwYyi^;2ns zy`~A>wUQ@Q%sP53uK z69an;O%S&*9;$zGv*OFh-3PVdjgU03V{uJyf>2a2A`TEs=toR^28S5^(DIK7vb+M7 zRe^&$5a5K9k(TNtLCW$e*g!?`cL(ljx(A$)k%*y!;EJH7itIY@#A;$w}AE?j_nX~Ra6UJK=qPo z&pjMJzBIhW8;rF6q=OJ=MqhxIhnfJc4V4n(QBuVT*>eT&FtEkP$0pe06vjI{;!MoB z!-3!|FFqoQZwTz=zlZYyrj!l+17YYRnXGHDS79GP;`Adu!iO-eC}m#B-Wu6;}%$UhXDeu2`7ghu8!kn>Ry@fdsCBXUv9S>Xp94NSl zn`F%jIxvmk3OY&{EyMt{Oh%jz%_m3!%0UfafkN~)BnV=|SOlhUfv^>)4;<)*I18){ zhM`evV4M*(fmVJMHz8P_9XjzxxmMtKzg#Z8aJfvT*a5g~V_bMRHf91rO z&f#8luh?4sOC@drXR*#7Y1~)Rh4bXb8{HD!Ccsk z03w4263QZB?%}|C*6!uNe=|?JfV2P~DJz&iD!Q~vx-vd=q2?85Mx0>L<_wVBS`PZD`(BL+s!=WaH1bb4j3o$Iw{As{+9>aMy+?nlR)- zZx!d#*kBGy^m%Ns^cPMC?s?|$`EW791Tc*7Fo5%vpPib+f6d01A*CdWle3r4IvMb%`t#a$yPt4?YKZ5H+yL=@KDC z>NV*ysu9t{p^WYQg*}wxjdV#*jlGpf+9l zY5O%Okfk)WLPq^LFs}so&Op5al>LPzVx@&qg&rb{*OeK?wbha6ze{j*36LeAKre|g zJ%~DD^{9uSnT8X+jXMZ#+qC;?!e??t0Z2;)|pS}qh5XeyH=LELXZBm@Rl6A7-=$pkuqXn-1W0V`gd+fC6iN#l3H|ecnGn0G-f|$cjIIX zqO^+Cx-RTO#`T|`#vi8TW=i_!b4cOy-!3f?1TbhNBgzxdQH-ObOBgUrp_ze1-3w~~ zWrTxka?k5169hJaaBemW-AcozQAwuOu_%D~8@FseB`LBGZ;c{Z|3iX=@s}d?84D_{&M1)e&J1?>>u)EtifB_w35JO&Iq%w~z6RH6Z0E|I7N}ezB@!o%> zHU=qh5NlixwR{Z*_MZiO?GlMZg}s!G-4PFJ!a!IvyLvLE`6m6|RuYn-d|CniAO&$0 z8mw(r$XQ``H$FIYEMcRHZs}D%Tgx5}27ie?w}lk~ZR#*8Dq18dlL*!E=aF{=RKZ6? zRAb|&&rn&=S3iAF_6Z2n<8T^E~UZsrA40#b&!q-)yWZQnji6wB{ntWuyosHv`52+D#t zE;W(IR!yv|`I^sk@lZ@6jG)&?H#Sm-VIqsYhMMG@G~~oWk3#<678fW?gpRfeQjrvL z!Xx>gW218EnUe2nx%ng%as(-!z~bLD!jqYoGVoLvrmQjd%E- z;nElJ>b$qW=B+AV^UVX6X@zCi;@W$rd-(A>TP=r11YQ#HgQk{pa~WL zfbvHmOZB+R0~iy4LjY#_LK{-*f=KnxL`jYE2XO%Gfq^IquM-HsKPwi>m41~2;XEX8 zff%nL3*xcgA7XmbnfTpA{uY{WzRe!z(Rqug+XPLK(u3n+a(kZ`A&K2t0=L-t_ht|z zy)`p6HIgj!-276XOh8IX4B1Gam|57~#t7GjS$(dx&;hU%?2IHSu{DQLNJ0Xb0fm8< zmM!0^N+Fy|zZtEiIUdS}o0I~UuetdM)P~#rZ!wf4m9moh!h)sJfw8obq9WKBor?`Q zn&pU68oxy{MlNH_!X$AAr3w$*viPRXW><@O+4c0^L3$@wPL#m~3`BF}SfQc_EI}U- z!0hSbemLVeGxJ}sVbHs=I+TRGzJ?heNuKr_O{biPa22e}-b!AtcbEQ2i6Z_*uw&S` zZ02QSrB!mLI-O3By_Ky8JRD~4#>l^?M#Iqt;J2_V+0N;#93wZBdOjCUBa>lr)6eua zp6^`5q>3&Z0n1L-A0^ziNSs)HombSC>nfqWr80 zqvFVl=nPtn>VTvJ2QVh$bsduc zL(;iab(pezAa*1e7@$iOiEdw7@%JpPG^A&?>M*AbD+eIJNusjBt4(6FLDV4nf+m>7lY<6|#w73#n8{HY90zV6uusgr$VTIIMi3 zyB@bu|4msIOxUiO*4c+SYMDAnXu|U!^!W=Aa&4`c;lYCG@VGnLvMXw5NYTqu47s(kC5Y4T zVuW!D_@bA@h(I8>#P>vi@R44V2rwicR1bhGRhTQnn9`ha7r>SGvwO?Nd;W*Edx*{? z?Aiq!+jcrh$F|Y2ZQHhujyp-mM#r{o+qRv&(VP7F{@FR}to4n~q@GEQYE`Y;wd>i} z9W+Fa?LUOzUg2WZ(eQ`Tx+Bxs$}VShc;`Aq+_s+huOoSLXRlRs%+DfeM~J2^sg8ba zyZS=gda~pVVBV&D^=7qRt6qg8uks&4YO2I6%_`|i)~7o`sC}oVz)rrqU8=Oeqh3)& znZCdf7gtGNy2;+LpL0t75CHNX-+h>w(R3!Ur)0sd&OC@Gc{>2qy&of9LAE5xraJXz zYk}+cM0+@Bs-U{_hO&YEA5Ab7Ki53RW9NKwUDvT6N7ACVt{jqo_YeX>p6F;Fhkr?Y-aR203zSd?%4UR8M(c zWs`5qliJtAVFsg2G%Zo2dem1*9BJ~m%I9)yv7$B=DzfBJn}zpn=N5~y_Q5l;_qpoeD~;1+@n-TWN8151>M;p=M0)*bqbsj%qgVI-VZ2I5k7)`#m6gpkmuRV zZcr~25JRzzhD==~YP7Ghal^snK<6ICH2CAb4@Ls>$aE$R(RQT@PfZ!~+<9Uah4ZE$ zfnZtIJUNz8vEvLaLP=>6KG6+9&Oh>TpuZv7{}4fV-Txw)R|50-8JGqm6(5`!s#uNl zr_GLHu}^FhZIoVIy-9}*TwPJU;@a>p5H3M3OmOw1Le^q+z*Z9Vmly86z#lfy!_hDY z3$F8_KMJA4fr+8ranSF5>a*#A&emnY3`Djvy`0FNAdIRMSB)Wdqjd=+{w%yRDyL69 z69N{anb1@>#Gtx)(~|evcvfU1wJ34y+&o%}9O(}=p(gKukqz8s$6p}xy=s5R#BjKu zO?RMvrGa{lY2coF#AIqLElW1>`U8ur*RxPA-N} zd^GGW^2O|%qr>yFv$I3Y-Lt+1Qo2$iT(?!SSL%?`{z*&;91{?2%wkYNFp~o{9H_V* zfo-h;S94*t^Ch8Av40;`@Xud!n#WD;@fYix$~=bi67GRcD+VFWPYS-C`i_RMGdS3f7DNJoj`sZSoeYR%9zN}U=6Q^`*rmE zF|=~eLs&;#oLzT@jhmEk-RwP}|IpY#HB^DThrv2EK(B*do+3RQt6ZNBg~3~6VvkKAZ!o^5(%ZFF?BV&X~G zj{7od)Po+Ji;HBr49Qba?czT>yfH1&B$%#w+QfUv-L49NkDRAf>fhQKKCe2+I6}&cYUqB>ZO`CbRBc-k}U#3V2tI>t1c{!1NaSihgiU5O;dZdQAS zD4_YGK<8AlVef=V{hk;W3o8`2=@b#;f>m_0HH+?^77H#YX2j#*K~GPwt4!#4IUFr{ z;L8Alg`4+^^D+Q8EvH&RYf{aoj(%f`im>^4Df*X4+8E_$IK1Q{ChYsRPJ zdNV}&8eg<>R5aVGGt2P8;Mvm;_@1JZ+AG@ zDVvV1_6mrxa}QVopDg?yNG=CWZUoS7Imj#M-g563crPK=NUiS>=@OCRCpj?!^O75Y z?T~N9=M*|$nhtGR{O$m|LM!UM3F&6rE~hsWqcVC9!Ab@{y2dqTqmQ`y&uWAfpyH{Y`2OwhSDKqiSu*9|ENVPy1`S)+r;&9r^;Uh`b}?6 zCAhjHRehKOR1WkV%xFMz)hruCK0lzjr3GxqMg!mNyZZmj}bSN9vWS?q#S@rE< z6L;t$#3^gPlz(M|j%`R!?>=}SkLz=_xpzws)DEHROI&5`0ky8KyS#4Rw5)N|6`YeVA-2)wsIFVV&%TD=BoxnP3hwkc@oy<%X5#EE{4Cit>7Oq;?PqWtL^YzT>Om-%h z;dl11m^Z6n8aCj6tM2@fT*|1tYm-Z~3!6!h??c9&=Lc)E49dHFWfftB;k-clYLX-J;c=;c?@dfXKOetUM6#3VbFGn!`%{ zxf||7>T`MLwt4F@wPsU5TAq4M9f`wL!+Y_jQNarzHJqhIj!5MG?|yiL-+?cMKnAw0 z&A;kKZ{t!6Y9dv-2)5>_Sn%UqKu_7lOR;=x_sNRC7DuK_-t1qqyCNjsZa7k-hGvz&N<@$e#4K5pk4jJoW2S|I zjovoI2c)PCX6_0YHRCg#9Ne{6F!}CSaFg6JAK18{)+ve2iGs{z^H`zx+QHYWv;JSNX~1b z*^%dS*7%7Npv2@^g_HOK}{7?l}P+h}%(Fn&7T;6<9e- zlD_Nx@?{ zm*G_TcFxz}W=;K&iCu%A%&+SfxKRD8t=IE-owNO4z&TROCiC%RAm)}AgNuUz&Z!S1 zg4~V&^<$dJ#*<)~OgZx6YxM{a+IJ?M^P&3~ZfYv0PC6CeHO4i&#`-`H`mq>U|3BTZL)9I_G08p^r8S7ymD%Zp~;dbroFav~+IDTyW zt>^QW;@|jhxWZ*(Myxs+RksSeQs$1;wZ8-(N?wnXH>|cB$vHRW+KW5o-`%flfex=r zsRi`vltS!IuT-KueM)L7Mu|C*a5mJob(q_S5vdC zh=tPv^@wiGTC6n19*j#7Y$G$^6bck@;yqU~bT4d=_myuY<_+P^Stp%p>sYBfHZG%w zVn%rq09ktcj!Dc0B7H;kXUz|%LFcOL?7tOQv6h#5ABdSY1Ql#(mT3908}>S(*F2{f zJ(gWkP9P4qV_qKZNV)2?y)8Hub|3df+Z30LUZNj>_?U3PR+_3gA9jL-qi=rJ!xQC` z#M_2O+(8ml^vIUxMO~hPrh*r#r>UPj_^Z`N-72MWsp?9p!PTy)afTObMC-AK;{2jz-1uyvZdSrA*V9|tJ`5xBsRERA*X(nTCTl18Yd*oVL^7iof*S@`B z#HC})0{2!h=kN(<@WJg*DS@B<>AT<0OqUbnW<%qL{mBbuOp z*att&YknVeM2S(4r4e-`y}e#!oA&_L64pw#$BxEE5(?#?Wj)*T9KE;kZbqX6QZ9A= z3I5!wwz}ivZB7WeQvpy=53@` z!hcewhBOkX;4<#+5v^&`;uu0^Vi9QgG|P#)sl=Lje)n2a8xnzsRy}EP7lI(~5O;&h zez@hjb+N*xz35$axWl@MTG;6K^Q++@i*^G1X$FU|o4s`x_#|e-k<0Mm9e2mGUw0k> zoMWh*FbFlV5)E@;%3ci)T$r4Z5{OvdN6?aQe#Q)ICD6!;DrKUdHjHgJ}d zi;%6$qI)pe{U8YGGOxk6Iglj`RjH%fGS(xp2+#mOD0b_?;x>KFoPo6=R5*mNyxpdh zb9viT?viP{Tl$2oF-X(D^6|1&*1Ai`KTDeNGl-v>#rGYwab9Zw%%y?+#TaFbwCK5& zY>vO+vIFTGuMIq_Mh-B#VHxN|?UGgoP_%jv5zMadZ#eAEwOsSuHCnJPL$g!Hwh{Z; zucMiRm(PwX{bhNwZKTlfEeU3}8I@mCwYgf13BK$i~ zD!x=&SXU#|QTfM#dAyaubYrj7O38uKDWg8aQz8RA(*qyUQVXI$1b*A9^hR>rEoV0e z%&7{up7#^Rrzw02oH_W&dRPxHcBfy76Z;Zo4D#i)21r_a?ws`-wT^C0RXjGlF7^OC z3w{ZU-Emj^l#}^AQ8n)z=`D@o41LPugAN;o>9nz93i=$c8++2d1xCN^e18+Qnf9$V z_opPEq?Dl-AhE%t=ZW8zS>7>xmAAx9dw)sc<44A&$c#K+JsHBHcejA^imS4c@Q+R_kat3$FduPOk4*l&Dn<0*W^99M55t(!=o6#Aq9acAcb90L& zYd(xGA&J)Dlwovq*DIRxvr`+vx@{X4npXL6JxI+dmF=^}iO#je}xc;;w_UWhd!D?F6BUvQ-o(ML_=?y2c zUpvVcGoUuRY1it76li0VD}j`xyc%Ygg4D9jZ~j#%l8ro*mp zls#epap@q-#@KeLQILp-{U2|v-|Ru!?RXV3S;XUO2H%_6anPDUxxo`|z2_eH!F=5w zx}3l}yDc8z+)#aWz97~>;e@`Trfq}TDW;X~(rq;~t&F1LfsR$x!(Ny3SgXf6)t-j` z?k}j#vTIx?4);&Dh`kg`fLj|rKu@mzdxM!SrTzQMR2+H^v2OpjkM5#yv7)<>FM~%^ z$*ausTv+RV0cS3~Ta^;iCnvkDykMbSMwzmBYRWhpV5h?q+8~cMzGb0bjWNcrFnL%u z)oJ;_!1i;>YJ7}#iuXW9xDX3X!NHO6cNJQ8Ea*hZjvn7u)YHFzMRRZQ$Fe(813iA; zO#HoWeY>;#>NdCJ6$3f((+bZ!CR>mC1~VI{6LmT(`qy2xp$STL!0~Dlok=8Gt-tE_ z8G?P3M-Ah^)_3Tft3}CJ@^Vd)-!$Uh7kV*ohYyytdB9Fg)wtLAP;G%#Ky-Jx##koq_k>WR$W zr;ltColo!sCxR2#0iV;It#Y;_;ZG~-JeBwbouA{A-6IPKI5RBJ{6~QLWp}T7ZR%%P zzuRVi4P>5$D0Pb-{)De)8R@F)j@fLFE|z5s(^hQ83RG(@z1!U7`&|y1D`n}idB+Y) zYabh~5P&?u?(L(OL~4PJrqBHjWlZmiVWa=uz|IySgXKf}tax52eC2~f{uJP9I|&oQ z*~H*SEPs98INdapZ|A@Bf_-k)jn7$?d(Qs&5ezp1n1fZB+^oXugl7pKy2`4lYi=0& zjeg@kFRm6KX(zB@vlDt&=yAiDr1kIH`Qf)RxiDkj=!h6eua8w(!PTNONPkr}X)(ayq-tO`N-*oA%rz?rZn=l~E%H^U*4tZ85EhT!LmhhB_N7v9E~DNd%OyKEnj9 zoGhM~zm7&luv4MhM$LVxEUAy5oem#mGMQHxhusFB5KSKK8Dso8T?VdaGdkB!ZuE&* z^RMp9QLiIrcv=IjcR+YIV?KvUpagYofzGtWty5B2?Yo_0zj%3=3vT!g{6jsajVtjJ zMD1K0DM^j33#>`S!@g1lh{G=vrk6a6!r8jy4t8kn6y_1G_{!j4pUxj$np&;68#<^oK87H z|Fi>h?4JsqVOM`~cBFZ$cOc>^OBIUwK+Olq?tPe}CdgT98z#K!)^ZT1&-UZ&9_)SX zSJO&)a7Tju zq9ZgrkNz@d(&6g^uS401tiMLMru1agSyWHh%>%~WbCgVWrUY6PT4zd>Xfl?=Gua&M!_@r!xruU02+TTV0whKy`ltk45B5lCbTO z0OrKzUrwG^?Gl;QTeG+etVQwI0eP`~wXrw0+V;Hed&iU8iyq%s+4Ge{D?~7)4WXgs zsp5P%a$I%IfcWWiyU0k~IQ#z3Q3%oNM)Wz}+mkf$k|Et=8vFV5QwzO=tIf&!CU2AL z@|p%P6cjm8>p|k38Jcy5nG-ABeVrD?)~efU^-niIz8BSPL!(8Efzbk}mC5oz)2fT# zUUIXcC6i3n&vv4kmILV?!7;6~PH$Qp`M&oMjm?P1GWemgimg{Ut8$WkdFz5_aUiMh`mJmq%B1mr8<@s(V>F^ZD$JMU-nioNzzcb{PW6dk#& zkYuZ&U*69|w1P8qxP0~+8Y2fHEyks%axszc(3uA8)_H{_u3;Lr8OUG}t|sLQ?rJhp zOV~+XQtKx(M3l}i33exAi%v`7etC7C1gohGGjS7AeBpYh>Y0R!IcC&ljS`?98& z2y<$Iew)$_IcV2w?`M=yzGYl`E2;wA+|ImQrsU=uV1e zFMs<(9i2<%jP6o{hpVi=>FaLQ;JV7BYFm{PHP5Q=u9B61-zF_yI!mSvTn}m`w~Edv z=(=u#OVkf|0hZd8o1QMy-S`?}7Lb}BjEG?onO0}LW$IIbN*dlrTxC?G*#Vsk#qSK-2HV;VVEhiLx%+tk7f(C zNDM-6NEr`yPh2Vo7A79U!z1>me%6Pzlvp(#l*u)!Y7C zM@N^(*U6&2cAyo#bsp@=yeX>oz>yv~d>kCK!$WBZNUpmOaFNgB7Au?bMFmu~$)N9_ zqTkqWjc(+pJZ10KNby7HhYVW|MEs1)lcNXaf|m!J8<|qUrJ!*cyOETZ^+yN3`gnU! z`=*vvWwTH1ax24TssUHSb^u-qE58O-jh7WQzH02pre+G^UYd95UczqtuZ<5D!o*Cs zecMyM1rU)C+~JaBZuAKV(VbY)+Tn{vX0rVd)f!PdfO0uK<@S0jFOjl`+Q*sW_wr$*7%Tf_g&<*xr2=HJvnL)b*(eTo~D`V^c5W`=u z7ykrjgo!5JtD0ATJJLiVM#Z{}<$b!&?Ti|m1dJLVeA;78c=HvPtOEx;EIcX*Bp>t? zHEbxV1L`gheYUq*W8P_d{G=yuWEa1js2)}Wd2e#ruy45Qjq{g6;ydtN4$zYcywxFX z0=7{(_YOPQuAD;T-`=4oJJJgP{6{7M{D8F-Sk(Grp{c?P03t8nWvqplGG`&Di?p}w z8RW8$)oGUpbs2`9P8&I3FJU2oh!|`TRkZeB+f2In`h0rQ+xpe^Te5$RBWh2?)XMgS zUbmee+nk$*_xUD%=T#}tp1C(e~XoZyYXm#w763q9gY@=5ir4qoWz%_i{6 zxo}+?e-j1&%P_TgOEblO*zJLqRZq{4^6zpo8f>$EVPQQnTQY4AGBtkS*oPm~8IT$1 zJ=$M?=N{g`=<<}ssZcXFEui{`*6r4bjRmj$RKVwFG-D^HO-j-Jpvexn46RPL3wYIA zuA*O~;HyFd*|p8SHH*Cmv*7&2#tUgJ8O7_}#fr6o0?i7JX^v?%=eiR`5YE$v4;D@zz5qWU_IL*d9mBWscT)?(|aW-3cuT@CVg9zQYZ@x%1Yuski&l zw?@`;Eq4WyBM))&A3;_8d4?G3V@bnR^>Bw{1zt*r$$KrvPD8n-X2qK2I4F3OYnq&M?Ssso#1 zmOY#SaF)eM&MQ}2_!c-J6YXdA#%7y%{8r)Aq3<9l01&8Y?~s1+-Q#(`aIdhxn#|F8 zJ)4Wldx#dOp*nbUz388*nGmeveGT1}ddY$2;7q;gws}-@uZl9^@6GlQNy+6qe-1X| zkaxge`HT2Bdre;@&|wim;)79Bo8QuN6q^bWzWs;y=V`Qy9i|+u16oZU9c_HxMysy73;>0;5dtR*r{C);a+CI}qnB%up->JBaa? zugeya@!28m0fI08I9!zso9@XlliShDpOcXt%ulP}89EAq=iZ$*8s2A{z5GW?oW>4- zE~fP#9#?TzoV1ygW(u>l zok}PLxwIACjsW8O&TGBLoHwS9=o!J5N>l`8Wj%bao8lOau$~Co8+L84h0nF3y%wvf zcn=fbexW;3*{lE9sn_k|u0yFeV9*2&Ro;98e{t-lyw4Dz^))=8-=JPLt;(IF<9+yR z^kY~;@QVA;PJ2HMC_%Jtj;6skz!KUa3w6@^c8PP+XgrlxOcK5D$N-t);9bpW^1d<$ z7BFEl*Wf-bu({R_C`5F)3(AB{?H~l`3z%pg32$2go8oFx1`WKLc_#W$zFdv724{M% z*YGpTSP|XX4g5~qot_)IR~RkbGLF=bQ3HV0)eB=9H#qvQ5oZo9vffwjvzDLDh2rKe ziAk4<#7{A8t1Oc?n`Y!E@MSEv6B>GZ`ZcCEVTA(+Jw>N~eM?!_(DygIPL{&t7{4ZE zvH^EzYA3(qrxZ#`XW}INftI@Uj??EEeg)Qr=38E33fFk_o~muH6ZBVi6ecdxQPt|z z8TBsnqe{@p3k=h^559BDw!VkVuQvz(H$B1m5^%`}3j*>-_WuJt@!t?t-7S|54zz$9 z*)Qmrob@tkUb#$to@UP@AZFOGYjsy0OpNVK@qX~kv zf^CDXW=={C!+lo8+8lYBFzggp z^p(gTrjW^k5PreJyWLRQoYebaIf3lLPaMtfb|;>M^K%;o^HHltj`l48Kr_DXvc6vb zDd6kr)I-D80IRyR+5@3yTI{lzDU^kzGCP?kY>Ag7;!|~r@RK{>`E~8cK=&tZ*8N!I zBqeTRhWXv8v9SUcO}L<-@9I~Dj=*iwUtGsM!FgS3p|lp3AUd99R@BrP5ohl(&bTGX z_caGN)Rj`gk-_3E*za=AXIXgOj}uJ?{z@{hc4h&m?TCk?8q7;sEeLX}G4onBail>BHJo z41Y-lSJXkmIn4RmNDbX`*b;b}nkfvVv(+Zr%+jLztKH=@dYLeO@EH^HetUM6hQZe| zBo<>Uljc@6U~l9-OC0xliWi0$I2Z#YZCw0E)ni?e6(OanIJk8n!p>ZahSI{NSjSL* zKulVPy=0M?>>(ar$wHm!;FZv(U)?gWUlSpv6LiM<+z`-h7B&0+^iPx|qFu@ZAx0u- zhb-v8nT5H=RD!|{%Z5SaDE135P^^|rO?@PO_GfJj8)so_siTH@!V$c&6<~+8;pjUv z2h&)I1}%$eb~6b}wgzw94TA`Fl-80#*tN4~IwPosEKsIBuZ7wi)PswgYFQ&LRH_9+ z_vK%gV3hEduK!w+Q*1g)jUc?e3PcXN>5@j=RDd+sTC$n3ZALq0LK7C6-Z6mUWn1=c z%q*ZQ4e0>mBSi+pc-CQrmw<7&Vv2;*ArcfjHV z4evT8;5sT%2KT!g`ZFtM50oTv(eBFW_B$pgti&ZK--C@qaRaU^+)moa6 z6)EV%H$&xX$D1dBMPzaOqQ~?--2krC>Y@Lj zHu!YUi|i)<#*&`U>8*6v(f^e1%7&(g7?}b)|!`)CF(21?(~O&?G;z``nRx$qXM1p|(X)NCml#PvA7Z-RfI1 zRtT85SyYhD`q}_&S2t&L9*J(hJP{E4pqc){jk~Qx79Zu1T-ndi8|axJnbRfR)9u}Z zR^zW&CtnNomS?nwnk6~6X`FVjg1Yi^WI}TArUon;-li_lX zZj>5;TEuhfekDcyqi+yvw9jZ^Em~IWS8m60Nqy|KFD%9C%SDq>fM|Man2!B*fH9KdfKUz3Uvg*!Qmu?062Y5EojESZ>{yE== zq!!8yuSnP#Xe^_nO44M@?deZo`o`3m$R?j0auIikx_Pfu{800JqEaLZylBT8X5Srp zpl!C*F_BBZmL!aGLtyPyv>AVt;czW1y1Xv1EJj(^Mod=a>n3Zv7mshxnI{|Q3<1*o zN~%^}KGAovo4W_fxSN27U1TSP>N|E1pNi(`S?w!@&?~n|)o}fn4N_*e7`6`>=i!bM zw%WXW+VK2cv{PsMKSjrxY5eh83G3=ZPTGpcf|-`74FdLbAuf&!2zypcm> zc*?5fI{YeSlHxKA=IUp(E*v?+K!L4+f){=RXWg?7(%MK@64M(Bxp1=CR?d5w!c`Kw zUgCD8xI@%-``WU?LDkCp#2ZyUW6L>#eiFO?q!##@B-~GJnTPjdZ2VU5)X4IXOU$w8 z%?)>paI^I2#M|js>QuFOPU{UOc7U%G>+$;C>pSt!9hXI;iujIHc}!6jde7B3rdA&g zX=}0P1ATy)Aj&5K!%Wzu+CZv~`6OMs+nKzw0Y?*i+gZbKlv| zrdhq&aOkQp$!ee46Mv`6um97(m$7%4R+9q(x%~qIBK!XW#F)rggk5aezKA?l&IB)O}KvI18q% z+WRBVRUQn6>W7|EMxY@mb0|mxnrv`X9@z7CEoUuY+vi5Frpx#Sxc;=Ul@wa)nfv}7 zzVLDL{`qOp`R#{&BbwiQSoRh{Yn|ROC=^H_Y(V!nAjX;}NV01XFuoV>lvFir*wqL7 zJ|#K{`+lg~CaqbddPqeMDO^@mtC){vJ{~&0FPz`0h=ZE@lTOiej4w9EGY*dkHUVT1 z1z{J!O(!)0!1{6Z3PBv$jIuZ1XwQuT!!8WUG-Q^zj33xexhl8N^Gvqe+KwzPHy7Zh zuoc1}(tX7qg39tlg9hq}i;%kng3~`jjtjyOFhJ2BuUNwK=@|Ct*hs9Y&{<=`GnVZ_$I_bPzaXd&>OVB|_E~4~+#qr5}msIl{eRZmx@HL0d zRZ5(mW(3#+6xcR+Dm)WtC@!{oB@mNz;u(Aw$z5;Dt}faM_?xW1EFG3U67(1@HQzrQ z6gkL&PlHH^L@@!y`qoV=5AvsT)BX4!o2@#>{uQpct}A|)x8Lu%)hqY!GUUQYf`=0% z@MOFMW>&WlU27eN=XXEY{8@nuRwJ3#I*t-O$rDuJ8saV-%q31r?enewXzo3BCb4d=2jjt+Ms!W$%(M)63Q}L zZLQ)j()j9p%!GpG*3nu;q2f;SYLGOQpN@qkiiW~mA}t3`yLI&5zY$maZ+3c+Pf6xe zCF+l+QA|3D{}B291DUg9);rQ=TtZ4OnNU!Lnvc;#ZiBU+3jb;h2Z{?yS@^(Y^Q}(3 zHRL@5GmH;NS9kG^USlnHCx3BJ^wbglkURQ4d=>geD|KRiI~Ev>cL968LZDVq#~KJv zz#Ah4R*w-EIAZd^jbI^pP?rA-4?ofD_xMrXua3J_f}70R4TtwOV66W&$O!T(GId{J z$HN*CLR<$XKSe#p*)$F$wt-0)?|dWmn4;$_jR}!ucOD5u3}h){y!lXx7OwLqH$ihh zdZfpRvs80G{L`cAFUo^tvWK=PDRwsAJp{t2EdVscy&b~q$-Im~uOqV2qXpRwI@`-| zvv_xytxlX|n!GXayKJnKAfxb&Bj-*v8OoVZiu|#Ku?Yg?UcW|E@?bvy&sjV^CX7WZ zVBl;nps^^#L}%KgFGkk5vY3yu?t%>SJ8^VF3P%cdZ@52lCjI%m|NMhddnuS3nS%+T z6LXu!aPE1t%#fcZg0YG$Y8L7~jPMjHdwGpk4PdjF^am|PV-YHqrxDJBP%TM%gRjDu z8&GBk>J)rZ3(Bx8Axx@r)~2xa*A{RCL#;FB2VluCs|-_zb8P3=&{08l2bym3Vs+B; zp>tIstV90lLo0{|F2DNVl)7VJf~|<;W(Jnj#7U`_4lsgX_Og zM2!hw$3xu0_sX3|teQhnEkOjC<(LRkV=e{j|>v}*)S^IkQ&)-Ph= z!gWwB76!2*^jx;D!h?u`65Y2D7yUl7pC(-oZVeYV%rg(sjP1(Gr)}6me8T4)K#X7M ziBvBXE>hx}he=@4Ti^jhqt7OrJ1t~0!l}05a3rsdgg|^jM8L->JNy&GtWToTQxhtud1ThOP}kpjuQ)d-Oi_gop@kGXXtMN5Ly>2 zZ0+lNgGtb`%3e3hP9q|S5x%~1D(Xktzm|ws&LjL6Z~ymq=oy~enNdBvh^dKrj{MKm zl-!bJhtaB}ndMOm#8dItb#Za1C)&t;OxVdLfgp?8&$eUdvo>*o=u1TGE|ARF5qF2) z&o$Yif3!sGDNnJEVW?-R-{}K)DL7lf4pL;^6-vZc;)NMzM1?xXme;UF$bnj=y$HSy zOhFZ4SK|#uz+ebR>O5VU*&TxP|8KhybK zID2hBaq$dd{y~d!2I_A5+xLpH*@Z|B=0lD-hWkWix^(&*a9Br_bCpI_>{Re~m0K1O z5{BR6_%(6Elrlmy4{`r?X1f1C5=wm;#bpz*Yc=e+{yA}(fQr^c4W^P18a?ZlrXFQ_ z$j(N1VpeV9Z&h^q;({OO+)$w?NY=>VMFaWsUJAbEEjd_96;7Kf4oKf*Q-tn(pxP*o z0=s})E-z^`AF{OrHU%%SgiCK!1Ogqun+fSE6}$jK&MS*_g5PnPx`?zg>n&~7r}xK@ zHx9P%nJHM$+xqB!by`me*+&mqISJJHl)1zznEtVIc-kpr)FKK6oXuwn2NC1Uvrq2F zyN*@F5^mj1czBp(+Vx~1rH)-(Vk*L5lVC`wUA|36S$m-rr>FoZ{aLs?${!PoGlZ3F zd|Q*?_3uJOWl)T_%yn7??#dzN%3;g`M=OJMYZDP-@+@3ej03MR5_fkWIEWjUdNq7N zYuKSvhuKEO5E(P3jAQ6!D~4PNHL~@ag6jShMKwd=W+6>I z5c69zggQ40HfbzJkzf=TguExjNfm*y(;bfMr5D3|`xR0_Bit~H-ozM=h|lZgn2|6I zmPHnq;KP>J(VJ5mDI8f)!>b=`8yA5Jz}JC{rg7`~)q!JGb+#%Kz=8gREeW5c%YqxV z4I^?8v@Bww3Tix2?SNyeMl5u)Aj^aIQN+#XhCwDl^=tS`in`UKo!!JFAxb$`d9`Bl zi4uoKE!?*16uOa{p(+*RY>C)G;OUGVP$bROMv1Y*dQ z{kS@U7+3@e;9a~ORXwBXXJ3d&dANu*bh8gS%deXBWXh1eVe?%ADP}O}7zil6K&34- zF*gGK)#@fD`+{2VD-01!1sh;hlZ;wHw9xm{`I9iH@t|%t20AwDil;-s{ZBlmb^%#J zlUku=M?L|IcoI7ECSqFDTLCFE#>EW0FY$LnA8ekm*e%eoRg|;jRcW*4W~CNqk+5A^HM2 ze@i%z=;1(K4xz~4H4zc7LHstLXl7w~vPBZLsTn7g^0BPBV8v=XL`Hr(u7q`qI9o0- z<9RcC!rw6}){AI%ld5EPh%_mm*dF2wSwQ4wb8EjJ#-ewGcnp| z(jJ}!-_%%IKnvVvWbdA>9;TlhrM^#Z^8zy*3t^EWF=#y75toS=#oUkz{i%JdJm^S+ zPW58Iev|{;$X3*0M%*`CIEuV=bbG)Y9IAvQw3uLU4;{LR@xa`9%@7U1MOQO?3lk1t zW@8hYg&hz=;5Au=9=O9{7`YAZ0|n>UeGtH*1DEq01))j_W_tO0&1s1Rp^&|4l`Rh-%iEKmP|2>z5^hI}T~I9*Za$JF{@% zwRH@Y8IC-M_@mo!>5aXKst@)8qAUtV=8ujhCb5(l4n!8S5dC6hm}p39Fb+%0aMQNT z{BBefu&GKi$w0W%$LUpQ%Nh>I&mR~j1VTc>oQep3A-zOKa8N=BOSmDVvfBwoE(!tGz6DSsGt8&;$YZ5mF) zo&14{70v82iw2Mx08Z|ep~n7_$3UgS$rriB2{)d^D>9iX|Bd&X9YR^RC520VRk*7@ z-&BPuHez@i=Fo6*2*!v*D6Woz0tOunayUGL^nUc9V%Yo5vRe6PV)lOfQ%jGJn)w$L-2 zG}tb(GxUt+8tfpM0W)(Kj195ANJ>$jj&>uA<>;`3#C5U&2a|HJ$2Y5h>fE$?kL707y%D!uxg0Gn24`Y_7j^JYoHJLW9&Au8)A(>1jZ^rEn^eR zFiJ5t-g+lL1NzW>j73FrPtev<90Fv1Xt~!(};B3YvqJIxgQK zwnHa@N4S6kdUY>wrrr!|-t#Kgd+Io&dhRYZ7$WM{fAg;hed z0E1|ZD`O2H{J>V{x_R&eQ=8E(j~j)u{J{=qt=2<{0C3K^PV1K7mUErfEx`-tI;~rQ zZ_agN4+PdOT6>O%n5Rn}mq6g-QpY6_B)imc2?A=Dy0Hg?UM_XM6buHs(CgtUD}f9K z<8)Xm*&58(Vcp44uttX!kzwF~4yz<1z*!wOnv4Xubl7yV4S1%*R>Jl8S%ZCG?I+s- zuB#S1O11~qI_wM?12*fhD`Xs)<3?iwb}g9zmg}&`WCyTMhkYRvfrYyk<1muIZg+Yf zGTAnaWKiHi*A=n@7%5llU<4e3v5OZx-S62u^XbiMA$|4HE0u9y~ zVhXTZgQ*}^1jL%vF&eIpo?xv8TLdvB=uw^2`=h6OT}w6a zr!g?obTUT``g+vW6@y9|0|tT+ZZRAi8eKQ0gcsmuT)(N`L{CEV{YoPpus-@thoF2Nku;qo3m`nHw-y}`1i!n0Lv;N zj`F1NJa87m;g~)i_nJna?CUaYGnaW8i22Kz(I9}oiCKedZ2;Oq9RbQAme4#wIsXLH z9p}dGI9sX!h=V)MklnE?cbqf3<7{~iF^PYfxrJE5zsFodxNt5rdx9-|bCx?mSy&*r zPOgEuKFaxe;=V_ql=iGWSgSKccf&;1WmwK+bpUAJjli13;OsgAXU-8gyG{mc4I2|3 zz+uDwu;n>JDR@PojHLs3Za9cF9DFex!TN|tG#<*5f({_ZcmXR7Yd#IAjMuOX$PvaH zSp>P%cst7gY&Jf{YDk_n{)3f;+jIb5jPJoV<@}ATd@L8WbY~+N!WNO%Cg~XVWFxCy zWCW1N+Lr->YS71I3R?{Zn>>QDsvsP%;dzmq1?gzi)4*z6yVqm^q#QF@!5)QsRpFL1 z@#yB`ax|H2>dc8IyPCG;EXQr4$x737&Uy{cm8Op%+z#P(aLjZ*XFtyTkApuBaTT5X5B=o*kr z(AKy}1{xdzZv<^2B+MScUT9oLfQi`%)?GN#7=vVZifBwoNPDwHgEYd4bCM$=o12BQ z(x3-UVW(kzPa^W`Qy zPndUJfv_PNLcv7up+{VzJL{LiZW2y`W;_^HU_h7gW!`m3%!4NPIBrs%P zD8$eK!*Vu)OrANE;)vmX3;`e0`KT3VDz&V@GeR!ODO9M`a;eHw zTc-jE=ygb$N)_2lR;X?(Da^{3DZ7j6MClqpqPCc%mLM)5R8>+aO_C{l$)z%tR!m}X zp;}%bgCYuwji)JBCnE{Z@KqSkqZ9%g?Hl zU59E~M)uK;<0lj2TAf14P)%j5q)?Ir`~BPj+C?QR$jmQ^m8m6J615~$tyao2i`6on zjbz#RGN~F)6DUwg70P^hrltzSXZCpsMHa%d|8e}uQP2W5Un>eDU$qR zS#n7cq=qZys9%1ZLM_iOL8i=?VM)=yP?8g6Dkufi=@%|3l*;n+C8#=CktZumQWPtt zT6$DU-bHHa+C(mGvOzCxM@Jf&)d5=0mFf?_~4 zb|tMks2ncI&(D;=c44v{d7-8mWTGi0!6vy%MWMVe))lcvZ>$z%sOql>#ny(}6=dYn zP7ab}g<0{+1h^t}vI;Wfn7w8l)UA$i*eOSr1teKn89&pMvI0df*)Qby!bDk-LaAGR zy6Fl`4))YkX&%u(3XPCuOQ0RJsz>&b%8Kauf&=S~tpgR46-ksbU0swynJ81EdN>Ga zz00K_Lyaa3SF7cP#j^Oqa7mFGHPed9k*PDHRT>Y0W6-D`u29M}7KFp9tL|8+l4Q&D zDbO1)oJU%WtI<8}6MtodGcxXa$$Hd5p3`C6Vl$;R}85PZbO%6NElyFGR4j!nQ$-sInnRDIr(rZ4sIpL!58x__Q`DK3 z9yw+lqmW88CXFu4mlvWH{TEd#Xiu$Tp~{@%0vJc*i`DVjiO3H!&}vZ>tD!b=XcfzQ z$>No<(E6(QLK#xx*Chv{iVLOCQ{lRoltA`HN|{c5yyQ}IWrd+I;Ok~5UlUAJo^51> zGNoJ!q9Y5TB1%m-)HuHwuh6>nPp@rQuVIL%8J7!7K$KEZpqWY>BteW^rAEB6vJw<< zk5S9vqABTE*jp(nDw1XCEUCgh^#@g_XF-vo5cY)InJizk%C!T-+YdCKN;9F6k|Mo8 z6(PqXkSI&gAW-auc2O!6$RY?+A+_LYLJJY7=#Z5K10o8O*y(@o@~|dLPDf(sDlnb{ z1s#D4;Br!A0TqlAP+Tt*V1ZN{D3r8iw4p?$M)6su^Cq=K2^~r+0@Ae#&<2svOG*06 z%xA-y*Dyd^PJ%=!DF{_6B_(wcTBTiKp;A3jXmWrWZplhn&tkb!7AsLpbAb%GwPq5F z3zaaC!ii97;tWt@JLbtse%`rLpg|#Pt5ZX}#f2-1N|f@PTy=d_ z1#p)r`L!Yn?(G^Gzg9*UW-F8h*d~(v-?sW~MY3F-FZ-1oAyY|}ay&WpDN2V+N&VF@ zZf6xs>lt9OQj#Srkko4yXmYdz{<`tg-l+m{vSPRy=IaPCFj^Et_xq)bUfKpjLS}JJ z4qDZ9&1f2&EVQgps)TYUJd{KjK>Fa4s;;?alJVrI<(cw)xms_Ebm?Oq>9v6oNA|GAIy@8Yoma+oFrwY(kUjXoz(Y1jH5RL%U?llrq?? zj{IwI)!P}7FYC5(dJD!eJz1fa6uN&y!Vd4!!b710uia(?ha4r)RihR(aSXM0S2$Qr_ zxWc1R4*F9(z++St)g}6BC0q|Nk`lPD)tQOL+somej4Y-JJ2-2G(Xm*CshT1h1icwy zPtc!y)as{gxe!iC9qG4u!ms`)0V*j7tY`P9r{H%r-oLH!`E8Bpw>7??2!(M9WB}D~ z8;SqkRQmnBX41dcEDKLTlmt0w2{yHU8D=apdioHHVzgr*vL-pDXAk-ivV6Q|=ZCYa zRL9AB1AG#JxgdUO+z6HFtw&pf5(N!~PE6{yNG(SVO_nNG=W5Ppy7Miad;B``SN;7e~vRJQ7fn;S#l5YE?5v{vw6J)NsOcn9tX;}6^1_~=E+>R%pL~4ERN(BQ zo=j3dgM{{kf$SGMXTfYRP%m{vk~1}yi9$Z|lby7tQ9yst*i%3LY9?Bf+y1(@P#R%{ zczUwyjP_$+n7aPj*ITD5-CHECFL|c-BRV@xgwZj+5akBiddT9}XaraE&*|>J5#B}h z_ZDM8C?Y4}yi(&(sEx*kkxC`pQ(|F`hW3_76iDFKE!R8AcU1k5OXx~;LWkcO1SVOa z80Lt{Kn@Dv6BwugjF=z~*5txcA;<#xkgf!vbuvKNq!4IZ2th6`31KS*qzXX^tVd5N z#0x+X?g>+0$iowWhKLGtRVb+t%9P*|qJZ)(b*yPM6tDqeQ~;kUT*}1tg}8$U{DBtH zu;_(r6i`JWtPufs_@osV!rJ<{AhlFjaW$X^sqHTVJ+W%}xK06KG*;Ogh~W@oVND;9 zg6omdJORPi8UtF>L5g`vVNE{#S2w_92=gEn4s}*yKbxmRueINC%d@KL&4!hLTlRGD z#hr^v#&B1+&KMy0gV&O6VP-^_12!NDGkY!vKLk!}KnN%^7ZX#0un_nVcEG~S1439W z5SqD=rltgGA#m2wNfzu!8l&59h7b@eAxYR+vk^20JR#Fe1fOQUHY_1Qn28u{vj7eh z8wAC|a;O2M(ioze!Y55ZCDg+lFd?+j)L{)H%>tl?@Da&i3mlOks1#EO1dfoQ3&|#- z79^Gy&2R=J5#++xD{q?tS$e@jP9!uX7vNHP6%H&OgsDww*JrvgsFv@1UoZ5 zsMxwjf>>w+7D4Mkn#pJ@LW4u6m6K)#HrTHU(0VgA#@~l9(KiHWy%@705R|V#Wo~&j zaD?P?0IC3bnI8g(Cnkl8kQV5DS3yQdzMXePS12-Ds#8}bRkHcuJE|`s(-gtCi^D`HM1FE7A~_E7VMtr6WitN zM7VAX;E%n5kV%-8pRnO_;h;z^m&qZ_65wh!VsHo^n~p_nI`lxzVHmJ5YXH{~A6lpU zGX0;SDZ#JxHBASizap;`GoxbV#)Ssd8*9UOKv z8w<2Sqm5+2aa9m3ngFoJLjuc8$U-g$i8g{*L4^S%AyySeTOQ8WEztz8Xhtmy>FWD6>6S-1#8CY%Wlnh7Y6BP3uAbaEk}?Z$?-jW+AVrq>%! zZ#BWiqgkRhMr^$WYlHdP80wSYm~4#U8rSxKi=P9vgUiWqW1#~BZ&BOK3#k9c#a?x-z#A8JivkDhuJ<+g^#l!OO$jyPVzOKjxkt-oBP#A#D zj+S>C?KkQ4c8Ikxi!}P7A2OIZFegknEV?U+;}hN6j_z#-7?5Q2Lonl@$%mLF@+e!{ z7i{aC#f-zKBhsvB#o?|7HNlD^gsU+ZX-gq*#nBIS(AZGR4%(eWUe=wD`_WTM56Ocb zV;0()>*_GYu8so5Yoe+lX0Ay&oG6l(O4w>WOjl_~Xr;4waNbBRhoG541ecK+kf-|_ zASbJUJ{!r=JmI2*>yu?l0Ne!I5&1eFCl4Kg0NktlDnF(o;gc+BG<$H7G$ z2`T~_5}MyyNhXcpDMQg4f5`@q5kwjR+&tqVlM@t5{LP@d=7uo{{U(lkf>Mz!&zA*h zp8o!jgK-1hwW#K-5eLx*h>1|kMVM5asgkLE2;jAMiBNZwCWObOA_aXM^%M%BCPI9N zsuC(?FzfFn%Yr#`BLY~|+XDb&0vL!qDNj)ge@_YkYXb1XiskuPF_KJKK3C*J`A~kI zVgQ;FfR8J}l<@eFD@cUr4v9*ZhOd*-M5wO?Y@)f?K?*aImBsKRU`K$4zrXhbEd0$k zhXAAuYQrToe;EcA=)WmrM_?0Mro!`ioZbx$zROY(nl}lwe^Uo_wt>XAQ1II}XeW$F zTB!VH5Zk99V(P)8M^|oWk%an4Tc%~E`S|&W(!{<2erYPDG)<09J_WKYIXot%{r=l= zsj5h+=#dfNmnjYqw~(f3?eO~^MOoV4l=`3b@z1F%$Dy*Y{&pd{cJREdjL6TAmB=;U zHOpl9Z2|Q8?gaar*3aR8;)lS>TL1E=e&|(A)k8-g^tXdL!J7Syx|;nA9|%)G63Bos z5+uS>G>8Xr5RZm13YO7l2lK_Zy5DqLtb4ZB@Ih(bPk$B(MBr8^Ggm@Ba-89#%sm_C z@aW@+dnLnKlw{fV|LIBpjbPiZImICJmt9#nH-+z-JXH)~V4zQzqUnyzP+y)N?-YE~pwi|h`I9E92z;`2}4=>B~@ zJn=0DS`UMO7vvqIInCu`n-oFYq0#0*9_a63ErGWB`}XsMH9`=I`3v>`}+#B5hp|?W++CTpFT>9g={E_F+Gg{w#2I9Bt zLh%V$1~tfp8kRuo{JyVP)ARp*{(tf5PQSC*-S3}PrUEG|J&Flsz#u?1 zb1qp9D0{tr%myP8oRf@}rF-009(uG|_3d7j`}_~pl@^s$C37ED$yip+APJH*N5B8> zeXseDdB*Kr%dv*ul#xy`f(2FRjWuF)WU|f4j!7bON`MfqIWJYB%7q!GT2Ux6rHm1g zW6nvGWfdq2vqW~34WjVO>(BW`_EZy8&oH;Ht4CjYdnBnP1x3Py@KDOm%1Go*d5itT z6y-1W?gCLCs)Y`vD%Sl+G&7?3sGe`mjEzr76g8)uXwcimJeOI#W4ypRLTHniR;ezUFb;rf`x?6{4`X7=-En`|{r#$|+@L1TX^yDnBiVvs! zfr)9}?SY=7gWEohPHFday8P`i6VuNepLUt~#OT69!a+yV&Pb=(jY)rMvcR(K(!3k? zUL^ErVqPU-04>6zY@tbQjhU9r2B1^p;AaP3u_x{n1+`eeoS!a!S%H1X)`4kFS(Z0& z@cD2#F{+67EaY>q&+FV)@AF+}LM5XHO_;G%dn&rRO?Bju@LaXJsHK;eRGIHtpgS%} z6$M^Jd2&ScDxzPHQF-a65x*dcCJ}n2Cu~A>VsqgdWWmEc!Hl8WQEjz2MGgtn2>Orp%GPPE13Jr)A0D{K|#)uxq~yEYv!Z6(g|{d{nI;PDs6)5?R{Q@qr{Z=&|cUtDh zD^>+Pzu~ev;@G|kIa|R=lQDu9XUIxXbk)>Z9oqI;VS6EDBMf6tVHi8F7sgf#R`Euj zZZ+pRKGLlIIgFM3M}ma|Wlt~qM*8(xGGUTD2fc8n7sy0nAF`_`s>(>12EdN&N^z>UT$Y_O(mz5G~q#^{VVq!FadC_gYoztk3Pw8&_WSA8YpQ&V|0}VOh5`_d9vI zuAF7v#Mo}*-c^q4jT5%tu$h<^y|84%#;Yek7L_^^gEqUmoZ7X7#kzgVq-X5c6=@Cw zU7j2|(C+ZV=7Y}lKN!xR1Xye0WjzmQ15#R2=!L*I3I;*F5E%UTLf~(BtLuw*qKk#DW~ts4f6O}g zqtpV3s44haHcIjc+eXHsjxw!_;AIT{%1dOdYi7WOz zTBllgR(hgcZSdVUabLgJ+}cK(w@Me@=-7JR%5fng|6=EE%q39;_uus`3E9!)#KXux zR@SBmzbig;KU>=U_#e{;4IS-By?^0zT57u{ET^4u`&})KUu>Mza*_XCrwQDJ!?I!8 z#@Y_!-F!OU@g&~O8sThB^mCZYz|n(eFrnG-iLc$Wh=!I7Xn0XWlsD=T4RrG&@}S)4 zxZqe97ZMc;7#!e4$+P8BiCQKMEmr3$lyY?m4rVX`^A?H4q5y9(3}#{tDn{r(8E5}h z1Y4`@oYs)a+GRVvyHFT5tyfZhaN`S#uYN;w>z{QHIZ+5(HG5<(f z;I8)PufX(L!SXpt_I35pEn1o558q8RX@7rp9@Bq&(fnlPEr1BXy%Yy-_H#DZY5 zFk_hh>S!e5^7V`;?p(7GlWtG#-fFQ(u`qD^B@e2hu2BP$X=uj-NuU^Hf^ZP}Lo731 zUfDe)rTLV5PUc@+Z}XBSb-p{FN}yv|G}VTRtPZaZ9n$*m$1+_tddnV#ARNV#^`cl? z3I=7pDCYm~BywoMgwtGqjb9`IItK&~Xco2Vi6Uf;ctejT#$JVsqu)QtD1H{x%Hv}A z3jViak32;49FCVIOf9!hUmoNYvvuy`l$m#mwryVjp=3j}@_q2*&;dtp8(PVaEto0v z_{2}xpK`+EPP?<)iykaCn#)*_a%=O5_NlKYh0T2R=Ed_nLz?&mZcds0GRa}E>-_@eY@J9oO;OM`C#Kw z@dd`_aY1D+ZD%UayvaYh=V{Tr)CsBmszz5gZp-NM{?xo2o_axxXC7Wwhwm%>%-$;2 z1m;wJOk6wK+frs{JmR|PjjXqdlTqi-Sv@M*&s=}*v-`~^BW5q>eKv0%vf}Q?+e-#S zZR2!rBkLX#w>s=;+_QDPN-pty3<_+@MNMjrlds>a`FyX9>58nW-xDl7%XYEs`_@hh zZ7$z8aqOfcqc6>{Uul#!^X1%?LvjZi_VC!&D-YOCUh&$p^iRuyj$4ME>anq4t4^;DW6u4!Fn?ms zMdxc#NvnsPzULg}*?jqs_>PH&cNy-VdyE@L6%KvVnVR*f|Ai^*9@7un!98#o^tmbyQ1CPkAoHo+B7hzoHOWI$3EYP>9z^n!N8P?dba6? zL)5nY9?5f7+4Tt(^*%o1W~+e{Yb4|bTcb5!-p^P|oNU@Y`TIxKzP&=eHhM3E7FqOH z(YxM*@DI`3R6lw{3ZN>c(!sZ4991#8{_tBPoiF*1yJw|o$qLJwcGU}3#Hc#G<(PZQ z{?|nPzjbtnwlsR!?da|TLEV0H@-Lq?fq4~0tJ4?rI_B?MkcT_>< z=2Y@noX|XB+V#F6wW-@yb((H-+m;xzd|RK_BTqkVMLe(FIhMydJi2Y|%Os2I@yjOM zeK5MmALV=QSG{I?4Q4zV@9NmJ=<}an?)I7HY4n~`TeRIeZq}GQo^sOWnt+)(9tS!Y zKh8{RZ8>$Muyrk`k@(|rQM+EEAU7rd@Z+MO?}K^fH}~=+V_sg|Z1p5=%qstLymVyc{r=6Dt~!E z%=te{b}hB;o9Xgm?hF?ncJD@+M}q7MnpD2zA9CMzDtz6&k5Bt;xHEsT+IMr@fu0U# z&3f?z6G!#z5*6NH`?__jV{;DA3Hx4NVqZSng35jvX4b9I;n_{?PlrEpd$jFs+vD!% zFNw=znz^=h%;@qs<;B7q(`FrQsn}7`T+J3d?`6MhM&+L7$s5=72pV3~OR~PO#(d$f zrEOlCDZY*n=db;Cv%}$04o9+g%(5M7mPH16tm-^=^IiLU8&)5cuJ4n~Iv?tpu)J#Z zfFy;>aL@lc2&O^bkzRB6TA2$)1OD*dQZp{!}Fm+HXsmjCzP1=chwxBlJo{b_4qRuX{i+di+oQPF0DrSC#Mc672} z^u4&pbe-KF`_qTTkL`8Re#Ew-tKQ2FuHDZWl^@skO;+^0>KW}iRi?KvElEkN&A8D0 z>yYwXh25@ULA595oOrpFv2$SgfW4;gmrdI@Bls+58*_g5fq}gy%^CgVtFO=7JtNGw z&kbpJWNEWktqH3YpHH2-b@2T4z0(KXGf`Y$A!l6hNj=A0@Al}4Xxbu#bJqJRs>M-3=0x1F7S^4=bcG~XpGSIMavRHdV5-C|`DqDn_Q zNNe=NcUX>mNaCRHuuPB%yANqg$QVo#E;lOehwrh_h0$-n#}fV2mnmFh4!X85Kk4Og z(1?GkSXgCUPn*tFu^v33HArQ3*kn+x2e~0&REj_kF`en zv&x4m_5Y7Jw=>m@cJ3y>54=J#B@$_Fg`r!D{Cq?{B77?>66?_aCAY%&%Dg-bmptve z*ymPE>jBZmMjI_wG&H}FIHK7!i=Im|n{)gY45TVE^ZE0>vW=`7u1lz1mtTou&c`qhlP?b8HzFYFs^ zm(QS7+m9?J`psH#=AG(g*G8pYO-71$t{bzV)#dl!-(;*aFEgK*y1BZW@6>@cK0dDx zFz0Of7G-5P{^kplj(`-&!zJ{xbVs+KqvK}Ib}m*1o-$k)bbq;HO6Py$hPZ`~ z*iG!;g39z2%RHn$5^oP5U!N?GOsPob;VqW>O0u#x{9;~ZO}mt%LNlHkbda_q=|Dd3kY z;$KCmVZxz30+AH>X?5dFTcGUDf4#ifMkXu!nt!K@=ku>PEbZbyCxb(QjaaApTt zXDd+$e(UoF#{Mk^x;*GJHMwBE!hr7~P%YXkSs_b8Nz_F-t?t!z zk6iCQ>hb>h=69zw?9l9$uu1><`|hkfR66{lv}WUCc3Rl=4_Uomutf`+JQ8Fan_q2_ zJInf&b7^1mmC7jLuBQFCF~YOdWRcP2^UdEzMRxZXfBfRht;r=(v9qa%SA}lWMy17? z&_z|Z=2kgzzI-To)@<*~?4Yp&zkRw>73w{!chnB2<>dTjZ66OU=o+%4*^779Rsl9& zj$FU|bmzJGtgQ0Q7q|7@V1JP7P+GBe=BU85&-~h?+C7i9nq(wUm7Km*B`Z^V>0&(Y zEZzzjKW_yU!~P?oR!mWJY<2lNN8h?#K}7jc{$k2EfWDq-fl(2K(0_c_sw98i4@k5h zkZ?bMYi`-gPfAl8&lQ&nmsXm_`fPo@v6KCru*R-=kGdo*-OToH#EjlLV4tDgb-%oW zW|#Oc{r65|uRa{`2hl(jc5b*)N!HN*Roxx)SIv%|`6##B*_$(x*7Drrr;EhvLL$W?m1LaT89hi`bNYX}>32terO= zZ|>~xG&P`Ii&JH5Cakn^ShOVjsiaAd+s@ImGKSSUrJu8JADp;+E(yL$cM zaHlBUq(fBibsxa(?aRr^jH|mX*6nC~zGM3b0W~I%9HO^dZ;mL7yt`+gvhOYB1IL@Y zqNW{qvDYT`>cG)YW231>%f{S%+I7yVFV|OR*Y258QTpt{v-S_7T^5-;FI?0wr~Lki z%sv@wy#`%Ootd_)x3lxBX9fG5$GVRV@r&PcdvL_?{RS}y&Mye}Qcrqc_@R%mle>9( z_es-(zC^<{cTR^(UKI63*XX!6?gmbqC=uH4#Rz@F7!4BcOojjI<~s~km!Hwi%__3;i`p; zRkssmP~I70G2ZOD>1}q2R00*Jx7mgLy$hwk;IF1C<{;&T%!(;gMHN*sUS}jv222yF z)>?5SVd?#^_SP(gR0T&SFOVopq(v&vTy+5zqGLc(K6YZEt=?P18Tc*We0(M^!GH5X zjo%2C;rDCNd&{0e+xm9joYzAZOudy{(#Z4NC3Q~I8T`qD+tLZs!Y21STVgnFk1WH} zJ@~^u<(Yzk-*&cs$UE9?cQy50FeP0!Xk5RMQ3)L{8BQoW+o-+Go4~M< ziKkb8&ASuK@pPGSKdAA7^BZh?R|V8Q$~qDe)Tgh*8}oh($EgR7etWDL8Rfcngz2{V zOIU_8p5=bZ^_*1g+S)a*Q?#^+fxNKG)X8@TzTG|cO_bY>FRf1R@O@F}wDR7n=Fd)F ze`CCAn)8&YvBp9C*WBS3n(Px>*S5SFF6Z_VQJWVI3kn`HOot zZ!}=d+vXo`xVIF_r>^ZhJhxD>Xp?$h2#dXtaCHu@Y;7K!&ELH)_TBBV18fu){UR6j zx)}a1TWO0aLvCJq^Wn8+&GhECPb`>n`gyuE^iEgK%%Q>T-t05%HN{OD z?3740yu5a>F>~k5&_l+~&u_@Qo=*9*CT;R1aG@q@N9Q+F78tZ|YdWpG$!XwnV9ksL zts{He`5rtwckZ0NeVcx2JE_UC&utva-_8E8D{oW#DYZ|E`!ss`*l${ib^GrZ);Z)B z-(U6V%g87E^2hR4tG-arm@#8+-YhPVjt@FBD8L2%};@U>;4m&cVS65zn+q|zObN1{gDClt{QDtt_H{pb+(&95!Y4IN4B~1FK zH?H3v3H45z)fJD><+k>IpdnMlK+6AL-+_7Q-!(L43Qxa3-``?V@6Fa*8f-f>YeIp~ zpu1B%J?&PV?zr}7O41$XKYSl1ESoecGWgN>R%18$&Rc#>UYhIM`uqNuQ~Gre8pXCa zbZ63~S#9@j{JQnqs3&U@Qlig%TiWdTC&xxdR}8&c;NK&cKjSlh#6l-YB(LS>k4r{x zspVUZ^?tgmRYqRNo7^LY_J^J)OzYMu;$+Z;K21c$7sp9id5^1%%b8PLj`!MPt~Piv zt0QylmQiPq9SgnPe?FhQks0>jTbgt3oXs9-ug-M;Fm~d_XQ4)I#-_808<)lz`wl0( zkFUNRFMplAdHjQt#9_B(Ur&q-T$E4tPdE5p+R~NGGMO{5-{Ffl%}2Qn9Fu9U3~&9W z^`&8o0~=bkToA!B-XuwD?bBt*xGj6Y1W8+Qlf^Za=Iy9T^C;aUFc^fW(!2$viGR4~ zFn55YCM3c5^`4`W2x9ZKlWs~dt1Ah2Xj^Ak;Rt<6!+KC>9)qaoqN8G%=Xyb{+M(&z zz-bbrNe1GT8#ccl-~Lh$-<30-e{Z;qWGDG8?fk;Q+8nxc-L;m#r^w&G3x#f8%1PpF zb;XwX6&wHY*JH!NBEvnrsqjz_aYR_;-+Vo`y3+UrRmtv2RWdtk({_Uj{69(nT zozlD&<41|aBJUQyz9?SWVD7Vtpj;Lp#>a@)IS9N2eHvbWc!;B2?9FD;UqGeu288#kI{d(yys zOqqo0yoQP}dDVT`pyY7Fi?N&ix$DBNPh5UMMWr^YoEK?y`tiFq6(@E%b{BW*9`(9Y zn<3&sc4|q^_>79=HK!)VOxUx3Vfq<~d7<;cMjwZiZ@Ve^61Atftz(XvvXT9WRqeBe zCuFWk|Ju7r(96`~MC0CsmzG5}KH#0(WpF{q|DL4vk3Un6jeR&bEi?B_P}R7u7f(*N z-v3{Hdry~CqJ)z2pjvo{z5l!3-un%2n5(-$%!tC>wq*2G;b~hW* z>v%{==!|P=R^QV;cC+%G>X_1A{UXft@Ty${4i0$j*RM-!o7dAy+Ko>HtNcx@-g%W& z$SyD0kazdc$v=nWX8YG1H#=DfLqp9b`s++$pyg#~AC z&-`fn#s5;(+k*>ulZVXTF}u-9X4t^Z8_H)i^%rh%x|j9z{o7srrJbEj`g#VW_L|#s zDSL#;aLcWdMS^3~FB!L)UVh;8iAASh^c(o{cB`HSH`CQqn{p*rRwvjgcD%X`Zaxrk z=1*+-Ue>11!w-wwE_;7N*R ztnGT`uu;cpeTS-Aaqmy{cs%-+x2KuQyWL*N&F$YGULJSFdGnejS0}Gs6gKzBsfMAk zw}yOlojy;HO`Y4O7Pr4CEqym_gjeH3_NzK?Sa~fXa7seYi#2Btbi5BUkp}*JmQ=M3zFN~@ae6PGPXm0bzy8ga)+^ttyTs@aD_J(>`v>DuR zu27YXy?WmtxL_9yhXlxzZ`?n|DC)4zuc%cGJ5Yz zNWQbp)MYrwGV4myi<7;*gGQCkE2UDL{fEZp-g(i_;9X={4?-Oh*vo2f)s@KEWg}f0 zPrV?t@?2k4ZI*kWFi+(c=x$@ve@-oLFh?xCJ!Oir{Mh}VJqs#6d>4i}bvtHwZ+F)} z?GO1bPpZzk(X#2G#BU>u!It>0_g}p-`g+`;x>5FV_9~k#r?Q3Z6H2EluD4t|`$fF_ zsvezZC>L6lU3)*XyZC#});C?MBrYTEt3kTPizIc{7}~;b@nTgUc$zOs-B@yv6#*-KD;L>%X|W!1;r-hu+_& zcK|;RO7!2gyZnat&zJuH>YW?D=Jj!_$nLX-E}XRKV#bwKf)}>JArsy|dbjySRg$`8 zbH-egmM+J;G&UT1`g6L+k}5CSe&dd-}Abv%l6qROq2eL z0vqO!&+RVRGJ22KQ-@t;)(m2->8eXf+g@!xI=xmjx(z>irgWw26_=&gx8_c-_;hb^ z_}Mw17nhlL@M$S7m{)Mpa@;Y=gXkT1nqOPA{g%yF_2o+QW<7jGSJeewhuoO8u(`*Z zXUofas!wgME+p5Off5M;j{Rin*YTIgt<;U zIEK1c0T>owtzYNw_gw<=zo`P2g%5h#Vo;BkU8*bgQWd-AS8S&$w)``rj7v_UM@fnO zJi=Q<`Fn^W{QX64lnXt|raz8SNdNJ2VXOrGVNGE;`V+iAy@x=uz=dbM$5KtLP3n$+ zA|J7L7ahT0L!i`D%eu2BlMuO6t`twh0A;i=^#UYWFilgi?m^c+KVpJvTj=#A(H)EK zVgsLCt9cX`bz@lG>0YBPb83Y3{o=+lr}ukX+?h1wV&;prue_e5zFs!8a$)-l5E0oa zC5uJP34Cj?NBW}us%LiJY^U6vwe&{XLD$7y6<=S@J;~d?^U7MVZWF5~>+`MX_8-1= z>f3H>uQuQJf2oO@6E@o59-lw&n4xRM-D_D^D)N`UfBgBwa!D_);fk2s*VLj)@*P}xukgy7_|GN{zfEiO z@4zYvG1W-_#>?o33yohcwf^ix+D%%&JY)JSz{QmzFjRp7G+lAep9rT~F)NnHY=>J)E z_3_89bKX8ht8+l3X}QdCn~v6hiT)7y!~N-T>w3=GnagHvD!+M7`jn2y^{V;P7|%UF zrPmUBK>bN{MZ3S5B)_BEm+g*0terEMAV9W8+qP}nwr$(CZQHhO8`HKuZQJhNN#9F0 z*|5F}DySP2?te~?>D*7vw9V$k6}t1i)NykO4lrKi7Bz|P;&58N|7!=^=fwq%&uMYc3g$p zK8q$>!{(_CZYbq^KDAumma8r5)JSwul3i(B9}Zh@)y7@$V6klN_9uCtr7Q1icI(&v ziCT5h+6;30hC@ja<`@!ewdBUCk_op2l@O3{P{8tZw^8A2JEBp2Wix~Rj!SxK9 z?wtis_9Q5Yz@&L0WPJDdpUKtz@vC_VfFA7*mTWq%oZjg#BbF`c^0(Dhm-KY>!88iIWP(ucl`Z z`rH$iwfc8g$HfAsAz$q1QbrWL{VG#gG)&P`d;?gA>yUr>RT%luzoh1ia+ul_ux(Z4Gz`JA2?h#L)li_;P!dEF1A{d0>J(&* zA~PaPNuC83nZy~1PKM)NH2N?*J;-9HB8t?7^T`=_wCbT3ViZi{!M@;!LPz87F*WH}<}WvA{Xz9CY^AnbDkh1=)`OAcvJ6@He4nd;(ej(CeA@nAEf z=m%(?eYpIDq#d!q$@OmqKJ}m)x?xq&2cyL`DOdq6OJ7xr@VTc3@pS$?wVPO4fD#sf zk`cqRD1>n$#j$Ww2E9P{J06Yf?8J08X0D8wHv)5-t+qx2szSS`vu}RU&ms%}m)C?S4L8M)SgQSZ z{Lq_iYhMXXfsk|RPYm&4fL%_k@pd8wqg|pOM2D8{<>8MCVK3mq`xG4p5N1z{{4eV} z2tXo+#~~aKU*#Jrrl$9L%G;yM4qPl&z>J|1dy=ZcWMNgBUeHiZ|J2Yiqc%5~w$(po zMi#+2QpkEdARh?hR4m6W4G1jw!)@)5hhD;WPraX>B;4yg3|Q_0z_$x8B;xWO=fHY0 zd2^?D57B+rcCpn=AT!6tOYFxae0P>|S=#Llu==ziP)fk5E)^8SGxT9@3Th-P;le4n zP?zKWk8-T@m?|~Ifx^26k3%mF?16Rz6=@rlvPW@_jta8by`I`(y<9-b-YLG|-W_JR zIlbmZHJr)7F$k|NC>8J`G)M-iqDtl3hp=%*o8!A06cbx337Fd;bkpA@Dc06l%ZjZ_!gG}m@8}^mETbw3O#q#M{nvYt3G-eY(VV=MT?soQzdBLM3+j;_I7rvE8E1wUr zZ{cSGzyti@On_^T-bBK`)CBR_PT*H=BXy{%eP4I3ywT^{14|N=r_?5`hp91hC45?^ z1e#zZQ*hr*5~&83SU!o*(S05%0eUAajVsvdR7lo~n48>xMi5JlRSe2^u*|o$&2WqZ zWPx=PF7XuFP!_a45)ojh#bTAAHCjL4jbqs>nGLY4S>xvIdIV2%Qoj38C%FB%9onm= zM`dFg9eXQ(6U76cO1h+pHN|myug&9dCixP$@rH166uIMthmc_5!f=xpW^rVI@6S+k zlSrc2-_wj6gfB+5;FU*A84;Ofs?c(d^6)|o3ok-o42qfH@Vyo5(|&y+c_4z;$~ zGve!)Nvp|obh&INVxFl)Ve9s#WQ{nnEJ~Fu{_2z+7M@bPB^7kqBiCBna4(*_An7@Y z1PZD@BB+SEo$;XT-^m6L3%9 zRYZ!`q!aYnUcDdU@TW|YK}OvSx?d7T&~388X5=6whUk zw_yVsTL5d|O4J+gev*i|O}Ag}Y~ zb3#z`!0>89DlXt{y~7jGyfJ;QeGURXPv;c%oV|c3CO{Y>OLc%}E5f=eZpUFg*xJc+ zX&}OmCXE};QL#z)fgj{n=1|He-P^(~T&X+}8Ni1@P*i|=Uv}V~+Q>E26eI9Cp}kms zFdFijsJA8bUPpYytfrGWSXXy9{+oS7Lmae z|1x{bRu7}@B3rJaaI!SCSfe;vf^gUvWlme|R7B27yp1{UhvorK^b{w_R2obG8)TyHHgO|B6hsYuL?CTz3VDF1U7)Fs9KyPT zDP|<*5p#7-<(L$vAXGbM*Wr>sPF6Gpxc+T<*q2jH1j&7_Mam7!bN zPwGt1)UY-!E}Xfuzc{4p)*r{ZUw9GNRUU>+(;u@Mcgh;)$Q%YtftVlaN0Xsh(-VJ%b4TJBGFb4DJiJVFK_t{xA_QGRSw9<23w% z@2=K~b_Z@G>z1aAXEW{Vw3YCHrKBf(;~`Cm)if4N0lRUiE4j4)Foq2rKp4zpl5k5N ztV4|}4EMh7G_HNjWJ3JGe0W=k9re(om z%wAvthe2OO>e@UdX;c5#m>~5jR(8e}Uajx|69|p)z#3grek?lmQ9Zs+i1<0}? zbwRFFm5W{}TY);rY=^_E5LVmJSFA{#phDyr5nDMmOZ=K=y|-e=2`y)v^NC(AXWI6^ z%&J&s-8!x5jo3FE->zF}bhV2fGhhLo2^fkQT0SoR}92E1R$CZ^U1Wya@!ig);?8p56Ay(xGrihEx3WnRS%&ZN-> zh1PAH_w`53&R%^9@+Oe>5iKfFtAv?#Mkh^=+w$j@R@U7)jpqHE&jeFDP8yu2v5{=8 zf8d*F7pfcjk$-Xgtc6r$PrM}Jo*TCB!7$hza> z+tG|H*~7|Lug`!cT=OUnRCbAhGlsU>NEpTO+p+Oxy32iY*v*)VUCY*~*&##ZE125& zwDJ>6ErQgp3VHJn&P;`v$e`%~n1c4#t*HK%7K-;<;+w>d`gwL?k}jH#&;(4Dq#3YT zN?VrMzWN*y(Ou#kV~;9{^E*{i+$e2#OwlXz^?trvwN=9Lowc6A-F{ya%#JH z1HkuBm{UezV^d73C+wZ*&=;)zm)!)nGDaou>v}h<+Eu%F2_sIxtNf<0MVxJgKgD$+ zzGGxvU};w-;fOq}`))myrwiR!qw?o^t5m40CyJgV7Fti3XSrZzAG)3hcBe92cxknO>+A**MbaQk=XCA4xXMi*m3W4_g6IEn=+1lIe z4vgtzu*$*)P$uak5nyqoeevlPgNmT>s}}pR=`p>&k$1SOB@Jx&g&4W~BbG?5f?=je(xtZ? z>e%7FB)MuD0u5O~x)4~zKS60?e*X3Y$!riaD{2WAR;$2h^X0uAGL5cUQ5l!q+3rwF z2W$Ucki)4u{K2J^QFPOKD^9a8P6cO~FT%Rr!E7?tMFBvil&@j5S|k~j5}x!lju8Te!c#P`B6XYdGQ&E%%nmhC)Luo_0oknjQ&ro935$h=>$ z%{*MN8%E2p@B*BdR)$jn@rb9D%Nw%aXby+LryxSCt# z1f!WE!B&%HZY2KsvPTxW8nDpiU=%Kk%7};h$&At=fjzYZKS}Iqp_R zgs7JCtf#lyk^{J#g2WO5_=Qu9X98(m)APQASHT0Y$j=@UyWh+Q!7{MS4;#}9y+_&L zBiN+ZOo_jtd(gSG0{g%dmW1r8sT4b2UUG)3Lb0ia^=c2qGLJ!#Q`l#S|IUV6w$8p+ zxn`mU!r31-tjgz+OwsnSZYw(lsAamRq~D{FKE)0zM*?iEQw&`-g@U%lW{t&rN9CQ3 za;BgHBGeT;`8{#9R1zR?Gno^q^C2J(s&a;#Jeyp%kk4H0P0 zI)k)Es8U{4C`q=$lugPmSPt|tjBr8iJYkZ;NTQeSHl*WDndeyK*)T`)g)z0JF7iGf zua@^py)na2iy1sSgcFt=!ebC+9J1LN>sPpXFGH2+qw+bMHl`4cXgY0ZW~?yNMDU5?G<_IGn^1YO2DSG6&1H!9;2fsm42{9oO! z&FrSs8}lP2rKW6)Rpgs~kediar@3$2R291|SDvsI();SnMQ!29VVmn;$EPn<1p?#$ z0$$i3Sgq(}nWV7|V42I!6=^dTlesa)m0nQha;33}v=|y@Zy?x_}lzE1`mbpa?^VNHah{0YR@o zz3T~H>ejo_y>EM8!wkBOeqXO35m0x%`)~bsfBkkJzZU+93UYJ*xeES?3P?mqWx-eg z0C4;I|9J|y3-o^W>h)3YYVEp|ac$K2Oxtjyc}&srbBT}9r2c3k3G%5^P*5ODb(|B` zl~e>|D-XcNMIN3+GmFexS=mT;#;hX%5HVui{or7%QN7X)%&0J+0=yw87Fj@h3k`(c zvV>R_G0APf3Vb3jD?E*CVqB?jN+hLz?f%$!7pP;TM573IqPm1a;aAjQuSlvk$TR}3xNQ(pLX#o^`A?wqmBYmpZw@O;Cf#F5Se`VOr z#4zzc*iMdi%3`m1oTi=UG)V6<^&GDjsONzSeqW-;dodaYart?9#Efd7C&!!C;j4dl zwteKd{jOYedqwFvxMirp=yOnCb&qs(XxjJMs#jOz!W(QO&5wYYgFv_K)ZC``Z$G=z zkJ+ZN*Q4P054UrC-0OKo->OkA{q%t~90LrvDJ2>Jph$5KJ|q-2NVqRvJjG4~2ve*C zwm>C?oOP(6AG`zz8w9|90$6Ho?q$RIU@={zyOF>{1w{m_z!P<-;Io2LfxrcHqm+Flz-qGKn6z~)dz$RcRMnn%b=rbrjDUo*-& z*{K9J!QBy(;3$!l8lI3aFEfzKHwMQ^I*+USC2$zQAz zEIN8ac45$}gAP|V7nQ@!&*8%QqqD`(MOR1^X_2k2b0sCm3Xa~bs2sQ1S?u;erDdIJ zt)1F~s(kSe4NhrbVZfTG8U_NaVq{@yb>4Wd#PQ&wT8iLQ3Kw!KUsCBo39VG!yH}7p z%qsDUC9Nc#c?6J>1ftuM5{tlb?82hi)#i}fywYOXrn{dkyjHgLkpKp=-*sF9r4y}J zC&V|k_cfrkjaCN;uKQApMv_%?Fz;wP%8t8^DHAQocv;Y!c%IJ|7O`H|e#(4yG}SVH^Lk++Se)~VG^OS7F8YST$ODlN$s9%@bPyA;@G zTv00GI0$AH646Vx)G){jnmQQo#+>81gs|)7tB_W%Dj-QH!CDB)`{e` zIpi=&C$0#BrcQNB^m9fyqFrjUI+;*YNW?!MrrO0MMu+8Fk7HzA)B{V+$A}PyQB4kMkzd4Cme6F@Rb`k&cCu4T(2rV ztdY60GJPl~3^;|}LNfQL>#5T5Dn{i(nF_SO!o_Z921Rw0vI|AUGC&0@iRw^$EPlCM z=E6DglDXgslgJmWe@XmH4Ih8heDe>EwlC8%Wk&*{l3h#zWKdZNVXyy#Ih!T4yj?V+ zX*A=pFj)$GCec)kpE>3)y*Q8@L%K?C!I>~siJp3=9-Y$QcP>@2#R~n%}ccbpGak*Agp|QIFMv7uQs4 z*5NAa-*TaI`c-ekY?yp^O6$yA(|$?>MAzjK=kiKQgl8mj*3rZ!U3HS1`_%2hCU&Y9 z;#8<#B`98{z?lM^6c%Viyl^RbF>W(XQ4u93L^GOD#_|`dM6T}1mu?F4*YX#$Ka%ZO zmD;*>-T;(T40YlJVrC;L@WFz1vmwpY`;(7g6d$L8>ptoxH3^SJArgl zl8d(yZ>R?Z_2LShTmfQ12vztO8pY-1%oQKwXWK6%n6&>wlT`pe66$~wV%vl*uJ3WI z0~!)j`3EZCt{dWXXp0*@2C_wrN&HCJFpPqTBYwdZ(lz|yKI{qzNPx^}Nk_<9q#`s& z2RTHb5pf_3xA@PgvB z6JlABfPt(YR@^{-S#yKf?|2|?4@04j7i^F9x0IfK^{Tmi%5m~ell&Nvw?nM4flth8 zGXQgbB{0*FV;U4cfEn>KsB=ZH%K|J$)np(mvJ}^GM@b{D)7r6v--TzBZ8cb8 z^l6--vZJ2Ei|g0IjsbAzrQ>J^zy!ZNZ8bOz8p=?kXz{0m0BnMD*Y==(-=v!Nh zY&KvRts4fbR6mtCe)(2W+yISc4VrPf<5z(B=GzM!%py925ZP+et^*anbg|taJOUiH z)UHtOfKYAMP3J*d#u?fC;NJpay47sppW32r*9j2-uCBBjl?fn9S`E_;S$eH@H($LO z(j}Y=8tUGZ=Yh9Vj1%9q5df8DD*yVK@Qo4&CK_Mj_yQ{u%mw|qG0fNCW6-+PR>Y94 zM5YCcX|l?n(O^g%8jv=n<3)3*LA`{bgmE!Sc8&I{(59=0HXR%0+7@e!lQlG8sG9mJ ztP{{{&yqD-^Q-74ukQ}JK(ax-{7}Yti@L!3Qg{{8GcOb}Ds+o-T|fatQrwBdzknOR zq*BZc?={NJ@7$WK!{F+;ar2>vHMA zopf+QryZT}btdUD#Enf}u!5?p6>hCoxE53C{??zzbjtkwR;%TSa(ekuDI0uSM-2Uu zu8uoPd6DjKyfF8o?g{j``7P_YD1V4|vir&=q1YTYOT4QL!eKQ9;{cNy5QvFWCE`FE zq=c9iY(N`Kg|HKG01pC3;0fE~1gR(VfEO~oVhzDs7Z>nC4og(P6l8A5SqQK+Br)fx z;SF*PyF*!pOpPV@LVg7EXL8`dIoaoP$X79BGe|374*44}r!q_%2%jA69@GlffHT1| zk_t%LNxuZ;4iYNE-b0=-@-)1YFr8&!3HW?Z=8|q z#I8kqQi>y{9SKUwZs6R&acrT1S8xS9t_4U7>Ol!#XbRB81`MOXHgIadbe!43sX=TUU>j)P@z@?APgSk(6;wZk_T1Cy^IOwLqS07eCUROV~} zO2xo~hlo00H|DIv+AYj^7y*_LbOLZ8aFF00Zn6z4=->>38|WBej4%Vx3K?+*G@l>^ zCxH){(*%bS`-<#4pq@ zWna`j(-C7b1}KhDoGnmSc<-eu$jfEm26JUI28aq7Oe~Lrd4L1!U4M`V|0jLg1*8S| zOkKtNRn?&IWT(YQSTQWw3ZU_`oxd&xeZ< zE`VW-hXI_gtbiUMpTbd0A%6s3{F>gGchHZt{#~21lR!9!cM6ARfGWo2^CV*!vjc3td~Pg1yG3O z*hhrQDsve4rblF{m&G2GQy-3CJ`h8dJ-AhiNYQ!c7hVI+34XY z5vYT?0YjOh;I)N$j3yRsLZFxeCk_J_rXrFGjuu(MG_OlyO{y%50Jx%~QIA^4=}FWXr%yc$%`}qaW70`*+pg1J8!?x7 z9O*|29$g|NDOXrC%qDmcG@VmJ6j^Y1p#cd4G6ctkK_6(BN`K~{u@{3XDS}&LX0=#C zprt~R4DqlDkr)(ILnOFbFB{|xq6uomkvq>BBzi8YsTt%lLZ`&Sp?Tz#^23vUL^80S z)-pmG70|UQokC6_Mrzs3;VI1G*_88?(}R;agwiHj=eD>D89#7(nsAt&mn9WYz#)y# zf4jU)5XhjNf~Y`1M=^npE@{Xxjb;uK{UD+VloFA z&!PwxU|2zcA6A?}q$y)Y&(T+uU{nafDL4jppV;wNi9?5}0xSd_Cg>6g@wi68s;7iR zj-=QjqAi+aLx=y*y>SvP)~Gy+sW7O?GId~MBFPjZLL5*?PJUE)RAy( z88;LcVax-86psXotRE)C>;^n4pI^_i3grXLa?};uaaEuwr{@ve;UT%StgO9g#lYoh zUe*OvB2uP=lw10r9lw4n6sw;RtTLc9ieMWg28{$_Vq+n37ZVjltE$p~p>0ZRL;3>d zZ!x%YkSJRofkJ>A01yZo!frVv)HJtj1Qo#>*V?FK>t@{+erW{4!tUf$}rR#CE*B3gF>?1;^WIQ@4|pDICbJfXI|`_1HJxXl4f z+qoEoe(cmHmx0S?=z4Q-o%4PNNUlAkiB7*WT>4^O-H%q-{53^vz6HQ??eLsBTn8_= z@$-L!z0>v4*P8(7xcfOsoC8!PL*>FasHQp-7}b&_y|M;AFLanR2q=HmBdKxJ?;H#w z+f1lU6pT$5%Eis?zV@eZkfK@Lq{dVxUvvl8JvnKyY5&O-uMh>2RVU>=A4VWxN8$$u^7?_r7OJM8hE zUAKsO&CnF7y*Qqxw+~5?QrKOka7$f(ZiYZI+OpEpqR7I|EiMhn1f-?Kk&OjPm_;0H zjd5+6HRjuj90AL~&PbAz+Hx6%B_)9wP#9=w*$S+y6(gt&TF_cs5}<6kNhx6YT3U`k zZMi-Elt4*QsVHkKE?Oxcn8+wADS?gCx!RJWS&b^E^IN81Gym}(0lgcqM@h`@Z=Cg& z;_0~2a?X8>P{q3JtK#+ka2=SEEaqPVJBE$VVO}v&UL$v|*X{D$Tit%d!(sMmiu!YE zJQ8CFeha&rrMwj-msh>dvS%V5^Q4JjrEO`+ z$ifIfL1Cg;@!dQu^8W=+o2z-jh#%`qKJhcaO9c4v^KD-}18w&2pLB#>? znA@9Dh{>|WqD%lRwv;Fki9rSHQcVW2q!!gK6`-oprwV{! zn2i__S0sJ}fYzK0;Fl?a64TPuM#LnFQ*eeerCiF?Mkp%=<3>Y(0lLMI==Nol{>{?L zKzik;?XGv@2wy-ebJm>`vOULrgic};qp%Y-@5TuWo z9jXXcBby4gl1hi>K$2DjrKmbaT1h%iz$z4Z=yMwn+>~d-gzuVbpM6@OmTQ27CB6uu zFI<3->uAT03>D5)EXg$tvz*~d(a_08>PW#Xnx;HK#K=8|I90AH2KSZK$^#Lvi{ai^ z3Fj-4OX?tL2xao*RMyRsqL-%{ack#D5~t(Eir^IT#Vm^xfk19c?1=*5BfTXPU`Rcx z9ROLWGFOH(rMuuRf~)N3^p#Ka29A)T`;EZ3RXbaDHz$x=b!R(S+UBi~?%o88*)-v& zIFPpW3|L0Tkd#O{fVA#Nb`NRUHWk}65vOi_7i`PbZP)2`=vF&$D<$AkQY7VQ)JoMb zKi~6%9XPfI^zhv8QDg)h4~W1@4+aD~yGZ!ZOb<+uEGYVcyps0&96-#CXEKOBr}Fpq z6o5R-*}j53_|jt)+De2oKXaFhux)eB^I2DrWxJ(cn zONrdMut}us!vp|=xp3J425^C;c+Q3}&kavy0tny(+oTkULoJGWO7XA{#ooDu#aYGy zqN*TL1fF)<(0UM|L6#Ju9Q~o>X{v=YNhJSUGWg^niMV}s#bEH>4%ZhDXh*DxF(5k6 zKq~W-4Wv=v7i$nyxUec4A_>HU)^^-~WNFrr@*yX7Y0o%bCYEr70ln+vlnxPR?SYGP zN7L5%Ib?hbA2~C*n?xI;tF)-R&9mb{>Emuchf*n$ktAF3a5w4>t9wPqz*MZ6^(Q>Uauoc z**) zlR;giOR?HRL)t8V5uZu^qBW2&NQSvUmT6q{Buf)lLQ0rNWQ(6YK`st30;DSe55)69 zkZ@5E$eSb}141%BC@Dmt4kMw{mTY-YbQ@`$R!pr`n;2M4L9P16Amtk>Q8tu+{i|BW ze0|tP0#VQt^MNmc1@LG*)ZU!qVkAL6WHcZtq%RKqb5LzQGr-BJGKdb(MtXo9-UEPM zh3vW|*mk@zk0c&q^-j+K*3Q-Lk>u|CB3 z^L1ybc~Y%=hs2S9mbg>p!mIBN8YVtpM1!RA63i70I4ha`FCVi`%#EdMgZ zzCQoTic*ejoc?GO3>1OP%Zf*RDD`%N9D=^j8cAdaBAzX!qUJYVqfD$K;h74@OGU

    jF@S1t6*?}EljYghc`=Jw?Jwej@& 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 literal 0 HcmV?d00001 diff --git a/src/packages/Microsoft.Bcl.Async.1.0.168/lib/net40/Microsoft.Threading.Tasks.Extensions.Desktop.dll b/src/packages/Microsoft.Bcl.Async.1.0.168/lib/net40/Microsoft.Threading.Tasks.Extensions.Desktop.dll new file mode 100644 index 0000000000000000000000000000000000000000..1288a177051fd60c5aa7ef8f9266efb7775a754d GIT binary patch literal 47424 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

    !oCb34bXoY0QB>Bv?4f_phw!L4KBC6 zvme@+cg`w)buBp*EPj8<3+*abJUu|Wb3FyeghTG*G#TK#uwn9no>th(O}s;!By#Djh!AB3)wZwK!XH7D_hn9hpT<{w}0Bm)yqM|(oHciM%X^|TPmng z2BstGf{X{uhHZKyxZQ76-5A8q#kpSPTCwjEK_&{lMLNa9tCe#|IVch689AB`eicvm zTOIz!xuo9P^He&C{CU>Igd^i!8U8v$7TY3n9T`^BsK_M8+0w(}#XJG67i{Luw6iRg zvvqvB{Rd;o-tbeuQqbQHc$dFqQg_Ed>gRXsE9EF(TE<&P#s<+~_GTG;^X7Noyc>V5 z4%~Cgeuvh4>z2U)?k{!+7$jr*#?S!1cfU$aH02KdoZ}}V>cN|nR4JNt4gS>PG2K*4 zSalvUAa5AJj(;@(IT##!24K4ZY$pKD=Jt=@dw0QnD;O;+2>xHZSztJB%<~kfMLDIE zF`1#=J+O5GnMs=Z`pE||XD3^vp51b)H~a@n86|^sn`qLb#(P;dwn=qblkElDQ{o3& zOfRU`w3lZXu~6kZPfB>ty9Bkbs0H^H%Rarvp%crRjT#zJVV2xn-iF1UNBCgwcWP$J zjLv2Xk5+iLrM@+FhxcSX2PeKVI9VoOZa!1PQs<1fK3q!iv#kV82b91y6mNa0+BE^T zh-H{JTN&!9OgNXEH+qW&h6!ci_z~M4$85KHO=s+6*hpX|dR5Wj(fUhg)7yG&kEa(>|A4d_~reX ZH&}yh-!nT9!?h@L7<;!Y`^-Vo{C~shP~iXo literal 0 HcmV?d00001 diff --git a/src/packages/Microsoft.Bcl.Async.1.0.168/lib/net40/Microsoft.Threading.Tasks.Extensions.Desktop.xml b/src/packages/Microsoft.Bcl.Async.1.0.168/lib/net40/Microsoft.Threading.Tasks.Extensions.Desktop.xml new file mode 100644 index 00000000..6fad7c97 --- /dev/null +++ b/src/packages/Microsoft.Bcl.Async.1.0.168/lib/net40/Microsoft.Threading.Tasks.Extensions.Desktop.xml @@ -0,0 +1,684 @@ + + + + Microsoft.Threading.Tasks.Extensions.Desktop + + + +

    Returns a canceled task. + The cancellation token. + The canceled task. + + + Returns a canceled task. + Specifies the type of the result. + The cancellation token. + The canceled task. + + + + Completes the Task if the user state matches the TaskCompletionSource. + + Specifies the type of data returned by the Task. + The TaskCompletionSource. + The completion event arguments. + Whether we require the tcs to match the e.UserState. + A function that gets the result with which to complete the task. + An action used to unregister work when the operaiton completes. + + + + Provides asynchronous wrappers for .NET Framework operations. + + + Provides asynchronous wrappers for .NET Framework operations. + + + + Downloads the resource with the specified URI as a string, asynchronously. + The WebClient. + The URI from which to download data. + A Task that contains the downloaded string. + + + Downloads the resource with the specified URI as a string, asynchronously. + The WebClient. + The URI from which to download data. + A Task that contains the downloaded string. + + + Opens a readable stream for the data downloaded from a resource, asynchronously. + The WebClient. + The URI for which the stream should be opened. + A Task that contains the opened stream. + + + Opens a readable stream for the data downloaded from a resource, asynchronously. + The WebClient. + The URI for which the stream should be opened. + A Task that contains the opened stream. + + + Opens a writeable stream for uploading data to a resource, asynchronously. + The WebClient. + The URI for which the stream should be opened. + A Task that contains the opened stream. + + + Opens a writeable stream for uploading data to a resource, asynchronously. + The WebClient. + The URI for which the stream should be opened. + A Task that contains the opened stream. + + + Opens a writeable stream for uploading data to a resource, asynchronously. + The WebClient. + The URI for which the stream should be opened. + The HTTP method that should be used to open the stream. + A Task that contains the opened stream. + + + Opens a writeable stream for uploading data to a resource, asynchronously. + The WebClient. + The URI for which the stream should be opened. + The HTTP method that should be used to open the stream. + A Task that contains the opened stream. + + + Uploads data in a string to the specified resource, asynchronously. + The WebClient. + The URI to which the data should be uploaded. + The data to upload. + A Task containing the data in the response from the upload. + + + Uploads data in a string to the specified resource, asynchronously. + The WebClient. + The URI to which the data should be uploaded. + The data to upload. + A Task containing the data in the response from the upload. + + + Uploads data in a string to the specified resource, asynchronously. + The WebClient. + The URI to which the data should be uploaded. + The HTTP method that should be used to upload the data. + The data to upload. + A Task containing the data in the response from the upload. + + + Uploads data in a string to the specified resource, asynchronously. + The WebClient. + The URI to which the data should be uploaded. + The HTTP method that should be used to upload the data. + The data to upload. + A Task containing the data in the response from the upload. + + + Converts a path to a Uri using the WebClient's logic. + Based on WebClient's private GetUri method. + + + Converts a path to a Uri using the WebClient's logic. + Based on WebClient's private GetUri method. + + + Downloads the resource with the specified URI as a byte array, asynchronously. + The WebClient. + The URI from which to download data. + A Task that contains the downloaded data. + + + Downloads the resource with the specified URI as a byte array, asynchronously. + The WebClient. + The URI from which to download data. + A Task that contains the downloaded data. + + + Downloads the resource with the specified URI to a local file, asynchronously. + The WebClient. + The URI from which to download data. + The name of the local file that is to receive the data. + A Task that contains the downloaded data. + + + Downloads the resource with the specified URI to a local file, asynchronously. + The WebClient. + The URI from which to download data. + The name of the local file that is to receive the data. + A Task that contains the downloaded data. + + + Uploads data to the specified resource, asynchronously. + The WebClient. + The URI to which the data should be uploaded. + The data to upload. + A Task containing the data in the response from the upload. + + + Uploads data to the specified resource, asynchronously. + The WebClient. + The URI to which the data should be uploaded. + The data to upload. + A Task containing the data in the response from the upload. + + + Uploads data to the specified resource, asynchronously. + The WebClient. + The URI to which the data should be uploaded. + The HTTP method that should be used to upload the data. + The data to upload. + A Task containing the data in the response from the upload. + + + Uploads data to the specified resource, asynchronously. + The WebClient. + The URI to which the data should be uploaded. + The HTTP method that should be used to upload the data. + The data to upload. + A Task containing the data in the response from the upload. + + + Uploads a file to the specified resource, asynchronously. + The WebClient. + The URI to which the file should be uploaded. + A path to the file to upload. + A Task containing the data in the response from the upload. + + + Uploads a file to the specified resource, asynchronously. + The WebClient. + The URI to which the file should be uploaded. + A path to the file to upload. + A Task containing the data in the response from the upload. + + + Uploads a file to the specified resource, asynchronously. + The WebClient. + The URI to which the file should be uploaded. + The HTTP method that should be used to upload the file. + A path to the file to upload. + A Task containing the data in the response from the upload. + + + Uploads a file to the specified resource, asynchronously. + The WebClient. + The URI to which the file should be uploaded. + The HTTP method that should be used to upload the file. + A path to the file to upload. + A Task containing the data in the response from the upload. + + + Causes an online announcement (Hello) message to be sent asynchronously with the specified endpoint discovery metadata and user-defined state. The specified is called when the operation completes. + Task instance. + The endpoint discovery metadata. + The source. + + + Causes an offline announcement (Bye) message to be sent asynchronously with the specified endpoint discovery metadata and user-defined state. The specified is called when the operation completes. + Task instance. + The endpoint discovery metadata. + The source. + + + Begins asynchronously retrieving an incoming request. + Task object that indicates the status of the asynchronous operation. + A Win32 function call failed. Check the exception's property to determine the cause of the exception. + This object has not been started or is currently stopped. + This object is closed. + The source. + + + Starts an asynchronous request for the client's X.509 v.3 certificate. + Task that indicates the status of the operation. + The source. + + + Called by clients to begin an asynchronous operation to authenticate the client, and optionally the server, in a client-server connection. This method does not block. + Task object indicating the status of the asynchronous operation. + The authentication failed. You can use this object to retry the authentication. + The authentication failed. You can use this object to retry the authentication. + This object has been closed. + Authentication has already occurred.- or -This stream was used previously to attempt authentication as the server. You cannot use the stream to retry authentication as the client. + The source. + + + Called by clients to begin an asynchronous operation to authenticate the client, and optionally the server, in a client-server connection. The authentication process uses the specified credentials. This method does not block. + Task object indicating the status of the asynchronous operation. + The that is used to establish the identity of the client. + The Service Principal Name (SPN) that uniquely identifies the server to authenticate. + is null.- or - is null. + The authentication failed. You can use this object to retry the authentication. + The authentication failed. You can use this object to retry the authentication. + This object has been closed. + Authentication has already occurred.- or -This stream was used previously to attempt authentication as the server. You cannot use the stream to retry authentication as the client. + The source. + + + Called by clients to begin an asynchronous operation to authenticate the client, and optionally the server, in a client-server connection. The authentication process uses the specified credentials and channel binding. This method does not block. + Task object indicating the status of the asynchronous operation. + The that is used to establish the identity of the client. + The that is used for extended protection. + The Service Principal Name (SPN) that uniquely identifies the server to authenticate. + is null.- or - is null. + The authentication failed. You can use this object to retry the authentication. + The authentication failed. You can use this object to retry the authentication. + Authentication has already occurred.- or -This stream was used previously to attempt authentication as the server. You cannot use the stream to retry authentication as the client. + This object has been closed. + The source. + + + Called by servers to begin an asynchronous operation to authenticate the client, and optionally the server, in a client-server connection. This method does not block. + Task object indicating the status of the asynchronous operation. + The authentication failed. You can use this object to retry the authentication. + The authentication failed. You can use this object to retry the authentication. + This object has been closed. + Windows 95 and Windows 98 are not supported. + The source. + + + Called by servers to begin an asynchronous operation to authenticate the client, and optionally the server, in a client-server connection. The authentication process uses the specified extended protection policy. This method does not block. + Task object indicating the status of the asynchronous operation. + The that is used for extended protection. + The and on the extended protection policy passed in the parameter are both null. + The authentication failed. You can use this object to retry the authentication. + The authentication failed. You can use this object to retry the authentication. + Windows 95 and Windows 98 are not supported. + This object has been closed. + The source. + + + Called by servers to begin an asynchronous operation to authenticate the client, and optionally the server, in a client-server connection. The authentication process uses the specified server credentials and authentication options. This method does not block. + Task object indicating the status of the asynchronous operation. + The that is used to establish the identity of the client. + One of the values, indicating the security services for the stream. + One of the values, indicating how the server can use the client's credentials to access resources. + is null. + must be , , or , + The authentication failed. You can use this object to retry the authentication. + The authentication failed. You can use this object to retry the authentication. + This object has been closed. + Authentication has already occurred.- or -This stream was used previously to attempt authentication as the client. You cannot use the stream to retry authentication as the server. + Windows 95 and Windows 98 are not supported. + The source. + + + Called by clients to begin an asynchronous operation to authenticate the server and optionally the client. + Task object that indicates the status of the asynchronous operation. + The name of the server that shares this . + is null. + The authentication failed and left this object in an unusable state. + Authentication has already occurred.-or-Server authentication using this was tried previously.-or- Authentication is already in progress. + This object has been closed. + The source. + + + Called by servers to begin an asynchronous operation to authenticate the client and optionally the server in a client-server connection. + Task object indicating the status of the asynchronous operation. + The X509Certificate used to authenticate the server. + is null. + The authentication failed and left this object in an unusable state. + Authentication has already occurred.-or-Client authentication using this was tried previously.-or- Authentication is already in progress. + This object has been closed. + The method is not supported on Windows 95, Windows 98, or Windows Millennium. + The source. + + + Starts an asynchronous request for a remote host connection. The host is specified by a host name and a port number. + Task that represents the asynchronous connection. + The name of the remote host. + The port number of the remote host. + is null. + The has been closed. + This method is valid for sockets in the or families. + The port number is not valid. + The is ing. + + The source. + + + Starts an asynchronous request for a remote host connection. The host is specified by an and a port number. + Task that represents the asynchronous connection. + The of the remote host. + The port number of the remote host. + is null. + An error occurred when attempting to access the socket. See the Remarks section for more information. + The has been closed. + The is not in the socket family. + The port number is not valid. + The length of is zero. + The is ing. + + The source. + + + Starts an asynchronous request for a remote host connection. The host is specified by an array and a port number. + Task that represents the asynchronous connections. + At least one , designating the remote host. + The port number of the remote host. + is null. + An error occurred when attempting to access the socket. See the Remarks section for more information. + The has been closed. + This method is valid for sockets that use or . + The port number is not valid. + The length of is zero. + The is ing. + + The source. + + + Starts an asynchronous operation to accept an incoming connection attempt. + Task that represents the asynchronous creation of the . + An error occurred while attempting to access the socket. See the Remarks section for more information. + The has been closed. + + The source. + + + Starts an asynchronous operation to accept an incoming connection attempt. + Task that represents the asynchronous creation of the . + An error occurred while attempting to access the socket. See the Remarks section for more information. + The has been closed. + + The source. + + + Sends a datagram to a destination asynchronously. The destination is specified by a . + Task object that represents the asynchronous send. + A array that contains the data to be sent. + The number of bytes to send. + The that represents the destination for the data. + The source. + + + Sends a datagram to a remote host asynchronously. The destination was specified previously by a call to . + Task object that represents the asynchronous send. + A array that contains the data to be sent. + The number of bytes to send. + The source. + + + Sends a datagram to a remote host asynchronously. The destination was specified previously by a call to . + Task object that represents the asynchronous send. + A array that contains the data to be sent. + The number of bytes to send. + The host name. + The host name. + The source. + + + Starts an asynchronous request to retrieve the stable unicast IP address table on the local computer. + Task that represents the asynchronous request. + This method is not implemented on the platform. This method uses the native NotifyStableUnicastIpAddressTable function that is supported on Windows Vista and later. + The call to the native NotifyStableUnicastIpAddressTable function failed. + The source. + + + Opens the connection asynchronously. + The source. + Task that represents the asynchronous request. + + + Opens the connection asynchronously. + The source. + The cancellation token. + Task that represents the asynchronous request. + + + Initiates the asynchronous execution of the Transact-SQL statement or stored procedure that is described by this , given a callback procedure and state information. + Task that can be used to poll or wait for results, or both; this value is also needed when invoking , which returns the number of affected rows. + Any error that occurred while executing the command text. + The name/value pair "Asynchronous Processing=true" was not included within the connection string defining the connection for this . + 2 + The source. + + + Initiates the asynchronous execution of the Transact-SQL statement or stored procedure that is described by this , given a callback procedure and state information. + Task that can be used to poll or wait for results, or both; this value is also needed when invoking , which returns the number of affected rows. + Any error that occurred while executing the command text. + The name/value pair "Asynchronous Processing=true" was not included within the connection string defining the connection for this . + 2 + The cancellation token. + The source. + + + Initiates the asynchronous execution of the Transact-SQL statement or stored procedure that is described by this and returns results as an object, using a callback procedure. + Task that can be used to poll, wait for results, or both; this value is also needed when the is called, which returns the results of the command as XML. + Any error that occurred while executing the command text. + The name/value pair "Asynchronous Processing=true" was not included within the connection string defining the connection for this . + 2 + The source. + + + Initiates the asynchronous execution of the Transact-SQL statement or stored procedure that is described by this and returns results as an object, using a callback procedure. + Task that can be used to poll, wait for results, or both; this value is also needed when the is called, which returns the results of the command as XML. + Any error that occurred while executing the command text. + The name/value pair "Asynchronous Processing=true" was not included within the connection string defining the connection for this . + 2 + The cancellation token. + The source. + + + Initiates the asynchronous execution of the Transact-SQL statement or stored procedure that is described by this and retrieves one or more result sets from the server, given a callback procedure and state information. + Task that can be used to poll, wait for results, or both; this value is also needed when invoking , which returns a instance which can be used to retrieve the returned rows. + Any error that occurred while executing the command text. + The name/value pair "Asynchronous Processing=true" was not included within the connection string defining the connection for this . + 2 + The source. + + + Initiates the asynchronous execution of the Transact-SQL statement or stored procedure that is described by this and retrieves one or more result sets from the server, given a callback procedure and state information. + Task that can be used to poll, wait for results, or both; this value is also needed when invoking , which returns a instance which can be used to retrieve the returned rows. + Any error that occurred while executing the command text. + The name/value pair "Asynchronous Processing=true" was not included within the connection string defining the connection for this . + 2 + The cancellation token. + The source. + + + Starts an asynchronous method call that returns a . + The metadata. + The source. + + + Starts an asynchronous method call that returns a using the specified address, callback, asynchronous state, and download mechanism. + The metadata obtained from the specified . + The address of the metadata. + The value to use when downloading the metadata. + The source. + + + Starts an asynchronous method call that returns a using the specified address, callback, and asynchronous state. + The metadata obtained from the specified . + The address of the metadata. + The source. + + + + Begins an asynchronous find operation with the specified criteria. + + The discovery client. + The criteria for finding services. + A Task that represents the asynchronous operation. + + + + Begins an asynchronous resolve operation with the specified criteria. + + The discovery client. + The criteria for matching a service endpoint. + A Task that represents the asynchronous operation. + + + + Asynchronously attempts to send an Internet Control Message Protocol (ICMP) echo message. + + The Ping. + An IPAddress that identifies the computer that is the destination for the ICMP echo message. + A task that represents the asynchronous operation. + + + + Asynchronously attempts to send an Internet Control Message Protocol (ICMP) echo message. + + The Ping. + + A String that identifies the computer that is the destination for the ICMP echo message. + The value specified for this parameter can be a host name or a string representation of an IP address. + + A task that represents the asynchronous operation. + + + + Asynchronously attempts to send an Internet Control Message Protocol (ICMP) echo message. + + The Ping. + An IPAddress that identifies the computer that is the destination for the ICMP echo message. + + An Int32 value that specifies the maximum number of milliseconds (after sending the echo message) + to wait for the ICMP echo reply message. + + A task that represents the asynchronous operation. + + + + Asynchronously attempts to send an Internet Control Message Protocol (ICMP) echo message. + + The Ping. + + A String that identifies the computer that is the destination for the ICMP echo message. + The value specified for this parameter can be a host name or a string representation of an IP address. + + + An Int32 value that specifies the maximum number of milliseconds (after sending the echo message) + to wait for the ICMP echo reply message. + + A task that represents the asynchronous operation. + + + + Asynchronously attempts to send an Internet Control Message Protocol (ICMP) echo message. + + The Ping. + An IPAddress that identifies the computer that is the destination for the ICMP echo message. + + An Int32 value that specifies the maximum number of milliseconds (after sending the echo message) + to wait for the ICMP echo reply message. + + + A Byte array that contains data to be sent with the ICMP echo message and returned + in the ICMP echo reply message. The array cannot contain more than 65,500 bytes. + + A task that represents the asynchronous operation. + + + + Asynchronously attempts to send an Internet Control Message Protocol (ICMP) echo message. + + The Ping. + + A String that identifies the computer that is the destination for the ICMP echo message. + The value specified for this parameter can be a host name or a string representation of an IP address. + + + An Int32 value that specifies the maximum number of milliseconds (after sending the echo message) + to wait for the ICMP echo reply message. + + + A Byte array that contains data to be sent with the ICMP echo message and returned + in the ICMP echo reply message. The array cannot contain more than 65,500 bytes. + + A task that represents the asynchronous operation. + + + + Asynchronously attempts to send an Internet Control Message Protocol (ICMP) echo message. + + The Ping. + An IPAddress that identifies the computer that is the destination for the ICMP echo message. + + An Int32 value that specifies the maximum number of milliseconds (after sending the echo message) + to wait for the ICMP echo reply message. + + + A Byte array that contains data to be sent with the ICMP echo message and returned + in the ICMP echo reply message. The array cannot contain more than 65,500 bytes. + + A PingOptions object used to control fragmentation and Time-to-Live values for the ICMP echo message packet. + A task that represents the asynchronous operation. + + + + Asynchronously attempts to send an Internet Control Message Protocol (ICMP) echo message. + + The Ping. + + A String that identifies the computer that is the destination for the ICMP echo message. + The value specified for this parameter can be a host name or a string representation of an IP address. + + + An Int32 value that specifies the maximum number of milliseconds (after sending the echo message) + to wait for the ICMP echo reply message. + + + A Byte array that contains data to be sent with the ICMP echo message and returned + in the ICMP echo reply message. The array cannot contain more than 65,500 bytes. + + A PingOptions object used to control fragmentation and Time-to-Live values for the ICMP echo message packet. + A task that represents the asynchronous operation. + + + The core implementation of SendTaskAsync. + The Ping. + A user-defined object stored in the resulting Task. + + A delegate that initiates the asynchronous send. + The provided TaskCompletionSource must be passed as the user-supplied state to the actual Ping.SendAsync method. + + + + + Sends an e-mail message asynchronously. + The client. + A String that contains the address information of the message sender. + A String that contains the address that the message is sent to. + A String that contains the subject line for the message. + A String that contains the message body. + A Task that represents the asynchronous send. + + + Sends an e-mail message asynchronously. + The client. + A MailMessage that contains the message to send. + A Task that represents the asynchronous send. + + + The core implementation of SendTaskAsync. + The client. + The user-supplied state. + + A delegate that initiates the asynchronous send. + The provided TaskCompletionSource must be passed as the user-supplied state to the actual SmtpClient.SendAsync method. + + + + + Provides asynchronous wrappers for the class. + + + Asynchronously returns the Internet Protocol (IP) addresses for the specified host. + The host name or IP address to resolve. + An array of type System.Net.IPAddress that holds the IP addresses for the host specified. + + + Asynchronously resolves an IP address to an System.Net.IPHostEntry instance. + The IP address to resolve. + An System.Net.IPHostEntry instance that contains address information about the host. + + + Asynchronously resolves an IP address to an System.Net.IPHostEntry instance. + The host name or IP address to resolve. + An System.Net.IPHostEntry instance that contains address information about the host. + + + diff --git a/src/packages/Microsoft.Bcl.Async.1.0.168/lib/net40/Microsoft.Threading.Tasks.Extensions.dll b/src/packages/Microsoft.Bcl.Async.1.0.168/lib/net40/Microsoft.Threading.Tasks.Extensions.dll new file mode 100644 index 0000000000000000000000000000000000000000..4d862e1730a34a6a5cfa39d04840bd039cf9de29 GIT binary patch literal 31520 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 literal 0 HcmV?d00001 diff --git a/src/packages/Microsoft.Bcl.Async.1.0.168/lib/net40/Microsoft.Threading.Tasks.Extensions.xml b/src/packages/Microsoft.Bcl.Async.1.0.168/lib/net40/Microsoft.Threading.Tasks.Extensions.xml new file mode 100644 index 00000000..af646a2d --- /dev/null +++ b/src/packages/Microsoft.Bcl.Async.1.0.168/lib/net40/Microsoft.Threading.Tasks.Extensions.xml @@ -0,0 +1,275 @@ + + + + Microsoft.Threading.Tasks.Extensions + + + + Returns a canceled task. + The cancellation token. + The canceled task. + + + Returns a canceled task. + Specifies the type of the result. + The cancellation token. + The canceled task. + + + + Completes the Task if the user state matches the TaskCompletionSource. + + Specifies the type of data returned by the Task. + The TaskCompletionSource. + The completion event arguments. + Whether we require the tcs to match the e.UserState. + A function that gets the result with which to complete the task. + An action used to unregister work when the operaiton completes. + + + + Provides asynchronous wrappers for .NET Framework operations. + + + + + Reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read. + + A Task that represents the asynchronous read. + The source. + The buffer to read data into. + The byte offset in at which to begin reading. + The maximum number of bytes to read. + The array length minus is less than . + is null. + or is negative. + An asynchronous read was attempted past the end of the file. + + + + Reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read. + + A Task that represents the asynchronous read. + The source. + The buffer to read data into. + The byte offset in at which to begin reading. + The maximum number of bytes to read. + The cancellation token. + The array length minus is less than . + is null. + or is negative. + An asynchronous read was attempted past the end of the file. + + + + Writes asynchronously a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written. + + A Task that represents the asynchronous write. + The source. + The buffer containing data to write to the current stream. + The zero-based byte offset in at which to begin copying bytes to the current stream. + The maximum number of bytes to write. + length minus is less than . + is null. + or is negative. + The stream does not support writing. + The stream is closed. + An I/O error occurred. + + + + Writes asynchronously a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written. + + A Task that represents the asynchronous write. + The source. + The buffer containing data to write to the current stream. + The zero-based byte offset in at which to begin copying bytes to the current stream. + The maximum number of bytes to write. + The cancellation token. + length minus is less than . + is null. + or is negative. + The stream does not support writing. + The stream is closed. + An I/O error occurred. + + + + Flushes asynchronously the current stream. + + A Task that represents the asynchronous flush. + + + + Flushes asynchronously the current stream. + + A Task that represents the asynchronous flush. + + + + Reads all the bytes from the current stream and writes them to the destination stream. + + The source stream. + The stream that will contain the contents of the current stream. + A Task that represents the asynchronous operation. + + + + Reads all the bytes from the current stream and writes them to the destination stream. + + The source stream. + The stream that will contain the contents of the current stream. + The size of the buffer. This value must be greater than zero. The default size is 4096. + A Task that represents the asynchronous operation. + + + + Reads all the bytes from the current stream and writes them to the destination stream. + + The source stream. + The stream that will contain the contents of the current stream. + The size of the buffer. This value must be greater than zero. The default size is 4096. + The cancellation token to use to cancel the asynchronous operation. + A Task that represents the asynchronous operation. + + + + Reads all the bytes from the current stream and writes them to the destination stream. + + The source stream. + The stream that will contain the contents of the current stream. + The size of the buffer. This value must be greater than zero. The default size is 4096. + The cancellation token to use to cancel the asynchronous operation. + A Task that represents the asynchronous operation. + + + + Reads a maximum of count characters from the reader asynchronously and writes + the data to buffer, beginning at index. + + + When the operation completes, contains the specified character array with the + values between index and (index + count - 1) replaced by the characters read + from the current source. + + + The maximum number of characters to read. If the end of the stream is reached + before count of characters is read into buffer, the current method returns. + + The place in buffer at which to begin writing. + the source reader. + A Task that represents the asynchronous operation. + + + + Reads asynchronously a maximum of count characters from the current stream, and writes the + data to buffer, beginning at index. + + The source reader. + + When this method returns, this parameter contains the specified character + array with the values between index and (index + count -1) replaced by the + characters read from the current source. + + The position in buffer at which to begin writing. + The maximum number of characters to read. + A Task that represents the asynchronous operation. + + + + Reads a line of characters from the reader and returns the string asynchronously. + + the source reader. + A Task that represents the asynchronous operation. + + + + Reads all characters from the current position to the end of the TextReader + and returns them as one string asynchronously. + + the source reader. + A Task that represents the asynchronous operation. + + + Writes a string asynchronously to a text stream. + The writer. + The string to write. + A Task representing the asynchronous write. + + + Writes a char asynchronously to a text stream. + The writer. + The char to write. + A Task representing the asynchronous write. + + + Writes a char array asynchronously to a text stream. + The writer. + The buffer to write. + A Task representing the asynchronous write. + + + Writes a subarray of characters asynchronously to a text stream. + The writer. + The buffer to write. + Starting index in the buffer. + The number of characters to write. + A Task representing the asynchronous write. + + + Writes a line terminator asynchronously to a text stream. + The writer. + A Task representing the asynchronous write. + + + Writes a string followed by a line terminator asynchronously to a text stream. + The writer. + The string to write. + A Task representing the asynchronous write. + + + Writes a char followed by a line terminator asynchronously to a text stream. + The writer. + The char to write. + A Task representing the asynchronous write. + + + Writes a char array followed by a line terminator asynchronously to a text stream. + The writer. + The buffer to write. + A Task representing the asynchronous write. + + + Writes a subarray of characters followed by a line terminator asynchronously to a text stream. + The writer. + The buffer to write. + Starting index in the buffer. + The number of characters to write. + A Task representing the asynchronous write. + + + + Clears all buffers for the current writer and causes any buffered data to + be written to the underlying device. + + The writer. + A Task representing the asynchronous flush. + + + Starts an asynchronous request for a web resource. + Task that represents the asynchronous request. + The stream is already in use by a previous call to . + + The source. + + + Starts an asynchronous request for a object to use to write data. + Task that represents the asynchronous request. + The property is GET and the application writes to the stream. + The stream is being used by a previous call to . + No write stream is available. + + The source. + + + diff --git a/src/packages/Microsoft.Bcl.Async.1.0.168/lib/net40/Microsoft.Threading.Tasks.dll b/src/packages/Microsoft.Bcl.Async.1.0.168/lib/net40/Microsoft.Threading.Tasks.dll new file mode 100644 index 0000000000000000000000000000000000000000..8438577c2042e5d6899425d500bf8074aae650a1 GIT binary patch literal 37104 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 literal 0 HcmV?d00001 diff --git a/src/packages/Microsoft.Bcl.Async.1.0.168/lib/net40/Microsoft.Threading.Tasks.xml b/src/packages/Microsoft.Bcl.Async.1.0.168/lib/net40/Microsoft.Threading.Tasks.xml new file mode 100644 index 00000000..5c22030d --- /dev/null +++ b/src/packages/Microsoft.Bcl.Async.1.0.168/lib/net40/Microsoft.Threading.Tasks.xml @@ -0,0 +1,630 @@ + + + + Microsoft.Threading.Tasks + + + + + Provides extension methods for threading-related types. + + + + Cancels the after the specified duration. + The CancellationTokenSource. + The due time in milliseconds for the source to be canceled. + + + Cancels the after the specified duration. + The CancellationTokenSource. + The due time for the source to be canceled. + + + Gets an awaiter used to await this . + The task to await. + An awaiter instance. + + + Gets an awaiter used to await this . + Specifies the type of data returned by the task. + The task to await. + An awaiter instance. + + + Creates and configures an awaitable object for awaiting the specified task. + The task to be awaited. + + true to automatic marshag back to the original call site's current SynchronizationContext + or TaskScheduler; otherwise, false. + + The instance to be awaited. + + + Creates and configures an awaitable object for awaiting the specified task. + The task to be awaited. + + true to automatic marshag back to the original call site's current SynchronizationContext + or TaskScheduler; otherwise, false. + + The instance to be awaited. + + + Event handler for progress reports. + Specifies the type of data for the progress report. + The sender of the report. + The reported value. + + + + Provides an IProgress{T} that invokes callbacks for each reported progress value. + + Specifies the type of the progress report value. + + Any handler provided to the constructor or event handlers registered with + the event are invoked through a + instance captured + when the instance is constructed. If there is no current SynchronizationContext + at the time of construction, the callbacks will be invoked on the ThreadPool. + + + + The synchronization context captured upon construction. This will never be null. + + + The handler specified to the constructor. This may be null. + + + A cached delegate used to post invocation to the synchronization context. + + + Initializes the . + + + Initializes the with the specified callback. + + A handler to invoke for each reported progress value. This handler will be invoked + in addition to any delegates registered with the event. + + The is null (Nothing in Visual Basic). + + + Reports a progress change. + The value of the updated progress. + + + Reports a progress change. + The value of the updated progress. + + + Invokes the action and event callbacks. + The progress value. + + + Raised for each reported progress value. + + Handlers registered with this event will be invoked on the + captured when the instance was constructed. + + + + Holds static values for . + This avoids one static instance per type T. + + + A default synchronization context that targets the ThreadPool. + + + Throws the exception on the ThreadPool. + The exception to propagate. + The target context on which to propagate the exception. Null to use the ThreadPool. + + + Copies the exception's stack trace so its stack trace isn't overwritten. + The exception to prepare. + + + Provides an awaitable object that allows for configured awaits on . + This type is intended for compiler use only. + + + The task being awaited. + + + Initializes the . + The awaitable . + + true to attempt to marshal the continuation back to the original context captured; otherwise, false. + + + + Gets an awaiter for this awaitable. + The awaiter. + + + Provides an awaiter for a . + This type is intended for compiler use only. + + + The task being awaited. + + + Whether to attempt marshaling back to the original context. + + + Initializes the . + The to await. + + true to attempt to marshal the continuation back to the original context captured + when BeginAwait is called; otherwise, false. + + + + Schedules the continuation onto the associated with this . + The action to invoke when the await operation completes. + The argument is null (Nothing in Visual Basic). + The awaiter was not properly initialized. + This method is intended for compiler user rather than use directly in code. + + + Schedules the continuation onto the associated with this . + The action to invoke when the await operation completes. + The argument is null (Nothing in Visual Basic). + The awaiter was not properly initialized. + This method is intended for compiler user rather than use directly in code. + + + Ends the await on the completed . + The result of the completed . + The awaiter was not properly initialized. + The task was not yet completed. + The task was canceled. + The task completed in a Faulted state. + + + Gets whether the task being awaited is completed. + This property is intended for compiler user rather than use directly in code. + The awaiter was not properly initialized. + + + Provides an awaitable object that allows for configured awaits on . + This type is intended for compiler use only. + + + The underlying awaitable on whose logic this awaitable relies. + + + Initializes the . + The awaitable . + + true to attempt to marshal the continuation back to the original context captured; otherwise, false. + + + + Gets an awaiter for this awaitable. + The awaiter. + + + Provides an awaiter for a . + This type is intended for compiler use only. + + + The task being awaited. + + + Whether to attempt marshaling back to the original context. + + + Initializes the . + The awaitable . + + true to attempt to marshal the continuation back to the original context captured; otherwise, false. + + + + Schedules the continuation onto the associated with this . + The action to invoke when the await operation completes. + The argument is null (Nothing in Visual Basic). + The awaiter was not properly initialized. + This method is intended for compiler user rather than use directly in code. + + + Schedules the continuation onto the associated with this . + The action to invoke when the await operation completes. + The argument is null (Nothing in Visual Basic). + The awaiter was not properly initialized. + This method is intended for compiler user rather than use directly in code. + + + Ends the await on the completed . + The result of the completed . + The awaiter was not properly initialized. + The task was not yet completed. + The task was canceled. + The task completed in a Faulted state. + + + Gets whether the task being awaited is completed. + This property is intended for compiler user rather than use directly in code. + The awaiter was not properly initialized. + + + Provides an awaiter for awaiting a . + This type is intended for compiler use only. + + + The default value to use for continueOnCapturedContext. + + + Error message for GetAwaiter. + + + The task being awaited. + + + Initializes the . + The to be awaited. + + + Schedules the continuation onto the associated with this . + The action to invoke when the await operation completes. + The argument is null (Nothing in Visual Basic). + The awaiter was not properly initialized. + This method is intended for compiler user rather than use directly in code. + + + Schedules the continuation onto the associated with this . + The action to invoke when the await operation completes. + The argument is null (Nothing in Visual Basic). + The awaiter was not properly initialized. + This method is intended for compiler user rather than use directly in code. + + + Ends the await on the completed . + The awaiter was not properly initialized. + The task was not yet completed. + The task was canceled. + The task completed in a Faulted state. + + + + Fast checks for the end of an await operation to determine whether more needs to be done + prior to completing the await. + + The awaited task. + + + Handles validations on tasks that aren't successfully completed. + The awaited task. + + + Throws an exception to handle a task that completed in a state other than RanToCompletion. + + + Schedules the continuation onto the associated with this . + The awaited task. + The action to invoke when the await operation completes. + Whether to capture and marshal back to the current context. + The argument is null (Nothing in Visual Basic). + The awaiter was not properly initialized. + This method is intended for compiler user rather than use directly in code. + + + Invokes the delegate in a try/catch that will propagate the exception asynchronously on the ThreadPool. + + + + Copies the exception's stack trace so its stack trace isn't overwritten. + The exception to prepare. + + + Gets whether the task being awaited is completed. + This property is intended for compiler user rather than use directly in code. + The awaiter was not properly initialized. + + + Whether the current thread is appropriate for inlining the await continuation. + + + Provides an awaiter for awaiting a . + This type is intended for compiler use only. + + + The task being awaited. + + + Initializes the . + The to be awaited. + + + Schedules the continuation onto the associated with this . + The action to invoke when the await operation completes. + The argument is null (Nothing in Visual Basic). + The awaiter was not properly initialized. + This method is intended for compiler user rather than use directly in code. + + + Schedules the continuation onto the associated with this . + The action to invoke when the await operation completes. + The argument is null (Nothing in Visual Basic). + The awaiter was not properly initialized. + This method is intended for compiler user rather than use directly in code. + + + Ends the await on the completed . + The result of the completed . + The awaiter was not properly initialized. + The task was not yet completed. + The task was canceled. + The task completed in a Faulted state. + + + Gets whether the task being awaited is completed. + This property is intended for compiler user rather than use directly in code. + The awaiter was not properly initialized. + + + Provides an awaitable context for switching into a target environment. + This type is intended for compiler use only. + + + Gets an awaiter for this . + An awaiter for this awaitable. + This method is intended for compiler user rather than use directly in code. + + + Provides an awaiter that switches into a target environment. + This type is intended for compiler use only. + + + A completed task. + + + Posts the back to the current context. + The action to invoke asynchronously. + The awaiter was not properly initialized. + + + Posts the back to the current context. + The action to invoke asynchronously. + The awaiter was not properly initialized. + + + Ends the await operation. + + + Gets whether a yield is not required. + This property is intended for compiler user rather than use directly in code. + + + Provides methods for creating and manipulating tasks. + + + Creates a task that runs the specified action. + The action to execute asynchronously. + A task that represents the completion of the action. + The argument is null. + + + Creates a task that runs the specified action. + The action to execute. + The CancellationToken to use to request cancellation of this task. + A task that represents the completion of the action. + The argument is null. + + + Creates a task that runs the specified function. + The function to execute asynchronously. + A task that represents the completion of the action. + The argument is null. + + + Creates a task that runs the specified function. + The action to execute. + The CancellationToken to use to cancel the task. + A task that represents the completion of the action. + The argument is null. + + + Creates a task that runs the specified function. + The action to execute asynchronously. + A task that represents the completion of the action. + The argument is null. + + + Creates a task that runs the specified function. + The function to execute. + The CancellationToken to use to request cancellation of this task. + A task that represents the completion of the function. + The argument is null. + + + Creates a task that runs the specified function. + The function to execute asynchronously. + A task that represents the completion of the action. + The argument is null. + + + Creates a task that runs the specified function. + The action to execute. + The CancellationToken to use to cancel the task. + A task that represents the completion of the action. + The argument is null. + + + Starts a Task that will complete after the specified due time. + The delay in milliseconds before the returned task completes. + The timed Task. + + The argument must be non-negative or -1 and less than or equal to Int32.MaxValue. + + + + Starts a Task that will complete after the specified due time. + The delay before the returned task completes. + The timed Task. + + The argument must be non-negative or -1 and less than or equal to Int32.MaxValue. + + + + Starts a Task that will complete after the specified due time. + The delay before the returned task completes. + A CancellationToken that may be used to cancel the task before the due time occurs. + The timed Task. + + The argument must be non-negative or -1 and less than or equal to Int32.MaxValue. + + + + Starts a Task that will complete after the specified due time. + The delay in milliseconds before the returned task completes. + A CancellationToken that may be used to cancel the task before the due time occurs. + The timed Task. + + The argument must be non-negative or -1 and less than or equal to Int32.MaxValue. + + + + An already completed task. + + + Creates a Task that will complete only when all of the provided collection of Tasks has completed. + The Tasks to monitor for completion. + A Task that represents the completion of all of the provided tasks. + + If any of the provided Tasks faults, the returned Task will also fault, and its Exception will contain information + about all of the faulted tasks. If no Tasks fault but one or more Tasks is canceled, the returned + Task will also be canceled. + + The argument is null. + The argument contains a null reference. + + + Creates a Task that will complete only when all of the provided collection of Tasks has completed. + The Tasks to monitor for completion. + A Task that represents the completion of all of the provided tasks. + + If any of the provided Tasks faults, the returned Task will also fault, and its Exception will contain information + about all of the faulted tasks. If no Tasks fault but one or more Tasks is canceled, the returned + Task will also be canceled. + + The argument is null. + The argument contains a null reference. + + + Creates a Task that will complete only when all of the provided collection of Tasks has completed. + The Tasks to monitor for completion. + A Task that represents the completion of all of the provided tasks. + + If any of the provided Tasks faults, the returned Task will also fault, and its Exception will contain information + about all of the faulted tasks. If no Tasks fault but one or more Tasks is canceled, the returned + Task will also be canceled. + + The argument is null. + The argument contains a null reference. + + + Creates a Task that will complete only when all of the provided collection of Tasks has completed. + The Tasks to monitor for completion. + A Task that represents the completion of all of the provided tasks. + + If any of the provided Tasks faults, the returned Task will also fault, and its Exception will contain information + about all of the faulted tasks. If no Tasks fault but one or more Tasks is canceled, the returned + Task will also be canceled. + + The argument is null. + The argument contains a null reference. + + + Creates a Task that will complete only when all of the provided collection of Tasks has completed. + The Tasks to monitor for completion. + + A callback invoked when all of the tasks complete successfully in the RanToCompletion state. + This callback is responsible for storing the results into the TaskCompletionSource. + + A Task that represents the completion of all of the provided tasks. + The argument is null. + The argument contains a null reference. + + + Creates a Task that will complete when any of the tasks in the provided collection completes. + The Tasks to be monitored. + + A Task that represents the completion of any of the provided Tasks. The completed Task is this Task's result. + + Any Tasks that fault will need to have their exceptions observed elsewhere. + The argument is null. + The argument contains a null reference. + + + Creates a Task that will complete when any of the tasks in the provided collection completes. + The Tasks to be monitored. + + A Task that represents the completion of any of the provided Tasks. The completed Task is this Task's result. + + Any Tasks that fault will need to have their exceptions observed elsewhere. + The argument is null. + The argument contains a null reference. + + + Creates a Task that will complete when any of the tasks in the provided collection completes. + The Tasks to be monitored. + + A Task that represents the completion of any of the provided Tasks. The completed Task is this Task's result. + + Any Tasks that fault will need to have their exceptions observed elsewhere. + The argument is null. + The argument contains a null reference. + + + Creates a Task that will complete when any of the tasks in the provided collection completes. + The Tasks to be monitored. + + A Task that represents the completion of any of the provided Tasks. The completed Task is this Task's result. + + Any Tasks that fault will need to have their exceptions observed elsewhere. + The argument is null. + The argument contains a null reference. + + + Creates an already completed from the specified result. + The result from which to create the completed task. + The completed task. + + + Creates an awaitable that asynchronously yields back to the current context when awaited. + + A context that, when awaited, will asynchronously transition back into the current context. + If SynchronizationContext.Current is non-null, that is treated as the current context. + Otherwise, TaskScheduler.Current is treated as the current context. + + + + Adds the target exception to the list, initializing the list if it's null. + The list to which to add the exception and initialize if the list is null. + The exception to add, and unwrap if it's an aggregate. + + + Returns a canceled task. + The cancellation token. + The canceled task. + + + Returns a canceled task. + Specifies the type of the result. + The cancellation token. + The canceled task. + + + + Completes the Task if the user state matches the TaskCompletionSource. + + Specifies the type of data returned by the Task. + The TaskCompletionSource. + The completion event arguments. + Whether we require the tcs to match the e.UserState. + A function that gets the result with which to complete the task. + An action used to unregister work when the operaiton completes. + + + diff --git a/src/packages/Microsoft.Bcl.Async.1.0.168/lib/portable-net40+sl4+win8+wp71+wpa81/Microsoft.Threading.Tasks.Extensions.dll b/src/packages/Microsoft.Bcl.Async.1.0.168/lib/portable-net40+sl4+win8+wp71+wpa81/Microsoft.Threading.Tasks.Extensions.dll new file mode 100644 index 0000000000000000000000000000000000000000..4d862e1730a34a6a5cfa39d04840bd039cf9de29 GIT binary patch literal 31520 zcmeHw2Ut@})9{`&Ak+{ArG}<-PC{2ex*}CTQ9&UX6l4GLITK9mFF((0Z$%$li-Vx4wa_K z^~M=kf9g{S5b_u6640)sk(d2>#JXagaUY;g@NMz&MaaJeN+nBizrqLWMngJ@7lHg2V&zs#dlzZn;-o?W#ioXjcYu!irb#FN!~KN@%EtC?zsW|YZi}sIbnhp z?ac5ka#d+QStF?CZ5WVE?FfARva8|b;7UN=Oz4NqQt)+Rwk9k|j z5F4BoF4%UfreDr-=Qq*z+bnNg%{}o}U~%lz{p3dPtx}fl18ro@MTqU7E+G)gleU5M zkfD%dIB?p0XEC7*rEMXv6lYQSG^rlowunm-hz-qx0*)^F-WHyQEZc>x@dHLsYA4l) ziZp3Esyb39X(&w5Ep&S|hPXX0b?%}CT0`oN8$)aePkS|*7)*)X!OoH)HpUs+GG5m8l8vdwY3%&(+PS)E>#<&z@JVs&}d2$^c|Q2D4Zt+f5IL@ z2h6z%W9X6UlF%kQp^2f0?ZBmpVUA%FqUyO)^%O;PWf8@MDpJ&9NnvqQDX#( zf>wqk6O}=0p-CKlHmwMHo}r-{1SlE^-_P)+(TY?cx55KDtpw&E!(%MYErMCkpcUZ^ zJz5d;C?GK83~NZT^sHf?vo&?;)}7(WW#}@j!FjPA0%&?ASOks3C;?~6pcTXTKq<|d z3FD;4zTHT%#zkBPO_%w-Ei{JUFy+K;sk*?+2YBf+TG;3%s=yFF)E5i9)6`HQ<_qJd=h8$Hn zr9u%EYk#bWioB4kM&qbiaoHufFF0&H@9W=x{J5j9PBZ;3mqYPau?~Pbcep?2S_eX= zEwtUQg+uQJ+YDpaz+oK6@fiN2ZI>{1hWCi0VoC& zrF7Tz>I@uA&bqTmEbxodI_$?VwB)oEM^I=#-i9M&6qNOY96z`vpPUsDR?V3 zHE$GC3kKA#r82s}gH{CI6d?FffZ#b9;t07iN?o8YIM|<1y5K6H3$6pY;7XtiuEi?C zMXl;${V#P9(2BrEGsKZtGL{R*fR{p!)J7o}7qcj$Rz<*gv!qeKG#8Agxw#+$2A?7B zK{ZY(1ICpjwNuEzy_9``Z3w&{M+%;t>H}QNqKH}*0ZYQa z?rbyQK`S!Hf}mYZa~6*;cr}jHRUr%0K^rk4s|X{lii8E_UyB5P1tKj0ihC>DhUI}n zmoJ2xR_OhVXGow z)%+Koeb71{nA3{Dn=oKkl>mseU(1~SI42Q68*vgqyr*PR+jVft9I3ZL4_sY2gJF4P zNnv9DG=sq^?X1CEn!VFO>lC1&6@e?ll2ZXuNLJ*Ca84S4HsW-EAfib&tOOis7lmw0 zu9WSIWoH0&%QXP3#t!eQDA@xrEB~18{si6?!v~Z?gIpX*M`zNR595j8%#aPR5o%Zr zMJN?I{1OmZ#Kx#?0&;Q{kG51tl1W6%mnLth|^u02Bn;kg}f7jUu`{@LPW!10F$ z>u;PsjjaYe(Pt}X1il?h_k}O4D+roErC~9k@$^T@yBa6wmQYBV3#k5vHKXftqQqZ4Qcz&a}Z6`&TfA-J$whZFOWE{X-ng5BF-f`yJz@CQIW zWJzmJ(?cXc7Glv~0W_tT0c9r&#!xVif-@<&o`Odx_>h7$2BtTppc@5~7?BJXn!zY% zNYP3Lj1juV*bX_30CkZb6Q?Iou$GCnvS#5{B(r=WT?}a!8Vk?>Z2+i?_EDwhsL}>1 zt*e6DYY&ixLR2t)0R<;haG6Ru@V^adHhQYEoxw&Xs@oYRXufKp>P55}7AX_-2+}vH zGz+y+n-4kd)v%u9)yf$Ls9FtcxEJzuk);Oa(@6u%S`BFyss)HYa(j~7l@4--9%n)x z0e!4P?QobdmUskpP&z7u^C%seBRZ7TLgrz>EGXZK}0w~N3xl&jTg;^kX3Y$e? zR>+gW4p5j4>P%rzDa;mmQ&<$t5GH8S1#DKt+(}^g5^RU7YDi}xS5*^$)ieu$dntH= zhVzqY9Rd2Q+5wCNN&=lwbpm)@)dk>pRd>j*rnQ5CsK;-+9Vul$8IqTGh0jz!}2}JZud!(Jh$U1Tr^MVg@k&VG1ms=l~l?;J;MNVP&-*i1Br zSc+_s7c6?XwHE<%M4J`Z1EK~3K`rfyEMYnM#~S z9;mbly8)FChQ7$(`yQB0dXJp zrb%{k%FeWBs5`o)z`|(nP$){I+CBw+Vm+aSAtQTCiO1+W3P;(n(Lm@v@ma+SMWS|8 zPuwTys%_|zXcUFXM>7gdlw;_X8jlf$xKzI=%M9fhYQx55i+(Cwt|$v;$3hv6>Lq18 zwj4u)sj{@6%5oKDtJz*C3SIxH?7pJxDpl5t>Q5!l{&Ea`qskusRQ6I)W}%LG22*{l ztQR52P#jgZ%bB$V2ht281WJz*?E#)9+E8gDfPWC4 z=np2176SWlFIXqlS+#^EY7fv830RsmOXS7k(%L|&0i?rNrZhFE<%P^pAC?u(9_6uI zXg$y@mJiK^;@JajWA&qXQRzT*gq2Tg4>T)*<`&TOKu=lg!6#u&LWm=*eUPI8o+y^e z=|k{TKGQ-7Ull~pq;&3q5>;x69w-aoKq{vYpcm{&Fq}epu_=`II!@TAb)i=g9%|j_ zD~SNLT4D|nqZR?_0cu_dmkQ|#$U|)iJr&{7R5U=%fHsGasm-L%A@xEf~|BPebIk)6h4#sn%o9r_c&{u1}z8zMx* zg}FpQUk3C8(JYN*<{GMWGexXf!2t9g(z?VH3T_728Jz$aL%~q0G@gQ4=riO?5lzL9 zl9)pAAC5xli zjY*98j4H-5#%jg}#ui36b0(9Cf*~-?gm*(ybdz{S)DtY4BQ1=UO3S5frM;s`=_Ba& zjNXi+jBAWKMk9mAjAssD<}*u}j8g24sq+OJp6c+` zfUhQewcx7_Umf^z;0y6yuvUDU#P#1(PZcDlbkPJ{13e@d$QHcJVp=?Wi%=i>Fu;q@ zc=|NNV$6f|Jk%eacFe=58*?5S1J5Z`mmsfjacX|H$OnaIrbxt6ahl9AHbWv3rot)O zF;*zek~#(z$V9o)OmVK%F*Q3I;mjD3WKd>`NQz<#r7}^@uT_wrv@kcNxgOwBQBHDp zVYo;pOclz6elj?wC+EvVN(RxQv}{p|41}N@X^L2qotdmCLXpV>paeBn!3rqrHR*~1 zgt;lA>}(!AG((;Y5a$)fihoOonTpL^V>f$6u_u z5_$hgkdzu2l$@WI2CWmPrAa}j6mfp845fk|nYq-EE6QUshlo&SZmOsN$%GPMiv|g^ z^F=62REQK!iiVn*IU>hiA_+EXuye2kOd1Tg2SkI#lB{M^Q`#-=eo1C}hOD)soIGJ} z;qL{(nb{(RjNc1Ga?`|;97=Ox_McMyX+dnJEL-$D*FcdpMUt6^&H4Aj0C8?wW_rGa z68d{_lmr|>N-GVFm4I302wUwI7_odw3q_P&ERqkJ6h(;gWfEaF7z#Ct(lB9edcH9I z_bP#z!t`7*3?~>zpeQ*%JzbdGvWfCM7%V&;o2H#|Eb$bB?v^z9C3yzb)M!z*uz*TQ zn_I1@h{>QRIWs#`)?x^oJXdptzvCW}*RL+eCpj^ZL;*3DUOt|Qi2=ft3{k3It~j?a zN1QJOXP6;Q4HRXI(uFb+A1NErRg^1&Q3A>)FA3I}7$R-y%%Wief%S`05xAlJ9B@aG z`Lf8gXy{*2P(g}_GJ@6>65#2U*i#DKB?B=iBzF+_ODa<#0l3CW3S&evISyzuOI$Zd zA^|5RCuuH`;|k}B$s)jiQeHM#h`nAR_(q(qz)%R~AQbdeIzX76oh(erLjK?baZav+)Y!OjaUt$L!;p znCOhWk_%-bDQ+&tUH*Ji(W2xp=CIshiBho&euIUXGVBvzp8S?iDV3j?Xeq>0B8jV9 zM`#5YQ!DhC4>kgy7IoZEo)A_568S?L5GAh34@jGtPz8ALqY?@efw?K)NZ|R1Rp^;3 z6{d+IbDOiFhQidL!<&Z|5Jk3fkh^83riy;@->@xcIYP}tPmOH=Hc8k>VN0a!mD(S9 z`J^N!V*AP#76xPsrSKBW3y%vmq}bv;sEq=2!7p?va=PXn1SU>y-c|fwBTZhTY43n5 zh^PuU>vwv-KwhDFAA)P}`BW7uvz0n9qSVZ3(x2}l-?Fqq>+u_{dn;7QzflQWp#uFW zxj(gzpW3`#`n`?-4D0tg0HpX-c$Xv4-&!b@r?r1O!4qC)zq zkSnF=a$C@&w#h(~2LD7r83SB~KniKffCknENXy_f_BHj6z%VSi>*g`f_C2Om?n0`? zuSQV__f!#J1Oomhy_)#Py0bqJ!ZZd<|xaX4*t2qqxy0io#{x79U+gsv5x zhX_r?z(lILHpWal(sfXw>hrY}Pr959-E2laG_CrIpAMBAulOO@|(1;WIPf(J_8}#K5O#0;!z;9Cv8l^@eK4 z5v#PlSY4`56T`MHfO5Irp{02UcY?n!0ovg+_+}6$?6iXPo*=49lAeQ zXVMXs!I3u41X@#HFkd}-X10H6{j)cz31J%34y>MI-7ndGmB`-s^A&GdKe5B(H$(fc z*FH4UyMxg<-2hQLUe5k$F5!JIOoQ_^L1*b&G4Qz>hJl6~V$@Crpsp2%!_*<*btBCL zF;rln7;FG6`JllAkEl8j;tVc~EmSvxY&^D19?~tXVDShVJQzGU$V0EtxVY6o$0k(e zqpOBcTiwzrP+OD7)GeKXM_#vdj*$-JE?_A!C;(1SFhdRUtAOPURgeSqRP9MRr3e@E zS->(uCWHx;&oKfTB`p_PfU}KQY&vEM5dhuNrNEKEjDTt-PILfHx|*$Wp~@9J7>FQ@ zRIv1w1a2&TPz={{p#``;WEgQcoYIZDrEBFvj?-AG3>K&KG)Swm4~2&P10zDjtSB+Ayn8UBa@jfW^6 zTo@aQ7n_XKpYOJC zj0u{iLJ|bl7fgiH1_oSLQ$>XaI#Z2yfCkgSI#gA7bX7c+VD!xhReh46raW#B_5;dZ z16$K=hk+5)(V}Rzz-F{?77qhU=tw?|rKQEgP65nR-rKmyn#Q8zsYl0%J;)=lJdBVS zxM1Lcffok87z6@0PgUqcYF1O`r0c52!)AspNdw0816^TLDm*;#OJ}ellQKkIR~1N3 zfm~A_9dn>8v58(u#zjU@#Z2KjRN0CIx5+c&s`62V9@KTkdUaFkWFyzf1`D_ONw|$d zxJ@&28zpla%*X~a3c~}-DI?m;U;h&*mZs^Koh=?54*UB|2m}!c1hR9C2#Sq@9XQ@3 z+AEIW-uUu~J)Du#;F#&HczSpM2dy?uaRbG6D+0m@Z7>s_k_#^;KUpf0xe&aLXK?W&LB7)P|AW^C#LIwnC+iDHCTtXl^UWx}+v3`{r*|&Pz?kt^5Z+ zc|DqiPsC|nGu|?#{JlkUULqJ@V0L!6FjEn76^W?uE~fZl1$=axY5&tHf)WN-I7@$) zB%h{Wp1RSWA^3O9tGQM7?0ImIyEi?oP+RJ%UIS0eA?&U`XT79!C9l zyzh{IS2R80x*GMtEafJw$bd&6ddMe5ugo>5qO&cI>~@46R6T#;gm$tkVyH@1tmioey;=<(g?UQAx1fHuMNv6gcb<_ zgQ*IiaNw8%e8nJJ3|h%x5HYm`s4;Bb2O}u60$$2i1Of*sRW}o8mAmEEc{)N1Gk}{2 z_@ye^fb)dFAq&2a(CZLu{n@_je#$>HMyZ$X-6_5unB?kXs7IUnkh@a4lz6Avnl z^|XOHxR)_U2|R_+ug$Igz0LogevZ%izw7Yd zZ+|vr8&M!z4Ep4QUC3JWcx!g{@5#jN^q_3wXIZ~mMr(Ef@BU$o{GjJ>-{rsz$%YZ) z!R-9ms+#Kx6c&Z0{{PQE-UG0{-0CI(EteEMBwdE0WboKZ`b(^ps0X#|bNb%s80 ze%x_XwN`iAQmQ|k$!5g}xRXE*rZl4WWWZISo-uqb$zcJa%4Nq1r4Uh1mx*)vI;0lP zRN<;bi&AsMxv6{;(g^3Uxvg*F`DUakE~j(bHSIWgvG97*0phtidAz6qKhi{BlMmP4 z1?~cp^bk1r1=NLfYeLDgn*WGqnxs0`Or6UJkBo}ucOW?qI!!V8QE;swP- zbP9GAcsMw_ySqDh__@3Btw;-bi;P-rk>Zp=mJ{YJdzgTm5#@w77zDwll@oBs_|A#; z+NLvml_y^F7hF=!*}7o=!Mb9P)xDk9W|c*4A7jSuw|@u&5-}q6m^U=WFg+CfkK9B1nD|+&_q&Tj()0zufE3S{Z?rYk~-0y)}2U_K+$5v-1 zqz}Iv+&D74_C}h?QR&dmn+NGHTUuEu>$&1_Qait7kE5dC)eOC~UN1f^JL!M6Uu>#V zS>ss`q^*;6f4F0XPq$Ygy}G}eoB95vw$2w7m+r~gL`CjV-iQ+k=TqjGOzihcd#PTx zRatk;oM>RtM0Gi#20g+gjiF18wHSJgHmJ9uPu<}+tZ94s-fo-MsP_{zluXo*!aA~|A9h}Fm^ZhdDOO4%zTGtwFG8Wf2WrUNVWJqP#%AipJ88TU3Cnu*ANw#B7 z)76g@agI}7RwmAMf^!jmAuM%j8b)lFlv#pRIsysVo23e~lF3vd2u2v$o$RK>N!lnc zg@D0>2e&3bB>4-@GLnn+wPI+HY$Z#&YD;s02?^!`$IKrOC(vKi5B1owqj*v0=;2E~ zTXc;o!t9g8OQi~PzO zKWo+}n|U97jibvZ4(di9`gWfFwsqIz&8MVv79_fUIWooTRK3=mQXke75AG0+u)WSV z_tmZSJ5p?DSZgY*Hkt35YJF|PgqTSgUAtCYBR0Gdwmqa@ zP5vXpksar~ zYjjxX=Vqtw`(3?%^s|JNVs+V=2SkQjQ(Mz>#gZ=3%-P2(kj2{F-iCP z!z)8%V^Z%YAF^_^UALf}sg}vsgX=9fYent8V>B%xWLe>stvAnn$}6%aMr^mWIlFHq zlX?H1_Q3FOYZEMn+q^t_xcjkZ9Y;v!7_$pN0^JUek=vtDoFxVxjXp5BhIxolIi z7nW(th$O)UR)Py074%8@ANm%Rn4g!)-QZBHs(m#Oz z{t0i{FEf|&cl@ilwz_f7WtSHmdHJc+rND62g|GYH9T2~*@GNcq?m-y~Cs)l^uN}5{ z!kh4&Gd#a&-n&2VeLqWW!-_F&I~Cttd#2`i_D)axpb|??YzI}_Ob*20yRBW~2qth_5-Qa`|8O=$AMH^uwg4C{6}d{f}32Cr#3{@0!r zKhdw8myw}n{fRcKo03n{0&Kk#|9HZ;$tlEi%=b);_)iX(xAK%^^=-v>5)9OaQD^nQ56R5L4v&<-?sFxS>}_ z?aE+3=FAre_@2%JaAtUWhEV}V|4BdlueMg3Bz+Rvld1cR=O*!Z{&NP!WcwIi5uZBw z=0(=`S$aD6?sk$5H`wM>DR}kc&O!eOi^~#p(>0Dg_QX0~$oqzjHQ}KZOZOCp4xHCj z<;FLwy9@HioLwai9Co$r=DR&_-Ig3r2)ea?t@l0aj9CWDmrA6)-sn$%^v!j;r1Hw3 zM3ccm!$*4Pos-5h!DK3yZpw7J(O&)gRGH0#K~Ax^+mL-4FH|IdJ9#`Ym>;#HBlnRn zc~)YhV{LxaJ;J+E;63?tl?Q8NLPW1}Yg?vZTjg9D{janl8qSAx)2M^Yl)W)8HOAtR8Op*?d z7T&8>Pl9*F#@Y-992`cGx-2!txuh+@U{Z`>``eU9!#lQb=lKyAJB*uge|A#m6@2kB zuie)i$o5S{ZD)Wm;>>lYD!1ob}j>`_=Y7J7z|oM@z^kxi1SL zyOKeb0hNBEy8L}#)@1JzFzpnuY|4wpD!mqXv2G+dWhD+?%;WEQG5O_TJYn#B0j|IM zFB*aRc=`WKE6!MuM6w!a5Z49`uCI19r)E2r;4Lymzwok zI-lq8Sv~4duhR|>yI+miF3A15WCr)q%gm=M7u)YWW~ZYinmFg?hsB?DJE(~~roS0t+I`pg`@No>E120X z;kc__;_Ye1Arl?;u5}4Cdacve0QI}=8gF)H_EELhBef<(=4f#vyo+tR&6k{imwn>E ztGw#Csc|LKD=H1U(ffWpTb<69Ep@ANaMC~aMB=XdUcAvOz5G-3rV3|0k%`v0+d6kr z-;2)#U%IIOyzmfX^TjXrcTLAFT*Lmt?dZGq(Wm<>hXwCaN$M&}@{QQw|0<%cW>DcZ zwu@ShQ7PZ_fmZD8$5me*chy;&I{QbIo@4PorrD4OGyFPc)=rx=<9Nljd1mW06XrK8 zUNZ9Y zI8g1qp5{B?N9Mel4|G=OY<7=Qy;AEya4v_EPwW;cvIWqQ)ta`b|?@6(O! zzZN|mWBlT2M0M2xiJv?u$Q-SkCF%My-6&h`OEy--)@#QK}=64jEjx?T$t8u0sy7i`JVI`0)pyns>MJ z@M%>-+7@HYjbA^`+eDl(4~_ltiCKG)r>^wgtHFCO|10m^>OuG?@2%71gu#1*KSyNQ zZ0uVt7-f^mvWn6+t-0T-lqJId`1Yb)r*N%aRrkuJYr~|y->YyPMgM2K{@*&fLtpF6 z8dsY@4|KczeDm7DH_sII2q!i=$_B>gXmD4b*;_PeyW=I@#S?Opx5v>=M)0^%b8Zju zeGs>6eebzO_l=2BYjzd99e?gsXX5pPy_49?V-?*VG{m&M9l3hyqo)-EE|(s7GW{*f zX(avm6kAL4yf1%zeN-^VQS+n9gS_4CA{I={VoPRhukxIq?r^w=){EqXE_$=a^SV4x zF%Wz@#qU0d?`i$KSVkBm- z$rHN@L<#YPKD&+9g&S>VfAHFo*1N{R>FKADqfYhc^=v`j^z1dBVVC|W+_$RTkYt1wL{y$0!%}N)xCDWey>-IM|w$R+{T)=a?=eyo_J7s_AnxHhSgKam<#J(?j z)i1jbgqw4#xXbpf>e`?y{x(jKz3Kbi z9>*qF98cS`z<9K7D$UzreV<9&ADKPgvf)I^=7Lz}B|pcgHPbgNEm&PsIWynj`qa_f zd~+wk3f0`o_z70~D(gp_FuU^7B=Y#&*CF>l5+do~Xi8^7E}mn^r@f>v9rET$MP+5_|hs|Icsrfo?Y0cz-sSb_-BWXh;M~+V;%Sv1D z(BMnRyvpd(s8(Ju{(CRl6fZZc3`*Pm*e2g2m-;pFd)?fXpT>^fXN`{B9-RB(#-cTw z&*XhO&wLa5MC0TBWm^&}W-lv_NpJUEqCb7tje-KJkt{~U&8|0QjQw6QcZ1z|pMiZneYF$k%-=Gi z<7#2=#dne(m3PhZ4@fug(y8lusowmvBuDmk${)dBKGvDgAG&c|^C!4fm3NSkB2kLz(Qve{74;`s<1o2HTHp*Q_<2uik{H5MZuN2Fc`WQ|}Vsnh@Vp;NtAw z_cwDr;CjGqw8($qaK_}PLnjvw*FL-NLQ7kLI4rgmH`i_sK?Bw;uHNL^J^aV(fics% zUJo0x{Oy-sYwb^F`f2k&^quDLrLkg{THWjY3*Njmz1HW-*uKRDM~5a)KL2AqF++dw zQIE;x>-v8#69&A@k33N6aZj3I%*cB0_al7u=X+j)g*}T6vqwZ1ChqO!>=Ai@v&FmL zz+>-R+s4wL&sZPO(09y(h})YPoXu95H%r`-`WoE!QIqBvcRcdIRAc9+_mR)b4vyNn zR!utgdFIVB&zp`lOPQ~10_L50S-x{xSjw%7>q?Bq-dqs0VnW@ikF20}_O78bTwEfp zUTWlxeVaUKtIy_s{pa*uyFgIm?iA4BL5EkKW4pTc2!B;|z3PCJA7^2g-N5j5h6N+2Gfm9Xs!&ew{RTkPhW3Qk&YI18N434 z745S#W>$#ympz_&N1N5F@wyY=P^vX)${tP5u8OG2a?Po*@795RcVmk6d4`abox!RIC(-O&wIxxYDj?CAxQtnRjNkAxZLEh?_f@So^aS7s3X&_^)cduY2i z^B#pJa2{Q$9chwHC#AcOuOLbmtUdoh+7NG0|imGg0@8!4~Zp-!WdHj^?`RE#Y-u&4v z3vJw1>bFl+->2NH4};Bmkvy_tgGyQV)-h4cX#tGIV(=&(`Nkno3mD5Y>D%v)XOul?xwIVHs?eP97uNu(t`@P2$dZG z0hgX+475z~CJh2E%ERM5yL2X`0d#>czd*So~`JZ#Zto66I$jbkHAlaIz#h74U;+it&k@Usm$Pk2Xc zOjYNO$T?A}HGIz=y*tD9s=hm2S~%rm`_VSl92bO*dIofyhGpEE`y{(PBH-TO_P z!;_t2=T#)BSeljPxSX82VB#uYuKyZdmwSKci1x>yC|z-5V*RMTvzC0|gpL|1PF_9E zu`<$HQ}@&1(^IzxYAWxwi5nv>?)IkJgvhBTtFtXrHFj=XH|BZ23a2jWJ!lC7)~snC zb}4K~;tsi9l5 zD9K^UsjCe;V+(`B7n09z^6bd1lC~TDmQTO8c)FF!*T%xS4hI|3yeAF+{`ui_Kj#I5 zgZEgip)Fb6?ZxPvc;7u8>OZv8_cZ!?{Py)%doM0wrj~BMx@*W5vm>e&MP-}jPw-0k zqW&P}!GY&HwG*Sra+M(vPfu3HVzee-pq2vqFUCTajrotP1rRTnuLU;EYr&rf+?!Vg zKE!Q21f;8{JZj@cp?ngf|M;p^PW$~<0}bD5puw#Mm~*QeK1+0r9M@jUT~)3V?y~dk z*4}1|{0(ihp7)JfwVmZ*zzEqntX9M1wtLnQ-D~O%9tY>JHXQT3Otj(qUmUAhm^yms z^d!sd^$SDhKhNlY;qJVcO>Fzx_19P0tsA1Y{_4y=Cz1@9&(j7y6GV5=b$Ys5HR^0l z;I@9(4mr~ES7*FCne(nwLY3b8;GOq8QrG0Bx)v;}Owo3@=sT_P;T;vt%L#=`Lu{UE z?yckw-aFm9{>wwVzB;Diy{s1xk=)bmv@N9nwYs{1DZ{T9Z7LdNc-?2?gnrM)MvgFe zTjkW}(d5n!>zsQZ-sbaNaIuE&y>Zj}sUAZwEGV`A5YcOjnX6T;XKw1Sn4R;r*S5D9 zaq|66`lyPJi4EtX_f42SdiQ=anN?yt>#e6cT6tac7I6oxb>9WPcynfm}f(O?$qWino(8?2U?r&SO$M90m z(5IeN+RrUQcDLIeSRC}|K&@oRJ;_tcyZeIY9IiiT6nArY#jEfTa{20scVERXTL1O- zhO`Fq+*LeBC1t z+#eY@_K;fG;Y&*coMbaT<~A1adfRjRCC!-Y6X`tS#)dKacNRvxpSfXoaAo%F3-_*! zna~uxs)P0LIr)41srjBqtBcWJyfyeKu=U$J4SdN+c|ktjON>fzNkq+BLvWrq2jnH%cD{*-7 zP8Fv};p$5!{K135lsu_phAfBlZDK$pT}%W#;}(~L6RFG9*>E*D1umc_!gW;q<3M~_ z8DG%F*Onc5#=kgJYV}QjJ8J3dd$ENEju)@V(#_|o&*a=snL5XRX32#@jmZZ@iH`O@ zjkS{VIm5s2?edI$qVvA4E34mS-b~qN?z(hVKhcQECF6smdS26*T71DE)aad;|M=*0 z8@^>d^igrNnfJuoaOtHj#)GGOK6svbJkYyfh{Zc@$+F3^;T7*scAy2@9vr8$YspHc z#=N?W&l!$0Ds8*iX7vt9F;&aV?K^wsqv7xOPkI+@cjs&8b9-FtbFJ1rUf;3q-0gQ- z>*rX{njNm?t^QVZ>=n~mLAwVHhaJwuFWemB$v(n9cx3Im$D6L-Y&)h$P;U>xz>WsP zHoouJc*njIFLU;$K4UX-#ml$JYJHikWrVG@Pk9$^c$)hDn(zR{mHDH6Sc6&TSsU|B+w2tz zw=~>3V#wHg*YBv7_3Jw#r&qK7s7jc54PB`U-qYvZtfgw9-E`)Znw~>8hd0h!+9hbP ziR+OIix)2%GQ|9Iw;86ZzjU=I{jjicU)HwJSr1<37Z|*H;XbFZUFeT1H5M89Pu73_ zI{u}4>5I(H>%Wq9jIfD!@8;*EOz}RypjSlXzS21JssfI{Y)HKydt;X`D^4xxcc5y_ zytskABDw|b_dh;wP&~V|Th_P2MF;leo~SkbH8$ z*U~f9^(B+T%ObSDP24j%@PB8VZ0Orv**B*Z*Y_H`?6_xeupr$|bmC0!3rl-^>G^c) z%fr6jJyJhv7o`2@$0E~%_xW4x9~@fUcf5w`q+820hIKIF^48U^IDN&YMyAONP}?(2 znxCmYymQIh$CU-QBG(k$h!akJ9b4IZeb4I+jT)Z1es9Qa?qBKz9V~XKPG8io;ZA14 zOx5iu{)z;qc-$BJ#yGni#J{Smh5r;5LeiC6O9$)zN$}s$97y;ov2^MQQwtZf+j+Gz z>hE+S+Apim|DNqUsklVrPVxnOXE#?@{1Vm`w)23xV3aKWj~qNYke2d;hjH`4mvrA zMwRZmEBqRKprf&6x~{~)Y~1?L)Ui>?8~c45Z0g+*m%nDuIR9|p9_O{^vwYHreMs9+ zpBXr`{#@v{+{bfIY+Uhnh%KAna3g{>W$PGK*JlMr8=lWO?e)|taOd*(w^H{kArA1= zrWKt2x_kfez<&Mp<`c|F^KfNw=Lz)GgTLI&UWVUlj^j^$7f@6jYcDiI*@J-0%vL?`#*5m?@xHc zCbp8=#NvBMWi!aKsbtxtpZ2k3q<7Ocl+fe<={`0pG(^6M4Ty?yN|pcVqQ9|=je;M0 zHSc2a4;25_E>`8qm>!xBj@+BwrEDPGdqH)TnYiZVvQr=Ud(Sc-to;5tE~h_er|r2A%Tt^_zDqLH|d>r~dk` zvn_jt%If`fj;-G}?8vaU?j?P@7`>fS*nLVgTJNE)|G}xSOmuzamaIod&-`&>2oi^q zftKc8XY1%oXHM#4vwQ0|#{IlSg6TzxQ`y)%)Ge<4i zv(R82!+-epEv56!J$PHJ9;d$g_0l*0`eE>W_CM zLxox5!7Iy7E>~OQx$D)Dlh?{OOHLcV-#(HsDg9zN);892Q~Zr%nmy+X87=Ls`ee4l zi;8>Bj=DA<_B+LPH2ZjLO~eiB?HgC#oVjVa|Kj6k+xvyz8}-R{ZZ#*3ytqpy2)&z9 z^kL38C&Qy=>-%h3cPr3qR@A_&RTmETe3*GB?!fswTT{<>nRrFGCm|vag z?Cd?EsJe*kW$iIKJmX<~iQ0#t;sJ!r*K3ge!Ra@G78Z}UF`Rvcr|-CVdZlj0;oK~# zotM3l(a=Q?*dtX0Dfeg1l9Zl&;(cIgS>q3$zg7Q}8jttK|6z92bxllV>YYyJN29-w z&qq5VAm;5>CJV+Ia$jV=dB+YJutZV`u6doPlbOTd!%|t%Cq?6 z)x3e7c3;%q>Z3M5bSwR+prXW@y)U@PWcj_t>#tWjW!|wQgvBYJlna$1^pt*!mkh5V|E>(+nsDmm;l;72t0D!F`hfp-G@|EbmGPk8_O zGT>ib(V^ZD5CqZ>N?I^_*^F&h6K|~N)Eo0gP5t=%!}j{=F|tk_>5H{H*_`TYs4@E7 zmwpb{@0j-?V;+r8ozy;d_2|{Lj^n4dvq*Y!1lP9`+#53RXt>W$~xN{Hmh#$%$QsD`SFT?3yZ$2DCYKX=_JUh z&N-tu`K0h^$exECZ!O<_&*+=%dO5el09XD^Sx)?@I}4U|ba+>{rg)(2?DooB+D098 z)c2yL)x+9H0-@@#fQzCRkH0!rmD2}7=(ay~Mt@lKfB1l~*oqA&_2w%A^tNb|d!HXq zY&^5SOFdTyjCkcXVnC<9m1PIXvVBX+c9Ug0{v%uOUw-TH`;Q7EVq>Tu75b9`cZUGC zU=Ig=poa(FjFeVV#zCZ8 zi@G#Eyy|Yc3q+kQYd#tWreNw}=?9r`M{dIxGcXeOih;{DFD4OfP zrzHGl)SW&TM;m0V-7)P}S;M4^3GEsaPg?{{H+vqGI@xun$D+DLLJNMnqsmDW&)lrF zCkw)>>MpK(!wi^ivbgtwsbLRJ&npPH9rMG&@#MU?C&Do^QtDTA@37o($Wck3H&K2I zVm%fH|TQaz5^8sew8*1iF z`)ALA^4M4_+nS$aV*=8kIi5x5YyK3_Ab*W@jp$5Uz6%|&&#>zLIrt_~+?f4GA6ci7SKYg%rtC5qoayYfW1Pc^HDl_B zEKbtD>~Fs5h5n4~-$o04Essac+9~^ZckA9y9r=q7+{(Su<%H+*8Nof7@~DOoLqw*B&` literal 0 HcmV?d00001 diff --git a/src/packages/Microsoft.Bcl.Async.1.0.168/lib/portable-net40+sl4+win8+wp71+wpa81/Microsoft.Threading.Tasks.Extensions.xml b/src/packages/Microsoft.Bcl.Async.1.0.168/lib/portable-net40+sl4+win8+wp71+wpa81/Microsoft.Threading.Tasks.Extensions.xml new file mode 100644 index 00000000..af646a2d --- /dev/null +++ b/src/packages/Microsoft.Bcl.Async.1.0.168/lib/portable-net40+sl4+win8+wp71+wpa81/Microsoft.Threading.Tasks.Extensions.xml @@ -0,0 +1,275 @@ + + + + Microsoft.Threading.Tasks.Extensions + + + + Returns a canceled task. + The cancellation token. + The canceled task. + + + Returns a canceled task. + Specifies the type of the result. + The cancellation token. + The canceled task. + + + + Completes the Task if the user state matches the TaskCompletionSource. + + Specifies the type of data returned by the Task. + The TaskCompletionSource. + The completion event arguments. + Whether we require the tcs to match the e.UserState. + A function that gets the result with which to complete the task. + An action used to unregister work when the operaiton completes. + + + + Provides asynchronous wrappers for .NET Framework operations. + + + + + Reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read. + + A Task that represents the asynchronous read. + The source. + The buffer to read data into. + The byte offset in at which to begin reading. + The maximum number of bytes to read. + The array length minus is less than . + is null. + or is negative. + An asynchronous read was attempted past the end of the file. + + + + Reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read. + + A Task that represents the asynchronous read. + The source. + The buffer to read data into. + The byte offset in at which to begin reading. + The maximum number of bytes to read. + The cancellation token. + The array length minus is less than . + is null. + or is negative. + An asynchronous read was attempted past the end of the file. + + + + Writes asynchronously a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written. + + A Task that represents the asynchronous write. + The source. + The buffer containing data to write to the current stream. + The zero-based byte offset in at which to begin copying bytes to the current stream. + The maximum number of bytes to write. + length minus is less than . + is null. + or is negative. + The stream does not support writing. + The stream is closed. + An I/O error occurred. + + + + Writes asynchronously a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written. + + A Task that represents the asynchronous write. + The source. + The buffer containing data to write to the current stream. + The zero-based byte offset in at which to begin copying bytes to the current stream. + The maximum number of bytes to write. + The cancellation token. + length minus is less than . + is null. + or is negative. + The stream does not support writing. + The stream is closed. + An I/O error occurred. + + + + Flushes asynchronously the current stream. + + A Task that represents the asynchronous flush. + + + + Flushes asynchronously the current stream. + + A Task that represents the asynchronous flush. + + + + Reads all the bytes from the current stream and writes them to the destination stream. + + The source stream. + The stream that will contain the contents of the current stream. + A Task that represents the asynchronous operation. + + + + Reads all the bytes from the current stream and writes them to the destination stream. + + The source stream. + The stream that will contain the contents of the current stream. + The size of the buffer. This value must be greater than zero. The default size is 4096. + A Task that represents the asynchronous operation. + + + + Reads all the bytes from the current stream and writes them to the destination stream. + + The source stream. + The stream that will contain the contents of the current stream. + The size of the buffer. This value must be greater than zero. The default size is 4096. + The cancellation token to use to cancel the asynchronous operation. + A Task that represents the asynchronous operation. + + + + Reads all the bytes from the current stream and writes them to the destination stream. + + The source stream. + The stream that will contain the contents of the current stream. + The size of the buffer. This value must be greater than zero. The default size is 4096. + The cancellation token to use to cancel the asynchronous operation. + A Task that represents the asynchronous operation. + + + + Reads a maximum of count characters from the reader asynchronously and writes + the data to buffer, beginning at index. + + + When the operation completes, contains the specified character array with the + values between index and (index + count - 1) replaced by the characters read + from the current source. + + + The maximum number of characters to read. If the end of the stream is reached + before count of characters is read into buffer, the current method returns. + + The place in buffer at which to begin writing. + the source reader. + A Task that represents the asynchronous operation. + + + + Reads asynchronously a maximum of count characters from the current stream, and writes the + data to buffer, beginning at index. + + The source reader. + + When this method returns, this parameter contains the specified character + array with the values between index and (index + count -1) replaced by the + characters read from the current source. + + The position in buffer at which to begin writing. + The maximum number of characters to read. + A Task that represents the asynchronous operation. + + + + Reads a line of characters from the reader and returns the string asynchronously. + + the source reader. + A Task that represents the asynchronous operation. + + + + Reads all characters from the current position to the end of the TextReader + and returns them as one string asynchronously. + + the source reader. + A Task that represents the asynchronous operation. + + + Writes a string asynchronously to a text stream. + The writer. + The string to write. + A Task representing the asynchronous write. + + + Writes a char asynchronously to a text stream. + The writer. + The char to write. + A Task representing the asynchronous write. + + + Writes a char array asynchronously to a text stream. + The writer. + The buffer to write. + A Task representing the asynchronous write. + + + Writes a subarray of characters asynchronously to a text stream. + The writer. + The buffer to write. + Starting index in the buffer. + The number of characters to write. + A Task representing the asynchronous write. + + + Writes a line terminator asynchronously to a text stream. + The writer. + A Task representing the asynchronous write. + + + Writes a string followed by a line terminator asynchronously to a text stream. + The writer. + The string to write. + A Task representing the asynchronous write. + + + Writes a char followed by a line terminator asynchronously to a text stream. + The writer. + The char to write. + A Task representing the asynchronous write. + + + Writes a char array followed by a line terminator asynchronously to a text stream. + The writer. + The buffer to write. + A Task representing the asynchronous write. + + + Writes a subarray of characters followed by a line terminator asynchronously to a text stream. + The writer. + The buffer to write. + Starting index in the buffer. + The number of characters to write. + A Task representing the asynchronous write. + + + + Clears all buffers for the current writer and causes any buffered data to + be written to the underlying device. + + The writer. + A Task representing the asynchronous flush. + + + Starts an asynchronous request for a web resource. + Task that represents the asynchronous request. + The stream is already in use by a previous call to . + + The source. + + + Starts an asynchronous request for a object to use to write data. + Task that represents the asynchronous request. + The property is GET and the application writes to the stream. + The stream is being used by a previous call to . + No write stream is available. + + The source. + + + diff --git a/src/packages/Microsoft.Bcl.Async.1.0.168/lib/portable-net40+sl4+win8+wp71+wpa81/Microsoft.Threading.Tasks.dll b/src/packages/Microsoft.Bcl.Async.1.0.168/lib/portable-net40+sl4+win8+wp71+wpa81/Microsoft.Threading.Tasks.dll new file mode 100644 index 0000000000000000000000000000000000000000..8438577c2042e5d6899425d500bf8074aae650a1 GIT binary patch literal 37104 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 literal 0 HcmV?d00001 diff --git a/src/packages/Microsoft.Bcl.Async.1.0.168/lib/portable-net40+sl4+win8+wp71+wpa81/Microsoft.Threading.Tasks.xml b/src/packages/Microsoft.Bcl.Async.1.0.168/lib/portable-net40+sl4+win8+wp71+wpa81/Microsoft.Threading.Tasks.xml new file mode 100644 index 00000000..5c22030d --- /dev/null +++ b/src/packages/Microsoft.Bcl.Async.1.0.168/lib/portable-net40+sl4+win8+wp71+wpa81/Microsoft.Threading.Tasks.xml @@ -0,0 +1,630 @@ + + + + Microsoft.Threading.Tasks + + + + + Provides extension methods for threading-related types. + + + + Cancels the after the specified duration. + The CancellationTokenSource. + The due time in milliseconds for the source to be canceled. + + + Cancels the after the specified duration. + The CancellationTokenSource. + The due time for the source to be canceled. + + + Gets an awaiter used to await this . + The task to await. + An awaiter instance. + + + Gets an awaiter used to await this . + Specifies the type of data returned by the task. + The task to await. + An awaiter instance. + + + Creates and configures an awaitable object for awaiting the specified task. + The task to be awaited. + + true to automatic marshag back to the original call site's current SynchronizationContext + or TaskScheduler; otherwise, false. + + The instance to be awaited. + + + Creates and configures an awaitable object for awaiting the specified task. + The task to be awaited. + + true to automatic marshag back to the original call site's current SynchronizationContext + or TaskScheduler; otherwise, false. + + The instance to be awaited. + + + Event handler for progress reports. + Specifies the type of data for the progress report. + The sender of the report. + The reported value. + + + + Provides an IProgress{T} that invokes callbacks for each reported progress value. + + Specifies the type of the progress report value. + + Any handler provided to the constructor or event handlers registered with + the event are invoked through a + instance captured + when the instance is constructed. If there is no current SynchronizationContext + at the time of construction, the callbacks will be invoked on the ThreadPool. + + + + The synchronization context captured upon construction. This will never be null. + + + The handler specified to the constructor. This may be null. + + + A cached delegate used to post invocation to the synchronization context. + + + Initializes the . + + + Initializes the with the specified callback. + + A handler to invoke for each reported progress value. This handler will be invoked + in addition to any delegates registered with the event. + + The is null (Nothing in Visual Basic). + + + Reports a progress change. + The value of the updated progress. + + + Reports a progress change. + The value of the updated progress. + + + Invokes the action and event callbacks. + The progress value. + + + Raised for each reported progress value. + + Handlers registered with this event will be invoked on the + captured when the instance was constructed. + + + + Holds static values for . + This avoids one static instance per type T. + + + A default synchronization context that targets the ThreadPool. + + + Throws the exception on the ThreadPool. + The exception to propagate. + The target context on which to propagate the exception. Null to use the ThreadPool. + + + Copies the exception's stack trace so its stack trace isn't overwritten. + The exception to prepare. + + + Provides an awaitable object that allows for configured awaits on . + This type is intended for compiler use only. + + + The task being awaited. + + + Initializes the . + The awaitable . + + true to attempt to marshal the continuation back to the original context captured; otherwise, false. + + + + Gets an awaiter for this awaitable. + The awaiter. + + + Provides an awaiter for a . + This type is intended for compiler use only. + + + The task being awaited. + + + Whether to attempt marshaling back to the original context. + + + Initializes the . + The to await. + + true to attempt to marshal the continuation back to the original context captured + when BeginAwait is called; otherwise, false. + + + + Schedules the continuation onto the associated with this . + The action to invoke when the await operation completes. + The argument is null (Nothing in Visual Basic). + The awaiter was not properly initialized. + This method is intended for compiler user rather than use directly in code. + + + Schedules the continuation onto the associated with this . + The action to invoke when the await operation completes. + The argument is null (Nothing in Visual Basic). + The awaiter was not properly initialized. + This method is intended for compiler user rather than use directly in code. + + + Ends the await on the completed . + The result of the completed . + The awaiter was not properly initialized. + The task was not yet completed. + The task was canceled. + The task completed in a Faulted state. + + + Gets whether the task being awaited is completed. + This property is intended for compiler user rather than use directly in code. + The awaiter was not properly initialized. + + + Provides an awaitable object that allows for configured awaits on . + This type is intended for compiler use only. + + + The underlying awaitable on whose logic this awaitable relies. + + + Initializes the . + The awaitable . + + true to attempt to marshal the continuation back to the original context captured; otherwise, false. + + + + Gets an awaiter for this awaitable. + The awaiter. + + + Provides an awaiter for a . + This type is intended for compiler use only. + + + The task being awaited. + + + Whether to attempt marshaling back to the original context. + + + Initializes the . + The awaitable . + + true to attempt to marshal the continuation back to the original context captured; otherwise, false. + + + + Schedules the continuation onto the associated with this . + The action to invoke when the await operation completes. + The argument is null (Nothing in Visual Basic). + The awaiter was not properly initialized. + This method is intended for compiler user rather than use directly in code. + + + Schedules the continuation onto the associated with this . + The action to invoke when the await operation completes. + The argument is null (Nothing in Visual Basic). + The awaiter was not properly initialized. + This method is intended for compiler user rather than use directly in code. + + + Ends the await on the completed . + The result of the completed . + The awaiter was not properly initialized. + The task was not yet completed. + The task was canceled. + The task completed in a Faulted state. + + + Gets whether the task being awaited is completed. + This property is intended for compiler user rather than use directly in code. + The awaiter was not properly initialized. + + + Provides an awaiter for awaiting a . + This type is intended for compiler use only. + + + The default value to use for continueOnCapturedContext. + + + Error message for GetAwaiter. + + + The task being awaited. + + + Initializes the . + The to be awaited. + + + Schedules the continuation onto the associated with this . + The action to invoke when the await operation completes. + The argument is null (Nothing in Visual Basic). + The awaiter was not properly initialized. + This method is intended for compiler user rather than use directly in code. + + + Schedules the continuation onto the associated with this . + The action to invoke when the await operation completes. + The argument is null (Nothing in Visual Basic). + The awaiter was not properly initialized. + This method is intended for compiler user rather than use directly in code. + + + Ends the await on the completed . + The awaiter was not properly initialized. + The task was not yet completed. + The task was canceled. + The task completed in a Faulted state. + + + + Fast checks for the end of an await operation to determine whether more needs to be done + prior to completing the await. + + The awaited task. + + + Handles validations on tasks that aren't successfully completed. + The awaited task. + + + Throws an exception to handle a task that completed in a state other than RanToCompletion. + + + Schedules the continuation onto the associated with this . + The awaited task. + The action to invoke when the await operation completes. + Whether to capture and marshal back to the current context. + The argument is null (Nothing in Visual Basic). + The awaiter was not properly initialized. + This method is intended for compiler user rather than use directly in code. + + + Invokes the delegate in a try/catch that will propagate the exception asynchronously on the ThreadPool. + + + + Copies the exception's stack trace so its stack trace isn't overwritten. + The exception to prepare. + + + Gets whether the task being awaited is completed. + This property is intended for compiler user rather than use directly in code. + The awaiter was not properly initialized. + + + Whether the current thread is appropriate for inlining the await continuation. + + + Provides an awaiter for awaiting a . + This type is intended for compiler use only. + + + The task being awaited. + + + Initializes the . + The to be awaited. + + + Schedules the continuation onto the associated with this . + The action to invoke when the await operation completes. + The argument is null (Nothing in Visual Basic). + The awaiter was not properly initialized. + This method is intended for compiler user rather than use directly in code. + + + Schedules the continuation onto the associated with this . + The action to invoke when the await operation completes. + The argument is null (Nothing in Visual Basic). + The awaiter was not properly initialized. + This method is intended for compiler user rather than use directly in code. + + + Ends the await on the completed . + The result of the completed . + The awaiter was not properly initialized. + The task was not yet completed. + The task was canceled. + The task completed in a Faulted state. + + + Gets whether the task being awaited is completed. + This property is intended for compiler user rather than use directly in code. + The awaiter was not properly initialized. + + + Provides an awaitable context for switching into a target environment. + This type is intended for compiler use only. + + + Gets an awaiter for this . + An awaiter for this awaitable. + This method is intended for compiler user rather than use directly in code. + + + Provides an awaiter that switches into a target environment. + This type is intended for compiler use only. + + + A completed task. + + + Posts the back to the current context. + The action to invoke asynchronously. + The awaiter was not properly initialized. + + + Posts the back to the current context. + The action to invoke asynchronously. + The awaiter was not properly initialized. + + + Ends the await operation. + + + Gets whether a yield is not required. + This property is intended for compiler user rather than use directly in code. + + + Provides methods for creating and manipulating tasks. + + + Creates a task that runs the specified action. + The action to execute asynchronously. + A task that represents the completion of the action. + The argument is null. + + + Creates a task that runs the specified action. + The action to execute. + The CancellationToken to use to request cancellation of this task. + A task that represents the completion of the action. + The argument is null. + + + Creates a task that runs the specified function. + The function to execute asynchronously. + A task that represents the completion of the action. + The argument is null. + + + Creates a task that runs the specified function. + The action to execute. + The CancellationToken to use to cancel the task. + A task that represents the completion of the action. + The argument is null. + + + Creates a task that runs the specified function. + The action to execute asynchronously. + A task that represents the completion of the action. + The argument is null. + + + Creates a task that runs the specified function. + The function to execute. + The CancellationToken to use to request cancellation of this task. + A task that represents the completion of the function. + The argument is null. + + + Creates a task that runs the specified function. + The function to execute asynchronously. + A task that represents the completion of the action. + The argument is null. + + + Creates a task that runs the specified function. + The action to execute. + The CancellationToken to use to cancel the task. + A task that represents the completion of the action. + The argument is null. + + + Starts a Task that will complete after the specified due time. + The delay in milliseconds before the returned task completes. + The timed Task. + + The argument must be non-negative or -1 and less than or equal to Int32.MaxValue. + + + + Starts a Task that will complete after the specified due time. + The delay before the returned task completes. + The timed Task. + + The argument must be non-negative or -1 and less than or equal to Int32.MaxValue. + + + + Starts a Task that will complete after the specified due time. + The delay before the returned task completes. + A CancellationToken that may be used to cancel the task before the due time occurs. + The timed Task. + + The argument must be non-negative or -1 and less than or equal to Int32.MaxValue. + + + + Starts a Task that will complete after the specified due time. + The delay in milliseconds before the returned task completes. + A CancellationToken that may be used to cancel the task before the due time occurs. + The timed Task. + + The argument must be non-negative or -1 and less than or equal to Int32.MaxValue. + + + + An already completed task. + + + Creates a Task that will complete only when all of the provided collection of Tasks has completed. + The Tasks to monitor for completion. + A Task that represents the completion of all of the provided tasks. + + If any of the provided Tasks faults, the returned Task will also fault, and its Exception will contain information + about all of the faulted tasks. If no Tasks fault but one or more Tasks is canceled, the returned + Task will also be canceled. + + The argument is null. + The argument contains a null reference. + + + Creates a Task that will complete only when all of the provided collection of Tasks has completed. + The Tasks to monitor for completion. + A Task that represents the completion of all of the provided tasks. + + If any of the provided Tasks faults, the returned Task will also fault, and its Exception will contain information + about all of the faulted tasks. If no Tasks fault but one or more Tasks is canceled, the returned + Task will also be canceled. + + The argument is null. + The argument contains a null reference. + + + Creates a Task that will complete only when all of the provided collection of Tasks has completed. + The Tasks to monitor for completion. + A Task that represents the completion of all of the provided tasks. + + If any of the provided Tasks faults, the returned Task will also fault, and its Exception will contain information + about all of the faulted tasks. If no Tasks fault but one or more Tasks is canceled, the returned + Task will also be canceled. + + The argument is null. + The argument contains a null reference. + + + Creates a Task that will complete only when all of the provided collection of Tasks has completed. + The Tasks to monitor for completion. + A Task that represents the completion of all of the provided tasks. + + If any of the provided Tasks faults, the returned Task will also fault, and its Exception will contain information + about all of the faulted tasks. If no Tasks fault but one or more Tasks is canceled, the returned + Task will also be canceled. + + The argument is null. + The argument contains a null reference. + + + Creates a Task that will complete only when all of the provided collection of Tasks has completed. + The Tasks to monitor for completion. + + A callback invoked when all of the tasks complete successfully in the RanToCompletion state. + This callback is responsible for storing the results into the TaskCompletionSource. + + A Task that represents the completion of all of the provided tasks. + The argument is null. + The argument contains a null reference. + + + Creates a Task that will complete when any of the tasks in the provided collection completes. + The Tasks to be monitored. + + A Task that represents the completion of any of the provided Tasks. The completed Task is this Task's result. + + Any Tasks that fault will need to have their exceptions observed elsewhere. + The argument is null. + The argument contains a null reference. + + + Creates a Task that will complete when any of the tasks in the provided collection completes. + The Tasks to be monitored. + + A Task that represents the completion of any of the provided Tasks. The completed Task is this Task's result. + + Any Tasks that fault will need to have their exceptions observed elsewhere. + The argument is null. + The argument contains a null reference. + + + Creates a Task that will complete when any of the tasks in the provided collection completes. + The Tasks to be monitored. + + A Task that represents the completion of any of the provided Tasks. The completed Task is this Task's result. + + Any Tasks that fault will need to have their exceptions observed elsewhere. + The argument is null. + The argument contains a null reference. + + + Creates a Task that will complete when any of the tasks in the provided collection completes. + The Tasks to be monitored. + + A Task that represents the completion of any of the provided Tasks. The completed Task is this Task's result. + + Any Tasks that fault will need to have their exceptions observed elsewhere. + The argument is null. + The argument contains a null reference. + + + Creates an already completed from the specified result. + The result from which to create the completed task. + The completed task. + + + Creates an awaitable that asynchronously yields back to the current context when awaited. + + A context that, when awaited, will asynchronously transition back into the current context. + If SynchronizationContext.Current is non-null, that is treated as the current context. + Otherwise, TaskScheduler.Current is treated as the current context. + + + + Adds the target exception to the list, initializing the list if it's null. + The list to which to add the exception and initialize if the list is null. + The exception to add, and unwrap if it's an aggregate. + + + Returns a canceled task. + The cancellation token. + The canceled task. + + + Returns a canceled task. + Specifies the type of the result. + The cancellation token. + The canceled task. + + + + Completes the Task if the user state matches the TaskCompletionSource. + + Specifies the type of data returned by the Task. + The TaskCompletionSource. + The completion event arguments. + Whether we require the tcs to match the e.UserState. + A function that gets the result with which to complete the task. + An action used to unregister work when the operaiton completes. + + + diff --git a/src/packages/Microsoft.Bcl.Async.1.0.168/lib/portable-net45+win8+wp8+wpa81/Microsoft.Threading.Tasks.Extensions.dll b/src/packages/Microsoft.Bcl.Async.1.0.168/lib/portable-net45+win8+wp8+wpa81/Microsoft.Threading.Tasks.Extensions.dll new file mode 100644 index 0000000000000000000000000000000000000000..4d862e1730a34a6a5cfa39d04840bd039cf9de29 GIT binary patch literal 31520 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 literal 0 HcmV?d00001 diff --git a/src/packages/Microsoft.Bcl.Async.1.0.168/lib/portable-net45+win8+wp8+wpa81/Microsoft.Threading.Tasks.Extensions.xml b/src/packages/Microsoft.Bcl.Async.1.0.168/lib/portable-net45+win8+wp8+wpa81/Microsoft.Threading.Tasks.Extensions.xml new file mode 100644 index 00000000..af646a2d --- /dev/null +++ b/src/packages/Microsoft.Bcl.Async.1.0.168/lib/portable-net45+win8+wp8+wpa81/Microsoft.Threading.Tasks.Extensions.xml @@ -0,0 +1,275 @@ + + + + Microsoft.Threading.Tasks.Extensions + + + + Returns a canceled task. + The cancellation token. + The canceled task. + + + Returns a canceled task. + Specifies the type of the result. + The cancellation token. + The canceled task. + + + + Completes the Task if the user state matches the TaskCompletionSource. + + Specifies the type of data returned by the Task. + The TaskCompletionSource. + The completion event arguments. + Whether we require the tcs to match the e.UserState. + A function that gets the result with which to complete the task. + An action used to unregister work when the operaiton completes. + + + + Provides asynchronous wrappers for .NET Framework operations. + + + + + Reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read. + + A Task that represents the asynchronous read. + The source. + The buffer to read data into. + The byte offset in at which to begin reading. + The maximum number of bytes to read. + The array length minus is less than . + is null. + or is negative. + An asynchronous read was attempted past the end of the file. + + + + Reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read. + + A Task that represents the asynchronous read. + The source. + The buffer to read data into. + The byte offset in at which to begin reading. + The maximum number of bytes to read. + The cancellation token. + The array length minus is less than . + is null. + or is negative. + An asynchronous read was attempted past the end of the file. + + + + Writes asynchronously a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written. + + A Task that represents the asynchronous write. + The source. + The buffer containing data to write to the current stream. + The zero-based byte offset in at which to begin copying bytes to the current stream. + The maximum number of bytes to write. + length minus is less than . + is null. + or is negative. + The stream does not support writing. + The stream is closed. + An I/O error occurred. + + + + Writes asynchronously a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written. + + A Task that represents the asynchronous write. + The source. + The buffer containing data to write to the current stream. + The zero-based byte offset in at which to begin copying bytes to the current stream. + The maximum number of bytes to write. + The cancellation token. + length minus is less than . + is null. + or is negative. + The stream does not support writing. + The stream is closed. + An I/O error occurred. + + + + Flushes asynchronously the current stream. + + A Task that represents the asynchronous flush. + + + + Flushes asynchronously the current stream. + + A Task that represents the asynchronous flush. + + + + Reads all the bytes from the current stream and writes them to the destination stream. + + The source stream. + The stream that will contain the contents of the current stream. + A Task that represents the asynchronous operation. + + + + Reads all the bytes from the current stream and writes them to the destination stream. + + The source stream. + The stream that will contain the contents of the current stream. + The size of the buffer. This value must be greater than zero. The default size is 4096. + A Task that represents the asynchronous operation. + + + + Reads all the bytes from the current stream and writes them to the destination stream. + + The source stream. + The stream that will contain the contents of the current stream. + The size of the buffer. This value must be greater than zero. The default size is 4096. + The cancellation token to use to cancel the asynchronous operation. + A Task that represents the asynchronous operation. + + + + Reads all the bytes from the current stream and writes them to the destination stream. + + The source stream. + The stream that will contain the contents of the current stream. + The size of the buffer. This value must be greater than zero. The default size is 4096. + The cancellation token to use to cancel the asynchronous operation. + A Task that represents the asynchronous operation. + + + + Reads a maximum of count characters from the reader asynchronously and writes + the data to buffer, beginning at index. + + + When the operation completes, contains the specified character array with the + values between index and (index + count - 1) replaced by the characters read + from the current source. + + + The maximum number of characters to read. If the end of the stream is reached + before count of characters is read into buffer, the current method returns. + + The place in buffer at which to begin writing. + the source reader. + A Task that represents the asynchronous operation. + + + + Reads asynchronously a maximum of count characters from the current stream, and writes the + data to buffer, beginning at index. + + The source reader. + + When this method returns, this parameter contains the specified character + array with the values between index and (index + count -1) replaced by the + characters read from the current source. + + The position in buffer at which to begin writing. + The maximum number of characters to read. + A Task that represents the asynchronous operation. + + + + Reads a line of characters from the reader and returns the string asynchronously. + + the source reader. + A Task that represents the asynchronous operation. + + + + Reads all characters from the current position to the end of the TextReader + and returns them as one string asynchronously. + + the source reader. + A Task that represents the asynchronous operation. + + + Writes a string asynchronously to a text stream. + The writer. + The string to write. + A Task representing the asynchronous write. + + + Writes a char asynchronously to a text stream. + The writer. + The char to write. + A Task representing the asynchronous write. + + + Writes a char array asynchronously to a text stream. + The writer. + The buffer to write. + A Task representing the asynchronous write. + + + Writes a subarray of characters asynchronously to a text stream. + The writer. + The buffer to write. + Starting index in the buffer. + The number of characters to write. + A Task representing the asynchronous write. + + + Writes a line terminator asynchronously to a text stream. + The writer. + A Task representing the asynchronous write. + + + Writes a string followed by a line terminator asynchronously to a text stream. + The writer. + The string to write. + A Task representing the asynchronous write. + + + Writes a char followed by a line terminator asynchronously to a text stream. + The writer. + The char to write. + A Task representing the asynchronous write. + + + Writes a char array followed by a line terminator asynchronously to a text stream. + The writer. + The buffer to write. + A Task representing the asynchronous write. + + + Writes a subarray of characters followed by a line terminator asynchronously to a text stream. + The writer. + The buffer to write. + Starting index in the buffer. + The number of characters to write. + A Task representing the asynchronous write. + + + + Clears all buffers for the current writer and causes any buffered data to + be written to the underlying device. + + The writer. + A Task representing the asynchronous flush. + + + Starts an asynchronous request for a web resource. + Task that represents the asynchronous request. + The stream is already in use by a previous call to . + + The source. + + + Starts an asynchronous request for a object to use to write data. + Task that represents the asynchronous request. + The property is GET and the application writes to the stream. + The stream is being used by a previous call to . + No write stream is available. + + The source. + + + diff --git a/src/packages/Microsoft.Bcl.Async.1.0.168/lib/portable-net45+win8+wp8+wpa81/Microsoft.Threading.Tasks.dll b/src/packages/Microsoft.Bcl.Async.1.0.168/lib/portable-net45+win8+wp8+wpa81/Microsoft.Threading.Tasks.dll new file mode 100644 index 0000000000000000000000000000000000000000..8438577c2042e5d6899425d500bf8074aae650a1 GIT binary patch literal 37104 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 literal 0 HcmV?d00001 diff --git a/src/packages/Microsoft.Bcl.Async.1.0.168/lib/portable-net45+win8+wp8+wpa81/Microsoft.Threading.Tasks.xml b/src/packages/Microsoft.Bcl.Async.1.0.168/lib/portable-net45+win8+wp8+wpa81/Microsoft.Threading.Tasks.xml new file mode 100644 index 00000000..5c22030d --- /dev/null +++ b/src/packages/Microsoft.Bcl.Async.1.0.168/lib/portable-net45+win8+wp8+wpa81/Microsoft.Threading.Tasks.xml @@ -0,0 +1,630 @@ + + + + Microsoft.Threading.Tasks + + + + + Provides extension methods for threading-related types. + + + + Cancels the after the specified duration. + The CancellationTokenSource. + The due time in milliseconds for the source to be canceled. + + + Cancels the after the specified duration. + The CancellationTokenSource. + The due time for the source to be canceled. + + + Gets an awaiter used to await this . + The task to await. + An awaiter instance. + + + Gets an awaiter used to await this . + Specifies the type of data returned by the task. + The task to await. + An awaiter instance. + + + Creates and configures an awaitable object for awaiting the specified task. + The task to be awaited. + + true to automatic marshag back to the original call site's current SynchronizationContext + or TaskScheduler; otherwise, false. + + The instance to be awaited. + + + Creates and configures an awaitable object for awaiting the specified task. + The task to be awaited. + + true to automatic marshag back to the original call site's current SynchronizationContext + or TaskScheduler; otherwise, false. + + The instance to be awaited. + + + Event handler for progress reports. + Specifies the type of data for the progress report. + The sender of the report. + The reported value. + + + + Provides an IProgress{T} that invokes callbacks for each reported progress value. + + Specifies the type of the progress report value. + + Any handler provided to the constructor or event handlers registered with + the event are invoked through a + instance captured + when the instance is constructed. If there is no current SynchronizationContext + at the time of construction, the callbacks will be invoked on the ThreadPool. + + + + The synchronization context captured upon construction. This will never be null. + + + The handler specified to the constructor. This may be null. + + + A cached delegate used to post invocation to the synchronization context. + + + Initializes the . + + + Initializes the with the specified callback. + + A handler to invoke for each reported progress value. This handler will be invoked + in addition to any delegates registered with the event. + + The is null (Nothing in Visual Basic). + + + Reports a progress change. + The value of the updated progress. + + + Reports a progress change. + The value of the updated progress. + + + Invokes the action and event callbacks. + The progress value. + + + Raised for each reported progress value. + + Handlers registered with this event will be invoked on the + captured when the instance was constructed. + + + + Holds static values for . + This avoids one static instance per type T. + + + A default synchronization context that targets the ThreadPool. + + + Throws the exception on the ThreadPool. + The exception to propagate. + The target context on which to propagate the exception. Null to use the ThreadPool. + + + Copies the exception's stack trace so its stack trace isn't overwritten. + The exception to prepare. + + + Provides an awaitable object that allows for configured awaits on . + This type is intended for compiler use only. + + + The task being awaited. + + + Initializes the . + The awaitable . + + true to attempt to marshal the continuation back to the original context captured; otherwise, false. + + + + Gets an awaiter for this awaitable. + The awaiter. + + + Provides an awaiter for a . + This type is intended for compiler use only. + + + The task being awaited. + + + Whether to attempt marshaling back to the original context. + + + Initializes the . + The to await. + + true to attempt to marshal the continuation back to the original context captured + when BeginAwait is called; otherwise, false. + + + + Schedules the continuation onto the associated with this . + The action to invoke when the await operation completes. + The argument is null (Nothing in Visual Basic). + The awaiter was not properly initialized. + This method is intended for compiler user rather than use directly in code. + + + Schedules the continuation onto the associated with this . + The action to invoke when the await operation completes. + The argument is null (Nothing in Visual Basic). + The awaiter was not properly initialized. + This method is intended for compiler user rather than use directly in code. + + + Ends the await on the completed . + The result of the completed . + The awaiter was not properly initialized. + The task was not yet completed. + The task was canceled. + The task completed in a Faulted state. + + + Gets whether the task being awaited is completed. + This property is intended for compiler user rather than use directly in code. + The awaiter was not properly initialized. + + + Provides an awaitable object that allows for configured awaits on . + This type is intended for compiler use only. + + + The underlying awaitable on whose logic this awaitable relies. + + + Initializes the . + The awaitable . + + true to attempt to marshal the continuation back to the original context captured; otherwise, false. + + + + Gets an awaiter for this awaitable. + The awaiter. + + + Provides an awaiter for a . + This type is intended for compiler use only. + + + The task being awaited. + + + Whether to attempt marshaling back to the original context. + + + Initializes the . + The awaitable . + + true to attempt to marshal the continuation back to the original context captured; otherwise, false. + + + + Schedules the continuation onto the associated with this . + The action to invoke when the await operation completes. + The argument is null (Nothing in Visual Basic). + The awaiter was not properly initialized. + This method is intended for compiler user rather than use directly in code. + + + Schedules the continuation onto the associated with this . + The action to invoke when the await operation completes. + The argument is null (Nothing in Visual Basic). + The awaiter was not properly initialized. + This method is intended for compiler user rather than use directly in code. + + + Ends the await on the completed . + The result of the completed . + The awaiter was not properly initialized. + The task was not yet completed. + The task was canceled. + The task completed in a Faulted state. + + + Gets whether the task being awaited is completed. + This property is intended for compiler user rather than use directly in code. + The awaiter was not properly initialized. + + + Provides an awaiter for awaiting a . + This type is intended for compiler use only. + + + The default value to use for continueOnCapturedContext. + + + Error message for GetAwaiter. + + + The task being awaited. + + + Initializes the . + The to be awaited. + + + Schedules the continuation onto the associated with this . + The action to invoke when the await operation completes. + The argument is null (Nothing in Visual Basic). + The awaiter was not properly initialized. + This method is intended for compiler user rather than use directly in code. + + + Schedules the continuation onto the associated with this . + The action to invoke when the await operation completes. + The argument is null (Nothing in Visual Basic). + The awaiter was not properly initialized. + This method is intended for compiler user rather than use directly in code. + + + Ends the await on the completed . + The awaiter was not properly initialized. + The task was not yet completed. + The task was canceled. + The task completed in a Faulted state. + + + + Fast checks for the end of an await operation to determine whether more needs to be done + prior to completing the await. + + The awaited task. + + + Handles validations on tasks that aren't successfully completed. + The awaited task. + + + Throws an exception to handle a task that completed in a state other than RanToCompletion. + + + Schedules the continuation onto the associated with this . + The awaited task. + The action to invoke when the await operation completes. + Whether to capture and marshal back to the current context. + The argument is null (Nothing in Visual Basic). + The awaiter was not properly initialized. + This method is intended for compiler user rather than use directly in code. + + + Invokes the delegate in a try/catch that will propagate the exception asynchronously on the ThreadPool. + + + + Copies the exception's stack trace so its stack trace isn't overwritten. + The exception to prepare. + + + Gets whether the task being awaited is completed. + This property is intended for compiler user rather than use directly in code. + The awaiter was not properly initialized. + + + Whether the current thread is appropriate for inlining the await continuation. + + + Provides an awaiter for awaiting a . + This type is intended for compiler use only. + + + The task being awaited. + + + Initializes the . + The to be awaited. + + + Schedules the continuation onto the associated with this . + The action to invoke when the await operation completes. + The argument is null (Nothing in Visual Basic). + The awaiter was not properly initialized. + This method is intended for compiler user rather than use directly in code. + + + Schedules the continuation onto the associated with this . + The action to invoke when the await operation completes. + The argument is null (Nothing in Visual Basic). + The awaiter was not properly initialized. + This method is intended for compiler user rather than use directly in code. + + + Ends the await on the completed . + The result of the completed . + The awaiter was not properly initialized. + The task was not yet completed. + The task was canceled. + The task completed in a Faulted state. + + + Gets whether the task being awaited is completed. + This property is intended for compiler user rather than use directly in code. + The awaiter was not properly initialized. + + + Provides an awaitable context for switching into a target environment. + This type is intended for compiler use only. + + + Gets an awaiter for this . + An awaiter for this awaitable. + This method is intended for compiler user rather than use directly in code. + + + Provides an awaiter that switches into a target environment. + This type is intended for compiler use only. + + + A completed task. + + + Posts the back to the current context. + The action to invoke asynchronously. + The awaiter was not properly initialized. + + + Posts the back to the current context. + The action to invoke asynchronously. + The awaiter was not properly initialized. + + + Ends the await operation. + + + Gets whether a yield is not required. + This property is intended for compiler user rather than use directly in code. + + + Provides methods for creating and manipulating tasks. + + + Creates a task that runs the specified action. + The action to execute asynchronously. + A task that represents the completion of the action. + The argument is null. + + + Creates a task that runs the specified action. + The action to execute. + The CancellationToken to use to request cancellation of this task. + A task that represents the completion of the action. + The argument is null. + + + Creates a task that runs the specified function. + The function to execute asynchronously. + A task that represents the completion of the action. + The argument is null. + + + Creates a task that runs the specified function. + The action to execute. + The CancellationToken to use to cancel the task. + A task that represents the completion of the action. + The argument is null. + + + Creates a task that runs the specified function. + The action to execute asynchronously. + A task that represents the completion of the action. + The argument is null. + + + Creates a task that runs the specified function. + The function to execute. + The CancellationToken to use to request cancellation of this task. + A task that represents the completion of the function. + The argument is null. + + + Creates a task that runs the specified function. + The function to execute asynchronously. + A task that represents the completion of the action. + The argument is null. + + + Creates a task that runs the specified function. + The action to execute. + The CancellationToken to use to cancel the task. + A task that represents the completion of the action. + The argument is null. + + + Starts a Task that will complete after the specified due time. + The delay in milliseconds before the returned task completes. + The timed Task. + + The argument must be non-negative or -1 and less than or equal to Int32.MaxValue. + + + + Starts a Task that will complete after the specified due time. + The delay before the returned task completes. + The timed Task. + + The argument must be non-negative or -1 and less than or equal to Int32.MaxValue. + + + + Starts a Task that will complete after the specified due time. + The delay before the returned task completes. + A CancellationToken that may be used to cancel the task before the due time occurs. + The timed Task. + + The argument must be non-negative or -1 and less than or equal to Int32.MaxValue. + + + + Starts a Task that will complete after the specified due time. + The delay in milliseconds before the returned task completes. + A CancellationToken that may be used to cancel the task before the due time occurs. + The timed Task. + + The argument must be non-negative or -1 and less than or equal to Int32.MaxValue. + + + + An already completed task. + + + Creates a Task that will complete only when all of the provided collection of Tasks has completed. + The Tasks to monitor for completion. + A Task that represents the completion of all of the provided tasks. + + If any of the provided Tasks faults, the returned Task will also fault, and its Exception will contain information + about all of the faulted tasks. If no Tasks fault but one or more Tasks is canceled, the returned + Task will also be canceled. + + The argument is null. + The argument contains a null reference. + + + Creates a Task that will complete only when all of the provided collection of Tasks has completed. + The Tasks to monitor for completion. + A Task that represents the completion of all of the provided tasks. + + If any of the provided Tasks faults, the returned Task will also fault, and its Exception will contain information + about all of the faulted tasks. If no Tasks fault but one or more Tasks is canceled, the returned + Task will also be canceled. + + The argument is null. + The argument contains a null reference. + + + Creates a Task that will complete only when all of the provided collection of Tasks has completed. + The Tasks to monitor for completion. + A Task that represents the completion of all of the provided tasks. + + If any of the provided Tasks faults, the returned Task will also fault, and its Exception will contain information + about all of the faulted tasks. If no Tasks fault but one or more Tasks is canceled, the returned + Task will also be canceled. + + The argument is null. + The argument contains a null reference. + + + Creates a Task that will complete only when all of the provided collection of Tasks has completed. + The Tasks to monitor for completion. + A Task that represents the completion of all of the provided tasks. + + If any of the provided Tasks faults, the returned Task will also fault, and its Exception will contain information + about all of the faulted tasks. If no Tasks fault but one or more Tasks is canceled, the returned + Task will also be canceled. + + The argument is null. + The argument contains a null reference. + + + Creates a Task that will complete only when all of the provided collection of Tasks has completed. + The Tasks to monitor for completion. + + A callback invoked when all of the tasks complete successfully in the RanToCompletion state. + This callback is responsible for storing the results into the TaskCompletionSource. + + A Task that represents the completion of all of the provided tasks. + The argument is null. + The argument contains a null reference. + + + Creates a Task that will complete when any of the tasks in the provided collection completes. + The Tasks to be monitored. + + A Task that represents the completion of any of the provided Tasks. The completed Task is this Task's result. + + Any Tasks that fault will need to have their exceptions observed elsewhere. + The argument is null. + The argument contains a null reference. + + + Creates a Task that will complete when any of the tasks in the provided collection completes. + The Tasks to be monitored. + + A Task that represents the completion of any of the provided Tasks. The completed Task is this Task's result. + + Any Tasks that fault will need to have their exceptions observed elsewhere. + The argument is null. + The argument contains a null reference. + + + Creates a Task that will complete when any of the tasks in the provided collection completes. + The Tasks to be monitored. + + A Task that represents the completion of any of the provided Tasks. The completed Task is this Task's result. + + Any Tasks that fault will need to have their exceptions observed elsewhere. + The argument is null. + The argument contains a null reference. + + + Creates a Task that will complete when any of the tasks in the provided collection completes. + The Tasks to be monitored. + + A Task that represents the completion of any of the provided Tasks. The completed Task is this Task's result. + + Any Tasks that fault will need to have their exceptions observed elsewhere. + The argument is null. + The argument contains a null reference. + + + Creates an already completed from the specified result. + The result from which to create the completed task. + The completed task. + + + Creates an awaitable that asynchronously yields back to the current context when awaited. + + A context that, when awaited, will asynchronously transition back into the current context. + If SynchronizationContext.Current is non-null, that is treated as the current context. + Otherwise, TaskScheduler.Current is treated as the current context. + + + + Adds the target exception to the list, initializing the list if it's null. + The list to which to add the exception and initialize if the list is null. + The exception to add, and unwrap if it's an aggregate. + + + Returns a canceled task. + The cancellation token. + The canceled task. + + + Returns a canceled task. + Specifies the type of the result. + The cancellation token. + The canceled task. + + + + Completes the Task if the user state matches the TaskCompletionSource. + + Specifies the type of data returned by the Task. + The TaskCompletionSource. + The completion event arguments. + Whether we require the tcs to match the e.UserState. + A function that gets the result with which to complete the task. + An action used to unregister work when the operaiton completes. + + + diff --git a/src/packages/Microsoft.Bcl.Async.1.0.168/lib/portable-net45+win8+wpa81/Microsoft.Threading.Tasks.Extensions.dll b/src/packages/Microsoft.Bcl.Async.1.0.168/lib/portable-net45+win8+wpa81/Microsoft.Threading.Tasks.Extensions.dll new file mode 100644 index 0000000000000000000000000000000000000000..4d862e1730a34a6a5cfa39d04840bd039cf9de29 GIT binary patch literal 31520 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 literal 0 HcmV?d00001 diff --git a/src/packages/Microsoft.Bcl.Async.1.0.168/lib/portable-net45+win8+wpa81/Microsoft.Threading.Tasks.Extensions.xml b/src/packages/Microsoft.Bcl.Async.1.0.168/lib/portable-net45+win8+wpa81/Microsoft.Threading.Tasks.Extensions.xml new file mode 100644 index 00000000..af646a2d --- /dev/null +++ b/src/packages/Microsoft.Bcl.Async.1.0.168/lib/portable-net45+win8+wpa81/Microsoft.Threading.Tasks.Extensions.xml @@ -0,0 +1,275 @@ + + + + Microsoft.Threading.Tasks.Extensions + + + + Returns a canceled task. + The cancellation token. + The canceled task. + + + Returns a canceled task. + Specifies the type of the result. + The cancellation token. + The canceled task. + + + + Completes the Task if the user state matches the TaskCompletionSource. + + Specifies the type of data returned by the Task. + The TaskCompletionSource. + The completion event arguments. + Whether we require the tcs to match the e.UserState. + A function that gets the result with which to complete the task. + An action used to unregister work when the operaiton completes. + + + + Provides asynchronous wrappers for .NET Framework operations. + + + + + Reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read. + + A Task that represents the asynchronous read. + The source. + The buffer to read data into. + The byte offset in at which to begin reading. + The maximum number of bytes to read. + The array length minus is less than . + is null. + or is negative. + An asynchronous read was attempted past the end of the file. + + + + Reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read. + + A Task that represents the asynchronous read. + The source. + The buffer to read data into. + The byte offset in at which to begin reading. + The maximum number of bytes to read. + The cancellation token. + The array length minus is less than . + is null. + or is negative. + An asynchronous read was attempted past the end of the file. + + + + Writes asynchronously a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written. + + A Task that represents the asynchronous write. + The source. + The buffer containing data to write to the current stream. + The zero-based byte offset in at which to begin copying bytes to the current stream. + The maximum number of bytes to write. + length minus is less than . + is null. + or is negative. + The stream does not support writing. + The stream is closed. + An I/O error occurred. + + + + Writes asynchronously a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written. + + A Task that represents the asynchronous write. + The source. + The buffer containing data to write to the current stream. + The zero-based byte offset in at which to begin copying bytes to the current stream. + The maximum number of bytes to write. + The cancellation token. + length minus is less than . + is null. + or is negative. + The stream does not support writing. + The stream is closed. + An I/O error occurred. + + + + Flushes asynchronously the current stream. + + A Task that represents the asynchronous flush. + + + + Flushes asynchronously the current stream. + + A Task that represents the asynchronous flush. + + + + Reads all the bytes from the current stream and writes them to the destination stream. + + The source stream. + The stream that will contain the contents of the current stream. + A Task that represents the asynchronous operation. + + + + Reads all the bytes from the current stream and writes them to the destination stream. + + The source stream. + The stream that will contain the contents of the current stream. + The size of the buffer. This value must be greater than zero. The default size is 4096. + A Task that represents the asynchronous operation. + + + + Reads all the bytes from the current stream and writes them to the destination stream. + + The source stream. + The stream that will contain the contents of the current stream. + The size of the buffer. This value must be greater than zero. The default size is 4096. + The cancellation token to use to cancel the asynchronous operation. + A Task that represents the asynchronous operation. + + + + Reads all the bytes from the current stream and writes them to the destination stream. + + The source stream. + The stream that will contain the contents of the current stream. + The size of the buffer. This value must be greater than zero. The default size is 4096. + The cancellation token to use to cancel the asynchronous operation. + A Task that represents the asynchronous operation. + + + + Reads a maximum of count characters from the reader asynchronously and writes + the data to buffer, beginning at index. + + + When the operation completes, contains the specified character array with the + values between index and (index + count - 1) replaced by the characters read + from the current source. + + + The maximum number of characters to read. If the end of the stream is reached + before count of characters is read into buffer, the current method returns. + + The place in buffer at which to begin writing. + the source reader. + A Task that represents the asynchronous operation. + + + + Reads asynchronously a maximum of count characters from the current stream, and writes the + data to buffer, beginning at index. + + The source reader. + + When this method returns, this parameter contains the specified character + array with the values between index and (index + count -1) replaced by the + characters read from the current source. + + The position in buffer at which to begin writing. + The maximum number of characters to read. + A Task that represents the asynchronous operation. + + + + Reads a line of characters from the reader and returns the string asynchronously. + + the source reader. + A Task that represents the asynchronous operation. + + + + Reads all characters from the current position to the end of the TextReader + and returns them as one string asynchronously. + + the source reader. + A Task that represents the asynchronous operation. + + + Writes a string asynchronously to a text stream. + The writer. + The string to write. + A Task representing the asynchronous write. + + + Writes a char asynchronously to a text stream. + The writer. + The char to write. + A Task representing the asynchronous write. + + + Writes a char array asynchronously to a text stream. + The writer. + The buffer to write. + A Task representing the asynchronous write. + + + Writes a subarray of characters asynchronously to a text stream. + The writer. + The buffer to write. + Starting index in the buffer. + The number of characters to write. + A Task representing the asynchronous write. + + + Writes a line terminator asynchronously to a text stream. + The writer. + A Task representing the asynchronous write. + + + Writes a string followed by a line terminator asynchronously to a text stream. + The writer. + The string to write. + A Task representing the asynchronous write. + + + Writes a char followed by a line terminator asynchronously to a text stream. + The writer. + The char to write. + A Task representing the asynchronous write. + + + Writes a char array followed by a line terminator asynchronously to a text stream. + The writer. + The buffer to write. + A Task representing the asynchronous write. + + + Writes a subarray of characters followed by a line terminator asynchronously to a text stream. + The writer. + The buffer to write. + Starting index in the buffer. + The number of characters to write. + A Task representing the asynchronous write. + + + + Clears all buffers for the current writer and causes any buffered data to + be written to the underlying device. + + The writer. + A Task representing the asynchronous flush. + + + Starts an asynchronous request for a web resource. + Task that represents the asynchronous request. + The stream is already in use by a previous call to . + + The source. + + + Starts an asynchronous request for a object to use to write data. + Task that represents the asynchronous request. + The property is GET and the application writes to the stream. + The stream is being used by a previous call to . + No write stream is available. + + The source. + + + diff --git a/src/packages/Microsoft.Bcl.Async.1.0.168/lib/portable-net45+win8+wpa81/Microsoft.Threading.Tasks.dll b/src/packages/Microsoft.Bcl.Async.1.0.168/lib/portable-net45+win8+wpa81/Microsoft.Threading.Tasks.dll new file mode 100644 index 0000000000000000000000000000000000000000..8438577c2042e5d6899425d500bf8074aae650a1 GIT binary patch literal 37104 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 literal 0 HcmV?d00001 diff --git a/src/packages/Microsoft.Bcl.Async.1.0.168/lib/portable-net45+win8+wpa81/Microsoft.Threading.Tasks.xml b/src/packages/Microsoft.Bcl.Async.1.0.168/lib/portable-net45+win8+wpa81/Microsoft.Threading.Tasks.xml new file mode 100644 index 00000000..5c22030d --- /dev/null +++ b/src/packages/Microsoft.Bcl.Async.1.0.168/lib/portable-net45+win8+wpa81/Microsoft.Threading.Tasks.xml @@ -0,0 +1,630 @@ + + + + Microsoft.Threading.Tasks + + + + + Provides extension methods for threading-related types. + + + + Cancels the after the specified duration. + The CancellationTokenSource. + The due time in milliseconds for the source to be canceled. + + + Cancels the after the specified duration. + The CancellationTokenSource. + The due time for the source to be canceled. + + + Gets an awaiter used to await this . + The task to await. + An awaiter instance. + + + Gets an awaiter used to await this . + Specifies the type of data returned by the task. + The task to await. + An awaiter instance. + + + Creates and configures an awaitable object for awaiting the specified task. + The task to be awaited. + + true to automatic marshag back to the original call site's current SynchronizationContext + or TaskScheduler; otherwise, false. + + The instance to be awaited. + + + Creates and configures an awaitable object for awaiting the specified task. + The task to be awaited. + + true to automatic marshag back to the original call site's current SynchronizationContext + or TaskScheduler; otherwise, false. + + The instance to be awaited. + + + Event handler for progress reports. + Specifies the type of data for the progress report. + The sender of the report. + The reported value. + + + + Provides an IProgress{T} that invokes callbacks for each reported progress value. + + Specifies the type of the progress report value. + + Any handler provided to the constructor or event handlers registered with + the event are invoked through a + instance captured + when the instance is constructed. If there is no current SynchronizationContext + at the time of construction, the callbacks will be invoked on the ThreadPool. + + + + The synchronization context captured upon construction. This will never be null. + + + The handler specified to the constructor. This may be null. + + + A cached delegate used to post invocation to the synchronization context. + + + Initializes the . + + + Initializes the with the specified callback. + + A handler to invoke for each reported progress value. This handler will be invoked + in addition to any delegates registered with the event. + + The is null (Nothing in Visual Basic). + + + Reports a progress change. + The value of the updated progress. + + + Reports a progress change. + The value of the updated progress. + + + Invokes the action and event callbacks. + The progress value. + + + Raised for each reported progress value. + + Handlers registered with this event will be invoked on the + captured when the instance was constructed. + + + + Holds static values for . + This avoids one static instance per type T. + + + A default synchronization context that targets the ThreadPool. + + + Throws the exception on the ThreadPool. + The exception to propagate. + The target context on which to propagate the exception. Null to use the ThreadPool. + + + Copies the exception's stack trace so its stack trace isn't overwritten. + The exception to prepare. + + + Provides an awaitable object that allows for configured awaits on . + This type is intended for compiler use only. + + + The task being awaited. + + + Initializes the . + The awaitable . + + true to attempt to marshal the continuation back to the original context captured; otherwise, false. + + + + Gets an awaiter for this awaitable. + The awaiter. + + + Provides an awaiter for a . + This type is intended for compiler use only. + + + The task being awaited. + + + Whether to attempt marshaling back to the original context. + + + Initializes the . + The to await. + + true to attempt to marshal the continuation back to the original context captured + when BeginAwait is called; otherwise, false. + + + + Schedules the continuation onto the associated with this . + The action to invoke when the await operation completes. + The argument is null (Nothing in Visual Basic). + The awaiter was not properly initialized. + This method is intended for compiler user rather than use directly in code. + + + Schedules the continuation onto the associated with this . + The action to invoke when the await operation completes. + The argument is null (Nothing in Visual Basic). + The awaiter was not properly initialized. + This method is intended for compiler user rather than use directly in code. + + + Ends the await on the completed . + The result of the completed . + The awaiter was not properly initialized. + The task was not yet completed. + The task was canceled. + The task completed in a Faulted state. + + + Gets whether the task being awaited is completed. + This property is intended for compiler user rather than use directly in code. + The awaiter was not properly initialized. + + + Provides an awaitable object that allows for configured awaits on . + This type is intended for compiler use only. + + + The underlying awaitable on whose logic this awaitable relies. + + + Initializes the . + The awaitable . + + true to attempt to marshal the continuation back to the original context captured; otherwise, false. + + + + Gets an awaiter for this awaitable. + The awaiter. + + + Provides an awaiter for a . + This type is intended for compiler use only. + + + The task being awaited. + + + Whether to attempt marshaling back to the original context. + + + Initializes the . + The awaitable . + + true to attempt to marshal the continuation back to the original context captured; otherwise, false. + + + + Schedules the continuation onto the associated with this . + The action to invoke when the await operation completes. + The argument is null (Nothing in Visual Basic). + The awaiter was not properly initialized. + This method is intended for compiler user rather than use directly in code. + + + Schedules the continuation onto the associated with this . + The action to invoke when the await operation completes. + The argument is null (Nothing in Visual Basic). + The awaiter was not properly initialized. + This method is intended for compiler user rather than use directly in code. + + + Ends the await on the completed . + The result of the completed . + The awaiter was not properly initialized. + The task was not yet completed. + The task was canceled. + The task completed in a Faulted state. + + + Gets whether the task being awaited is completed. + This property is intended for compiler user rather than use directly in code. + The awaiter was not properly initialized. + + + Provides an awaiter for awaiting a . + This type is intended for compiler use only. + + + The default value to use for continueOnCapturedContext. + + + Error message for GetAwaiter. + + + The task being awaited. + + + Initializes the . + The to be awaited. + + + Schedules the continuation onto the associated with this . + The action to invoke when the await operation completes. + The argument is null (Nothing in Visual Basic). + The awaiter was not properly initialized. + This method is intended for compiler user rather than use directly in code. + + + Schedules the continuation onto the associated with this . + The action to invoke when the await operation completes. + The argument is null (Nothing in Visual Basic). + The awaiter was not properly initialized. + This method is intended for compiler user rather than use directly in code. + + + Ends the await on the completed . + The awaiter was not properly initialized. + The task was not yet completed. + The task was canceled. + The task completed in a Faulted state. + + + + Fast checks for the end of an await operation to determine whether more needs to be done + prior to completing the await. + + The awaited task. + + + Handles validations on tasks that aren't successfully completed. + The awaited task. + + + Throws an exception to handle a task that completed in a state other than RanToCompletion. + + + Schedules the continuation onto the associated with this . + The awaited task. + The action to invoke when the await operation completes. + Whether to capture and marshal back to the current context. + The argument is null (Nothing in Visual Basic). + The awaiter was not properly initialized. + This method is intended for compiler user rather than use directly in code. + + + Invokes the delegate in a try/catch that will propagate the exception asynchronously on the ThreadPool. + + + + Copies the exception's stack trace so its stack trace isn't overwritten. + The exception to prepare. + + + Gets whether the task being awaited is completed. + This property is intended for compiler user rather than use directly in code. + The awaiter was not properly initialized. + + + Whether the current thread is appropriate for inlining the await continuation. + + + Provides an awaiter for awaiting a . + This type is intended for compiler use only. + + + The task being awaited. + + + Initializes the . + The to be awaited. + + + Schedules the continuation onto the associated with this . + The action to invoke when the await operation completes. + The argument is null (Nothing in Visual Basic). + The awaiter was not properly initialized. + This method is intended for compiler user rather than use directly in code. + + + Schedules the continuation onto the associated with this . + The action to invoke when the await operation completes. + The argument is null (Nothing in Visual Basic). + The awaiter was not properly initialized. + This method is intended for compiler user rather than use directly in code. + + + Ends the await on the completed . + The result of the completed . + The awaiter was not properly initialized. + The task was not yet completed. + The task was canceled. + The task completed in a Faulted state. + + + Gets whether the task being awaited is completed. + This property is intended for compiler user rather than use directly in code. + The awaiter was not properly initialized. + + + Provides an awaitable context for switching into a target environment. + This type is intended for compiler use only. + + + Gets an awaiter for this . + An awaiter for this awaitable. + This method is intended for compiler user rather than use directly in code. + + + Provides an awaiter that switches into a target environment. + This type is intended for compiler use only. + + + A completed task. + + + Posts the back to the current context. + The action to invoke asynchronously. + The awaiter was not properly initialized. + + + Posts the back to the current context. + The action to invoke asynchronously. + The awaiter was not properly initialized. + + + Ends the await operation. + + + Gets whether a yield is not required. + This property is intended for compiler user rather than use directly in code. + + + Provides methods for creating and manipulating tasks. + + + Creates a task that runs the specified action. + The action to execute asynchronously. + A task that represents the completion of the action. + The argument is null. + + + Creates a task that runs the specified action. + The action to execute. + The CancellationToken to use to request cancellation of this task. + A task that represents the completion of the action. + The argument is null. + + + Creates a task that runs the specified function. + The function to execute asynchronously. + A task that represents the completion of the action. + The argument is null. + + + Creates a task that runs the specified function. + The action to execute. + The CancellationToken to use to cancel the task. + A task that represents the completion of the action. + The argument is null. + + + Creates a task that runs the specified function. + The action to execute asynchronously. + A task that represents the completion of the action. + The argument is null. + + + Creates a task that runs the specified function. + The function to execute. + The CancellationToken to use to request cancellation of this task. + A task that represents the completion of the function. + The argument is null. + + + Creates a task that runs the specified function. + The function to execute asynchronously. + A task that represents the completion of the action. + The argument is null. + + + Creates a task that runs the specified function. + The action to execute. + The CancellationToken to use to cancel the task. + A task that represents the completion of the action. + The argument is null. + + + Starts a Task that will complete after the specified due time. + The delay in milliseconds before the returned task completes. + The timed Task. + + The argument must be non-negative or -1 and less than or equal to Int32.MaxValue. + + + + Starts a Task that will complete after the specified due time. + The delay before the returned task completes. + The timed Task. + + The argument must be non-negative or -1 and less than or equal to Int32.MaxValue. + + + + Starts a Task that will complete after the specified due time. + The delay before the returned task completes. + A CancellationToken that may be used to cancel the task before the due time occurs. + The timed Task. + + The argument must be non-negative or -1 and less than or equal to Int32.MaxValue. + + + + Starts a Task that will complete after the specified due time. + The delay in milliseconds before the returned task completes. + A CancellationToken that may be used to cancel the task before the due time occurs. + The timed Task. + + The argument must be non-negative or -1 and less than or equal to Int32.MaxValue. + + + + An already completed task. + + + Creates a Task that will complete only when all of the provided collection of Tasks has completed. + The Tasks to monitor for completion. + A Task that represents the completion of all of the provided tasks. + + If any of the provided Tasks faults, the returned Task will also fault, and its Exception will contain information + about all of the faulted tasks. If no Tasks fault but one or more Tasks is canceled, the returned + Task will also be canceled. + + The argument is null. + The argument contains a null reference. + + + Creates a Task that will complete only when all of the provided collection of Tasks has completed. + The Tasks to monitor for completion. + A Task that represents the completion of all of the provided tasks. + + If any of the provided Tasks faults, the returned Task will also fault, and its Exception will contain information + about all of the faulted tasks. If no Tasks fault but one or more Tasks is canceled, the returned + Task will also be canceled. + + The argument is null. + The argument contains a null reference. + + + Creates a Task that will complete only when all of the provided collection of Tasks has completed. + The Tasks to monitor for completion. + A Task that represents the completion of all of the provided tasks. + + If any of the provided Tasks faults, the returned Task will also fault, and its Exception will contain information + about all of the faulted tasks. If no Tasks fault but one or more Tasks is canceled, the returned + Task will also be canceled. + + The argument is null. + The argument contains a null reference. + + + Creates a Task that will complete only when all of the provided collection of Tasks has completed. + The Tasks to monitor for completion. + A Task that represents the completion of all of the provided tasks. + + If any of the provided Tasks faults, the returned Task will also fault, and its Exception will contain information + about all of the faulted tasks. If no Tasks fault but one or more Tasks is canceled, the returned + Task will also be canceled. + + The argument is null. + The argument contains a null reference. + + + Creates a Task that will complete only when all of the provided collection of Tasks has completed. + The Tasks to monitor for completion. + + A callback invoked when all of the tasks complete successfully in the RanToCompletion state. + This callback is responsible for storing the results into the TaskCompletionSource. + + A Task that represents the completion of all of the provided tasks. + The argument is null. + The argument contains a null reference. + + + Creates a Task that will complete when any of the tasks in the provided collection completes. + The Tasks to be monitored. + + A Task that represents the completion of any of the provided Tasks. The completed Task is this Task's result. + + Any Tasks that fault will need to have their exceptions observed elsewhere. + The argument is null. + The argument contains a null reference. + + + Creates a Task that will complete when any of the tasks in the provided collection completes. + The Tasks to be monitored. + + A Task that represents the completion of any of the provided Tasks. The completed Task is this Task's result. + + Any Tasks that fault will need to have their exceptions observed elsewhere. + The argument is null. + The argument contains a null reference. + + + Creates a Task that will complete when any of the tasks in the provided collection completes. + The Tasks to be monitored. + + A Task that represents the completion of any of the provided Tasks. The completed Task is this Task's result. + + Any Tasks that fault will need to have their exceptions observed elsewhere. + The argument is null. + The argument contains a null reference. + + + Creates a Task that will complete when any of the tasks in the provided collection completes. + The Tasks to be monitored. + + A Task that represents the completion of any of the provided Tasks. The completed Task is this Task's result. + + Any Tasks that fault will need to have their exceptions observed elsewhere. + The argument is null. + The argument contains a null reference. + + + Creates an already completed from the specified result. + The result from which to create the completed task. + The completed task. + + + Creates an awaitable that asynchronously yields back to the current context when awaited. + + A context that, when awaited, will asynchronously transition back into the current context. + If SynchronizationContext.Current is non-null, that is treated as the current context. + Otherwise, TaskScheduler.Current is treated as the current context. + + + + Adds the target exception to the list, initializing the list if it's null. + The list to which to add the exception and initialize if the list is null. + The exception to add, and unwrap if it's an aggregate. + + + Returns a canceled task. + The cancellation token. + The canceled task. + + + Returns a canceled task. + Specifies the type of the result. + The cancellation token. + The canceled task. + + + + Completes the Task if the user state matches the TaskCompletionSource. + + Specifies the type of data returned by the Task. + The TaskCompletionSource. + The completion event arguments. + Whether we require the tcs to match the e.UserState. + A function that gets the result with which to complete the task. + An action used to unregister work when the operaiton completes. + + + diff --git a/src/packages/Microsoft.Bcl.Async.1.0.168/lib/sl4-windowsphone71/Microsoft.Threading.Tasks.Extensions.Phone.dll b/src/packages/Microsoft.Bcl.Async.1.0.168/lib/sl4-windowsphone71/Microsoft.Threading.Tasks.Extensions.Phone.dll new file mode 100644 index 0000000000000000000000000000000000000000..b9812870f70f534d6785d6a0735e931d0509d033 GIT binary patch literal 28984 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 Qt0R510!1UJpc$e60~XE>xBvhE literal 0 HcmV?d00001 diff --git a/src/packages/Microsoft.Bcl.Async.1.0.168/lib/sl4-windowsphone71/Microsoft.Threading.Tasks.Extensions.Phone.xml b/src/packages/Microsoft.Bcl.Async.1.0.168/lib/sl4-windowsphone71/Microsoft.Threading.Tasks.Extensions.Phone.xml new file mode 100644 index 00000000..515d7031 --- /dev/null +++ b/src/packages/Microsoft.Bcl.Async.1.0.168/lib/sl4-windowsphone71/Microsoft.Threading.Tasks.Extensions.Phone.xml @@ -0,0 +1,141 @@ + + + + Microsoft.Threading.Tasks.Extensions.Phone + + + + + Provides asynchronous wrappers for .NET Framework operations. + + + Provides asynchronous wrappers for .NET Framework operations. + + + + Downloads the resource with the specified URI as a string, asynchronously. + The WebClient. + The URI from which to download data. + A Task that contains the downloaded string. + + + Downloads the resource with the specified URI as a string, asynchronously. + The WebClient. + The URI from which to download data. + A Task that contains the downloaded string. + + + Opens a readable stream for the data downloaded from a resource, asynchronously. + The WebClient. + The URI for which the stream should be opened. + A Task that contains the opened stream. + + + Opens a readable stream for the data downloaded from a resource, asynchronously. + The WebClient. + The URI for which the stream should be opened. + A Task that contains the opened stream. + + + Opens a writeable stream for uploading data to a resource, asynchronously. + The WebClient. + The URI for which the stream should be opened. + A Task that contains the opened stream. + + + Opens a writeable stream for uploading data to a resource, asynchronously. + The WebClient. + The URI for which the stream should be opened. + A Task that contains the opened stream. + + + Opens a writeable stream for uploading data to a resource, asynchronously. + The WebClient. + The URI for which the stream should be opened. + The HTTP method that should be used to open the stream. + A Task that contains the opened stream. + + + Opens a writeable stream for uploading data to a resource, asynchronously. + The WebClient. + The URI for which the stream should be opened. + The HTTP method that should be used to open the stream. + A Task that contains the opened stream. + + + Uploads data in a string to the specified resource, asynchronously. + The WebClient. + The URI to which the data should be uploaded. + The data to upload. + A Task containing the data in the response from the upload. + + + Uploads data in a string to the specified resource, asynchronously. + The WebClient. + The URI to which the data should be uploaded. + The data to upload. + A Task containing the data in the response from the upload. + + + Uploads data in a string to the specified resource, asynchronously. + The WebClient. + The URI to which the data should be uploaded. + The HTTP method that should be used to upload the data. + The data to upload. + A Task containing the data in the response from the upload. + + + Uploads data in a string to the specified resource, asynchronously. + The WebClient. + The URI to which the data should be uploaded. + The HTTP method that should be used to upload the data. + The data to upload. + A Task containing the data in the response from the upload. + + + Converts a path to a Uri using the WebClient's logic. + Based on WebClient's private GetUri method. + + + Converts a path to a Uri using the WebClient's logic. + Based on WebClient's private GetUri method. + + + Asynchronously invokes an Action on the Dispatcher. + The Dispatcher. + The action to invoke. + A Task that represents the execution of the action. + + + Asynchronously invokes an Action on the Dispatcher. + The Dispatcher. + The function to invoke. + A Task that represents the execution of the function. + + + Used with Task(of void) + + + Returns a canceled task. + The cancellation token. + The canceled task. + + + Returns a canceled task. + Specifies the type of the result. + The cancellation token. + The canceled task. + + + + Completes the Task if the user state matches the TaskCompletionSource. + + Specifies the type of data returned by the Task. + The TaskCompletionSource. + The completion event arguments. + Whether we require the tcs to match the e.UserState. + A function that gets the result with which to complete the task. + An action used to unregister work when the operaiton completes. + + + diff --git a/src/packages/Microsoft.Bcl.Async.1.0.168/lib/sl4-windowsphone71/Microsoft.Threading.Tasks.Extensions.dll b/src/packages/Microsoft.Bcl.Async.1.0.168/lib/sl4-windowsphone71/Microsoft.Threading.Tasks.Extensions.dll new file mode 100644 index 0000000000000000000000000000000000000000..4d862e1730a34a6a5cfa39d04840bd039cf9de29 GIT binary patch literal 31520 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 literal 0 HcmV?d00001 diff --git a/src/packages/Microsoft.Bcl.Async.1.0.168/lib/sl4-windowsphone71/Microsoft.Threading.Tasks.Extensions.xml b/src/packages/Microsoft.Bcl.Async.1.0.168/lib/sl4-windowsphone71/Microsoft.Threading.Tasks.Extensions.xml new file mode 100644 index 00000000..af646a2d --- /dev/null +++ b/src/packages/Microsoft.Bcl.Async.1.0.168/lib/sl4-windowsphone71/Microsoft.Threading.Tasks.Extensions.xml @@ -0,0 +1,275 @@ + + + + Microsoft.Threading.Tasks.Extensions + + + + Returns a canceled task. + The cancellation token. + The canceled task. + + + Returns a canceled task. + Specifies the type of the result. + The cancellation token. + The canceled task. + + + + Completes the Task if the user state matches the TaskCompletionSource. + + Specifies the type of data returned by the Task. + The TaskCompletionSource. + The completion event arguments. + Whether we require the tcs to match the e.UserState. + A function that gets the result with which to complete the task. + An action used to unregister work when the operaiton completes. + + + + Provides asynchronous wrappers for .NET Framework operations. + + + + + Reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read. + + A Task that represents the asynchronous read. + The source. + The buffer to read data into. + The byte offset in at which to begin reading. + The maximum number of bytes to read. + The array length minus is less than . + is null. + or is negative. + An asynchronous read was attempted past the end of the file. + + + + Reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read. + + A Task that represents the asynchronous read. + The source. + The buffer to read data into. + The byte offset in at which to begin reading. + The maximum number of bytes to read. + The cancellation token. + The array length minus is less than . + is null. + or is negative. + An asynchronous read was attempted past the end of the file. + + + + Writes asynchronously a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written. + + A Task that represents the asynchronous write. + The source. + The buffer containing data to write to the current stream. + The zero-based byte offset in at which to begin copying bytes to the current stream. + The maximum number of bytes to write. + length minus is less than . + is null. + or is negative. + The stream does not support writing. + The stream is closed. + An I/O error occurred. + + + + Writes asynchronously a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written. + + A Task that represents the asynchronous write. + The source. + The buffer containing data to write to the current stream. + The zero-based byte offset in at which to begin copying bytes to the current stream. + The maximum number of bytes to write. + The cancellation token. + length minus is less than . + is null. + or is negative. + The stream does not support writing. + The stream is closed. + An I/O error occurred. + + + + Flushes asynchronously the current stream. + + A Task that represents the asynchronous flush. + + + + Flushes asynchronously the current stream. + + A Task that represents the asynchronous flush. + + + + Reads all the bytes from the current stream and writes them to the destination stream. + + The source stream. + The stream that will contain the contents of the current stream. + A Task that represents the asynchronous operation. + + + + Reads all the bytes from the current stream and writes them to the destination stream. + + The source stream. + The stream that will contain the contents of the current stream. + The size of the buffer. This value must be greater than zero. The default size is 4096. + A Task that represents the asynchronous operation. + + + + Reads all the bytes from the current stream and writes them to the destination stream. + + The source stream. + The stream that will contain the contents of the current stream. + The size of the buffer. This value must be greater than zero. The default size is 4096. + The cancellation token to use to cancel the asynchronous operation. + A Task that represents the asynchronous operation. + + + + Reads all the bytes from the current stream and writes them to the destination stream. + + The source stream. + The stream that will contain the contents of the current stream. + The size of the buffer. This value must be greater than zero. The default size is 4096. + The cancellation token to use to cancel the asynchronous operation. + A Task that represents the asynchronous operation. + + + + Reads a maximum of count characters from the reader asynchronously and writes + the data to buffer, beginning at index. + + + When the operation completes, contains the specified character array with the + values between index and (index + count - 1) replaced by the characters read + from the current source. + + + The maximum number of characters to read. If the end of the stream is reached + before count of characters is read into buffer, the current method returns. + + The place in buffer at which to begin writing. + the source reader. + A Task that represents the asynchronous operation. + + + + Reads asynchronously a maximum of count characters from the current stream, and writes the + data to buffer, beginning at index. + + The source reader. + + When this method returns, this parameter contains the specified character + array with the values between index and (index + count -1) replaced by the + characters read from the current source. + + The position in buffer at which to begin writing. + The maximum number of characters to read. + A Task that represents the asynchronous operation. + + + + Reads a line of characters from the reader and returns the string asynchronously. + + the source reader. + A Task that represents the asynchronous operation. + + + + Reads all characters from the current position to the end of the TextReader + and returns them as one string asynchronously. + + the source reader. + A Task that represents the asynchronous operation. + + + Writes a string asynchronously to a text stream. + The writer. + The string to write. + A Task representing the asynchronous write. + + + Writes a char asynchronously to a text stream. + The writer. + The char to write. + A Task representing the asynchronous write. + + + Writes a char array asynchronously to a text stream. + The writer. + The buffer to write. + A Task representing the asynchronous write. + + + Writes a subarray of characters asynchronously to a text stream. + The writer. + The buffer to write. + Starting index in the buffer. + The number of characters to write. + A Task representing the asynchronous write. + + + Writes a line terminator asynchronously to a text stream. + The writer. + A Task representing the asynchronous write. + + + Writes a string followed by a line terminator asynchronously to a text stream. + The writer. + The string to write. + A Task representing the asynchronous write. + + + Writes a char followed by a line terminator asynchronously to a text stream. + The writer. + The char to write. + A Task representing the asynchronous write. + + + Writes a char array followed by a line terminator asynchronously to a text stream. + The writer. + The buffer to write. + A Task representing the asynchronous write. + + + Writes a subarray of characters followed by a line terminator asynchronously to a text stream. + The writer. + The buffer to write. + Starting index in the buffer. + The number of characters to write. + A Task representing the asynchronous write. + + + + Clears all buffers for the current writer and causes any buffered data to + be written to the underlying device. + + The writer. + A Task representing the asynchronous flush. + + + Starts an asynchronous request for a web resource. + Task that represents the asynchronous request. + The stream is already in use by a previous call to . + + The source. + + + Starts an asynchronous request for a object to use to write data. + Task that represents the asynchronous request. + The property is GET and the application writes to the stream. + The stream is being used by a previous call to . + No write stream is available. + + The source. + + + diff --git a/src/packages/Microsoft.Bcl.Async.1.0.168/lib/sl4-windowsphone71/Microsoft.Threading.Tasks.dll b/src/packages/Microsoft.Bcl.Async.1.0.168/lib/sl4-windowsphone71/Microsoft.Threading.Tasks.dll new file mode 100644 index 0000000000000000000000000000000000000000..8438577c2042e5d6899425d500bf8074aae650a1 GIT binary patch literal 37104 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 literal 0 HcmV?d00001 diff --git a/src/packages/Microsoft.Bcl.Async.1.0.168/lib/sl4-windowsphone71/Microsoft.Threading.Tasks.xml b/src/packages/Microsoft.Bcl.Async.1.0.168/lib/sl4-windowsphone71/Microsoft.Threading.Tasks.xml new file mode 100644 index 00000000..5c22030d --- /dev/null +++ b/src/packages/Microsoft.Bcl.Async.1.0.168/lib/sl4-windowsphone71/Microsoft.Threading.Tasks.xml @@ -0,0 +1,630 @@ + + + + Microsoft.Threading.Tasks + + + + + Provides extension methods for threading-related types. + + + + Cancels the after the specified duration. + The CancellationTokenSource. + The due time in milliseconds for the source to be canceled. + + + Cancels the after the specified duration. + The CancellationTokenSource. + The due time for the source to be canceled. + + + Gets an awaiter used to await this . + The task to await. + An awaiter instance. + + + Gets an awaiter used to await this . + Specifies the type of data returned by the task. + The task to await. + An awaiter instance. + + + Creates and configures an awaitable object for awaiting the specified task. + The task to be awaited. + + true to automatic marshag back to the original call site's current SynchronizationContext + or TaskScheduler; otherwise, false. + + The instance to be awaited. + + + Creates and configures an awaitable object for awaiting the specified task. + The task to be awaited. + + true to automatic marshag back to the original call site's current SynchronizationContext + or TaskScheduler; otherwise, false. + + The instance to be awaited. + + + Event handler for progress reports. + Specifies the type of data for the progress report. + The sender of the report. + The reported value. + + + + Provides an IProgress{T} that invokes callbacks for each reported progress value. + + Specifies the type of the progress report value. + + Any handler provided to the constructor or event handlers registered with + the event are invoked through a + instance captured + when the instance is constructed. If there is no current SynchronizationContext + at the time of construction, the callbacks will be invoked on the ThreadPool. + + + + The synchronization context captured upon construction. This will never be null. + + + The handler specified to the constructor. This may be null. + + + A cached delegate used to post invocation to the synchronization context. + + + Initializes the . + + + Initializes the with the specified callback. + + A handler to invoke for each reported progress value. This handler will be invoked + in addition to any delegates registered with the event. + + The is null (Nothing in Visual Basic). + + + Reports a progress change. + The value of the updated progress. + + + Reports a progress change. + The value of the updated progress. + + + Invokes the action and event callbacks. + The progress value. + + + Raised for each reported progress value. + + Handlers registered with this event will be invoked on the + captured when the instance was constructed. + + + + Holds static values for . + This avoids one static instance per type T. + + + A default synchronization context that targets the ThreadPool. + + + Throws the exception on the ThreadPool. + The exception to propagate. + The target context on which to propagate the exception. Null to use the ThreadPool. + + + Copies the exception's stack trace so its stack trace isn't overwritten. + The exception to prepare. + + + Provides an awaitable object that allows for configured awaits on . + This type is intended for compiler use only. + + + The task being awaited. + + + Initializes the . + The awaitable . + + true to attempt to marshal the continuation back to the original context captured; otherwise, false. + + + + Gets an awaiter for this awaitable. + The awaiter. + + + Provides an awaiter for a . + This type is intended for compiler use only. + + + The task being awaited. + + + Whether to attempt marshaling back to the original context. + + + Initializes the . + The to await. + + true to attempt to marshal the continuation back to the original context captured + when BeginAwait is called; otherwise, false. + + + + Schedules the continuation onto the associated with this . + The action to invoke when the await operation completes. + The argument is null (Nothing in Visual Basic). + The awaiter was not properly initialized. + This method is intended for compiler user rather than use directly in code. + + + Schedules the continuation onto the associated with this . + The action to invoke when the await operation completes. + The argument is null (Nothing in Visual Basic). + The awaiter was not properly initialized. + This method is intended for compiler user rather than use directly in code. + + + Ends the await on the completed . + The result of the completed . + The awaiter was not properly initialized. + The task was not yet completed. + The task was canceled. + The task completed in a Faulted state. + + + Gets whether the task being awaited is completed. + This property is intended for compiler user rather than use directly in code. + The awaiter was not properly initialized. + + + Provides an awaitable object that allows for configured awaits on . + This type is intended for compiler use only. + + + The underlying awaitable on whose logic this awaitable relies. + + + Initializes the . + The awaitable . + + true to attempt to marshal the continuation back to the original context captured; otherwise, false. + + + + Gets an awaiter for this awaitable. + The awaiter. + + + Provides an awaiter for a . + This type is intended for compiler use only. + + + The task being awaited. + + + Whether to attempt marshaling back to the original context. + + + Initializes the . + The awaitable . + + true to attempt to marshal the continuation back to the original context captured; otherwise, false. + + + + Schedules the continuation onto the associated with this . + The action to invoke when the await operation completes. + The argument is null (Nothing in Visual Basic). + The awaiter was not properly initialized. + This method is intended for compiler user rather than use directly in code. + + + Schedules the continuation onto the associated with this . + The action to invoke when the await operation completes. + The argument is null (Nothing in Visual Basic). + The awaiter was not properly initialized. + This method is intended for compiler user rather than use directly in code. + + + Ends the await on the completed . + The result of the completed . + The awaiter was not properly initialized. + The task was not yet completed. + The task was canceled. + The task completed in a Faulted state. + + + Gets whether the task being awaited is completed. + This property is intended for compiler user rather than use directly in code. + The awaiter was not properly initialized. + + + Provides an awaiter for awaiting a . + This type is intended for compiler use only. + + + The default value to use for continueOnCapturedContext. + + + Error message for GetAwaiter. + + + The task being awaited. + + + Initializes the . + The to be awaited. + + + Schedules the continuation onto the associated with this . + The action to invoke when the await operation completes. + The argument is null (Nothing in Visual Basic). + The awaiter was not properly initialized. + This method is intended for compiler user rather than use directly in code. + + + Schedules the continuation onto the associated with this . + The action to invoke when the await operation completes. + The argument is null (Nothing in Visual Basic). + The awaiter was not properly initialized. + This method is intended for compiler user rather than use directly in code. + + + Ends the await on the completed . + The awaiter was not properly initialized. + The task was not yet completed. + The task was canceled. + The task completed in a Faulted state. + + + + Fast checks for the end of an await operation to determine whether more needs to be done + prior to completing the await. + + The awaited task. + + + Handles validations on tasks that aren't successfully completed. + The awaited task. + + + Throws an exception to handle a task that completed in a state other than RanToCompletion. + + + Schedules the continuation onto the associated with this . + The awaited task. + The action to invoke when the await operation completes. + Whether to capture and marshal back to the current context. + The argument is null (Nothing in Visual Basic). + The awaiter was not properly initialized. + This method is intended for compiler user rather than use directly in code. + + + Invokes the delegate in a try/catch that will propagate the exception asynchronously on the ThreadPool. + + + + Copies the exception's stack trace so its stack trace isn't overwritten. + The exception to prepare. + + + Gets whether the task being awaited is completed. + This property is intended for compiler user rather than use directly in code. + The awaiter was not properly initialized. + + + Whether the current thread is appropriate for inlining the await continuation. + + + Provides an awaiter for awaiting a . + This type is intended for compiler use only. + + + The task being awaited. + + + Initializes the . + The to be awaited. + + + Schedules the continuation onto the associated with this . + The action to invoke when the await operation completes. + The argument is null (Nothing in Visual Basic). + The awaiter was not properly initialized. + This method is intended for compiler user rather than use directly in code. + + + Schedules the continuation onto the associated with this . + The action to invoke when the await operation completes. + The argument is null (Nothing in Visual Basic). + The awaiter was not properly initialized. + This method is intended for compiler user rather than use directly in code. + + + Ends the await on the completed . + The result of the completed . + The awaiter was not properly initialized. + The task was not yet completed. + The task was canceled. + The task completed in a Faulted state. + + + Gets whether the task being awaited is completed. + This property is intended for compiler user rather than use directly in code. + The awaiter was not properly initialized. + + + Provides an awaitable context for switching into a target environment. + This type is intended for compiler use only. + + + Gets an awaiter for this . + An awaiter for this awaitable. + This method is intended for compiler user rather than use directly in code. + + + Provides an awaiter that switches into a target environment. + This type is intended for compiler use only. + + + A completed task. + + + Posts the back to the current context. + The action to invoke asynchronously. + The awaiter was not properly initialized. + + + Posts the back to the current context. + The action to invoke asynchronously. + The awaiter was not properly initialized. + + + Ends the await operation. + + + Gets whether a yield is not required. + This property is intended for compiler user rather than use directly in code. + + + Provides methods for creating and manipulating tasks. + + + Creates a task that runs the specified action. + The action to execute asynchronously. + A task that represents the completion of the action. + The argument is null. + + + Creates a task that runs the specified action. + The action to execute. + The CancellationToken to use to request cancellation of this task. + A task that represents the completion of the action. + The argument is null. + + + Creates a task that runs the specified function. + The function to execute asynchronously. + A task that represents the completion of the action. + The argument is null. + + + Creates a task that runs the specified function. + The action to execute. + The CancellationToken to use to cancel the task. + A task that represents the completion of the action. + The argument is null. + + + Creates a task that runs the specified function. + The action to execute asynchronously. + A task that represents the completion of the action. + The argument is null. + + + Creates a task that runs the specified function. + The function to execute. + The CancellationToken to use to request cancellation of this task. + A task that represents the completion of the function. + The argument is null. + + + Creates a task that runs the specified function. + The function to execute asynchronously. + A task that represents the completion of the action. + The argument is null. + + + Creates a task that runs the specified function. + The action to execute. + The CancellationToken to use to cancel the task. + A task that represents the completion of the action. + The argument is null. + + + Starts a Task that will complete after the specified due time. + The delay in milliseconds before the returned task completes. + The timed Task. + + The argument must be non-negative or -1 and less than or equal to Int32.MaxValue. + + + + Starts a Task that will complete after the specified due time. + The delay before the returned task completes. + The timed Task. + + The argument must be non-negative or -1 and less than or equal to Int32.MaxValue. + + + + Starts a Task that will complete after the specified due time. + The delay before the returned task completes. + A CancellationToken that may be used to cancel the task before the due time occurs. + The timed Task. + + The argument must be non-negative or -1 and less than or equal to Int32.MaxValue. + + + + Starts a Task that will complete after the specified due time. + The delay in milliseconds before the returned task completes. + A CancellationToken that may be used to cancel the task before the due time occurs. + The timed Task. + + The argument must be non-negative or -1 and less than or equal to Int32.MaxValue. + + + + An already completed task. + + + Creates a Task that will complete only when all of the provided collection of Tasks has completed. + The Tasks to monitor for completion. + A Task that represents the completion of all of the provided tasks. + + If any of the provided Tasks faults, the returned Task will also fault, and its Exception will contain information + about all of the faulted tasks. If no Tasks fault but one or more Tasks is canceled, the returned + Task will also be canceled. + + The argument is null. + The argument contains a null reference. + + + Creates a Task that will complete only when all of the provided collection of Tasks has completed. + The Tasks to monitor for completion. + A Task that represents the completion of all of the provided tasks. + + If any of the provided Tasks faults, the returned Task will also fault, and its Exception will contain information + about all of the faulted tasks. If no Tasks fault but one or more Tasks is canceled, the returned + Task will also be canceled. + + The argument is null. + The argument contains a null reference. + + + Creates a Task that will complete only when all of the provided collection of Tasks has completed. + The Tasks to monitor for completion. + A Task that represents the completion of all of the provided tasks. + + If any of the provided Tasks faults, the returned Task will also fault, and its Exception will contain information + about all of the faulted tasks. If no Tasks fault but one or more Tasks is canceled, the returned + Task will also be canceled. + + The argument is null. + The argument contains a null reference. + + + Creates a Task that will complete only when all of the provided collection of Tasks has completed. + The Tasks to monitor for completion. + A Task that represents the completion of all of the provided tasks. + + If any of the provided Tasks faults, the returned Task will also fault, and its Exception will contain information + about all of the faulted tasks. If no Tasks fault but one or more Tasks is canceled, the returned + Task will also be canceled. + + The argument is null. + The argument contains a null reference. + + + Creates a Task that will complete only when all of the provided collection of Tasks has completed. + The Tasks to monitor for completion. + + A callback invoked when all of the tasks complete successfully in the RanToCompletion state. + This callback is responsible for storing the results into the TaskCompletionSource. + + A Task that represents the completion of all of the provided tasks. + The argument is null. + The argument contains a null reference. + + + Creates a Task that will complete when any of the tasks in the provided collection completes. + The Tasks to be monitored. + + A Task that represents the completion of any of the provided Tasks. The completed Task is this Task's result. + + Any Tasks that fault will need to have their exceptions observed elsewhere. + The argument is null. + The argument contains a null reference. + + + Creates a Task that will complete when any of the tasks in the provided collection completes. + The Tasks to be monitored. + + A Task that represents the completion of any of the provided Tasks. The completed Task is this Task's result. + + Any Tasks that fault will need to have their exceptions observed elsewhere. + The argument is null. + The argument contains a null reference. + + + Creates a Task that will complete when any of the tasks in the provided collection completes. + The Tasks to be monitored. + + A Task that represents the completion of any of the provided Tasks. The completed Task is this Task's result. + + Any Tasks that fault will need to have their exceptions observed elsewhere. + The argument is null. + The argument contains a null reference. + + + Creates a Task that will complete when any of the tasks in the provided collection completes. + The Tasks to be monitored. + + A Task that represents the completion of any of the provided Tasks. The completed Task is this Task's result. + + Any Tasks that fault will need to have their exceptions observed elsewhere. + The argument is null. + The argument contains a null reference. + + + Creates an already completed from the specified result. + The result from which to create the completed task. + The completed task. + + + Creates an awaitable that asynchronously yields back to the current context when awaited. + + A context that, when awaited, will asynchronously transition back into the current context. + If SynchronizationContext.Current is non-null, that is treated as the current context. + Otherwise, TaskScheduler.Current is treated as the current context. + + + + Adds the target exception to the list, initializing the list if it's null. + The list to which to add the exception and initialize if the list is null. + The exception to add, and unwrap if it's an aggregate. + + + Returns a canceled task. + The cancellation token. + The canceled task. + + + Returns a canceled task. + Specifies the type of the result. + The cancellation token. + The canceled task. + + + + Completes the Task if the user state matches the TaskCompletionSource. + + Specifies the type of data returned by the Task. + The TaskCompletionSource. + The completion event arguments. + Whether we require the tcs to match the e.UserState. + A function that gets the result with which to complete the task. + An action used to unregister work when the operaiton completes. + + + diff --git a/src/packages/Microsoft.Bcl.Async.1.0.168/lib/sl4/Microsoft.Threading.Tasks.Extensions.Silverlight.dll b/src/packages/Microsoft.Bcl.Async.1.0.168/lib/sl4/Microsoft.Threading.Tasks.Extensions.Silverlight.dll new file mode 100644 index 0000000000000000000000000000000000000000..689120e11641b3051039e0f7ad7328f6a9015375 GIT binary patch literal 29008 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 literal 0 HcmV?d00001 diff --git a/src/packages/Microsoft.Bcl.Async.1.0.168/lib/sl4/Microsoft.Threading.Tasks.Extensions.Silverlight.xml b/src/packages/Microsoft.Bcl.Async.1.0.168/lib/sl4/Microsoft.Threading.Tasks.Extensions.Silverlight.xml new file mode 100644 index 00000000..950e092f --- /dev/null +++ b/src/packages/Microsoft.Bcl.Async.1.0.168/lib/sl4/Microsoft.Threading.Tasks.Extensions.Silverlight.xml @@ -0,0 +1,141 @@ + + + + Microsoft.Threading.Tasks.Extensions.Silverlight + + + + + Provides asynchronous wrappers for .NET Framework operations. + + + Provides asynchronous wrappers for .NET Framework operations. + + + + Downloads the resource with the specified URI as a string, asynchronously. + The WebClient. + The URI from which to download data. + A Task that contains the downloaded string. + + + Downloads the resource with the specified URI as a string, asynchronously. + The WebClient. + The URI from which to download data. + A Task that contains the downloaded string. + + + Opens a readable stream for the data downloaded from a resource, asynchronously. + The WebClient. + The URI for which the stream should be opened. + A Task that contains the opened stream. + + + Opens a readable stream for the data downloaded from a resource, asynchronously. + The WebClient. + The URI for which the stream should be opened. + A Task that contains the opened stream. + + + Opens a writeable stream for uploading data to a resource, asynchronously. + The WebClient. + The URI for which the stream should be opened. + A Task that contains the opened stream. + + + Opens a writeable stream for uploading data to a resource, asynchronously. + The WebClient. + The URI for which the stream should be opened. + A Task that contains the opened stream. + + + Opens a writeable stream for uploading data to a resource, asynchronously. + The WebClient. + The URI for which the stream should be opened. + The HTTP method that should be used to open the stream. + A Task that contains the opened stream. + + + Opens a writeable stream for uploading data to a resource, asynchronously. + The WebClient. + The URI for which the stream should be opened. + The HTTP method that should be used to open the stream. + A Task that contains the opened stream. + + + Uploads data in a string to the specified resource, asynchronously. + The WebClient. + The URI to which the data should be uploaded. + The data to upload. + A Task containing the data in the response from the upload. + + + Uploads data in a string to the specified resource, asynchronously. + The WebClient. + The URI to which the data should be uploaded. + The data to upload. + A Task containing the data in the response from the upload. + + + Uploads data in a string to the specified resource, asynchronously. + The WebClient. + The URI to which the data should be uploaded. + The HTTP method that should be used to upload the data. + The data to upload. + A Task containing the data in the response from the upload. + + + Uploads data in a string to the specified resource, asynchronously. + The WebClient. + The URI to which the data should be uploaded. + The HTTP method that should be used to upload the data. + The data to upload. + A Task containing the data in the response from the upload. + + + Converts a path to a Uri using the WebClient's logic. + Based on WebClient's private GetUri method. + + + Converts a path to a Uri using the WebClient's logic. + Based on WebClient's private GetUri method. + + + Asynchronously invokes an Action on the Dispatcher. + The Dispatcher. + The action to invoke. + A Task that represents the execution of the action. + + + Asynchronously invokes an Action on the Dispatcher. + The Dispatcher. + The function to invoke. + A Task that represents the execution of the function. + + + Returns a canceled task. + The cancellation token. + The canceled task. + + + Returns a canceled task. + Specifies the type of the result. + The cancellation token. + The canceled task. + + + + Completes the Task if the user state matches the TaskCompletionSource. + + Specifies the type of data returned by the Task. + The TaskCompletionSource. + The completion event arguments. + Whether we require the tcs to match the e.UserState. + A function that gets the result with which to complete the task. + An action used to unregister work when the operaiton completes. + + + Used with Task(of void) + + + diff --git a/src/packages/Microsoft.Bcl.Async.1.0.168/lib/sl4/Microsoft.Threading.Tasks.Extensions.dll b/src/packages/Microsoft.Bcl.Async.1.0.168/lib/sl4/Microsoft.Threading.Tasks.Extensions.dll new file mode 100644 index 0000000000000000000000000000000000000000..4d862e1730a34a6a5cfa39d04840bd039cf9de29 GIT binary patch literal 31520 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 literal 0 HcmV?d00001 diff --git a/src/packages/Microsoft.Bcl.Async.1.0.168/lib/sl4/Microsoft.Threading.Tasks.Extensions.xml b/src/packages/Microsoft.Bcl.Async.1.0.168/lib/sl4/Microsoft.Threading.Tasks.Extensions.xml new file mode 100644 index 00000000..af646a2d --- /dev/null +++ b/src/packages/Microsoft.Bcl.Async.1.0.168/lib/sl4/Microsoft.Threading.Tasks.Extensions.xml @@ -0,0 +1,275 @@ + + + + Microsoft.Threading.Tasks.Extensions + + + + Returns a canceled task. + The cancellation token. + The canceled task. + + + Returns a canceled task. + Specifies the type of the result. + The cancellation token. + The canceled task. + + + + Completes the Task if the user state matches the TaskCompletionSource. + + Specifies the type of data returned by the Task. + The TaskCompletionSource. + The completion event arguments. + Whether we require the tcs to match the e.UserState. + A function that gets the result with which to complete the task. + An action used to unregister work when the operaiton completes. + + + + Provides asynchronous wrappers for .NET Framework operations. + + + + + Reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read. + + A Task that represents the asynchronous read. + The source. + The buffer to read data into. + The byte offset in at which to begin reading. + The maximum number of bytes to read. + The array length minus is less than . + is null. + or is negative. + An asynchronous read was attempted past the end of the file. + + + + Reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read. + + A Task that represents the asynchronous read. + The source. + The buffer to read data into. + The byte offset in at which to begin reading. + The maximum number of bytes to read. + The cancellation token. + The array length minus is less than . + is null. + or is negative. + An asynchronous read was attempted past the end of the file. + + + + Writes asynchronously a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written. + + A Task that represents the asynchronous write. + The source. + The buffer containing data to write to the current stream. + The zero-based byte offset in at which to begin copying bytes to the current stream. + The maximum number of bytes to write. + length minus is less than . + is null. + or is negative. + The stream does not support writing. + The stream is closed. + An I/O error occurred. + + + + Writes asynchronously a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written. + + A Task that represents the asynchronous write. + The source. + The buffer containing data to write to the current stream. + The zero-based byte offset in at which to begin copying bytes to the current stream. + The maximum number of bytes to write. + The cancellation token. + length minus is less than . + is null. + or is negative. + The stream does not support writing. + The stream is closed. + An I/O error occurred. + + + + Flushes asynchronously the current stream. + + A Task that represents the asynchronous flush. + + + + Flushes asynchronously the current stream. + + A Task that represents the asynchronous flush. + + + + Reads all the bytes from the current stream and writes them to the destination stream. + + The source stream. + The stream that will contain the contents of the current stream. + A Task that represents the asynchronous operation. + + + + Reads all the bytes from the current stream and writes them to the destination stream. + + The source stream. + The stream that will contain the contents of the current stream. + The size of the buffer. This value must be greater than zero. The default size is 4096. + A Task that represents the asynchronous operation. + + + + Reads all the bytes from the current stream and writes them to the destination stream. + + The source stream. + The stream that will contain the contents of the current stream. + The size of the buffer. This value must be greater than zero. The default size is 4096. + The cancellation token to use to cancel the asynchronous operation. + A Task that represents the asynchronous operation. + + + + Reads all the bytes from the current stream and writes them to the destination stream. + + The source stream. + The stream that will contain the contents of the current stream. + The size of the buffer. This value must be greater than zero. The default size is 4096. + The cancellation token to use to cancel the asynchronous operation. + A Task that represents the asynchronous operation. + + + + Reads a maximum of count characters from the reader asynchronously and writes + the data to buffer, beginning at index. + + + When the operation completes, contains the specified character array with the + values between index and (index + count - 1) replaced by the characters read + from the current source. + + + The maximum number of characters to read. If the end of the stream is reached + before count of characters is read into buffer, the current method returns. + + The place in buffer at which to begin writing. + the source reader. + A Task that represents the asynchronous operation. + + + + Reads asynchronously a maximum of count characters from the current stream, and writes the + data to buffer, beginning at index. + + The source reader. + + When this method returns, this parameter contains the specified character + array with the values between index and (index + count -1) replaced by the + characters read from the current source. + + The position in buffer at which to begin writing. + The maximum number of characters to read. + A Task that represents the asynchronous operation. + + + + Reads a line of characters from the reader and returns the string asynchronously. + + the source reader. + A Task that represents the asynchronous operation. + + + + Reads all characters from the current position to the end of the TextReader + and returns them as one string asynchronously. + + the source reader. + A Task that represents the asynchronous operation. + + + Writes a string asynchronously to a text stream. + The writer. + The string to write. + A Task representing the asynchronous write. + + + Writes a char asynchronously to a text stream. + The writer. + The char to write. + A Task representing the asynchronous write. + + + Writes a char array asynchronously to a text stream. + The writer. + The buffer to write. + A Task representing the asynchronous write. + + + Writes a subarray of characters asynchronously to a text stream. + The writer. + The buffer to write. + Starting index in the buffer. + The number of characters to write. + A Task representing the asynchronous write. + + + Writes a line terminator asynchronously to a text stream. + The writer. + A Task representing the asynchronous write. + + + Writes a string followed by a line terminator asynchronously to a text stream. + The writer. + The string to write. + A Task representing the asynchronous write. + + + Writes a char followed by a line terminator asynchronously to a text stream. + The writer. + The char to write. + A Task representing the asynchronous write. + + + Writes a char array followed by a line terminator asynchronously to a text stream. + The writer. + The buffer to write. + A Task representing the asynchronous write. + + + Writes a subarray of characters followed by a line terminator asynchronously to a text stream. + The writer. + The buffer to write. + Starting index in the buffer. + The number of characters to write. + A Task representing the asynchronous write. + + + + Clears all buffers for the current writer and causes any buffered data to + be written to the underlying device. + + The writer. + A Task representing the asynchronous flush. + + + Starts an asynchronous request for a web resource. + Task that represents the asynchronous request. + The stream is already in use by a previous call to . + + The source. + + + Starts an asynchronous request for a object to use to write data. + Task that represents the asynchronous request. + The property is GET and the application writes to the stream. + The stream is being used by a previous call to . + No write stream is available. + + The source. + + + diff --git a/src/packages/Microsoft.Bcl.Async.1.0.168/lib/sl4/Microsoft.Threading.Tasks.dll b/src/packages/Microsoft.Bcl.Async.1.0.168/lib/sl4/Microsoft.Threading.Tasks.dll new file mode 100644 index 0000000000000000000000000000000000000000..8438577c2042e5d6899425d500bf8074aae650a1 GIT binary patch literal 37104 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 literal 0 HcmV?d00001 diff --git a/src/packages/Microsoft.Bcl.Async.1.0.168/lib/sl4/Microsoft.Threading.Tasks.xml b/src/packages/Microsoft.Bcl.Async.1.0.168/lib/sl4/Microsoft.Threading.Tasks.xml new file mode 100644 index 00000000..5c22030d --- /dev/null +++ b/src/packages/Microsoft.Bcl.Async.1.0.168/lib/sl4/Microsoft.Threading.Tasks.xml @@ -0,0 +1,630 @@ + + + + Microsoft.Threading.Tasks + + + + + Provides extension methods for threading-related types. + + + + Cancels the after the specified duration. + The CancellationTokenSource. + The due time in milliseconds for the source to be canceled. + + + Cancels the after the specified duration. + The CancellationTokenSource. + The due time for the source to be canceled. + + + Gets an awaiter used to await this . + The task to await. + An awaiter instance. + + + Gets an awaiter used to await this . + Specifies the type of data returned by the task. + The task to await. + An awaiter instance. + + + Creates and configures an awaitable object for awaiting the specified task. + The task to be awaited. + + true to automatic marshag back to the original call site's current SynchronizationContext + or TaskScheduler; otherwise, false. + + The instance to be awaited. + + + Creates and configures an awaitable object for awaiting the specified task. + The task to be awaited. + + true to automatic marshag back to the original call site's current SynchronizationContext + or TaskScheduler; otherwise, false. + + The instance to be awaited. + + + Event handler for progress reports. + Specifies the type of data for the progress report. + The sender of the report. + The reported value. + + + + Provides an IProgress{T} that invokes callbacks for each reported progress value. + + Specifies the type of the progress report value. + + Any handler provided to the constructor or event handlers registered with + the event are invoked through a + instance captured + when the instance is constructed. If there is no current SynchronizationContext + at the time of construction, the callbacks will be invoked on the ThreadPool. + + + + The synchronization context captured upon construction. This will never be null. + + + The handler specified to the constructor. This may be null. + + + A cached delegate used to post invocation to the synchronization context. + + + Initializes the . + + + Initializes the with the specified callback. + + A handler to invoke for each reported progress value. This handler will be invoked + in addition to any delegates registered with the event. + + The is null (Nothing in Visual Basic). + + + Reports a progress change. + The value of the updated progress. + + + Reports a progress change. + The value of the updated progress. + + + Invokes the action and event callbacks. + The progress value. + + + Raised for each reported progress value. + + Handlers registered with this event will be invoked on the + captured when the instance was constructed. + + + + Holds static values for . + This avoids one static instance per type T. + + + A default synchronization context that targets the ThreadPool. + + + Throws the exception on the ThreadPool. + The exception to propagate. + The target context on which to propagate the exception. Null to use the ThreadPool. + + + Copies the exception's stack trace so its stack trace isn't overwritten. + The exception to prepare. + + + Provides an awaitable object that allows for configured awaits on . + This type is intended for compiler use only. + + + The task being awaited. + + + Initializes the . + The awaitable . + + true to attempt to marshal the continuation back to the original context captured; otherwise, false. + + + + Gets an awaiter for this awaitable. + The awaiter. + + + Provides an awaiter for a . + This type is intended for compiler use only. + + + The task being awaited. + + + Whether to attempt marshaling back to the original context. + + + Initializes the . + The to await. + + true to attempt to marshal the continuation back to the original context captured + when BeginAwait is called; otherwise, false. + + + + Schedules the continuation onto the associated with this . + The action to invoke when the await operation completes. + The argument is null (Nothing in Visual Basic). + The awaiter was not properly initialized. + This method is intended for compiler user rather than use directly in code. + + + Schedules the continuation onto the associated with this . + The action to invoke when the await operation completes. + The argument is null (Nothing in Visual Basic). + The awaiter was not properly initialized. + This method is intended for compiler user rather than use directly in code. + + + Ends the await on the completed . + The result of the completed . + The awaiter was not properly initialized. + The task was not yet completed. + The task was canceled. + The task completed in a Faulted state. + + + Gets whether the task being awaited is completed. + This property is intended for compiler user rather than use directly in code. + The awaiter was not properly initialized. + + + Provides an awaitable object that allows for configured awaits on . + This type is intended for compiler use only. + + + The underlying awaitable on whose logic this awaitable relies. + + + Initializes the . + The awaitable . + + true to attempt to marshal the continuation back to the original context captured; otherwise, false. + + + + Gets an awaiter for this awaitable. + The awaiter. + + + Provides an awaiter for a . + This type is intended for compiler use only. + + + The task being awaited. + + + Whether to attempt marshaling back to the original context. + + + Initializes the . + The awaitable . + + true to attempt to marshal the continuation back to the original context captured; otherwise, false. + + + + Schedules the continuation onto the associated with this . + The action to invoke when the await operation completes. + The argument is null (Nothing in Visual Basic). + The awaiter was not properly initialized. + This method is intended for compiler user rather than use directly in code. + + + Schedules the continuation onto the associated with this . + The action to invoke when the await operation completes. + The argument is null (Nothing in Visual Basic). + The awaiter was not properly initialized. + This method is intended for compiler user rather than use directly in code. + + + Ends the await on the completed . + The result of the completed . + The awaiter was not properly initialized. + The task was not yet completed. + The task was canceled. + The task completed in a Faulted state. + + + Gets whether the task being awaited is completed. + This property is intended for compiler user rather than use directly in code. + The awaiter was not properly initialized. + + + Provides an awaiter for awaiting a . + This type is intended for compiler use only. + + + The default value to use for continueOnCapturedContext. + + + Error message for GetAwaiter. + + + The task being awaited. + + + Initializes the . + The to be awaited. + + + Schedules the continuation onto the associated with this . + The action to invoke when the await operation completes. + The argument is null (Nothing in Visual Basic). + The awaiter was not properly initialized. + This method is intended for compiler user rather than use directly in code. + + + Schedules the continuation onto the associated with this . + The action to invoke when the await operation completes. + The argument is null (Nothing in Visual Basic). + The awaiter was not properly initialized. + This method is intended for compiler user rather than use directly in code. + + + Ends the await on the completed . + The awaiter was not properly initialized. + The task was not yet completed. + The task was canceled. + The task completed in a Faulted state. + + + + Fast checks for the end of an await operation to determine whether more needs to be done + prior to completing the await. + + The awaited task. + + + Handles validations on tasks that aren't successfully completed. + The awaited task. + + + Throws an exception to handle a task that completed in a state other than RanToCompletion. + + + Schedules the continuation onto the associated with this . + The awaited task. + The action to invoke when the await operation completes. + Whether to capture and marshal back to the current context. + The argument is null (Nothing in Visual Basic). + The awaiter was not properly initialized. + This method is intended for compiler user rather than use directly in code. + + + Invokes the delegate in a try/catch that will propagate the exception asynchronously on the ThreadPool. + + + + Copies the exception's stack trace so its stack trace isn't overwritten. + The exception to prepare. + + + Gets whether the task being awaited is completed. + This property is intended for compiler user rather than use directly in code. + The awaiter was not properly initialized. + + + Whether the current thread is appropriate for inlining the await continuation. + + + Provides an awaiter for awaiting a . + This type is intended for compiler use only. + + + The task being awaited. + + + Initializes the . + The to be awaited. + + + Schedules the continuation onto the associated with this . + The action to invoke when the await operation completes. + The argument is null (Nothing in Visual Basic). + The awaiter was not properly initialized. + This method is intended for compiler user rather than use directly in code. + + + Schedules the continuation onto the associated with this . + The action to invoke when the await operation completes. + The argument is null (Nothing in Visual Basic). + The awaiter was not properly initialized. + This method is intended for compiler user rather than use directly in code. + + + Ends the await on the completed . + The result of the completed . + The awaiter was not properly initialized. + The task was not yet completed. + The task was canceled. + The task completed in a Faulted state. + + + Gets whether the task being awaited is completed. + This property is intended for compiler user rather than use directly in code. + The awaiter was not properly initialized. + + + Provides an awaitable context for switching into a target environment. + This type is intended for compiler use only. + + + Gets an awaiter for this . + An awaiter for this awaitable. + This method is intended for compiler user rather than use directly in code. + + + Provides an awaiter that switches into a target environment. + This type is intended for compiler use only. + + + A completed task. + + + Posts the back to the current context. + The action to invoke asynchronously. + The awaiter was not properly initialized. + + + Posts the back to the current context. + The action to invoke asynchronously. + The awaiter was not properly initialized. + + + Ends the await operation. + + + Gets whether a yield is not required. + This property is intended for compiler user rather than use directly in code. + + + Provides methods for creating and manipulating tasks. + + + Creates a task that runs the specified action. + The action to execute asynchronously. + A task that represents the completion of the action. + The argument is null. + + + Creates a task that runs the specified action. + The action to execute. + The CancellationToken to use to request cancellation of this task. + A task that represents the completion of the action. + The argument is null. + + + Creates a task that runs the specified function. + The function to execute asynchronously. + A task that represents the completion of the action. + The argument is null. + + + Creates a task that runs the specified function. + The action to execute. + The CancellationToken to use to cancel the task. + A task that represents the completion of the action. + The argument is null. + + + Creates a task that runs the specified function. + The action to execute asynchronously. + A task that represents the completion of the action. + The argument is null. + + + Creates a task that runs the specified function. + The function to execute. + The CancellationToken to use to request cancellation of this task. + A task that represents the completion of the function. + The argument is null. + + + Creates a task that runs the specified function. + The function to execute asynchronously. + A task that represents the completion of the action. + The argument is null. + + + Creates a task that runs the specified function. + The action to execute. + The CancellationToken to use to cancel the task. + A task that represents the completion of the action. + The argument is null. + + + Starts a Task that will complete after the specified due time. + The delay in milliseconds before the returned task completes. + The timed Task. + + The argument must be non-negative or -1 and less than or equal to Int32.MaxValue. + + + + Starts a Task that will complete after the specified due time. + The delay before the returned task completes. + The timed Task. + + The argument must be non-negative or -1 and less than or equal to Int32.MaxValue. + + + + Starts a Task that will complete after the specified due time. + The delay before the returned task completes. + A CancellationToken that may be used to cancel the task before the due time occurs. + The timed Task. + + The argument must be non-negative or -1 and less than or equal to Int32.MaxValue. + + + + Starts a Task that will complete after the specified due time. + The delay in milliseconds before the returned task completes. + A CancellationToken that may be used to cancel the task before the due time occurs. + The timed Task. + + The argument must be non-negative or -1 and less than or equal to Int32.MaxValue. + + + + An already completed task. + + + Creates a Task that will complete only when all of the provided collection of Tasks has completed. + The Tasks to monitor for completion. + A Task that represents the completion of all of the provided tasks. + + If any of the provided Tasks faults, the returned Task will also fault, and its Exception will contain information + about all of the faulted tasks. If no Tasks fault but one or more Tasks is canceled, the returned + Task will also be canceled. + + The argument is null. + The argument contains a null reference. + + + Creates a Task that will complete only when all of the provided collection of Tasks has completed. + The Tasks to monitor for completion. + A Task that represents the completion of all of the provided tasks. + + If any of the provided Tasks faults, the returned Task will also fault, and its Exception will contain information + about all of the faulted tasks. If no Tasks fault but one or more Tasks is canceled, the returned + Task will also be canceled. + + The argument is null. + The argument contains a null reference. + + + Creates a Task that will complete only when all of the provided collection of Tasks has completed. + The Tasks to monitor for completion. + A Task that represents the completion of all of the provided tasks. + + If any of the provided Tasks faults, the returned Task will also fault, and its Exception will contain information + about all of the faulted tasks. If no Tasks fault but one or more Tasks is canceled, the returned + Task will also be canceled. + + The argument is null. + The argument contains a null reference. + + + Creates a Task that will complete only when all of the provided collection of Tasks has completed. + The Tasks to monitor for completion. + A Task that represents the completion of all of the provided tasks. + + If any of the provided Tasks faults, the returned Task will also fault, and its Exception will contain information + about all of the faulted tasks. If no Tasks fault but one or more Tasks is canceled, the returned + Task will also be canceled. + + The argument is null. + The argument contains a null reference. + + + Creates a Task that will complete only when all of the provided collection of Tasks has completed. + The Tasks to monitor for completion. + + A callback invoked when all of the tasks complete successfully in the RanToCompletion state. + This callback is responsible for storing the results into the TaskCompletionSource. + + A Task that represents the completion of all of the provided tasks. + The argument is null. + The argument contains a null reference. + + + Creates a Task that will complete when any of the tasks in the provided collection completes. + The Tasks to be monitored. + + A Task that represents the completion of any of the provided Tasks. The completed Task is this Task's result. + + Any Tasks that fault will need to have their exceptions observed elsewhere. + The argument is null. + The argument contains a null reference. + + + Creates a Task that will complete when any of the tasks in the provided collection completes. + The Tasks to be monitored. + + A Task that represents the completion of any of the provided Tasks. The completed Task is this Task's result. + + Any Tasks that fault will need to have their exceptions observed elsewhere. + The argument is null. + The argument contains a null reference. + + + Creates a Task that will complete when any of the tasks in the provided collection completes. + The Tasks to be monitored. + + A Task that represents the completion of any of the provided Tasks. The completed Task is this Task's result. + + Any Tasks that fault will need to have their exceptions observed elsewhere. + The argument is null. + The argument contains a null reference. + + + Creates a Task that will complete when any of the tasks in the provided collection completes. + The Tasks to be monitored. + + A Task that represents the completion of any of the provided Tasks. The completed Task is this Task's result. + + Any Tasks that fault will need to have their exceptions observed elsewhere. + The argument is null. + The argument contains a null reference. + + + Creates an already completed from the specified result. + The result from which to create the completed task. + The completed task. + + + Creates an awaitable that asynchronously yields back to the current context when awaited. + + A context that, when awaited, will asynchronously transition back into the current context. + If SynchronizationContext.Current is non-null, that is treated as the current context. + Otherwise, TaskScheduler.Current is treated as the current context. + + + + Adds the target exception to the list, initializing the list if it's null. + The list to which to add the exception and initialize if the list is null. + The exception to add, and unwrap if it's an aggregate. + + + Returns a canceled task. + The cancellation token. + The canceled task. + + + Returns a canceled task. + Specifies the type of the result. + The cancellation token. + The canceled task. + + + + Completes the Task if the user state matches the TaskCompletionSource. + + Specifies the type of data returned by the Task. + The TaskCompletionSource. + The completion event arguments. + Whether we require the tcs to match the e.UserState. + A function that gets the result with which to complete the task. + An action used to unregister work when the operaiton completes. + + + diff --git a/src/packages/Microsoft.Bcl.Async.1.0.168/lib/win8/Microsoft.Threading.Tasks.Extensions.dll b/src/packages/Microsoft.Bcl.Async.1.0.168/lib/win8/Microsoft.Threading.Tasks.Extensions.dll new file mode 100644 index 0000000000000000000000000000000000000000..4d862e1730a34a6a5cfa39d04840bd039cf9de29 GIT binary patch literal 31520 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 literal 0 HcmV?d00001 diff --git a/src/packages/Microsoft.Bcl.Async.1.0.168/lib/win8/Microsoft.Threading.Tasks.Extensions.xml b/src/packages/Microsoft.Bcl.Async.1.0.168/lib/win8/Microsoft.Threading.Tasks.Extensions.xml new file mode 100644 index 00000000..af646a2d --- /dev/null +++ b/src/packages/Microsoft.Bcl.Async.1.0.168/lib/win8/Microsoft.Threading.Tasks.Extensions.xml @@ -0,0 +1,275 @@ + + + + Microsoft.Threading.Tasks.Extensions + + + + Returns a canceled task. + The cancellation token. + The canceled task. + + + Returns a canceled task. + Specifies the type of the result. + The cancellation token. + The canceled task. + + + + Completes the Task if the user state matches the TaskCompletionSource. + + Specifies the type of data returned by the Task. + The TaskCompletionSource. + The completion event arguments. + Whether we require the tcs to match the e.UserState. + A function that gets the result with which to complete the task. + An action used to unregister work when the operaiton completes. + + + + Provides asynchronous wrappers for .NET Framework operations. + + + + + Reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read. + + A Task that represents the asynchronous read. + The source. + The buffer to read data into. + The byte offset in at which to begin reading. + The maximum number of bytes to read. + The array length minus is less than . + is null. + or is negative. + An asynchronous read was attempted past the end of the file. + + + + Reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read. + + A Task that represents the asynchronous read. + The source. + The buffer to read data into. + The byte offset in at which to begin reading. + The maximum number of bytes to read. + The cancellation token. + The array length minus is less than . + is null. + or is negative. + An asynchronous read was attempted past the end of the file. + + + + Writes asynchronously a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written. + + A Task that represents the asynchronous write. + The source. + The buffer containing data to write to the current stream. + The zero-based byte offset in at which to begin copying bytes to the current stream. + The maximum number of bytes to write. + length minus is less than . + is null. + or is negative. + The stream does not support writing. + The stream is closed. + An I/O error occurred. + + + + Writes asynchronously a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written. + + A Task that represents the asynchronous write. + The source. + The buffer containing data to write to the current stream. + The zero-based byte offset in at which to begin copying bytes to the current stream. + The maximum number of bytes to write. + The cancellation token. + length minus is less than . + is null. + or is negative. + The stream does not support writing. + The stream is closed. + An I/O error occurred. + + + + Flushes asynchronously the current stream. + + A Task that represents the asynchronous flush. + + + + Flushes asynchronously the current stream. + + A Task that represents the asynchronous flush. + + + + Reads all the bytes from the current stream and writes them to the destination stream. + + The source stream. + The stream that will contain the contents of the current stream. + A Task that represents the asynchronous operation. + + + + Reads all the bytes from the current stream and writes them to the destination stream. + + The source stream. + The stream that will contain the contents of the current stream. + The size of the buffer. This value must be greater than zero. The default size is 4096. + A Task that represents the asynchronous operation. + + + + Reads all the bytes from the current stream and writes them to the destination stream. + + The source stream. + The stream that will contain the contents of the current stream. + The size of the buffer. This value must be greater than zero. The default size is 4096. + The cancellation token to use to cancel the asynchronous operation. + A Task that represents the asynchronous operation. + + + + Reads all the bytes from the current stream and writes them to the destination stream. + + The source stream. + The stream that will contain the contents of the current stream. + The size of the buffer. This value must be greater than zero. The default size is 4096. + The cancellation token to use to cancel the asynchronous operation. + A Task that represents the asynchronous operation. + + + + Reads a maximum of count characters from the reader asynchronously and writes + the data to buffer, beginning at index. + + + When the operation completes, contains the specified character array with the + values between index and (index + count - 1) replaced by the characters read + from the current source. + + + The maximum number of characters to read. If the end of the stream is reached + before count of characters is read into buffer, the current method returns. + + The place in buffer at which to begin writing. + the source reader. + A Task that represents the asynchronous operation. + + + + Reads asynchronously a maximum of count characters from the current stream, and writes the + data to buffer, beginning at index. + + The source reader. + + When this method returns, this parameter contains the specified character + array with the values between index and (index + count -1) replaced by the + characters read from the current source. + + The position in buffer at which to begin writing. + The maximum number of characters to read. + A Task that represents the asynchronous operation. + + + + Reads a line of characters from the reader and returns the string asynchronously. + + the source reader. + A Task that represents the asynchronous operation. + + + + Reads all characters from the current position to the end of the TextReader + and returns them as one string asynchronously. + + the source reader. + A Task that represents the asynchronous operation. + + + Writes a string asynchronously to a text stream. + The writer. + The string to write. + A Task representing the asynchronous write. + + + Writes a char asynchronously to a text stream. + The writer. + The char to write. + A Task representing the asynchronous write. + + + Writes a char array asynchronously to a text stream. + The writer. + The buffer to write. + A Task representing the asynchronous write. + + + Writes a subarray of characters asynchronously to a text stream. + The writer. + The buffer to write. + Starting index in the buffer. + The number of characters to write. + A Task representing the asynchronous write. + + + Writes a line terminator asynchronously to a text stream. + The writer. + A Task representing the asynchronous write. + + + Writes a string followed by a line terminator asynchronously to a text stream. + The writer. + The string to write. + A Task representing the asynchronous write. + + + Writes a char followed by a line terminator asynchronously to a text stream. + The writer. + The char to write. + A Task representing the asynchronous write. + + + Writes a char array followed by a line terminator asynchronously to a text stream. + The writer. + The buffer to write. + A Task representing the asynchronous write. + + + Writes a subarray of characters followed by a line terminator asynchronously to a text stream. + The writer. + The buffer to write. + Starting index in the buffer. + The number of characters to write. + A Task representing the asynchronous write. + + + + Clears all buffers for the current writer and causes any buffered data to + be written to the underlying device. + + The writer. + A Task representing the asynchronous flush. + + + Starts an asynchronous request for a web resource. + Task that represents the asynchronous request. + The stream is already in use by a previous call to . + + The source. + + + Starts an asynchronous request for a object to use to write data. + Task that represents the asynchronous request. + The property is GET and the application writes to the stream. + The stream is being used by a previous call to . + No write stream is available. + + The source. + + + diff --git a/src/packages/Microsoft.Bcl.Async.1.0.168/lib/win8/Microsoft.Threading.Tasks.dll b/src/packages/Microsoft.Bcl.Async.1.0.168/lib/win8/Microsoft.Threading.Tasks.dll new file mode 100644 index 0000000000000000000000000000000000000000..8438577c2042e5d6899425d500bf8074aae650a1 GIT binary patch literal 37104 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 literal 0 HcmV?d00001 diff --git a/src/packages/Microsoft.Bcl.Async.1.0.168/lib/win8/Microsoft.Threading.Tasks.xml b/src/packages/Microsoft.Bcl.Async.1.0.168/lib/win8/Microsoft.Threading.Tasks.xml new file mode 100644 index 00000000..5c22030d --- /dev/null +++ b/src/packages/Microsoft.Bcl.Async.1.0.168/lib/win8/Microsoft.Threading.Tasks.xml @@ -0,0 +1,630 @@ + + + + Microsoft.Threading.Tasks + + + + + Provides extension methods for threading-related types. + + + + Cancels the after the specified duration. + The CancellationTokenSource. + The due time in milliseconds for the source to be canceled. + + + Cancels the after the specified duration. + The CancellationTokenSource. + The due time for the source to be canceled. + + + Gets an awaiter used to await this . + The task to await. + An awaiter instance. + + + Gets an awaiter used to await this . + Specifies the type of data returned by the task. + The task to await. + An awaiter instance. + + + Creates and configures an awaitable object for awaiting the specified task. + The task to be awaited. + + true to automatic marshag back to the original call site's current SynchronizationContext + or TaskScheduler; otherwise, false. + + The instance to be awaited. + + + Creates and configures an awaitable object for awaiting the specified task. + The task to be awaited. + + true to automatic marshag back to the original call site's current SynchronizationContext + or TaskScheduler; otherwise, false. + + The instance to be awaited. + + + Event handler for progress reports. + Specifies the type of data for the progress report. + The sender of the report. + The reported value. + + + + Provides an IProgress{T} that invokes callbacks for each reported progress value. + + Specifies the type of the progress report value. + + Any handler provided to the constructor or event handlers registered with + the event are invoked through a + instance captured + when the instance is constructed. If there is no current SynchronizationContext + at the time of construction, the callbacks will be invoked on the ThreadPool. + + + + The synchronization context captured upon construction. This will never be null. + + + The handler specified to the constructor. This may be null. + + + A cached delegate used to post invocation to the synchronization context. + + + Initializes the . + + + Initializes the with the specified callback. + + A handler to invoke for each reported progress value. This handler will be invoked + in addition to any delegates registered with the event. + + The is null (Nothing in Visual Basic). + + + Reports a progress change. + The value of the updated progress. + + + Reports a progress change. + The value of the updated progress. + + + Invokes the action and event callbacks. + The progress value. + + + Raised for each reported progress value. + + Handlers registered with this event will be invoked on the + captured when the instance was constructed. + + + + Holds static values for . + This avoids one static instance per type T. + + + A default synchronization context that targets the ThreadPool. + + + Throws the exception on the ThreadPool. + The exception to propagate. + The target context on which to propagate the exception. Null to use the ThreadPool. + + + Copies the exception's stack trace so its stack trace isn't overwritten. + The exception to prepare. + + + Provides an awaitable object that allows for configured awaits on . + This type is intended for compiler use only. + + + The task being awaited. + + + Initializes the . + The awaitable . + + true to attempt to marshal the continuation back to the original context captured; otherwise, false. + + + + Gets an awaiter for this awaitable. + The awaiter. + + + Provides an awaiter for a . + This type is intended for compiler use only. + + + The task being awaited. + + + Whether to attempt marshaling back to the original context. + + + Initializes the . + The to await. + + true to attempt to marshal the continuation back to the original context captured + when BeginAwait is called; otherwise, false. + + + + Schedules the continuation onto the associated with this . + The action to invoke when the await operation completes. + The argument is null (Nothing in Visual Basic). + The awaiter was not properly initialized. + This method is intended for compiler user rather than use directly in code. + + + Schedules the continuation onto the associated with this . + The action to invoke when the await operation completes. + The argument is null (Nothing in Visual Basic). + The awaiter was not properly initialized. + This method is intended for compiler user rather than use directly in code. + + + Ends the await on the completed . + The result of the completed . + The awaiter was not properly initialized. + The task was not yet completed. + The task was canceled. + The task completed in a Faulted state. + + + Gets whether the task being awaited is completed. + This property is intended for compiler user rather than use directly in code. + The awaiter was not properly initialized. + + + Provides an awaitable object that allows for configured awaits on . + This type is intended for compiler use only. + + + The underlying awaitable on whose logic this awaitable relies. + + + Initializes the . + The awaitable . + + true to attempt to marshal the continuation back to the original context captured; otherwise, false. + + + + Gets an awaiter for this awaitable. + The awaiter. + + + Provides an awaiter for a . + This type is intended for compiler use only. + + + The task being awaited. + + + Whether to attempt marshaling back to the original context. + + + Initializes the . + The awaitable . + + true to attempt to marshal the continuation back to the original context captured; otherwise, false. + + + + Schedules the continuation onto the associated with this . + The action to invoke when the await operation completes. + The argument is null (Nothing in Visual Basic). + The awaiter was not properly initialized. + This method is intended for compiler user rather than use directly in code. + + + Schedules the continuation onto the associated with this . + The action to invoke when the await operation completes. + The argument is null (Nothing in Visual Basic). + The awaiter was not properly initialized. + This method is intended for compiler user rather than use directly in code. + + + Ends the await on the completed . + The result of the completed . + The awaiter was not properly initialized. + The task was not yet completed. + The task was canceled. + The task completed in a Faulted state. + + + Gets whether the task being awaited is completed. + This property is intended for compiler user rather than use directly in code. + The awaiter was not properly initialized. + + + Provides an awaiter for awaiting a . + This type is intended for compiler use only. + + + The default value to use for continueOnCapturedContext. + + + Error message for GetAwaiter. + + + The task being awaited. + + + Initializes the . + The to be awaited. + + + Schedules the continuation onto the associated with this . + The action to invoke when the await operation completes. + The argument is null (Nothing in Visual Basic). + The awaiter was not properly initialized. + This method is intended for compiler user rather than use directly in code. + + + Schedules the continuation onto the associated with this . + The action to invoke when the await operation completes. + The argument is null (Nothing in Visual Basic). + The awaiter was not properly initialized. + This method is intended for compiler user rather than use directly in code. + + + Ends the await on the completed . + The awaiter was not properly initialized. + The task was not yet completed. + The task was canceled. + The task completed in a Faulted state. + + + + Fast checks for the end of an await operation to determine whether more needs to be done + prior to completing the await. + + The awaited task. + + + Handles validations on tasks that aren't successfully completed. + The awaited task. + + + Throws an exception to handle a task that completed in a state other than RanToCompletion. + + + Schedules the continuation onto the associated with this . + The awaited task. + The action to invoke when the await operation completes. + Whether to capture and marshal back to the current context. + The argument is null (Nothing in Visual Basic). + The awaiter was not properly initialized. + This method is intended for compiler user rather than use directly in code. + + + Invokes the delegate in a try/catch that will propagate the exception asynchronously on the ThreadPool. + + + + Copies the exception's stack trace so its stack trace isn't overwritten. + The exception to prepare. + + + Gets whether the task being awaited is completed. + This property is intended for compiler user rather than use directly in code. + The awaiter was not properly initialized. + + + Whether the current thread is appropriate for inlining the await continuation. + + + Provides an awaiter for awaiting a . + This type is intended for compiler use only. + + + The task being awaited. + + + Initializes the . + The to be awaited. + + + Schedules the continuation onto the associated with this . + The action to invoke when the await operation completes. + The argument is null (Nothing in Visual Basic). + The awaiter was not properly initialized. + This method is intended for compiler user rather than use directly in code. + + + Schedules the continuation onto the associated with this . + The action to invoke when the await operation completes. + The argument is null (Nothing in Visual Basic). + The awaiter was not properly initialized. + This method is intended for compiler user rather than use directly in code. + + + Ends the await on the completed . + The result of the completed . + The awaiter was not properly initialized. + The task was not yet completed. + The task was canceled. + The task completed in a Faulted state. + + + Gets whether the task being awaited is completed. + This property is intended for compiler user rather than use directly in code. + The awaiter was not properly initialized. + + + Provides an awaitable context for switching into a target environment. + This type is intended for compiler use only. + + + Gets an awaiter for this . + An awaiter for this awaitable. + This method is intended for compiler user rather than use directly in code. + + + Provides an awaiter that switches into a target environment. + This type is intended for compiler use only. + + + A completed task. + + + Posts the back to the current context. + The action to invoke asynchronously. + The awaiter was not properly initialized. + + + Posts the back to the current context. + The action to invoke asynchronously. + The awaiter was not properly initialized. + + + Ends the await operation. + + + Gets whether a yield is not required. + This property is intended for compiler user rather than use directly in code. + + + Provides methods for creating and manipulating tasks. + + + Creates a task that runs the specified action. + The action to execute asynchronously. + A task that represents the completion of the action. + The argument is null. + + + Creates a task that runs the specified action. + The action to execute. + The CancellationToken to use to request cancellation of this task. + A task that represents the completion of the action. + The argument is null. + + + Creates a task that runs the specified function. + The function to execute asynchronously. + A task that represents the completion of the action. + The argument is null. + + + Creates a task that runs the specified function. + The action to execute. + The CancellationToken to use to cancel the task. + A task that represents the completion of the action. + The argument is null. + + + Creates a task that runs the specified function. + The action to execute asynchronously. + A task that represents the completion of the action. + The argument is null. + + + Creates a task that runs the specified function. + The function to execute. + The CancellationToken to use to request cancellation of this task. + A task that represents the completion of the function. + The argument is null. + + + Creates a task that runs the specified function. + The function to execute asynchronously. + A task that represents the completion of the action. + The argument is null. + + + Creates a task that runs the specified function. + The action to execute. + The CancellationToken to use to cancel the task. + A task that represents the completion of the action. + The argument is null. + + + Starts a Task that will complete after the specified due time. + The delay in milliseconds before the returned task completes. + The timed Task. + + The argument must be non-negative or -1 and less than or equal to Int32.MaxValue. + + + + Starts a Task that will complete after the specified due time. + The delay before the returned task completes. + The timed Task. + + The argument must be non-negative or -1 and less than or equal to Int32.MaxValue. + + + + Starts a Task that will complete after the specified due time. + The delay before the returned task completes. + A CancellationToken that may be used to cancel the task before the due time occurs. + The timed Task. + + The argument must be non-negative or -1 and less than or equal to Int32.MaxValue. + + + + Starts a Task that will complete after the specified due time. + The delay in milliseconds before the returned task completes. + A CancellationToken that may be used to cancel the task before the due time occurs. + The timed Task. + + The argument must be non-negative or -1 and less than or equal to Int32.MaxValue. + + + + An already completed task. + + + Creates a Task that will complete only when all of the provided collection of Tasks has completed. + The Tasks to monitor for completion. + A Task that represents the completion of all of the provided tasks. + + If any of the provided Tasks faults, the returned Task will also fault, and its Exception will contain information + about all of the faulted tasks. If no Tasks fault but one or more Tasks is canceled, the returned + Task will also be canceled. + + The argument is null. + The argument contains a null reference. + + + Creates a Task that will complete only when all of the provided collection of Tasks has completed. + The Tasks to monitor for completion. + A Task that represents the completion of all of the provided tasks. + + If any of the provided Tasks faults, the returned Task will also fault, and its Exception will contain information + about all of the faulted tasks. If no Tasks fault but one or more Tasks is canceled, the returned + Task will also be canceled. + + The argument is null. + The argument contains a null reference. + + + Creates a Task that will complete only when all of the provided collection of Tasks has completed. + The Tasks to monitor for completion. + A Task that represents the completion of all of the provided tasks. + + If any of the provided Tasks faults, the returned Task will also fault, and its Exception will contain information + about all of the faulted tasks. If no Tasks fault but one or more Tasks is canceled, the returned + Task will also be canceled. + + The argument is null. + The argument contains a null reference. + + + Creates a Task that will complete only when all of the provided collection of Tasks has completed. + The Tasks to monitor for completion. + A Task that represents the completion of all of the provided tasks. + + If any of the provided Tasks faults, the returned Task will also fault, and its Exception will contain information + about all of the faulted tasks. If no Tasks fault but one or more Tasks is canceled, the returned + Task will also be canceled. + + The argument is null. + The argument contains a null reference. + + + Creates a Task that will complete only when all of the provided collection of Tasks has completed. + The Tasks to monitor for completion. + + A callback invoked when all of the tasks complete successfully in the RanToCompletion state. + This callback is responsible for storing the results into the TaskCompletionSource. + + A Task that represents the completion of all of the provided tasks. + The argument is null. + The argument contains a null reference. + + + Creates a Task that will complete when any of the tasks in the provided collection completes. + The Tasks to be monitored. + + A Task that represents the completion of any of the provided Tasks. The completed Task is this Task's result. + + Any Tasks that fault will need to have their exceptions observed elsewhere. + The argument is null. + The argument contains a null reference. + + + Creates a Task that will complete when any of the tasks in the provided collection completes. + The Tasks to be monitored. + + A Task that represents the completion of any of the provided Tasks. The completed Task is this Task's result. + + Any Tasks that fault will need to have their exceptions observed elsewhere. + The argument is null. + The argument contains a null reference. + + + Creates a Task that will complete when any of the tasks in the provided collection completes. + The Tasks to be monitored. + + A Task that represents the completion of any of the provided Tasks. The completed Task is this Task's result. + + Any Tasks that fault will need to have their exceptions observed elsewhere. + The argument is null. + The argument contains a null reference. + + + Creates a Task that will complete when any of the tasks in the provided collection completes. + The Tasks to be monitored. + + A Task that represents the completion of any of the provided Tasks. The completed Task is this Task's result. + + Any Tasks that fault will need to have their exceptions observed elsewhere. + The argument is null. + The argument contains a null reference. + + + Creates an already completed from the specified result. + The result from which to create the completed task. + The completed task. + + + Creates an awaitable that asynchronously yields back to the current context when awaited. + + A context that, when awaited, will asynchronously transition back into the current context. + If SynchronizationContext.Current is non-null, that is treated as the current context. + Otherwise, TaskScheduler.Current is treated as the current context. + + + + Adds the target exception to the list, initializing the list if it's null. + The list to which to add the exception and initialize if the list is null. + The exception to add, and unwrap if it's an aggregate. + + + Returns a canceled task. + The cancellation token. + The canceled task. + + + Returns a canceled task. + Specifies the type of the result. + The cancellation token. + The canceled task. + + + + Completes the Task if the user state matches the TaskCompletionSource. + + Specifies the type of data returned by the Task. + The TaskCompletionSource. + The completion event arguments. + Whether we require the tcs to match the e.UserState. + A function that gets the result with which to complete the task. + An action used to unregister work when the operaiton completes. + + + diff --git a/src/packages/Microsoft.Bcl.Async.1.0.168/lib/wp8/Microsoft.Threading.Tasks.Extensions.Phone.dll b/src/packages/Microsoft.Bcl.Async.1.0.168/lib/wp8/Microsoft.Threading.Tasks.Extensions.Phone.dll new file mode 100644 index 0000000000000000000000000000000000000000..b9812870f70f534d6785d6a0735e931d0509d033 GIT binary patch literal 28984 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 Qt0R510!1UJpc$e60~XE>xBvhE literal 0 HcmV?d00001 diff --git a/src/packages/Microsoft.Bcl.Async.1.0.168/lib/wp8/Microsoft.Threading.Tasks.Extensions.Phone.xml b/src/packages/Microsoft.Bcl.Async.1.0.168/lib/wp8/Microsoft.Threading.Tasks.Extensions.Phone.xml new file mode 100644 index 00000000..515d7031 --- /dev/null +++ b/src/packages/Microsoft.Bcl.Async.1.0.168/lib/wp8/Microsoft.Threading.Tasks.Extensions.Phone.xml @@ -0,0 +1,141 @@ + + + + Microsoft.Threading.Tasks.Extensions.Phone + + + + + Provides asynchronous wrappers for .NET Framework operations. + + + Provides asynchronous wrappers for .NET Framework operations. + + + + Downloads the resource with the specified URI as a string, asynchronously. + The WebClient. + The URI from which to download data. + A Task that contains the downloaded string. + + + Downloads the resource with the specified URI as a string, asynchronously. + The WebClient. + The URI from which to download data. + A Task that contains the downloaded string. + + + Opens a readable stream for the data downloaded from a resource, asynchronously. + The WebClient. + The URI for which the stream should be opened. + A Task that contains the opened stream. + + + Opens a readable stream for the data downloaded from a resource, asynchronously. + The WebClient. + The URI for which the stream should be opened. + A Task that contains the opened stream. + + + Opens a writeable stream for uploading data to a resource, asynchronously. + The WebClient. + The URI for which the stream should be opened. + A Task that contains the opened stream. + + + Opens a writeable stream for uploading data to a resource, asynchronously. + The WebClient. + The URI for which the stream should be opened. + A Task that contains the opened stream. + + + Opens a writeable stream for uploading data to a resource, asynchronously. + The WebClient. + The URI for which the stream should be opened. + The HTTP method that should be used to open the stream. + A Task that contains the opened stream. + + + Opens a writeable stream for uploading data to a resource, asynchronously. + The WebClient. + The URI for which the stream should be opened. + The HTTP method that should be used to open the stream. + A Task that contains the opened stream. + + + Uploads data in a string to the specified resource, asynchronously. + The WebClient. + The URI to which the data should be uploaded. + The data to upload. + A Task containing the data in the response from the upload. + + + Uploads data in a string to the specified resource, asynchronously. + The WebClient. + The URI to which the data should be uploaded. + The data to upload. + A Task containing the data in the response from the upload. + + + Uploads data in a string to the specified resource, asynchronously. + The WebClient. + The URI to which the data should be uploaded. + The HTTP method that should be used to upload the data. + The data to upload. + A Task containing the data in the response from the upload. + + + Uploads data in a string to the specified resource, asynchronously. + The WebClient. + The URI to which the data should be uploaded. + The HTTP method that should be used to upload the data. + The data to upload. + A Task containing the data in the response from the upload. + + + Converts a path to a Uri using the WebClient's logic. + Based on WebClient's private GetUri method. + + + Converts a path to a Uri using the WebClient's logic. + Based on WebClient's private GetUri method. + + + Asynchronously invokes an Action on the Dispatcher. + The Dispatcher. + The action to invoke. + A Task that represents the execution of the action. + + + Asynchronously invokes an Action on the Dispatcher. + The Dispatcher. + The function to invoke. + A Task that represents the execution of the function. + + + Used with Task(of void) + + + Returns a canceled task. + The cancellation token. + The canceled task. + + + Returns a canceled task. + Specifies the type of the result. + The cancellation token. + The canceled task. + + + + Completes the Task if the user state matches the TaskCompletionSource. + + Specifies the type of data returned by the Task. + The TaskCompletionSource. + The completion event arguments. + Whether we require the tcs to match the e.UserState. + A function that gets the result with which to complete the task. + An action used to unregister work when the operaiton completes. + + + diff --git a/src/packages/Microsoft.Bcl.Async.1.0.168/lib/wp8/Microsoft.Threading.Tasks.Extensions.dll b/src/packages/Microsoft.Bcl.Async.1.0.168/lib/wp8/Microsoft.Threading.Tasks.Extensions.dll new file mode 100644 index 0000000000000000000000000000000000000000..4d862e1730a34a6a5cfa39d04840bd039cf9de29 GIT binary patch literal 31520 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 literal 0 HcmV?d00001 diff --git a/src/packages/Microsoft.Bcl.Async.1.0.168/lib/wp8/Microsoft.Threading.Tasks.Extensions.xml b/src/packages/Microsoft.Bcl.Async.1.0.168/lib/wp8/Microsoft.Threading.Tasks.Extensions.xml new file mode 100644 index 00000000..af646a2d --- /dev/null +++ b/src/packages/Microsoft.Bcl.Async.1.0.168/lib/wp8/Microsoft.Threading.Tasks.Extensions.xml @@ -0,0 +1,275 @@ + + + + Microsoft.Threading.Tasks.Extensions + + + + Returns a canceled task. + The cancellation token. + The canceled task. + + + Returns a canceled task. + Specifies the type of the result. + The cancellation token. + The canceled task. + + + + Completes the Task if the user state matches the TaskCompletionSource. + + Specifies the type of data returned by the Task. + The TaskCompletionSource. + The completion event arguments. + Whether we require the tcs to match the e.UserState. + A function that gets the result with which to complete the task. + An action used to unregister work when the operaiton completes. + + + + Provides asynchronous wrappers for .NET Framework operations. + + + + + Reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read. + + A Task that represents the asynchronous read. + The source. + The buffer to read data into. + The byte offset in at which to begin reading. + The maximum number of bytes to read. + The array length minus is less than . + is null. + or is negative. + An asynchronous read was attempted past the end of the file. + + + + Reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read. + + A Task that represents the asynchronous read. + The source. + The buffer to read data into. + The byte offset in at which to begin reading. + The maximum number of bytes to read. + The cancellation token. + The array length minus is less than . + is null. + or is negative. + An asynchronous read was attempted past the end of the file. + + + + Writes asynchronously a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written. + + A Task that represents the asynchronous write. + The source. + The buffer containing data to write to the current stream. + The zero-based byte offset in at which to begin copying bytes to the current stream. + The maximum number of bytes to write. + length minus is less than . + is null. + or is negative. + The stream does not support writing. + The stream is closed. + An I/O error occurred. + + + + Writes asynchronously a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written. + + A Task that represents the asynchronous write. + The source. + The buffer containing data to write to the current stream. + The zero-based byte offset in at which to begin copying bytes to the current stream. + The maximum number of bytes to write. + The cancellation token. + length minus is less than . + is null. + or is negative. + The stream does not support writing. + The stream is closed. + An I/O error occurred. + + + + Flushes asynchronously the current stream. + + A Task that represents the asynchronous flush. + + + + Flushes asynchronously the current stream. + + A Task that represents the asynchronous flush. + + + + Reads all the bytes from the current stream and writes them to the destination stream. + + The source stream. + The stream that will contain the contents of the current stream. + A Task that represents the asynchronous operation. + + + + Reads all the bytes from the current stream and writes them to the destination stream. + + The source stream. + The stream that will contain the contents of the current stream. + The size of the buffer. This value must be greater than zero. The default size is 4096. + A Task that represents the asynchronous operation. + + + + Reads all the bytes from the current stream and writes them to the destination stream. + + The source stream. + The stream that will contain the contents of the current stream. + The size of the buffer. This value must be greater than zero. The default size is 4096. + The cancellation token to use to cancel the asynchronous operation. + A Task that represents the asynchronous operation. + + + + Reads all the bytes from the current stream and writes them to the destination stream. + + The source stream. + The stream that will contain the contents of the current stream. + The size of the buffer. This value must be greater than zero. The default size is 4096. + The cancellation token to use to cancel the asynchronous operation. + A Task that represents the asynchronous operation. + + + + Reads a maximum of count characters from the reader asynchronously and writes + the data to buffer, beginning at index. + + + When the operation completes, contains the specified character array with the + values between index and (index + count - 1) replaced by the characters read + from the current source. + + + The maximum number of characters to read. If the end of the stream is reached + before count of characters is read into buffer, the current method returns. + + The place in buffer at which to begin writing. + the source reader. + A Task that represents the asynchronous operation. + + + + Reads asynchronously a maximum of count characters from the current stream, and writes the + data to buffer, beginning at index. + + The source reader. + + When this method returns, this parameter contains the specified character + array with the values between index and (index + count -1) replaced by the + characters read from the current source. + + The position in buffer at which to begin writing. + The maximum number of characters to read. + A Task that represents the asynchronous operation. + + + + Reads a line of characters from the reader and returns the string asynchronously. + + the source reader. + A Task that represents the asynchronous operation. + + + + Reads all characters from the current position to the end of the TextReader + and returns them as one string asynchronously. + + the source reader. + A Task that represents the asynchronous operation. + + + Writes a string asynchronously to a text stream. + The writer. + The string to write. + A Task representing the asynchronous write. + + + Writes a char asynchronously to a text stream. + The writer. + The char to write. + A Task representing the asynchronous write. + + + Writes a char array asynchronously to a text stream. + The writer. + The buffer to write. + A Task representing the asynchronous write. + + + Writes a subarray of characters asynchronously to a text stream. + The writer. + The buffer to write. + Starting index in the buffer. + The number of characters to write. + A Task representing the asynchronous write. + + + Writes a line terminator asynchronously to a text stream. + The writer. + A Task representing the asynchronous write. + + + Writes a string followed by a line terminator asynchronously to a text stream. + The writer. + The string to write. + A Task representing the asynchronous write. + + + Writes a char followed by a line terminator asynchronously to a text stream. + The writer. + The char to write. + A Task representing the asynchronous write. + + + Writes a char array followed by a line terminator asynchronously to a text stream. + The writer. + The buffer to write. + A Task representing the asynchronous write. + + + Writes a subarray of characters followed by a line terminator asynchronously to a text stream. + The writer. + The buffer to write. + Starting index in the buffer. + The number of characters to write. + A Task representing the asynchronous write. + + + + Clears all buffers for the current writer and causes any buffered data to + be written to the underlying device. + + The writer. + A Task representing the asynchronous flush. + + + Starts an asynchronous request for a web resource. + Task that represents the asynchronous request. + The stream is already in use by a previous call to . + + The source. + + + Starts an asynchronous request for a object to use to write data. + Task that represents the asynchronous request. + The property is GET and the application writes to the stream. + The stream is being used by a previous call to . + No write stream is available. + + The source. + + + diff --git a/src/packages/Microsoft.Bcl.Async.1.0.168/lib/wp8/Microsoft.Threading.Tasks.dll b/src/packages/Microsoft.Bcl.Async.1.0.168/lib/wp8/Microsoft.Threading.Tasks.dll new file mode 100644 index 0000000000000000000000000000000000000000..8438577c2042e5d6899425d500bf8074aae650a1 GIT binary patch literal 37104 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 literal 0 HcmV?d00001 diff --git a/src/packages/Microsoft.Bcl.Async.1.0.168/lib/wp8/Microsoft.Threading.Tasks.xml b/src/packages/Microsoft.Bcl.Async.1.0.168/lib/wp8/Microsoft.Threading.Tasks.xml new file mode 100644 index 00000000..5c22030d --- /dev/null +++ b/src/packages/Microsoft.Bcl.Async.1.0.168/lib/wp8/Microsoft.Threading.Tasks.xml @@ -0,0 +1,630 @@ + + + + Microsoft.Threading.Tasks + + + + + Provides extension methods for threading-related types. + + + + Cancels the after the specified duration. + The CancellationTokenSource. + The due time in milliseconds for the source to be canceled. + + + Cancels the after the specified duration. + The CancellationTokenSource. + The due time for the source to be canceled. + + + Gets an awaiter used to await this . + The task to await. + An awaiter instance. + + + Gets an awaiter used to await this . + Specifies the type of data returned by the task. + The task to await. + An awaiter instance. + + + Creates and configures an awaitable object for awaiting the specified task. + The task to be awaited. + + true to automatic marshag back to the original call site's current SynchronizationContext + or TaskScheduler; otherwise, false. + + The instance to be awaited. + + + Creates and configures an awaitable object for awaiting the specified task. + The task to be awaited. + + true to automatic marshag back to the original call site's current SynchronizationContext + or TaskScheduler; otherwise, false. + + The instance to be awaited. + + + Event handler for progress reports. + Specifies the type of data for the progress report. + The sender of the report. + The reported value. + + + + Provides an IProgress{T} that invokes callbacks for each reported progress value. + + Specifies the type of the progress report value. + + Any handler provided to the constructor or event handlers registered with + the event are invoked through a + instance captured + when the instance is constructed. If there is no current SynchronizationContext + at the time of construction, the callbacks will be invoked on the ThreadPool. + + + + The synchronization context captured upon construction. This will never be null. + + + The handler specified to the constructor. This may be null. + + + A cached delegate used to post invocation to the synchronization context. + + + Initializes the . + + + Initializes the with the specified callback. + + A handler to invoke for each reported progress value. This handler will be invoked + in addition to any delegates registered with the event. + + The is null (Nothing in Visual Basic). + + + Reports a progress change. + The value of the updated progress. + + + Reports a progress change. + The value of the updated progress. + + + Invokes the action and event callbacks. + The progress value. + + + Raised for each reported progress value. + + Handlers registered with this event will be invoked on the + captured when the instance was constructed. + + + + Holds static values for . + This avoids one static instance per type T. + + + A default synchronization context that targets the ThreadPool. + + + Throws the exception on the ThreadPool. + The exception to propagate. + The target context on which to propagate the exception. Null to use the ThreadPool. + + + Copies the exception's stack trace so its stack trace isn't overwritten. + The exception to prepare. + + + Provides an awaitable object that allows for configured awaits on . + This type is intended for compiler use only. + + + The task being awaited. + + + Initializes the . + The awaitable . + + true to attempt to marshal the continuation back to the original context captured; otherwise, false. + + + + Gets an awaiter for this awaitable. + The awaiter. + + + Provides an awaiter for a . + This type is intended for compiler use only. + + + The task being awaited. + + + Whether to attempt marshaling back to the original context. + + + Initializes the . + The to await. + + true to attempt to marshal the continuation back to the original context captured + when BeginAwait is called; otherwise, false. + + + + Schedules the continuation onto the associated with this . + The action to invoke when the await operation completes. + The argument is null (Nothing in Visual Basic). + The awaiter was not properly initialized. + This method is intended for compiler user rather than use directly in code. + + + Schedules the continuation onto the associated with this . + The action to invoke when the await operation completes. + The argument is null (Nothing in Visual Basic). + The awaiter was not properly initialized. + This method is intended for compiler user rather than use directly in code. + + + Ends the await on the completed . + The result of the completed . + The awaiter was not properly initialized. + The task was not yet completed. + The task was canceled. + The task completed in a Faulted state. + + + Gets whether the task being awaited is completed. + This property is intended for compiler user rather than use directly in code. + The awaiter was not properly initialized. + + + Provides an awaitable object that allows for configured awaits on . + This type is intended for compiler use only. + + + The underlying awaitable on whose logic this awaitable relies. + + + Initializes the . + The awaitable . + + true to attempt to marshal the continuation back to the original context captured; otherwise, false. + + + + Gets an awaiter for this awaitable. + The awaiter. + + + Provides an awaiter for a . + This type is intended for compiler use only. + + + The task being awaited. + + + Whether to attempt marshaling back to the original context. + + + Initializes the . + The awaitable . + + true to attempt to marshal the continuation back to the original context captured; otherwise, false. + + + + Schedules the continuation onto the associated with this . + The action to invoke when the await operation completes. + The argument is null (Nothing in Visual Basic). + The awaiter was not properly initialized. + This method is intended for compiler user rather than use directly in code. + + + Schedules the continuation onto the associated with this . + The action to invoke when the await operation completes. + The argument is null (Nothing in Visual Basic). + The awaiter was not properly initialized. + This method is intended for compiler user rather than use directly in code. + + + Ends the await on the completed . + The result of the completed . + The awaiter was not properly initialized. + The task was not yet completed. + The task was canceled. + The task completed in a Faulted state. + + + Gets whether the task being awaited is completed. + This property is intended for compiler user rather than use directly in code. + The awaiter was not properly initialized. + + + Provides an awaiter for awaiting a . + This type is intended for compiler use only. + + + The default value to use for continueOnCapturedContext. + + + Error message for GetAwaiter. + + + The task being awaited. + + + Initializes the . + The to be awaited. + + + Schedules the continuation onto the associated with this . + The action to invoke when the await operation completes. + The argument is null (Nothing in Visual Basic). + The awaiter was not properly initialized. + This method is intended for compiler user rather than use directly in code. + + + Schedules the continuation onto the associated with this . + The action to invoke when the await operation completes. + The argument is null (Nothing in Visual Basic). + The awaiter was not properly initialized. + This method is intended for compiler user rather than use directly in code. + + + Ends the await on the completed . + The awaiter was not properly initialized. + The task was not yet completed. + The task was canceled. + The task completed in a Faulted state. + + + + Fast checks for the end of an await operation to determine whether more needs to be done + prior to completing the await. + + The awaited task. + + + Handles validations on tasks that aren't successfully completed. + The awaited task. + + + Throws an exception to handle a task that completed in a state other than RanToCompletion. + + + Schedules the continuation onto the associated with this . + The awaited task. + The action to invoke when the await operation completes. + Whether to capture and marshal back to the current context. + The argument is null (Nothing in Visual Basic). + The awaiter was not properly initialized. + This method is intended for compiler user rather than use directly in code. + + + Invokes the delegate in a try/catch that will propagate the exception asynchronously on the ThreadPool. + + + + Copies the exception's stack trace so its stack trace isn't overwritten. + The exception to prepare. + + + Gets whether the task being awaited is completed. + This property is intended for compiler user rather than use directly in code. + The awaiter was not properly initialized. + + + Whether the current thread is appropriate for inlining the await continuation. + + + Provides an awaiter for awaiting a . + This type is intended for compiler use only. + + + The task being awaited. + + + Initializes the . + The to be awaited. + + + Schedules the continuation onto the associated with this . + The action to invoke when the await operation completes. + The argument is null (Nothing in Visual Basic). + The awaiter was not properly initialized. + This method is intended for compiler user rather than use directly in code. + + + Schedules the continuation onto the associated with this . + The action to invoke when the await operation completes. + The argument is null (Nothing in Visual Basic). + The awaiter was not properly initialized. + This method is intended for compiler user rather than use directly in code. + + + Ends the await on the completed . + The result of the completed . + The awaiter was not properly initialized. + The task was not yet completed. + The task was canceled. + The task completed in a Faulted state. + + + Gets whether the task being awaited is completed. + This property is intended for compiler user rather than use directly in code. + The awaiter was not properly initialized. + + + Provides an awaitable context for switching into a target environment. + This type is intended for compiler use only. + + + Gets an awaiter for this . + An awaiter for this awaitable. + This method is intended for compiler user rather than use directly in code. + + + Provides an awaiter that switches into a target environment. + This type is intended for compiler use only. + + + A completed task. + + + Posts the back to the current context. + The action to invoke asynchronously. + The awaiter was not properly initialized. + + + Posts the back to the current context. + The action to invoke asynchronously. + The awaiter was not properly initialized. + + + Ends the await operation. + + + Gets whether a yield is not required. + This property is intended for compiler user rather than use directly in code. + + + Provides methods for creating and manipulating tasks. + + + Creates a task that runs the specified action. + The action to execute asynchronously. + A task that represents the completion of the action. + The argument is null. + + + Creates a task that runs the specified action. + The action to execute. + The CancellationToken to use to request cancellation of this task. + A task that represents the completion of the action. + The argument is null. + + + Creates a task that runs the specified function. + The function to execute asynchronously. + A task that represents the completion of the action. + The argument is null. + + + Creates a task that runs the specified function. + The action to execute. + The CancellationToken to use to cancel the task. + A task that represents the completion of the action. + The argument is null. + + + Creates a task that runs the specified function. + The action to execute asynchronously. + A task that represents the completion of the action. + The argument is null. + + + Creates a task that runs the specified function. + The function to execute. + The CancellationToken to use to request cancellation of this task. + A task that represents the completion of the function. + The argument is null. + + + Creates a task that runs the specified function. + The function to execute asynchronously. + A task that represents the completion of the action. + The argument is null. + + + Creates a task that runs the specified function. + The action to execute. + The CancellationToken to use to cancel the task. + A task that represents the completion of the action. + The argument is null. + + + Starts a Task that will complete after the specified due time. + The delay in milliseconds before the returned task completes. + The timed Task. + + The argument must be non-negative or -1 and less than or equal to Int32.MaxValue. + + + + Starts a Task that will complete after the specified due time. + The delay before the returned task completes. + The timed Task. + + The argument must be non-negative or -1 and less than or equal to Int32.MaxValue. + + + + Starts a Task that will complete after the specified due time. + The delay before the returned task completes. + A CancellationToken that may be used to cancel the task before the due time occurs. + The timed Task. + + The argument must be non-negative or -1 and less than or equal to Int32.MaxValue. + + + + Starts a Task that will complete after the specified due time. + The delay in milliseconds before the returned task completes. + A CancellationToken that may be used to cancel the task before the due time occurs. + The timed Task. + + The argument must be non-negative or -1 and less than or equal to Int32.MaxValue. + + + + An already completed task. + + + Creates a Task that will complete only when all of the provided collection of Tasks has completed. + The Tasks to monitor for completion. + A Task that represents the completion of all of the provided tasks. + + If any of the provided Tasks faults, the returned Task will also fault, and its Exception will contain information + about all of the faulted tasks. If no Tasks fault but one or more Tasks is canceled, the returned + Task will also be canceled. + + The argument is null. + The argument contains a null reference. + + + Creates a Task that will complete only when all of the provided collection of Tasks has completed. + The Tasks to monitor for completion. + A Task that represents the completion of all of the provided tasks. + + If any of the provided Tasks faults, the returned Task will also fault, and its Exception will contain information + about all of the faulted tasks. If no Tasks fault but one or more Tasks is canceled, the returned + Task will also be canceled. + + The argument is null. + The argument contains a null reference. + + + Creates a Task that will complete only when all of the provided collection of Tasks has completed. + The Tasks to monitor for completion. + A Task that represents the completion of all of the provided tasks. + + If any of the provided Tasks faults, the returned Task will also fault, and its Exception will contain information + about all of the faulted tasks. If no Tasks fault but one or more Tasks is canceled, the returned + Task will also be canceled. + + The argument is null. + The argument contains a null reference. + + + Creates a Task that will complete only when all of the provided collection of Tasks has completed. + The Tasks to monitor for completion. + A Task that represents the completion of all of the provided tasks. + + If any of the provided Tasks faults, the returned Task will also fault, and its Exception will contain information + about all of the faulted tasks. If no Tasks fault but one or more Tasks is canceled, the returned + Task will also be canceled. + + The argument is null. + The argument contains a null reference. + + + Creates a Task that will complete only when all of the provided collection of Tasks has completed. + The Tasks to monitor for completion. + + A callback invoked when all of the tasks complete successfully in the RanToCompletion state. + This callback is responsible for storing the results into the TaskCompletionSource. + + A Task that represents the completion of all of the provided tasks. + The argument is null. + The argument contains a null reference. + + + Creates a Task that will complete when any of the tasks in the provided collection completes. + The Tasks to be monitored. + + A Task that represents the completion of any of the provided Tasks. The completed Task is this Task's result. + + Any Tasks that fault will need to have their exceptions observed elsewhere. + The argument is null. + The argument contains a null reference. + + + Creates a Task that will complete when any of the tasks in the provided collection completes. + The Tasks to be monitored. + + A Task that represents the completion of any of the provided Tasks. The completed Task is this Task's result. + + Any Tasks that fault will need to have their exceptions observed elsewhere. + The argument is null. + The argument contains a null reference. + + + Creates a Task that will complete when any of the tasks in the provided collection completes. + The Tasks to be monitored. + + A Task that represents the completion of any of the provided Tasks. The completed Task is this Task's result. + + Any Tasks that fault will need to have their exceptions observed elsewhere. + The argument is null. + The argument contains a null reference. + + + Creates a Task that will complete when any of the tasks in the provided collection completes. + The Tasks to be monitored. + + A Task that represents the completion of any of the provided Tasks. The completed Task is this Task's result. + + Any Tasks that fault will need to have their exceptions observed elsewhere. + The argument is null. + The argument contains a null reference. + + + Creates an already completed from the specified result. + The result from which to create the completed task. + The completed task. + + + Creates an awaitable that asynchronously yields back to the current context when awaited. + + A context that, when awaited, will asynchronously transition back into the current context. + If SynchronizationContext.Current is non-null, that is treated as the current context. + Otherwise, TaskScheduler.Current is treated as the current context. + + + + Adds the target exception to the list, initializing the list if it's null. + The list to which to add the exception and initialize if the list is null. + The exception to add, and unwrap if it's an aggregate. + + + Returns a canceled task. + The cancellation token. + The canceled task. + + + Returns a canceled task. + Specifies the type of the result. + The cancellation token. + The canceled task. + + + + Completes the Task if the user state matches the TaskCompletionSource. + + Specifies the type of data returned by the Task. + The TaskCompletionSource. + The completion event arguments. + Whether we require the tcs to match the e.UserState. + A function that gets the result with which to complete the task. + An action used to unregister work when the operaiton completes. + + + diff --git a/src/packages/Microsoft.Bcl.Async.1.0.168/lib/wpa81/Microsoft.Threading.Tasks.Extensions.dll b/src/packages/Microsoft.Bcl.Async.1.0.168/lib/wpa81/Microsoft.Threading.Tasks.Extensions.dll new file mode 100644 index 0000000000000000000000000000000000000000..4d862e1730a34a6a5cfa39d04840bd039cf9de29 GIT binary patch literal 31520 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 literal 0 HcmV?d00001 diff --git a/src/packages/Microsoft.Bcl.Async.1.0.168/lib/wpa81/Microsoft.Threading.Tasks.Extensions.xml b/src/packages/Microsoft.Bcl.Async.1.0.168/lib/wpa81/Microsoft.Threading.Tasks.Extensions.xml new file mode 100644 index 00000000..af646a2d --- /dev/null +++ b/src/packages/Microsoft.Bcl.Async.1.0.168/lib/wpa81/Microsoft.Threading.Tasks.Extensions.xml @@ -0,0 +1,275 @@ + + + + Microsoft.Threading.Tasks.Extensions + + + + Returns a canceled task. + The cancellation token. + The canceled task. + + + Returns a canceled task. + Specifies the type of the result. + The cancellation token. + The canceled task. + + + + Completes the Task if the user state matches the TaskCompletionSource. + + Specifies the type of data returned by the Task. + The TaskCompletionSource. + The completion event arguments. + Whether we require the tcs to match the e.UserState. + A function that gets the result with which to complete the task. + An action used to unregister work when the operaiton completes. + + + + Provides asynchronous wrappers for .NET Framework operations. + + + + + Reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read. + + A Task that represents the asynchronous read. + The source. + The buffer to read data into. + The byte offset in at which to begin reading. + The maximum number of bytes to read. + The array length minus is less than . + is null. + or is negative. + An asynchronous read was attempted past the end of the file. + + + + Reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read. + + A Task that represents the asynchronous read. + The source. + The buffer to read data into. + The byte offset in at which to begin reading. + The maximum number of bytes to read. + The cancellation token. + The array length minus is less than . + is null. + or is negative. + An asynchronous read was attempted past the end of the file. + + + + Writes asynchronously a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written. + + A Task that represents the asynchronous write. + The source. + The buffer containing data to write to the current stream. + The zero-based byte offset in at which to begin copying bytes to the current stream. + The maximum number of bytes to write. + length minus is less than . + is null. + or is negative. + The stream does not support writing. + The stream is closed. + An I/O error occurred. + + + + Writes asynchronously a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written. + + A Task that represents the asynchronous write. + The source. + The buffer containing data to write to the current stream. + The zero-based byte offset in at which to begin copying bytes to the current stream. + The maximum number of bytes to write. + The cancellation token. + length minus is less than . + is null. + or is negative. + The stream does not support writing. + The stream is closed. + An I/O error occurred. + + + + Flushes asynchronously the current stream. + + A Task that represents the asynchronous flush. + + + + Flushes asynchronously the current stream. + + A Task that represents the asynchronous flush. + + + + Reads all the bytes from the current stream and writes them to the destination stream. + + The source stream. + The stream that will contain the contents of the current stream. + A Task that represents the asynchronous operation. + + + + Reads all the bytes from the current stream and writes them to the destination stream. + + The source stream. + The stream that will contain the contents of the current stream. + The size of the buffer. This value must be greater than zero. The default size is 4096. + A Task that represents the asynchronous operation. + + + + Reads all the bytes from the current stream and writes them to the destination stream. + + The source stream. + The stream that will contain the contents of the current stream. + The size of the buffer. This value must be greater than zero. The default size is 4096. + The cancellation token to use to cancel the asynchronous operation. + A Task that represents the asynchronous operation. + + + + Reads all the bytes from the current stream and writes them to the destination stream. + + The source stream. + The stream that will contain the contents of the current stream. + The size of the buffer. This value must be greater than zero. The default size is 4096. + The cancellation token to use to cancel the asynchronous operation. + A Task that represents the asynchronous operation. + + + + Reads a maximum of count characters from the reader asynchronously and writes + the data to buffer, beginning at index. + + + When the operation completes, contains the specified character array with the + values between index and (index + count - 1) replaced by the characters read + from the current source. + + + The maximum number of characters to read. If the end of the stream is reached + before count of characters is read into buffer, the current method returns. + + The place in buffer at which to begin writing. + the source reader. + A Task that represents the asynchronous operation. + + + + Reads asynchronously a maximum of count characters from the current stream, and writes the + data to buffer, beginning at index. + + The source reader. + + When this method returns, this parameter contains the specified character + array with the values between index and (index + count -1) replaced by the + characters read from the current source. + + The position in buffer at which to begin writing. + The maximum number of characters to read. + A Task that represents the asynchronous operation. + + + + Reads a line of characters from the reader and returns the string asynchronously. + + the source reader. + A Task that represents the asynchronous operation. + + + + Reads all characters from the current position to the end of the TextReader + and returns them as one string asynchronously. + + the source reader. + A Task that represents the asynchronous operation. + + + Writes a string asynchronously to a text stream. + The writer. + The string to write. + A Task representing the asynchronous write. + + + Writes a char asynchronously to a text stream. + The writer. + The char to write. + A Task representing the asynchronous write. + + + Writes a char array asynchronously to a text stream. + The writer. + The buffer to write. + A Task representing the asynchronous write. + + + Writes a subarray of characters asynchronously to a text stream. + The writer. + The buffer to write. + Starting index in the buffer. + The number of characters to write. + A Task representing the asynchronous write. + + + Writes a line terminator asynchronously to a text stream. + The writer. + A Task representing the asynchronous write. + + + Writes a string followed by a line terminator asynchronously to a text stream. + The writer. + The string to write. + A Task representing the asynchronous write. + + + Writes a char followed by a line terminator asynchronously to a text stream. + The writer. + The char to write. + A Task representing the asynchronous write. + + + Writes a char array followed by a line terminator asynchronously to a text stream. + The writer. + The buffer to write. + A Task representing the asynchronous write. + + + Writes a subarray of characters followed by a line terminator asynchronously to a text stream. + The writer. + The buffer to write. + Starting index in the buffer. + The number of characters to write. + A Task representing the asynchronous write. + + + + Clears all buffers for the current writer and causes any buffered data to + be written to the underlying device. + + The writer. + A Task representing the asynchronous flush. + + + Starts an asynchronous request for a web resource. + Task that represents the asynchronous request. + The stream is already in use by a previous call to . + + The source. + + + Starts an asynchronous request for a object to use to write data. + Task that represents the asynchronous request. + The property is GET and the application writes to the stream. + The stream is being used by a previous call to . + No write stream is available. + + The source. + + + diff --git a/src/packages/Microsoft.Bcl.Async.1.0.168/lib/wpa81/Microsoft.Threading.Tasks.dll b/src/packages/Microsoft.Bcl.Async.1.0.168/lib/wpa81/Microsoft.Threading.Tasks.dll new file mode 100644 index 0000000000000000000000000000000000000000..8438577c2042e5d6899425d500bf8074aae650a1 GIT binary patch literal 37104 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 literal 0 HcmV?d00001 diff --git a/src/packages/Microsoft.Bcl.Async.1.0.168/lib/wpa81/Microsoft.Threading.Tasks.xml b/src/packages/Microsoft.Bcl.Async.1.0.168/lib/wpa81/Microsoft.Threading.Tasks.xml new file mode 100644 index 00000000..5c22030d --- /dev/null +++ b/src/packages/Microsoft.Bcl.Async.1.0.168/lib/wpa81/Microsoft.Threading.Tasks.xml @@ -0,0 +1,630 @@ + + + + Microsoft.Threading.Tasks + + + + + Provides extension methods for threading-related types. + + + + Cancels the after the specified duration. + The CancellationTokenSource. + The due time in milliseconds for the source to be canceled. + + + Cancels the after the specified duration. + The CancellationTokenSource. + The due time for the source to be canceled. + + + Gets an awaiter used to await this . + The task to await. + An awaiter instance. + + + Gets an awaiter used to await this . + Specifies the type of data returned by the task. + The task to await. + An awaiter instance. + + + Creates and configures an awaitable object for awaiting the specified task. + The task to be awaited. + + true to automatic marshag back to the original call site's current SynchronizationContext + or TaskScheduler; otherwise, false. + + The instance to be awaited. + + + Creates and configures an awaitable object for awaiting the specified task. + The task to be awaited. + + true to automatic marshag back to the original call site's current SynchronizationContext + or TaskScheduler; otherwise, false. + + The instance to be awaited. + + + Event handler for progress reports. + Specifies the type of data for the progress report. + The sender of the report. + The reported value. + + + + Provides an IProgress{T} that invokes callbacks for each reported progress value. + + Specifies the type of the progress report value. + + Any handler provided to the constructor or event handlers registered with + the event are invoked through a + instance captured + when the instance is constructed. If there is no current SynchronizationContext + at the time of construction, the callbacks will be invoked on the ThreadPool. + + + + The synchronization context captured upon construction. This will never be null. + + + The handler specified to the constructor. This may be null. + + + A cached delegate used to post invocation to the synchronization context. + + + Initializes the . + + + Initializes the with the specified callback. + + A handler to invoke for each reported progress value. This handler will be invoked + in addition to any delegates registered with the event. + + The is null (Nothing in Visual Basic). + + + Reports a progress change. + The value of the updated progress. + + + Reports a progress change. + The value of the updated progress. + + + Invokes the action and event callbacks. + The progress value. + + + Raised for each reported progress value. + + Handlers registered with this event will be invoked on the + captured when the instance was constructed. + + + + Holds static values for . + This avoids one static instance per type T. + + + A default synchronization context that targets the ThreadPool. + + + Throws the exception on the ThreadPool. + The exception to propagate. + The target context on which to propagate the exception. Null to use the ThreadPool. + + + Copies the exception's stack trace so its stack trace isn't overwritten. + The exception to prepare. + + + Provides an awaitable object that allows for configured awaits on . + This type is intended for compiler use only. + + + The task being awaited. + + + Initializes the . + The awaitable . + + true to attempt to marshal the continuation back to the original context captured; otherwise, false. + + + + Gets an awaiter for this awaitable. + The awaiter. + + + Provides an awaiter for a . + This type is intended for compiler use only. + + + The task being awaited. + + + Whether to attempt marshaling back to the original context. + + + Initializes the . + The to await. + + true to attempt to marshal the continuation back to the original context captured + when BeginAwait is called; otherwise, false. + + + + Schedules the continuation onto the associated with this . + The action to invoke when the await operation completes. + The argument is null (Nothing in Visual Basic). + The awaiter was not properly initialized. + This method is intended for compiler user rather than use directly in code. + + + Schedules the continuation onto the associated with this . + The action to invoke when the await operation completes. + The argument is null (Nothing in Visual Basic). + The awaiter was not properly initialized. + This method is intended for compiler user rather than use directly in code. + + + Ends the await on the completed . + The result of the completed . + The awaiter was not properly initialized. + The task was not yet completed. + The task was canceled. + The task completed in a Faulted state. + + + Gets whether the task being awaited is completed. + This property is intended for compiler user rather than use directly in code. + The awaiter was not properly initialized. + + + Provides an awaitable object that allows for configured awaits on . + This type is intended for compiler use only. + + + The underlying awaitable on whose logic this awaitable relies. + + + Initializes the . + The awaitable . + + true to attempt to marshal the continuation back to the original context captured; otherwise, false. + + + + Gets an awaiter for this awaitable. + The awaiter. + + + Provides an awaiter for a . + This type is intended for compiler use only. + + + The task being awaited. + + + Whether to attempt marshaling back to the original context. + + + Initializes the . + The awaitable . + + true to attempt to marshal the continuation back to the original context captured; otherwise, false. + + + + Schedules the continuation onto the associated with this . + The action to invoke when the await operation completes. + The argument is null (Nothing in Visual Basic). + The awaiter was not properly initialized. + This method is intended for compiler user rather than use directly in code. + + + Schedules the continuation onto the associated with this . + The action to invoke when the await operation completes. + The argument is null (Nothing in Visual Basic). + The awaiter was not properly initialized. + This method is intended for compiler user rather than use directly in code. + + + Ends the await on the completed . + The result of the completed . + The awaiter was not properly initialized. + The task was not yet completed. + The task was canceled. + The task completed in a Faulted state. + + + Gets whether the task being awaited is completed. + This property is intended for compiler user rather than use directly in code. + The awaiter was not properly initialized. + + + Provides an awaiter for awaiting a . + This type is intended for compiler use only. + + + The default value to use for continueOnCapturedContext. + + + Error message for GetAwaiter. + + + The task being awaited. + + + Initializes the . + The to be awaited. + + + Schedules the continuation onto the associated with this . + The action to invoke when the await operation completes. + The argument is null (Nothing in Visual Basic). + The awaiter was not properly initialized. + This method is intended for compiler user rather than use directly in code. + + + Schedules the continuation onto the associated with this . + The action to invoke when the await operation completes. + The argument is null (Nothing in Visual Basic). + The awaiter was not properly initialized. + This method is intended for compiler user rather than use directly in code. + + + Ends the await on the completed . + The awaiter was not properly initialized. + The task was not yet completed. + The task was canceled. + The task completed in a Faulted state. + + + + Fast checks for the end of an await operation to determine whether more needs to be done + prior to completing the await. + + The awaited task. + + + Handles validations on tasks that aren't successfully completed. + The awaited task. + + + Throws an exception to handle a task that completed in a state other than RanToCompletion. + + + Schedules the continuation onto the associated with this . + The awaited task. + The action to invoke when the await operation completes. + Whether to capture and marshal back to the current context. + The argument is null (Nothing in Visual Basic). + The awaiter was not properly initialized. + This method is intended for compiler user rather than use directly in code. + + + Invokes the delegate in a try/catch that will propagate the exception asynchronously on the ThreadPool. + + + + Copies the exception's stack trace so its stack trace isn't overwritten. + The exception to prepare. + + + Gets whether the task being awaited is completed. + This property is intended for compiler user rather than use directly in code. + The awaiter was not properly initialized. + + + Whether the current thread is appropriate for inlining the await continuation. + + + Provides an awaiter for awaiting a . + This type is intended for compiler use only. + + + The task being awaited. + + + Initializes the . + The to be awaited. + + + Schedules the continuation onto the associated with this . + The action to invoke when the await operation completes. + The argument is null (Nothing in Visual Basic). + The awaiter was not properly initialized. + This method is intended for compiler user rather than use directly in code. + + + Schedules the continuation onto the associated with this . + The action to invoke when the await operation completes. + The argument is null (Nothing in Visual Basic). + The awaiter was not properly initialized. + This method is intended for compiler user rather than use directly in code. + + + Ends the await on the completed . + The result of the completed . + The awaiter was not properly initialized. + The task was not yet completed. + The task was canceled. + The task completed in a Faulted state. + + + Gets whether the task being awaited is completed. + This property is intended for compiler user rather than use directly in code. + The awaiter was not properly initialized. + + + Provides an awaitable context for switching into a target environment. + This type is intended for compiler use only. + + + Gets an awaiter for this . + An awaiter for this awaitable. + This method is intended for compiler user rather than use directly in code. + + + Provides an awaiter that switches into a target environment. + This type is intended for compiler use only. + + + A completed task. + + + Posts the back to the current context. + The action to invoke asynchronously. + The awaiter was not properly initialized. + + + Posts the back to the current context. + The action to invoke asynchronously. + The awaiter was not properly initialized. + + + Ends the await operation. + + + Gets whether a yield is not required. + This property is intended for compiler user rather than use directly in code. + + + Provides methods for creating and manipulating tasks. + + + Creates a task that runs the specified action. + The action to execute asynchronously. + A task that represents the completion of the action. + The argument is null. + + + Creates a task that runs the specified action. + The action to execute. + The CancellationToken to use to request cancellation of this task. + A task that represents the completion of the action. + The argument is null. + + + Creates a task that runs the specified function. + The function to execute asynchronously. + A task that represents the completion of the action. + The argument is null. + + + Creates a task that runs the specified function. + The action to execute. + The CancellationToken to use to cancel the task. + A task that represents the completion of the action. + The argument is null. + + + Creates a task that runs the specified function. + The action to execute asynchronously. + A task that represents the completion of the action. + The argument is null. + + + Creates a task that runs the specified function. + The function to execute. + The CancellationToken to use to request cancellation of this task. + A task that represents the completion of the function. + The argument is null. + + + Creates a task that runs the specified function. + The function to execute asynchronously. + A task that represents the completion of the action. + The argument is null. + + + Creates a task that runs the specified function. + The action to execute. + The CancellationToken to use to cancel the task. + A task that represents the completion of the action. + The argument is null. + + + Starts a Task that will complete after the specified due time. + The delay in milliseconds before the returned task completes. + The timed Task. + + The argument must be non-negative or -1 and less than or equal to Int32.MaxValue. + + + + Starts a Task that will complete after the specified due time. + The delay before the returned task completes. + The timed Task. + + The argument must be non-negative or -1 and less than or equal to Int32.MaxValue. + + + + Starts a Task that will complete after the specified due time. + The delay before the returned task completes. + A CancellationToken that may be used to cancel the task before the due time occurs. + The timed Task. + + The argument must be non-negative or -1 and less than or equal to Int32.MaxValue. + + + + Starts a Task that will complete after the specified due time. + The delay in milliseconds before the returned task completes. + A CancellationToken that may be used to cancel the task before the due time occurs. + The timed Task. + + The argument must be non-negative or -1 and less than or equal to Int32.MaxValue. + + + + An already completed task. + + + Creates a Task that will complete only when all of the provided collection of Tasks has completed. + The Tasks to monitor for completion. + A Task that represents the completion of all of the provided tasks. + + If any of the provided Tasks faults, the returned Task will also fault, and its Exception will contain information + about all of the faulted tasks. If no Tasks fault but one or more Tasks is canceled, the returned + Task will also be canceled. + + The argument is null. + The argument contains a null reference. + + + Creates a Task that will complete only when all of the provided collection of Tasks has completed. + The Tasks to monitor for completion. + A Task that represents the completion of all of the provided tasks. + + If any of the provided Tasks faults, the returned Task will also fault, and its Exception will contain information + about all of the faulted tasks. If no Tasks fault but one or more Tasks is canceled, the returned + Task will also be canceled. + + The argument is null. + The argument contains a null reference. + + + Creates a Task that will complete only when all of the provided collection of Tasks has completed. + The Tasks to monitor for completion. + A Task that represents the completion of all of the provided tasks. + + If any of the provided Tasks faults, the returned Task will also fault, and its Exception will contain information + about all of the faulted tasks. If no Tasks fault but one or more Tasks is canceled, the returned + Task will also be canceled. + + The argument is null. + The argument contains a null reference. + + + Creates a Task that will complete only when all of the provided collection of Tasks has completed. + The Tasks to monitor for completion. + A Task that represents the completion of all of the provided tasks. + + If any of the provided Tasks faults, the returned Task will also fault, and its Exception will contain information + about all of the faulted tasks. If no Tasks fault but one or more Tasks is canceled, the returned + Task will also be canceled. + + The argument is null. + The argument contains a null reference. + + + Creates a Task that will complete only when all of the provided collection of Tasks has completed. + The Tasks to monitor for completion. + + A callback invoked when all of the tasks complete successfully in the RanToCompletion state. + This callback is responsible for storing the results into the TaskCompletionSource. + + A Task that represents the completion of all of the provided tasks. + The argument is null. + The argument contains a null reference. + + + Creates a Task that will complete when any of the tasks in the provided collection completes. + The Tasks to be monitored. + + A Task that represents the completion of any of the provided Tasks. The completed Task is this Task's result. + + Any Tasks that fault will need to have their exceptions observed elsewhere. + The argument is null. + The argument contains a null reference. + + + Creates a Task that will complete when any of the tasks in the provided collection completes. + The Tasks to be monitored. + + A Task that represents the completion of any of the provided Tasks. The completed Task is this Task's result. + + Any Tasks that fault will need to have their exceptions observed elsewhere. + The argument is null. + The argument contains a null reference. + + + Creates a Task that will complete when any of the tasks in the provided collection completes. + The Tasks to be monitored. + + A Task that represents the completion of any of the provided Tasks. The completed Task is this Task's result. + + Any Tasks that fault will need to have their exceptions observed elsewhere. + The argument is null. + The argument contains a null reference. + + + Creates a Task that will complete when any of the tasks in the provided collection completes. + The Tasks to be monitored. + + A Task that represents the completion of any of the provided Tasks. The completed Task is this Task's result. + + Any Tasks that fault will need to have their exceptions observed elsewhere. + The argument is null. + The argument contains a null reference. + + + Creates an already completed from the specified result. + The result from which to create the completed task. + The completed task. + + + Creates an awaitable that asynchronously yields back to the current context when awaited. + + A context that, when awaited, will asynchronously transition back into the current context. + If SynchronizationContext.Current is non-null, that is treated as the current context. + Otherwise, TaskScheduler.Current is treated as the current context. + + + + Adds the target exception to the list, initializing the list if it's null. + The list to which to add the exception and initialize if the list is null. + The exception to add, and unwrap if it's an aggregate. + + + Returns a canceled task. + The cancellation token. + The canceled task. + + + Returns a canceled task. + Specifies the type of the result. + The cancellation token. + The canceled task. + + + + Completes the Task if the user state matches the TaskCompletionSource. + + Specifies the type of data returned by the Task. + The TaskCompletionSource. + The completion event arguments. + Whether we require the tcs to match the e.UserState. + A function that gets the result with which to complete the task. + An action used to unregister work when the operaiton completes. + + + diff --git a/src/packages/Microsoft.Bcl.Build.1.0.14/License-Stable.rtf b/src/packages/Microsoft.Bcl.Build.1.0.14/License-Stable.rtf new file mode 100644 index 00000000..3aec6b65 --- /dev/null +++ b/src/packages/Microsoft.Bcl.Build.1.0.14/License-Stable.rtf @@ -0,0 +1,118 @@ +{\rtf1\ansi\ansicpg1252\deff0\nouicompat\deflang1033{\fonttbl{\f0\fswiss\fprq2\fcharset0 Tahoma;}{\f1\froman\fprq2\fcharset0 Times New Roman;}{\f2\fswiss\fprq2\fcharset0 Calibri;}{\f3\fnil\fcharset0 Calibri;}{\f4\fnil\fcharset2 Symbol;}} +{\colortbl ;\red31\green73\blue125;\red0\green0\blue255;} +{\*\listtable +{\list\listhybrid +{\listlevel\levelnfc0\leveljc0\levelstartat1{\leveltext\'02\'00.;}{\levelnumbers\'01;}\jclisttab\tx360} +{\listlevel\levelnfc4\leveljc0\levelstartat1{\leveltext\'02\'01.;}{\levelnumbers\'01;}\jclisttab\tx363} +{\listlevel\levelnfc2\leveljc0\levelstartat1{\leveltext\'02\'02.;}{\levelnumbers\'01;}\jclisttab\tx720}\listid1 } +{\list\listhybrid +{\listlevel\levelnfc0\leveljc0\levelstartat1{\leveltext\'02\'00.;}{\levelnumbers\'01;}\jclisttab\tx363} +{\listlevel\levelnfc4\leveljc0\levelstartat1{\leveltext\'02\'01.;}{\levelnumbers\'01;}\jclisttab\tx363}\listid2 }} +{\*\listoverridetable{\listoverride\listid1\listoverridecount0\ls1}{\listoverride\listid2\listoverridecount0\ls2}} +{\stylesheet{ Normal;}{\s1 heading 1;}{\s2 heading 2;}{\s3 heading 3;}} +{\*\generator Riched20 6.2.9200}\viewkind4\uc1 +\pard\nowidctlpar\sb120\sa120\b\f0\fs24 MICROSOFT SOFTWARE LICENSE TERMS\par + +\pard\brdrb\brdrs\brdrw10\brsp20 \nowidctlpar\sb120\sa120 MICROSOFT .NET LIBRARY \par + +\pard\nowidctlpar\sb120\sa120\fs19 These license terms are an agreement between Microsoft Corporation (or based on where you live, one of its affiliates) and you. Please read them. They apply to the software named above, which includes the media on which you received it, if any. The terms also apply to any Microsoft\par + +\pard{\pntext\f4\'B7\tab}{\*\pn\pnlvlblt\pnf4\pnindent363{\pntxtb\'B7}}\nowidctlpar\fi-363\li720\sb120\sa120\b0 updates,\par +{\pntext\f4\'B7\tab}supplements,\par +{\pntext\f4\'B7\tab}Internet-based services, and\par +{\pntext\f4\'B7\tab}support services\par + +\pard\nowidctlpar\sb120\sa120\b for this software, unless other terms accompany those items. If so, those terms apply.\par +BY USING THE SOFTWARE, YOU ACCEPT THESE TERMS. IF YOU DO NOT ACCEPT THEM, DO NOT USE THE SOFTWARE.\par + +\pard\brdrt\brdrs\brdrw10\brsp20 \nowidctlpar\sb120\sa120 IF YOU COMPLY WITH THESE LICENSE TERMS, YOU HAVE THE PERPETUAL RIGHTS BELOW.\par + +\pard +{\listtext\f0 1.\tab}\jclisttab\tx360\ls1\nowidctlpar\s1\fi-357\li357\sb120\sa120 INSTALLATION AND USE RIGHTS. \par + +\pard +{\listtext\f0 a.\tab}\jclisttab\tx363\ls1\ilvl1\nowidctlpar\s2\fi-363\li720\sb120\sa120 Installation and Use.\b0\fs20 You may install and use any number of copies of the software to design, develop and test your programs.\par +{\listtext\f0 b.\tab}\b\fs19 Third Party Programs.\b0\fs20 The software may include third party programs that Microsoft, not the third party, licenses to you under this agreement. Notices, if any, for the third party program are included for your information only.\b\fs19\par + +\pard +{\listtext\f0 2.\tab}\jclisttab\tx360\ls1\nowidctlpar\s1\fi-357\li357\sb120\sa120\fs20 ADDITIONAL LICENSING REQUIREMENTS AND/OR USE RIGHTS.\par + +\pard +{\listtext\f0 a.\tab}\jclisttab\tx363\ls1\ilvl1\nowidctlpar\s2\fi-363\li720\sb120\sa120 DISTRIBUTABLE CODE.\~ \b0 The software is comprised of Distributable Code. \f1\ldblquote\f0 Distributable Code\f1\rdblquote\f0 is code that you are permitted to distribute in programs you develop if you comply with the terms below.\b\par + +\pard +{\listtext\f0 i.\tab}\jclisttab\tx720\ls1\ilvl2\nowidctlpar\s3\fi-357\li1077\sb120\sa120\tx1077 Right to Use and Distribute. \par + +\pard{\pntext\f4\'B7\tab}{\*\pn\pnlvlblt\pnf4\pnindent360{\pntxtb\'B7}}\nowidctlpar\fi-357\li1434\sb120\sa120\b0 You may copy and distribute the object code form of the software.\par +{\pntext\f4\'B7\tab}Third Party Distribution. You may permit distributors of your programs to copy and distribute the Distributable Code as part of those programs.\par + +\pard\nowidctlpar\s3\fi-357\li1077\sb120\sa120\tx1077\b ii.\tab Distribution Requirements.\b0 \b For any Distributable Code you distribute, you must\par + +\pard{\pntext\f4\'B7\tab}{\*\pn\pnlvlblt\pnf4\pnindent360{\pntxtb\'B7}}\nowidctlpar\fi-357\li1434\sb120\sa120\b0 add significant primary functionality to it in your programs;\par +{\pntext\f4\'B7\tab}require distributors and external end users to agree to terms that protect it at least as much as this agreement;\par +{\pntext\f4\'B7\tab}display your valid copyright notice on your programs; and\par +{\pntext\f4\'B7\tab}indemnify, defend, and hold harmless Microsoft from any claims, including attorneys\rquote fees, related to the distribution or use of your programs.\par + +\pard\nowidctlpar\s3\fi-357\li1077\sb120\sa120\tx1077\b iii.\tab Distribution Restrictions.\b0 \b You may not\par + +\pard{\pntext\f4\'B7\tab}{\*\pn\pnlvlblt\pnf4\pnindent360{\pntxtb\'B7}}\nowidctlpar\fi-357\li1434\sb120\sa120\b0 alter any copyright, trademark or patent notice in the Distributable Code;\par +{\pntext\f4\'B7\tab}use Microsoft\rquote s trademarks in your programs\rquote names or in a way that suggests your programs come from or are endorsed by Microsoft;\par +{\pntext\f4\'B7\tab}include Distributable Code in malicious, deceptive or unlawful programs; or\par +{\pntext\f4\'B7\tab}modify or distribute the source code of any Distributable Code so that any part of it becomes subject to an Excluded License. An Excluded License is one that requires, as a condition of use, modification or distribution, that\par + +\pard{\pntext\f4\'B7\tab}{\*\pn\pnlvlblt\pnf4\pnindent360{\pntxtb\'B7}}\nowidctlpar\fi-358\li1792\sb120\sa120 the code be disclosed or distributed in source code form; or\cf1\f2\par +{\pntext\f4\'B7\tab}\cf0\f0 others have the right to modify it.\cf1\f2\par + +\pard\nowidctlpar\s1\fi-357\li357\sb120\sa120\cf0\b\f0 3.\tab\fs19 SCOPE OF LICENSE. \b0 The software is licensed, not sold. This agreement only gives you some rights to use the software. Microsoft reserves all other rights. Unless applicable law gives you more rights despite this limitation, you may use the software only as expressly permitted in this agreement. In doing so, you must comply with any technical limitations in the software that only allow you to use it in certain ways. You may not\par + +\pard{\pntext\f4\'B7\tab}{\*\pn\pnlvlblt\pnf4\pnindent363{\pntxtb\'B7}}\nowidctlpar\fi-363\li720\sb120\sa120 work around any technical limitations in the software;\par +{\pntext\f4\'B7\tab}reverse engineer, decompile or disassemble the software, except and only to the extent that applicable law expressly permits, despite this limitation;\par +{\pntext\f4\'B7\tab}publish the software for others to copy;\par +{\pntext\f4\'B7\tab}rent, lease or lend the software;\par +{\pntext\f4\'B7\tab}transfer the software or this agreement to any third party; or\par +{\pntext\f4\'B7\tab}use the software for commercial software hosting services.\par + +\pard\nowidctlpar\s1\fi-357\li357\sb120\sa120\b\fs20 4.\tab\fs19 BACKUP COPY. \b0 You may make one backup copy of the software. You may use it only to reinstall the software.\par +\b\fs20 5.\tab\fs19 DOCUMENTATION. \b0 Any person that has valid access to your computer or internal network may copy and use the documentation for your internal, reference purposes.\par +\b\fs20 6.\tab\fs19 EXPORT RESTRICTIONS. \b0 The software is subject to United States export laws and regulations. You must comply with all domestic and international export laws and regulations that apply to the software. These laws include restrictions on destinations, end users and end use. For additional information, see {\cf2\ul\fs20{\field{\*\fldinst{HYPERLINK www.microsoft.com/exporting }}{\fldrslt{www.microsoft.com/exporting}}}}\f0\fs19 .\cf2\ul\fs20\par +\cf0\ulnone\b 7.\tab\fs19 SUPPORT SERVICES. \b0 Because this software is \ldblquote as is,\rdblquote we may not provide support services for it.\par +\b\fs20 8.\tab\fs19 ENTIRE AGREEMENT. \b0 This agreement, and the terms for supplements, updates, Internet-based services and support services that you use, are the entire agreement for the software and support services.\par +\b\fs20 9.\tab\fs19 APPLICABLE LAW.\par + +\pard +{\listtext\f0 a.\tab}\jclisttab\tx363\ls2\ilvl1\nowidctlpar\s2\fi-363\li720\sb120\sa120 United States. \b0 If you acquired the software in the United States, Washington state law governs the interpretation of this agreement and applies to claims for breach of it, regardless of conflict of laws principles. The laws of the state where you live govern all other claims, including claims under state consumer protection laws, unfair competition laws, and in tort.\par +{\listtext\f0 b.\tab}\b Outside the United States. If you acquired the software in any other country, the laws of that country apply.\par + +\pard\nowidctlpar\s1\fi-357\li357\sb120\sa120\fs20 10.\tab\fs19 LEGAL EFFECT. \b0 This agreement describes certain legal rights. You may have other rights under the laws of your country. You may also have rights with respect to the party from whom you acquired the software. This agreement does not change your rights under the laws of your country if the laws of your country do not permit it to do so.\par +\b\fs20 11.\tab\fs19 DISCLAIMER OF WARRANTY. THE SOFTWARE IS LICENSED \ldblquote AS-IS.\rdblquote YOU BEAR THE RISK OF USING IT. MICROSOFT GIVES NO EXPRESS WARRANTIES, GUARANTEES OR CONDITIONS. YOU MAY HAVE ADDITIONAL CONSUMER RIGHTS OR STATUTORY GUARANTEES UNDER YOUR LOCAL LAWS WHICH THIS AGREEMENT CANNOT CHANGE. TO THE EXTENT PERMITTED UNDER YOUR LOCAL LAWS, MICROSOFT EXCLUDES THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.\par + +\pard\nowidctlpar\li357\sb120\sa120 FOR AUSTRALIA \endash YOU HAVE STATUTORY GUARANTEES UNDER THE AUSTRALIAN CONSUMER LAW AND NOTHING IN THESE TERMS IS INTENDED TO AFFECT THOSE RIGHTS.\par + +\pard\nowidctlpar\s1\fi-357\li357\sb120\sa120\fs20 12.\tab\fs19 LIMITATION ON AND EXCLUSION OF REMEDIES AND DAMAGES. YOU CAN RECOVER FROM MICROSOFT AND ITS SUPPLIERS ONLY DIRECT DAMAGES UP TO U.S. $5.00. YOU CANNOT RECOVER ANY OTHER DAMAGES, INCLUDING CONSEQUENTIAL, LOST PROFITS, SPECIAL, INDIRECT OR INCIDENTAL DAMAGES.\par + +\pard\nowidctlpar\li357\sb120\sa120\b0 This limitation applies to\par + +\pard{\pntext\f4\'B7\tab}{\*\pn\pnlvlblt\pnf4\pnindent363{\pntxtb\'B7}}\nowidctlpar\fi-363\li720\sb120\sa120 anything related to the software, services, content (including code) on third party Internet sites, or third party programs; and\par +{\pntext\f4\'B7\tab}claims for breach of contract, breach of warranty, guarantee or condition, strict liability, negligence, or other tort to the extent permitted by applicable law.\par + +\pard\nowidctlpar\sb120\sa120 It also applies even if Microsoft knew or should have known about the possibility of the damages. The above limitation or exclusion may not apply to you because your country may not allow the exclusion or limitation of incidental, consequential or other damages.\par +\lang9 Please note: As this software is distributed in Quebec, Canada, some of the clauses in this agreement are provided below in French.\par +Remarque : Ce logiciel \'e9tant distribu\'e9 au Qu\'e9bec, Canada, certaines des clauses dans ce contrat sont fournies ci-dessous en fran\'e7ais.\par + +\pard\nowidctlpar\s1\sb120\sa120\b\lang1033 EXON\'c9RATION DE GARANTIE. \b0 Le logiciel vis\'e9 par une licence est offert \'ab tel quel \'bb. Toute utilisation de ce logiciel est \'e0 votre seule risque et p\'e9ril. Microsoft n\rquote accorde aucune autre garantie expresse. Vous pouvez b\'e9n\'e9ficier de droits additionnels en vertu du droit local sur la protection des consommateurs, que ce contrat ne peut modifier. La ou elles sont permises par le droit locale, les garanties implicites de qualit\'e9 marchande, d\rquote ad\'e9quation \'e0 un usage particulier et d\rquote absence de contrefa\'e7on sont exclues.\par +\b LIMITATION DES DOMMAGES-INT\'c9R\'caTS ET EXCLUSION DE RESPONSABILIT\'c9 POUR LES DOMMAGES. \b0 Vous pouvez obtenir de Microsoft et de ses fournisseurs une indemnisation en cas de dommages directs uniquement \'e0 hauteur de 5,00 $ US. Vous ne pouvez pr\'e9tendre \'e0 aucune indemnisation pour les autres dommages, y compris les dommages sp\'e9ciaux, indirects ou accessoires et pertes de b\'e9n\'e9fices.\par + +\pard\nowidctlpar\sb120\sa120\lang9 Cette limitation concerne :\par + +\pard{\pntext\f4\'B7\tab}{\*\pn\pnlvlblt\pnf4\pnindent360{\pntxtb\'B7}}\nowidctlpar\li720\sb120\sa120 tout ce qui est reli\'e9 au logiciel, aux services ou au contenu (y compris le code) figurant sur des sites Internet tiers ou dans des programmes tiers ; et\par +{\pntext\f4\'B7\tab}les r\'e9clamations au titre de violation de contrat ou de garantie, ou au titre de responsabilit\'e9 stricte, de n\'e9gligence ou d\rquote une autre faute dans la limite autoris\'e9e par la loi en vigueur.\par + +\pard\nowidctlpar\sb120\sa120 Elle s\rquote applique \'e9galement, m\'eame si Microsoft connaissait ou devrait conna\'eetre l\rquote\'e9ventualit\'e9 d\rquote un tel dommage. Si votre pays n\rquote autorise pas l\rquote exclusion ou la limitation de responsabilit\'e9 pour les dommages indirects, accessoires ou de quelque nature que ce soit, il se peut que la limitation ou l\rquote exclusion ci-dessus ne s\rquote appliquera pas \'e0 votre \'e9gard.\par + +\pard\nowidctlpar\s1\sb120\sa120\b\lang1033 EFFET JURIDIQUE. \b0 Le pr\'e9sent contrat d\'e9crit certains droits juridiques. Vous pourriez avoir d\rquote autres droits pr\'e9vus par les lois de votre pays. Le pr\'e9sent contrat ne modifie pas les droits que vous conf\'e8rent les lois de votre pays si celles-ci ne le permettent pas.\par + +\pard\nowidctlpar\sb120\sa120\b\fs20\lang1036\par + +\pard\sa200\sl276\slmult1\b0\f3\fs22\lang9\par +} + \ No newline at end of file diff --git a/src/packages/Microsoft.Bcl.Build.1.0.14/Microsoft.Bcl.Build.1.0.14.nupkg b/src/packages/Microsoft.Bcl.Build.1.0.14/Microsoft.Bcl.Build.1.0.14.nupkg new file mode 100644 index 0000000000000000000000000000000000000000..e99599cb673f2742e33734fc52f671a7f049f2fd GIT binary patch literal 33795 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

    MG@{6kgxZ{7m$m9b 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 a`(VXM^)H=Hv+Q@r=cuau`*#o6ZUz8~9Jqr3 literal 0 HcmV?d00001 diff --git a/src/packages/Microsoft.Bcl.Build.1.0.14/tools/Microsoft.Bcl.Build.targets b/src/packages/Microsoft.Bcl.Build.1.0.14/tools/Microsoft.Bcl.Build.targets new file mode 100644 index 00000000..a14b3eab --- /dev/null +++ b/src/packages/Microsoft.Bcl.Build.1.0.14/tools/Microsoft.Bcl.Build.targets @@ -0,0 +1,232 @@ + + + + true + + + + + false + + + $(ProjectConfigFileName) + + + + + + <_FullFrameworkReferenceAssemblyPaths>$(TargetFrameworkDirectory) + + + + + + <__IntermediateAppConfig>$(IntermediateOutputPath)$(MSBuildProjectFile).App.config + + true + + + + + + + + + <_EnsureBindingRedirectReference Include="@(Reference)" + Condition="'%(Reference.HintPath)' != '' and Exists('$([System.IO.Path]::GetDirectoryName("%(Reference.HintPath)"))\\ensureRedirect.xml')" /> + + + + + + + + + + + + + + + $(__IntermediateAppConfig) + + + + + $(TargetFileName).config + + + + + + + + + + + <_BclBuildProjectReferenceProperties>BclBuildReferencingProject=$(MSBuildProjectFullPath);BclBuildReferencingProjectConfig=$(MSBuildProjectDirectory)\packages.config + <_BclBuildProjectReferenceProperties Condition="'$(SkipValidatePackageReferences)' != ''">$(_BclBuildProjectReferenceProperties);SkipValidatePackageReferences=$(SkipValidatePackageReferences) + + + + + $(_BclBuildProjectReferenceProperties);%(ProjectReference.AdditionalProperties) + + + + + + + + true + + + + + + + + + + false + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/src/packages/Microsoft.Bcl.Build.1.0.14/tools/Uninstall.ps1 b/src/packages/Microsoft.Bcl.Build.1.0.14/tools/Uninstall.ps1 new file mode 100644 index 00000000..255a0591 --- /dev/null +++ b/src/packages/Microsoft.Bcl.Build.1.0.14/tools/Uninstall.ps1 @@ -0,0 +1,26 @@ +param($installPath, $toolsPath, $package, $project) + + # Need to load MSBuild assembly if it's not loaded yet. + Add-Type -AssemblyName 'Microsoft.Build, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a' + + # Grab the loaded MSBuild project for the project + # Normalize project path before calling GetLoadedProjects as it performs a string based match + $msbuild = [Microsoft.Build.Evaluation.ProjectCollection]::GlobalProjectCollection.GetLoadedProjects([System.IO.Path]::GetFullPath($project.FullName)) | Select-Object -First 1 + + # Find all the imports and targets added by this package. + $itemsToRemove = @() + + # Allow many in case a past package was incorrectly uninstalled + $itemsToRemove += $msbuild.Xml.Imports | Where-Object { $_.Project.EndsWith($package.Id + '.targets') } + $itemsToRemove += $msbuild.Xml.Targets | Where-Object { $_.Name -eq "EnsureBclBuildImported" } + + # Remove the elements and save the project + if ($itemsToRemove -and $itemsToRemove.length) + { + foreach ($itemToRemove in $itemsToRemove) + { + $msbuild.Xml.RemoveChild($itemToRemove) | out-null + } + + $project.Save() + } \ No newline at end of file From ff1ffc95655c19ce85ad23747e0b64f8cfbd66ec Mon Sep 17 00:00:00 2001 From: "jess.anderson" Date: Tue, 16 Dec 2014 10:44:29 -0700 Subject: [PATCH 3/3] Merged the latest master branch to include the BigEndianBinaryReader --- src/kafka-net/Common/BigEndianBinaryReader.cs | 4 ++++ src/kafka-net/Common/BigEndianBinaryWriter.cs | 4 ++++ src/kafka-net40/kafka-net40.csproj | 6 ++++++ src/kafka-tests40/kafka-tests40.csproj | 6 ++++++ 4 files changed, 20 insertions(+) diff --git a/src/kafka-net/Common/BigEndianBinaryReader.cs b/src/kafka-net/Common/BigEndianBinaryReader.cs index 16e29efd..7abb809e 100644 --- a/src/kafka-net/Common/BigEndianBinaryReader.cs +++ b/src/kafka-net/Common/BigEndianBinaryReader.cs @@ -26,7 +26,11 @@ public BigEndianBinaryReader(Stream input) } public BigEndianBinaryReader(Stream input, Boolean leaveOpen) +#if NET40 + : base(input, Encoding.UTF8) +#else : base(input, Encoding.UTF8, leaveOpen) +#endif { Contract.Requires(input != null); } diff --git a/src/kafka-net/Common/BigEndianBinaryWriter.cs b/src/kafka-net/Common/BigEndianBinaryWriter.cs index f81ca93a..cbf6390c 100644 --- a/src/kafka-net/Common/BigEndianBinaryWriter.cs +++ b/src/kafka-net/Common/BigEndianBinaryWriter.cs @@ -26,7 +26,11 @@ public BigEndianBinaryWriter(Stream stream) } public BigEndianBinaryWriter(Stream stream, Boolean leaveOpen) +#if NET40 + : base(stream, Encoding.UTF8) +#else : base(stream, Encoding.UTF8, leaveOpen) +#endif { Contract.Requires(stream != null); } diff --git a/src/kafka-net40/kafka-net40.csproj b/src/kafka-net40/kafka-net40.csproj index b8719f60..d4d25475 100644 --- a/src/kafka-net40/kafka-net40.csproj +++ b/src/kafka-net40/kafka-net40.csproj @@ -63,6 +63,12 @@ + + Common\BigEndianBinaryReader.cs + + + Common\BigEndianBinaryWriter.cs + Common\ThreadWall.cs diff --git a/src/kafka-tests40/kafka-tests40.csproj b/src/kafka-tests40/kafka-tests40.csproj index 375bd40e..47f9bfc0 100644 --- a/src/kafka-tests40/kafka-tests40.csproj +++ b/src/kafka-tests40/kafka-tests40.csproj @@ -110,6 +110,12 @@ Integration\ProducerConsumerIntegrationTests.cs + + Unit\BigEndianBinaryReaderTests.cs + + + Unit\BigEndianBinaryWriterTests.cs + Unit\FakeTcpServerTests.cs